products | blog

about

smalldose is a human-centered software development firm, focused on building the next generation of “personal” computing applications.

productstop

blogtop

Forms of emergence in software

2024-10-24 by Alonzo

Emergence refers to when complex behaviors or systems result from simple rules. To me, emergence is one of the most fascinating things to contemplate. The most religious I get is aweing at the complexity that comes from our universe’s mathematical and physical laws. Here I’ll focus on a form of emergence even closer to my heart though; emergence in software.

I grew up playing video games wondering how they work. Although I didn’t know anything about computers, these programs seemed simple in construction but complex in the things they let me do. For example, a game like Super Smash Bros has a limited number of characters, moves, and stages, yet the game feels oddly infinite. In this way, looking at the game at a sufficiently abstracted level, Super Smash Bros is pretty simple relative to what it lets you do. I didn’t conceptualize it in this way when I was a kid, but I was enthralled by this and it led me to start programming.

Programming is an inherently emergent activity. You take a finite and knowable set of instructions and can make a vast set of things. I’m not generally writing machine code, so there’s many layers of abstraction to what I’m doing, but I’m still extracting more from my code than is baked into any layer of its underlying definition.

Using code, you can create systems that are directly and obviously emergent in nature, even for the designer. For example, you can run Conway’s game of life. You may know the building blocks that go into it, but the system grows complex either way. From the user perspective, all software exists on a spectrum from simple to complex, and that complexity to them can be thought to come from a simple unknown black-box.

Let’s say you build a system where every part is hopefully completely known to you, like a calendar app where you can add events to days. From a user perspective, the black box seems to have simple rules, and things you can do are open-ended but simple. On the other end of the spectrum exists systems like some games, where your actions may be totally unpredicted by developers. The rules of Minecraft seem simple, but you can do so much. The creators of Minecraft may be able to say what kind of actions you take, but they cannot describe exactly what you’ll see in their system.

It’s fun to think about how these layers are connected. We live in an emergent universe, where we’ve built emergent programming tools, which help us build emergent products. When building software, no matter how complex the parts of your black box are, it can be valuable to hook into this pattern of simple rules that lead to unbound behavior. In that way, you can meet your users at the level of abstraction that they’re at and you can appeal to their very nature.

—

Using ChatGPT to study for technical interviews

2024-10-23 by Alonzo

It’s great to mock interview with humans, but it takes a while and can be a lot to ask of your friends to do it repeatedly. Today I forewent fleshy friends, and did a mock interview by myself using LeetCode and ChatGPT. Although there’s no back and forth in my method, ChatGPT was able to give me useful concrete suggestions. It was even able to accurately nitpick small but important parts of the way I communicated certain things, despite the pretty bad speech-to-text transcription I gave it.

Here’s how I did it:

1. Opened a Google Doc on my phone and started recording speech-to-text. As long as your phone stays open, this will continually record your talking.
2. Opened LeetCode and chose a problem (Medium).
3. Gave myself 30 minutes on a timer.
4. Solved the problem, talking through it like I would with an interviewer, albeit a cold and silent one.
5. Stopped recording and pasted my solution, the problem definition, and my time remaining in the doc where I did the recording.
6. Added a prompt at the beginning explaining that I want it to pretend it’s a software engineer at a top tech company and it’s conducting a technical programming interview with me.
7. Sent this bundle of info to ChatGPT.

ChatGPT said I did a few things well: Problem Understanding, Recursive Approach, Edge Cases, Correct Logic, and Good Use of Time. More importantly though, it helped me pick up on a number of things I wouldn’t have thought of myself: Code Readability, Clarifying Your Thought Process, Error Handling and Debugging, Handling Larger Input, and Consider Iterative Approaches. Its advice wasn’t perfect - its suggestion for Code Readability didn’t consider boolean shortcutting and was slightly suboptimal. But for others, like Clarifying Your Thought Process, it gave great feedback on a key part of the problem I didn’t explain well.

Overall, I think it did best on analyzing the soft elements of the interview. Based on this one test, I wouldn’t lean on it to give deep technical advice, but it really nailed the “language” part of the assignment. This is what’s really hard to practice alone anyway, so I mark this a win and I’ll probably try it again.

A few improvements I think would be interesting: timestamp the speaking, include in-progress code snippets at key moments, better capture vocal ticks (speech-to-text didn’t record my many “ums”), and preprocess the speech-to-text transcript with an LLM to clean it up.

—