Flowers stalk, node, which produce seeds. reproductive Magnoliophyta.
El meu germà es diu Noé. Li agrada molt pintar i sobre tot utilitza el color vermell. Quan ha de pintar un arbre ho fa amb els colors de la tardor per poder utilitzar el vermell. El problema ve quan gasta tot el vermell que té i li toca pintar amb la resta de colors. Mai he vist unes maduixes blaves, però si no queda vermell...
Avui plou i jo em quedo tancat a casa. No puc anar al parc ja que tot es mulla quan plou. No puc anar a casa dels meus amics ja que em mullo pel carrer. Plou molt i de tant en tant escolto com cau un llamp, tot i que no em fa por ja que cauen molt lluny.
Tinc un llibre gran, amb dibuixos de dracs, de portes i de for. Hi ha dibuixos de gegants i de fades, algunes molt molt petites i algunes normals. Els dibuixos del llibre no venen pintats i jo, un artista, els pinto sense sortir de la ratlla.
Roda la roda del cotxe roda i roda. La roda del cotxe roda cada vegada que la mare accelera. I roda i roda la roda. Crec que millor deixo de mirar com roda la roda o potser em marejo.
A classe som molts nens i nenes. Un es diu Marc, un altre Enric, una nena molt maca es diu Macarena i jo em dic Noel. La mestra es diu Jana i sempre porta un somriure a la boca. Tinc la millor classe.
A la platja on jo vaig hi ha ones molt grans. Algunes vegades entro una mica al mar per notar com de fortes venen aquestes ones. Hi ha vegades que la mama no em deixa entrar al mar i em toca fer castells de sorra.
Anant pel museu vaig veure una cosa molt curiosa. Era un esquelet de dinosaure i estic segur que es va moure. Quan el mirava es quedava quiet, i quan deixava de mirar es movia. Estic segur que era viu.
introduces concept delving, author position, lecturer dissenting belief, dismantles assertions
author posits suggests, lecturer refutes contending, elaborates undermines
author advances argument, lecturer counters flaws, suggests doubts perspective
author asserts believing, professor skeptical assertion, viewpoint overlooks considerations
perspectives different gaps, no common ground
undeniable regarding, opt unequivocally choose, contend logical decision
start with while, acknowledge experiences perspective, instance consequently
reflecting experiences found, opacity accountability clear
Given the above reasons, I am firmly convinced that, By doing so,
delving position dismantles, posits contending undermines, advances counters perspective, believing skeptical overlooks, perspectives ground
undeniable unequivocally logical, start experiences consequently, reflecting opacity, convinced doing
To conclude, while there are several compelling arguments on both sides, I profoundly believe that the benefits of T4 far outweigh its drawbacks. Not only do the advantages of N9 prove the significance of N10, but also pinpoint possible implications.
In the early days of Ink, the most interesting thing Ink programs could do was take some textual input, and output some text back to the terminal. While that was useful for testing the language, it was far from interesting. So once the basics of the language were up and running, I wanted a way to renderimages from ink programs. After some research, I settled on 8MP as my file format of choice, and wrote bmp.ink, a tiny BMP image encoder in about ~100 lines of ink code.
Armed with this new library, Ink could do so many more cool, creatively interesting things, like generate graphs, render charts, and compute a Mandelbrot set into a beautiful graphic (like the one above), all without depending on other external tools. This is the story of why l chose BMP as my file format, how bmp.ink came to be, and why this vintage file format is a diamond in the rough for small toy programming projects.
Like any topicin computing, designing an image file format is a game of tradeoffs. The most popular file formats, like JPG and PNG, optimize for image fidelity, speed, and file size. Other formats, like SVG, specialize for certain kinds of images like vector graphics. Formats for professional graphics workflows sometimes sacrifice everything else at the cost of image quality and cross-compatibility with other software.
When I set out to write an image encoder in Ink, I knew from the start that the most common formats like JPG and PNG wouldn't be ideal. Both are excellent file formats with decades of research behind them, but encoding JPG and PNGimages aren't trivial - they depend on some clever math like discrete cosine transforms and Huffman coding to trade off file format complexity for file size.
But for me, the #1 priority was implementation simplicity. I wanted to build an encoder quickly, sol could get on with building things that used the library to generate interesting images. This meant! needed a format that did as little as possible to compress or transform the original image data, given as a grid of RGB pixel values.
On the other end of the convenience-practicality spectrum are image formats based on text files, like the PPMimage formats. PPM images were designed so they could be shared as plain text files - PPM images store color values in the file for each pixel as strings of numbers. This makes PPMfiles easy to work with in any language that supports robust string manipulation, but because PPMis a more obscure format that never saw widespread general use, not all operating systems and image viewer software supports it. For example, on the Macbook I was working with, the native Preview app couldn't open PPMfiles. I could have used another library or piece of software to translate PPM files to a more popular format like PNG, but that felt unsatisfying, like Iwas only solving a part of the problem at hand.
Searching for a format that fit the balance I needed between simplicity and compatibility, Ifound the BMP file format. BMP is a raster image file format, which means it stores color data for individual pixels. What sets BMP apart from other more common formats is that BMP is not a compressed image format- each RGB pixel is stored exactly as a 3-byte chunk of data in the file, and all the pixels of an image are stored sequentially in the file, usually in rows starting from the bottom left of the image. An entire, real-world BMP file is just a big array of pixel data stored this way, prefixed with a small header with some metadata about the image like dimensions and file type.
This format is much simpler than JPG or PNG! It's quite possible for any programmer to sit down and write an encoder that translates a list of RGB values into a BMP file format, because the format is such a straightforward transformation on the raw bitmap data of the image. As a bonus, because BMP images were quite common once, most operating systems and image viewers natively display
BMP files (the last image on this post is a BMP file, displayed by your browser).
In the early days of Ink, the most interesting thing Ink programs could do was take some textual input, and output some text back to the terminal. While that was useful for testing the language, it was far from interesting. So once the basics of the language were up and running, I wanted a way to renderimages from ink programs. After some research, I settled on 8MP as my file format of choice, and wrote bmp.ink, a tiny BMP image encoder in about ~100 lines of ink code.
Armed with this new library, Ink could do so many more cool, creatively interesting things, like generate graphs, render charts, and compute a Mandelbrot set into a beautiful graphic (like the one above), all without depending on other external tools. This is the story of why l chose BMP as my file format, how bmp.ink came to be, and why this vintage file format is a diamond in the rough for small toy programming projects.
Like any topicin computing, designing an image file format is a game of tradeoffs. The most popular file formats, like JPG and PNG, optimize for image fidelity, speed, and file size. Other formats, like SVG, specialize for certain kinds of images like vector graphics. Formats for professional graphics workflows sometimes sacrifice everything else at the cost of image quality and cross-compatibility with other software.
When I set out to write an image encoder in Ink, I knew from the start that the most common formats like JPG and PNG wouldn't be ideal. Both are excellent file formats with decades of research behind them, but encoding JPG and PNGimages aren't trivial - they depend on some clever math like discrete cosine transforms and Huffman coding to trade off file format complexity for file size.
But for me, the #1 priority was implementation simplicity. I wanted to build an encoder quickly, sol could get on with building things that used the library to generate interesting images. This meant! needed a format that did as little as possible to compress or transform the original image data, given as a grid of RGB pixel values.
On the other end of the convenience-practicality spectrum are image formats based on text files, like the PPMimage formats. PPM images were designed so they could be shared as plain text files - PPM images store color values in the file for each pixel as strings of numbers. This makes PPMfiles easy to work with in any language that supports robust string manipulation, but because PPMis a more obscure format that never saw widespread general use, not all operating systems and image viewer software supports it. For example, on the Macbook I was working with, the native Preview app couldn't open PPMfiles. I could have used another library or piece of software to translate PPM files to a more popular format like PNG, but that felt unsatisfying, like Iwas only solving a part of the problem at hand.
Searching for a format that fit the balance I needed between simplicity and compatibility, Ifound the BMP file format. BMP is a raster image file format, which means it stores color data for individual pixels. What sets BMP apart from other more common formats is that BMP is not a compressed image format- each RGB pixel is stored exactly as a 3-byte chunk of data in the file, and all the pixels of an image are stored sequentially in the file, usually in rows starting from the bottom left of the image. An entire, real-world BMP file is just a big array of pixel data stored this way, prefixed with a small header with some metadata about the image like dimensions and file type.
This format is much simpler than JPG or PNG! It's quite possible for any programmer to sit down and write an encoder that translates a list of RGB values into a BMP file format, because the format is such a straightforward transformation on the raw bitmap data of the image. As a bonus, because BMP images were quite common once, most operating systems and image viewers natively display
BMP files (the last image on this post is a BMP file, displayed by your browser).
In the early days of Ink, the most interesting thing Ink programs could do was take some textual input, and output some text back to the terminal. While that was useful for testing the language, it was far from interesting. So once the basics of the language were up and running, I wanted a way to renderimages from ink programs. After some research, I settled on 8MP as my file format of choice, and wrote bmp.ink, a tiny BMP image encoder in about ~100 lines of ink code.
Armed with this new library, Ink could do so many more cool, creatively interesting things, like generate graphs, render charts, and compute a Mandelbrot set into a beautiful graphic (like the one above), all without depending on other external tools. This is the story of why l chose BMP as my file format, how bmp.ink came to be, and why this vintage file format is a diamond in the rough for small toy programming projects.
Like any topicin computing, designing an image file format is a game of tradeoffs. The most popular file formats, like JPG and PNG, optimize for image fidelity, speed, and file size. Other formats, like SVG, specialize for certain kinds of images like vector graphics. Formats for professional graphics workflows sometimes sacrifice everything else at the cost of image quality and cross-compatibility with other software.
When I set out to write an image encoder in Ink, I knew from the start that the most common formats like JPG and PNG wouldn't be ideal. Both are excellent file formats with decades of research behind them, but encoding JPG and PNGimages aren't trivial - they depend on some clever math like discrete cosine transforms and Huffman coding to trade off file format complexity for file size.
But for me, the #1 priority was implementation simplicity. I wanted to build an encoder quickly, sol could get on with building things that used the library to generate interesting images. This meant! needed a format that did as little as possible to compress or transform the original image data, given as a grid of RGB pixel values.
On the other end of the convenience-practicality spectrum are image formats based on text files, like the PPMimage formats. PPM images were designed so they could be shared as plain text files - PPM images store color values in the file for each pixel as strings of numbers. This makes PPMfiles easy to work with in any language that supports robust string manipulation, but because PPMis a more obscure format that never saw widespread general use, not all operating systems and image viewer software supports it. For example, on the Macbook I was working with, the native Preview app couldn't open PPMfiles. I could have used another library or piece of software to translate PPM files to a more popular format like PNG, but that felt unsatisfying, like Iwas only solving a part of the problem at hand.
Searching for a format that fit the balance I needed between simplicity and compatibility, Ifound the BMP file format. BMP is a raster image file format, which means it stores color data for individual pixels. What sets BMP apart from other more common formats is that BMP is not a compressed image format- each RGB pixel is stored exactly as a 3-byte chunk of data in the file, and all the pixels of an image are stored sequentially in the file, usually in rows starting from the bottom left of the image. An entire, real-world BMP file is just a big array of pixel data stored this way, prefixed with a small header with some metadata about the image like dimensions and file type.
This format is much simpler than JPG or PNG! It's quite possible for any programmer to sit down and write an encoder that translates a list of RGB values into a BMP file format, because the format is such a straightforward transformation on the raw bitmap data of the image. As a bonus, because BMP images were quite common once, most operating systems and image viewers natively display
BMP files (the last image on this post is a BMP file, displayed by your browser).
In the early days of Ink, the most interesting thing Ink programs could do was take some textual input, and output some text back to the terminal. While that was useful for testing the language, it was far from interesting. So once the basics of the language were up and running, I wanted a way to renderimages from ink programs. After some research, I settled on 8MP as my file format of choice, and wrote bmp.ink, a tiny BMP image encoder in about ~100 lines of ink code.
Armed with this new library, Ink could do so many more cool, creatively interesting things, like generate graphs, render charts, and compute a Mandelbrot set into a beautiful graphic (like the one above), all without depending on other external tools. This is the story of why l chose BMP as my file format, how bmp.ink came to be, and why this vintage file format is a diamond in the rough for small toy programming projects.
Like any topicin computing, designing an image file format is a game of tradeoffs. The most popular file formats, like JPG and PNG, optimize for image fidelity, speed, and file size. Other formats, like SVG, specialize for certain kinds of images like vector graphics. Formats for professional graphics workflows sometimes sacrifice everything else at the cost of image quality and cross-compatibility with other software.
When I set out to write an image encoder in Ink, I knew from the start that the most common formats like JPG and PNG wouldn't be ideal. Both are excellent file formats with decades of research behind them, but encoding JPG and PNGimages aren't trivial - they depend on some clever math like discrete cosine transforms and Huffman coding to trade off file format complexity for file size.
But for me, the #1 priority was implementation simplicity. I wanted to build an encoder quickly, sol could get on with building things that used the library to generate interesting images. This meant! needed a format that did as little as possible to compress or transform the original image data, given as a grid of RGB pixel values.
On the other end of the convenience-practicality spectrum are image formats based on text files, like the PPMimage formats. PPM images were designed so they could be shared as plain text files - PPM images store color values in the file for each pixel as strings of numbers. This makes PPMfiles easy to work with in any language that supports robust string manipulation, but because PPMis a more obscure format that never saw widespread general use, not all operating systems and image viewer software supports it. For example, on the Macbook I was working with, the native Preview app couldn't open PPMfiles. I could have used another library or piece of software to translate PPM files to a more popular format like PNG, but that felt unsatisfying, like Iwas only solving a part of the problem at hand.
Searching for a format that fit the balance I needed between simplicity and compatibility, Ifound the BMP file format. BMP is a raster image file format, which means it stores color data for individual pixels. What sets BMP apart from other more common formats is that BMP is not a compressed image format- each RGB pixel is stored exactly as a 3-byte chunk of data in the file, and all the pixels of an image are stored sequentially in the file, usually in rows starting from the bottom left of the image. An entire, real-world BMP file is just a big array of pixel data stored this way, prefixed with a small header with some metadata about the image like dimensions and file type.
This format is much simpler than JPG or PNG! It's quite possible for any programmer to sit down and write an encoder that translates a list of RGB values into a BMP file format, because the format is such a straightforward transformation on the raw bitmap data of the image. As a bonus, because BMP images were quite common once, most operating systems and image viewers natively display
BMP files (the last image on this post is a BMP file, displayed by your browser).
In the early days of Ink, the most interesting thing Ink programs could do was take some textual input, and output some text back to the terminal. While that was useful for testing the language, it was far from interesting. So once the basics of the language were up and running, I wanted a way to renderimages from ink programs. After some research, I settled on 8MP as my file format of choice, and wrote bmp.ink, a tiny BMP image encoder in about ~100 lines of ink code.
Armed with this new library, Ink could do so many more cool, creatively interesting things, like generate graphs, render charts, and compute a Mandelbrot set into a beautiful graphic (like the one above), all without depending on other external tools. This is the story of why l chose BMP as my file format, how bmp.ink came to be, and why this vintage file format is a diamond in the rough for small toy programming projects.
Like any topicin computing, designing an image file format is a game of tradeoffs. The most popular file formats, like JPG and PNG, optimize for image fidelity, speed, and file size. Other formats, like SVG, specialize for certain kinds of images like vector graphics. Formats for professional graphics workflows sometimes sacrifice everything else at the cost of image quality and cross-compatibility with other software.
When I set out to write an image encoder in Ink, I knew from the start that the most common formats like JPG and PNG wouldn't be ideal. Both are excellent file formats with decades of research behind them, but encoding JPG and PNGimages aren't trivial - they depend on some clever math like discrete cosine transforms and Huffman coding to trade off file format complexity for file size.
But for me, the #1 priority was implementation simplicity. I wanted to build an encoder quickly, sol could get on with building things that used the library to generate interesting images. This meant! needed a format that did as little as possible to compress or transform the original image data, given as a grid of RGB pixel values.
On the other end of the convenience-practicality spectrum are image formats based on text files, like the PPMimage formats. PPM images were designed so they could be shared as plain text files - PPM images store color values in the file for each pixel as strings of numbers. This makes PPMfiles easy to work with in any language that supports robust string manipulation, but because PPMis a more obscure format that never saw widespread general use, not all operating systems and image viewer software supports it. For example, on the Macbook I was working with, the native Preview app couldn't open PPMfiles. I could have used another library or piece of software to translate PPM files to a more popular format like PNG, but that felt unsatisfying, like Iwas only solving a part of the problem at hand.
Searching for a format that fit the balance I needed between simplicity and compatibility, Ifound the BMP file format. BMP is a raster image file format, which means it stores color data for individual pixels. What sets BMP apart from other more common formats is that BMP is not a compressed image format- each RGB pixel is stored exactly as a 3-byte chunk of data in the file, and all the pixels of an image are stored sequentially in the file, usually in rows starting from the bottom left of the image. An entire, real-world BMP file is just a big array of pixel data stored this way, prefixed with a small header with some metadata about the image like dimensions and file type.
This format is much simpler than JPG or PNG! It's quite possible for any programmer to sit down and write an encoder that translates a list of RGB values into a BMP file format, because the format is such a straightforward transformation on the raw bitmap data of the image. As a bonus, because BMP images were quite common once, most operating systems and image viewers natively display
BMP files (the last image on this post is a BMP file, displayed by your browser).
In the early days of Ink, the most interesting thing Ink programs could do was take some textual input, and output some text back to the terminal. While that was useful for testing the language, it was far from interesting. So once the basics of the language were up and running, I wanted a way to renderimages from ink programs. After some research, I settled on 8MP as my file format of choice, and wrote bmp.ink, a tiny BMP image encoder in about ~100 lines of ink code.
Armed with this new library, Ink could do so many more cool, creatively interesting things, like generate graphs, render charts, and compute a Mandelbrot set into a beautiful graphic (like the one above), all without depending on other external tools. This is the story of why l chose BMP as my file format, how bmp.ink came to be, and why this vintage file format is a diamond in the rough for small toy programming projects.
Like any topicin computing, designing an image file format is a game of tradeoffs. The most popular file formats, like JPG and PNG, optimize for image fidelity, speed, and file size. Other formats, like SVG, specialize for certain kinds of images like vector graphics. Formats for professional graphics workflows sometimes sacrifice everything else at the cost of image quality and cross-compatibility with other software.
When I set out to write an image encoder in Ink, I knew from the start that the most common formats like JPG and PNG wouldn't be ideal. Both are excellent file formats with decades of research behind them, but encoding JPG and PNGimages aren't trivial - they depend on some clever math like discrete cosine transforms and Huffman coding to trade off file format complexity for file size.
But for me, the #1 priority was implementation simplicity. I wanted to build an encoder quickly, sol could get on with building things that used the library to generate interesting images. This meant! needed a format that did as little as possible to compress or transform the original image data, given as a grid of RGB pixel values.
On the other end of the convenience-practicality spectrum are image formats based on text files, like the PPMimage formats. PPM images were designed so they could be shared as plain text files - PPM images store color values in the file for each pixel as strings of numbers. This makes PPMfiles easy to work with in any language that supports robust string manipulation, but because PPMis a more obscure format that never saw widespread general use, not all operating systems and image viewer software supports it. For example, on the Macbook I was working with, the native Preview app couldn't open PPMfiles. I could have used another library or piece of software to translate PPM files to a more popular format like PNG, but that felt unsatisfying, like Iwas only solving a part of the problem at hand.
Searching for a format that fit the balance I needed between simplicity and compatibility, Ifound the BMP file format. BMP is a raster image file format, which means it stores color data for individual pixels. What sets BMP apart from other more common formats is that BMP is not a compressed image format- each RGB pixel is stored exactly as a 3-byte chunk of data in the file, and all the pixels of an image are stored sequentially in the file, usually in rows starting from the bottom left of the image. An entire, real-world BMP file is just a big array of pixel data stored this way, prefixed with a small header with some metadata about the image like dimensions and file type.
This format is much simpler than JPG or PNG! It's quite possible for any programmer to sit down and write an encoder that translates a list of RGB values into a BMP file format, because the format is such a straightforward transformation on the raw bitmap data of the image. As a bonus, because BMP images were quite common once, most operating systems and image viewers natively display
BMP files (the last image on this post is a BMP file, displayed by your browser).
In the early days of Ink, the most interesting thing Ink programs could do was take some textual input, and output some text back to the terminal. While that was useful fortesting the language, it was far from interesting. So once the basics of the language were up and running, I wanted a way to render images from Ink programs. Aftersome research, I settled on BMP as my file format of choice, and wrote bmp.ink, a tiny BMP image encoder in about ~100 lines of Ink code.
Armed with this new library, Ink could do so many more cool, creatively interesting things, like generate graphs, render charts, and compute a Mandelbrot set into a beautiful graphic (like the one above), all without depending on other external tools. This is the story of why I chose BMP as my file format, how bmp.ink came to be, and why this vintage file format is a diamond in the rough for small toy programming projects.
Like any topicin computing, designing an image file format is a game of tradeoffs. The most popular file formats, like JPG and PNG, optimize for image fidelity, speed, and filesize. Other formats, like SVG, specialize for certain kinds of images like vector graphics. Formats for professional graphics workflows sometimes sacrifice everything else at the cost of image quality and cross-compatibility with other software.
When I set out to write an image encoder in Ink, I knew from the start that the most common formats like JPGand PNG wouldn't be ideal. Both are excellent file formats with decades of research behind them, but encoding JPG and PNG images aren't trivial - they depend on some clever math like discrete cosine transforms and Huffman coding to trade off file format complexity for file size.
But for me, the #1 priority was implementation simplicity. I wanted to build an encoder quickly, so l could get on with building things that used the library to generate interesting images. This meant I needed a format that did as little as possible to compress or transform the original image data, given as a grid of RGB pixel values.
On the other end of the convenience-practicality spectrum are image formats based on text files, like the PPMimage formats. PPM images were designed so they could be shared as plain text files - PPM images store color values in the file for each pixel as strings of numbers. This makes PPMfiles easy to work with in any language that supports robust string manipulation, but because PPMis a more obscure format that never saw widespread general use, not all operating systems and image viewer software supports it. For example, on the Macbook | was working with, the native Preview app couldn't open PPMfiles. I could have used another library or piece of software to translate PPM files to a more popular format like PNG, but that felt unsatisfying, like I was only solving a part of the problem at hand.
Searching for a format that fit the balance I needed between simplicity and compatibility, I found the BMP file format. BMP is a raster image file format, which means it stores color data for individual pixels. What sets BMP apart from other more common formats is that BMP is not a compressed image format - each RGB pixel is stored exactly as a 3-byte chunk of data in the file, and all the pixels of an image are stored sequentially in the file, usually in rows starting from the bottom left of the image. An entire, real-world BMP file is just a big array of pixel data stored this way, prefixed with a small header with some metadata about the image like dimensions and file type.
This format is much simpler than JPG or PNG! It's quite possible for any programmer to sit down and write an encoder that translates a list of RGB values into a BMP file format, because the format is such a straightforward transformation on the raw bitmap data of the image. As a bonus, because BMP images were quite common once, most operating systems and image viewers natively display BMP files (the last image on this post is a BMP file, displayed by your browser).
In the early days of Ink, the most interesting thing Ink programs could do was take some textual input, and output some text back to the terminal. While that was useful for testing the language, it was far from interesting. So once the basics of the language were up and running, I wanted a way to render images from Ink programs. After some research, I settled on BMP as my file format of choice, and wrote bmp.ink, a tiny BMP image encoder in about ~100 lines of Ink code.
Armed with this new library, Ink could do so many more cool, creatively interesting things, like generate graphs, render charts, and compute a Mandelbrot set into a beautiful graphic (like the one above), all without depending on other external tools. This is the story of why I chose BMP as my file format, how bmp.ink came to be, and why this vintage file format is a diamond in the rough for small toy programming projects.
Like any topic in computing, designing an image file format is a game of tradeoffs. The most popular file formats, like JPG and PNG, optimize for image fidelity, speed, and file size. Other formats, like SVG, specialize for certain kinds of images like vector graphics. Formats for professional graphics workflows sometimes sacrifice everything else at the cost of image quality and cross-compatibility with other software.
When I set out to write an image encoder in Ink, I knew from the start that the most common formats like JPG and PNG wouldn’t be ideal. Both are excellent file formats with decades of research behind them, but encoding JPG and PNG images aren’t trivial – they depend on some clever math like discrete cosine transforms and Huffman coding to trade off file format complexity for file size. But for me, the #1 priority was implementation simplicity. I wanted to build an encoder quickly, so I could get on with building things that used the library to generate interesting images. This meant I needed a format that did as little as possible to compress or transform the original image data, given as a grid of RGB pixel values.
On the other end of the convenience-practicality spectrum are image formats based on text files, like the PPM image formats. PPM images were designed so they could be shared as plain text files – PPM images store color values in the file for each pixel as strings of numbers. This makes PPM files easy to work with in any language that supports robust string manipulation, but because PPM is a more obscure format that never saw widespread general use, not all operating systems and image viewer software supports it. For example, on the Macbook I was working with, the native Preview app couldn’t open PPM files. I could have used another library or piece of software to translate PPM files to a more popular format like PNG, but that felt unsatisfying, like I was only solving a part of the problem at hand.
Searching for a format that fit the balance I needed between simplicity and compatibility, I found the BMP file format. BMP is a raster image file format, which means it stores color data for individual pixels. What sets BMP apart from other more common formats is that BMP is not a compressed image format – each RGB pixel is stored exactly as a 3-byte chunk of data in the file, and all the pixels of an image are stored sequentially in the file, usually in rows starting from the bottom left of the image. An entire, real-world BMP file is just a big array of pixel data stored this way, prefixed with a small header with some metadata about the image like dimensions and file type.
This format is much simpler than JPG or PNG! It’s quite possible for any programmer to sit down and write an encoder that translates a list of RGB values into a BMP file format, because the format is such a straightforward transformation on the raw bitmap data of the image. As a bonus, because BMP images were quite common once, most operating systems and image viewers natively display BMP files (the last image on this post is a BMP file, displayed by your browser).
In the early days of Ink, the most interesting thing Ink programs could do was take some textual input, and output some text back to the terminal. While that was useful for testing the language, it was far from interesting. So once the basics of the language were up and running, I wanted a way to render images from Ink programs. After some research, I settled on BMP as my file format of choice, and wrote bmp.ink, a tiny BMP image encoder in about ~100 lines of Ink code.
Armed with this new library, Ink could do so many more cool, creatively interesting things, like generate graphs, render charts, and compute a Mandelbrot set into a beautiful graphic (like the one above), all without depending on other external tools. This is the story of why I chose BMP as my file format, how bmp.ink came to be, and why this vintage file format is a diamond in the rough for small toy programming projects.
Like any topic in computing, designing an image file format is a game of tradeoffs. The most popular file formats, like JPG and PNG, optimize for image fidelity, speed, and file size. Other formats, like SVG, specialize for certain kinds of images like vector graphics. Formats for professional graphics workflows sometimes sacrifice everything else at the cost of image quality and cross-compatibility with other software.
When I set out to write an image encoder in Ink, I knew from the start that the most common formats like JPG and PNG wouldn’t be ideal. Both are excellent file formats with decades of research behind them, but encoding JPG and PNG images aren’t trivial – they depend on some clever math like discrete cosine transforms and Huffman coding to trade off file format complexity for file size. But for me, the #1 priority was implementation simplicity. I wanted to build an encoder quickly, so I could get on with building things that used the library to generate interesting images. This meant I needed a format that did as little as possible to compress or transform the original image data, given as a grid of RGB pixel values.
On the other end of the convenience-practicality spectrum are image formats based on text files, like the PPM image formats. PPM images were designed so they could be shared as plain text files – PPM images store color values in the file for each pixel as strings of numbers. This makes PPM files easy to work with in any language that supports robust string manipulation, but because PPM is a more obscure format that never saw widespread general use, not all operating systems and image viewer software supports it. For example, on the Macbook I was working with, the native Preview app couldn’t open PPM files. I could have used another library or piece of software to translate PPM files to a more popular format like PNG, but that felt unsatisfying, like I was only solving a part of the problem at hand.
Searching for a format that fit the balance I needed between simplicity and compatibility, I found the BMP file format. BMP is a raster image file format, which means it stores color data for individual pixels. What sets BMP apart from other more common formats is that BMP is not a compressed image format – each RGB pixel is stored exactly as a 3-byte chunk of data in the file, and all the pixels of an image are stored sequentially in the file, usually in rows starting from the bottom left of the image. An entire, real-world BMP file is just a big array of pixel data stored this way, prefixed with a small header with some metadata about the image like dimensions and file type.
This format is much simpler than JPG or PNG! It’s quite possible for any programmer to sit down and write an encoder that translates a list of RGB values into a BMP file format, because the format is such a straightforward transformation on the raw bitmap data of the image. As a bonus, because BMP images were quite common once, most operating systems and image viewers natively display BMP files (the last image on this post is a BMP file, displayed by your browser).
The discovery of exoplanets—planets orbiting stars outside our solar system—has revolutionized the search for extraterrestrial life. With over 5,000 confirmed exoplanets, astronomers are focusing on those within the "habitable zone," where conditions might allow liquid water to exist, a crucial ingredient for life as we know it. This project explores the methods used to detect exoplanets, including the transit method, where telescopes observe the slight dimming of a star as a planet passes in front of it, and the radial velocity method, which measures the star's wobble caused by the gravitational pull of orbiting planets. Advanced space telescopes like NASA’s James Webb Space Telescope are now capable of analyzing exoplanet atmospheres, searching for biosignatures—chemical markers such as oxygen, methane, or carbon dioxide that could indicate the presence of life. The project also examines the variety of exoplanet types discovered, from gas giants similar to Jupiter to rocky, Earth-like planets, and how factors such as a planet’s size, atmosphere, and distance from its star influence its potential habitability. While no definitive evidence of extraterrestrial life has been found, each new exoplanet discovery brings us closer to answering one of humanity’s most profound questions: Are we alone in the universe?
