Cracking the Shell - programming

Investigating the SuperNote Notebook Format

2026-02-20T00:00:00+00:00

I'm a big fan of eink tablets. I read a lot, I write a lot, I prefer handwritten notes, it's a match made in heaven. I've been using a Kindle Scribe for the past several years - I probably used it as much or more than my phone. Recently, I upgraded to a Supernote Nomad, which has been a lovely experience so far.

One thing that always bothered me about the Scribe is how subpar its notebook exporting is. I don't want to have to be online to do it, I want to be able to do it from my computer rather than my phone, and I want the output file to look exactly like the note I wrote on the screen. Amazon is 0 for 3 on that. Luckily, someone has already solved this problem with a third party app, and I was able to learn a lot from their implementation.

The SuperNote has its own proprietary format for its notebooks, so I figured I'd give it a look. This is mostly going to be about the SuperNote format, but the Scribe format will be my main point of reference.

LLDB's TypeSystems Part 2: PDB

2025-07-07T00:00:00+00:00

In my previous post, I described implementing PDB parsing as a can of worms. That might have been a bit of an understatement. PDB has been one "oh, it's gonna be twice as much work as I thought" after another. Implementing it has revealed many of the same issues as the TypeSystem</code> itself: lack of documentation, cryptic implementations, poor naming schemes, and unclear expectations. Despite all that, I was able to get it working.

That means TypeSystemRust</code> can be used for executables that target *-gnu</code> or *-msvc</code>. It's not quite done yet, but this is a massive step towards the TypeSystem</code> being fully complete. I want to talk a bit about the process, at least partially for posterity. As we'll see later, PDB itself is also not documented very well, so any additional literature could be helpful to someone down the line.

Fair warning, we're getting into the weeds. This is gonna be a long one.



LLDB's TypeSystems: An Unfinished Interface
2025-03-28T00:00:00+00:00
Well, it's "done". TypeSystemRust</code> has a (semi) working prototype for LLDB 19.x</a>. It doesn't support expressions or MSVC targets (i.e. PDB debug info), and there are a whole host of catastrophic crashes, but it more or less proves what it needs to: Rust's debugging experience can</em> be improved, and there are worthwhile benefits to a working TypeSystem</code> that can't be emulated on other layers of the debugging stack.</p>
If you want to test it out, you'll need to build my fork from source (sorry), but then lldb.exe</code> can be used as-is, or you can point a debugger extension like lldb-dap or CodeLLDB to your newly built lldb-dap.exe</code> or liblldb.dll</code> respectively. If you're on Windows, make sure to compile for MSVC otherwise CodeLLDB won't be able to interface with liblldb</code> properly.</p>


So you want better debug info?
2025-02-14T00:00:00+00:00
Let me start with an emphatic "me too"</strong>.</p>
I've put many of my side projects on hold because recent events have resulted in, what I consider to be, an unacceptable degredation of the debugging experience. It's a bit hard to focus on whatever I'm doing when I have to fight to figure out what's in a Vec</code>. One of the great things about programming is that we're the ones who make our own tools; we don't have to just blindly accept mediocrity.</p>


TwoVec: A Very Silly Container
2024-10-18T00:00:00+00:00
Lets say you want to store two different types of objects in 1 container. Simple right? Just slap those puppies in a tuple and you're good to go:</p>
let</span> list</span>:</span> Vec</span><(</span>u8</span>,</span> f32</span>)></span> =</span> vec!</span>[(</span>255</span>,</span> 20.0</span>), (</span>10</span>,</span> 37.0</span>)];</span></span></code></pre>
But what if you wanted to include elements of two different types in arbitrary orders</em>? Thankfully, there's sum types for that:</p>
pub enum</span> Val</span> {</span></span>
    A</span>(</span>u8</span>),</span></span>
    B</span>(</span>f32</span>),</span></span>
}</span></span>
</span>
... {</span></span>
    let</span> list</span> =</span> vec!</span>[</span>Val</span>::</span>A</span>(</span>255</span>),</span> Val</span>::</span>B</span>(</span>20.0</span>),</span> Val</span>::</span>B</span>(</span>37.0</span>),</span> Val</span>::</span>A</span>(</span>10</span>)];</span></span>
}</span></span></code></pre>
One small problem. That's wasteful</em>.</p>


Why is language documentation still so terrible?
2024-09-12T00:00:00+00:00
Seriously, is there a good reason for this? I feel like I'm going crazy because almost every language doc I've looked at is legitimately awful in a bunch of obvious ways. It's not uncommon to see third party libraries updated by a single person that are better structured, more thorough, with better layouts than the official documentation upheld by the language team itself.</p>


Bypassing the borrow checker - do ref -> ptr -> ref partial borrows cause UB?
2024-08-09T00:00:00+00:00
Partial borrows across function boundaries don't really work in Rust. Unfortunately, that's kind of a major issue. There are workarounds, some are outlined here</a>, but all of them come with pretty major drawbacks.</p>


Simulating Starcraft Part 2 - Data Wrangling
2024-06-02T00:00:00+00:00
Oh how naive I was when I thought I'd be moving on to pathfinding and abilities. I had hoped some of the game's mechanics would function better in isolation, so I could gradually add complexity on top of the tracer bullet in a modular way. Unfortunately, that doesn't seem possible without a huge refactoring burden every time I add the next layer. It'll be more worth my time to properly architect it right now, and build it from the ground up with all of the systems it'll need.</p>


Simulating Starcraft Part 1 - Tracer Bullet
2024-05-15T00:00:00+00:00
A while back, I made a small application</a> meant to demonstrate some important principles about RTS design, namely that unit stats in a vacuum can be very misleading. As a quick example, stalkers have ~9.7 dps on paper. When fighting marines though, their effective DPS drops to ~8.4 (8.2 with combat shields) due to overkill. That's about the same DPS as a sentry. Unfortunately, there's only so much info that can be extracted from a Time To Kill calculation between two units.</p>


The space time complexity tradeoff
2024-03-09T00:00:00+00:00
I encountered a neat example recently while solving Advent of Code 2015, day 6</a>. The problem can be boiled down to "There is a 2D array of values. Given a range and instruction, apply the instruction to all values in that range. How many values are 'on' at the end?". There are only 2 possible states for each value: on and off, and only 3 possible instructions: on, off, and toggle. I won't focus too much on parsing the input or the structure of the algorithm here, I just want to investigate the hot loop which applies the instruction to each value.</p>


Can you estimate playtime from replay folder size?
2024-01-25T00:00:00+00:00
I've seen this question come up a few times on r/ssbm and while I've given hand-wavey answers before, I find myself in a good place to answer more rigorously now. We can break this question down to more basic ones: "how many bytes of replay data correspond to a single frame of gameplay?" and "how many bytes in the replay are unrelated to frames?". From there, we can estimate a duration by simply translating the 16.667ms per frame to minutes and seconds.</p>


Syntax Test
2024-01-01T00:00:00+00:00
I write my own sublime-syntax files for the syntax highlighting on this site, this page is meant for testing edge cases.</p>