Parsing & Abstractions
You have 2 minutes, go!
Parsing information is interesting. You read something, maybe it goes in your head, maybe it doesn’t. Maybe you didn’t care about it, maybe you didn’t have the appropriate context. Alternatively, maybe you were under a lot of pressure, or a literal timer, and in the midst of trying to understand what the hell is going on, you feel the timer ticking in your stomach, tick tick tick, you’re running out.
What’s the best thing to do for this? How does one decide what’s the best level of abstraction to approach this understanding and problem solving? Especially in my work, you need to understand what’s happening quickly. I enjoy this process, I thrive in it, I become focused. Beforehand, you can spend some time systematizing things, automating things, but nothing beats manual hand-to-reality contact, at least at first. Otherwise, you miss the point. You abstracted too quickly, lost the plot of what you were supposed to be dealing with.
Deciding on the right level of abstraction for a problem is hard. You don’t know what you might need in the future. It’s a constant problem for not only programming, but anything that has contact with reality. You design your systems with future changes or refactoring in mind, yet you still need to be quick, not waste time. Things you first thought might be useful might no longer be. What you thought would help you quickly grok the codebase ended up being harmful. You still need to be fast, go go go.
I remember the first time I was shown https://grugbrain.dev/ . I loved it a lot, it gets across the idea of defeating the complexity demon by all means necessary, and as the systems get more complex, once you get how to bottle the complexity, things get so much better. It still pops into my brain occasionally even for unrelated work. It’s very useful advice. I sometimes fantasize about how it could be applied to running governments, how one might make things more efficient. Emphasis on fantasize.
Iterative vs recursive. Figuring out the best approach, how to deal with these computational graphs, these weird DAGs, sometimes you need to loop back, often you need to get good by practice. More and more practice to figure it out. Maybe you will, maybe you won’t.
Abstractions. Interfacing with your brain. Nontrivial all of it. Until LLMs get properly good, and they’re nearly there, you still need to figure out how best to approach the complexity demon. They still use the context you give them, and without it they still do silly things you can avoid as long as you have the systems mindset in mind. You basically need to workshop it for them, and they can end up doing it well afterwards, but you still need to get them to understand what exactly it is you want.
And what do I want? Man, I want to just get good. Get the right abstractions, the right things that are needed. Let’s get good. Let’s grok the things we want to grok.