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?
Antonio Torres
Epigenetics is the study of changes in gene expression that occur without altering the underlying DNA sequence. This emerging field challenges the classical view of genetics, showing that genes are not the sole determinants of biological traits and disease susceptibility. Instead, epigenetic mechanisms such as DNA methylation and histone modification play a pivotal role in turning genes on or off in response to environmental factors like diet, stress, and toxins. These chemical modifications can affect how tightly DNA is wound around histones, influencing which genes are accessible for transcription. Epigenetic changes are dynamic and can occur throughout an organism’s life, sometimes even being passed onto future generations. This project explores how epigenetic factors contribute to human health, focusing on conditions such as cancer, where abnormal epigenetic regulation can lead to uncontrolled cell growth. It also discusses the potential for therapeutic interventions that target epigenetic changes, offering hope for treating diseases that have a genetic component without directly altering the DNA itself. By understanding the epigenetic code, scientists can better grasp the complex interplay between genes and the environment, revolutionizing our approach to personalized medicine.
Plasma, the fourth state of matter, consists of superheated, ionized gas in which electrons are separated from their nuclei. Though less common on Earth, plasma makes up 99% of the visible universe, found in stars, including our Sun. Understanding plasma behavior is crucial for developing fusion energy, a process where atomic nuclei fuse together, releasing vast amounts of energy. Unlike nuclear fission, which powers today’s nuclear reactors, fusion produces minimal radioactive waste and has the potential to offer an almost limitless supply of clean energy. However, achieving sustained nuclear fusion on Earth requires replicating conditions similar to those in stars—temperatures reaching millions of degrees Celsius, at which hydrogen isotopes can fuse into helium. This project explores the science behind magnetic confinement in fusion reactors like tokamaks, which use powerful magnetic fields to control and stabilize plasma. It also discusses the current challenges in fusion research, including maintaining plasma stability and achieving "break-even" energy output, where the energy produced by fusion equals or exceeds the energy required to sustain the reaction. While fusion energy remains elusive, recent breakthroughs in plasma physics bring humanity closer to harnessing the same power that fuels the stars.
Neutrinos, often called "ghost particles," are among the most elusive and fascinating entities in particle physics. These subatomic particles are incredibly difficult to detect because they rarely interact with matter, passing through virtually everything, including entire planets, without leaving a trace. Neutrinos come in three known flavors—electron, muon, and tau—and can oscillate between these forms as they travel through space. This project explores the importance of neutrinos in the Standard Model of particle physics, where they play a role in weak nuclear interactions and beta decay processes. Despite being nearly massless, neutrinos could hold the key to understanding some of the universe's biggest mysteries, such as why there is more matter than antimatter. Their study is also crucial in astrophysics, as neutrinos provide insight into processes like supernovae and nuclear fusion in stars. Neutrino observatories, such as the IceCube Neutrino Observatory in Antarctica, aim to detect these particles by using massive detectors placed deep underground or under ice, capturing the rare instances when a neutrino interacts with surrounding matter.
Dark matter remains one of the most elusive substances in the universe, yet it accounts for roughly 27% of the total mass and energy content. Unlike normal matter, dark matter doesn’t interact with electromagnetic forces, making it invisible to telescopes and undetectable through emitted light. However, its gravitational influence is observable on the motion of galaxies and the formation of large-scale structures in the universe. This project investigates how dark matter’s gravitational effects, inferred from the rotation curves of galaxies and the cosmic microwave background (CMB) radiation, indicate the presence of an unseen mass that binds galaxies and galaxy clusters together. Without dark matter, the observed velocities of stars in the outer regions of galaxies would suggest they should fly apart, given the insufficient visible mass to produce such gravitational pull. The project also touches on leading candidates for dark matter, such as weakly interacting massive particles (WIMPs), and axions, exploring how current particle physics experiments, including those at the Large Hadron Collider (LHC) and deep underground detectors, aim to identify or even capture dark matter particles. Moreover, through the use of computer simulations, cosmologists have mapped how dark matter helps shape the web-like structure of the universe, providing a framework around which galaxies form. Though its precise nature remains a mystery, dark matter plays a critical role in the universe’s evolution, and understanding it could unravel some of the deepest secrets about the cosmos.
