Here’s a list of my recent blog posts
Ripping the data off an Atari cartridge
Ripping the data off an Atari cartridge A little while ago, I read Racing the Beam: The Atari Video Computer System about the Atari 2600. I quite enjoyed it. It’s fascinating to read about the herculean efforts required to write software for such limited hardware. One throwaway line caught my attention: since RAM was so expensive in those days, the game cartridges only had ROM chips to store the software.
Thinking too much about memory latency
Thinking too much about memory latency I’ve been learning about query optimizers in databases, which are responsible for determining the runtimes of various algorithms based on the size of the tables, memory, and data distribution. Which got me thinking: how long do these algorithms take to run? If we assign real-world values to these computations, it can give us an intuition of what values we might expect in the real world.
Justifying the visitor pattern for ASTs (in Java anyway)
Justifying the Visitor Pattern for ASTs (in Java anyway) (I mean, let’s take a second and appreciate how dumb this looks)
I’ve started writing a relational DBMS to better understand how they work. Any good relational DBMS uses SQL, and therefore requires parsing a SQL AST. So I find myself implementing a basic interpreter as well.
I turned to Robert Nystrom’s book Crafting Interpreters to help with this task. Nystrom’s book does a great job of explaining the different parts of an interpreter and creating intuition for the design choices made.
Three random thoughts at the end of 2023
Introduction Sometimes, I wonder why I made a blog. I mean, who really cares what a twenty five year old has to say? Then again, I suppose my writing doesn’t have to be FOR anything or anyone. It’s interesting to think if self-expression needs an ‘other’ to receive the expression. If so, are we beholden to the other to witness us? That need seems at odd with the power of self-expression, so that feels intuitively wrong.
A few thoughts on programming language as a set of vectors
Preamble Below are some thoughts on me trying to understand programming language design for the first time. I found an axiomatic or vector-based approach makes most intuitive sense to me, so I try to explain my thoughts. I can’t promise that all of the thoughts are complete, self-consistent, or even little more than emotions. But if we knew where we were going, we wouldn’t have to make the journey in the first place.
Updating Gdbgui with 0xide's Frontend: Part 1
Updating Gdbgui with 0xide’s Frontend: Part 1 Motivation While working on my OS, I’m constantly looking for tools to improve my development process. I was recently introduced to gdb’s tui (text user interface) mode by Greg Law’s Strangeloop talk. This mode replaces the arcane gdb terminal with a much more friendly user interface.
I wanted to see if anyone had improved gdb’s interface further. Surely the useful tool of gdb with the achilles heel of a horrible UI would have been fixed by now?
xv6 Diagrams
I’ve found diagrams and comics to be quite useful in understanding topics and digesting information. There are a few reasons for this:
Diagrams are a visually rich medium where the layout can convey as much information as the content of the diagram Because diagrams are non-linear, they allow a progressive disclosure of complexity, where the viewer can mentally zoom in/out freely to understand relationships They offer a fun and approachable way to learn about topics that are otherwise intimidating or opaque Therefore, for my current OS project, I’ve decided to diagram each chapter of MIT’s xv6 textbook and OS.
Writing a RiscV linter
Code https://github.com/enathang/riscv-linter
Introduction Recently, I’ve started writing an Operating System. I have been following Sarah Lewis’s tutorial and MIT’s xv6 OS textbook. Both encourage the use of assembly for parts of the OS (bootloader, certain trap handling, etc.) This was my first time writing in assembly. As I was writing and researching more about RISC-V assembly, I learned that the assembly should follow RISC-V’s ABI. The Application Binary Interface standardizes how assembly should be written, such as which registers can be overwritten, which registers should not, etc.