.png)
This most recent meetup, we gathered in Blue Ash for another Code Craft Community meetup, better known as C3. If you’re unfamiliar with C3, the idea is simple: software developers of all skill levels get together to practice coding together, usually through katas, pair programming, and spirited discussion.
This month’s session leaned a little more philosophical than usual. The core question we explored was:
Is the evolution from low-level languages (like assembly) to high-level languages (like Java) similar to the evolution from high-level languages to natural language (like English)?
It sounds abstract (and it was), but we grounded it in a concrete exercise.
The Assay: A Simple Spec, Three Levels of Abstraction
To explore the question, we worked through what we called the Assembly Assay. The spec was intentionally arbitrary and deceptively simple:
Given input from a user in a predefined format (name, birthday, and some punctuation representing mood), print those characters in order.
For example:
Matt Kuhn, 03/18/1993, ???
Edsger Dijkstra, 05/11/1930, !!
The task wasn’t what the program did; it was how the experience of implementing it changes as you move across layers of abstraction.
We approached it in three phases:
- Natural Language
Participants prompted an AI to “do the thing” in plain English. We cleared context, tried again, tweaked prompts, and observed how ambiguity, inference, and assumptions crept in. Questions like:
- Did the AI ask clarifying questions?
- Was the output consistent?
- Why did we feel compelled to refine the prompt?
- High-Level Language
Next, we implemented the same spec in their language of choice, Java, JavaScript, C#, and others. Then we had the AI write it. Then we cleared the context and asked again.
This is where subtle questions about the spec itself started to surface. What exactly counts as “input”? Who owns validation? What assumptions are we making without realizing it?
- Low-Level Language (C and Assembly)
Finally, we dropped down the abstraction ladder. Writing the program in C, and especially in assembly, forced the spec to become painfully precise. Things that “just exist” in higher-level languages suddenly required explicit decisions. Memory. Buffers. String termination. Control flow.
What Jumped Out (For Me, at Least)
On the natural language side, the AI produced different results each time you prompted it (as expected). I was legitimately surprised, though, at the range of ways it interpreted the “in order” specification, ranging from “the order that the characters appeared in the input” to “each character now gets its own line”.
What I didn’t expect was how shocking it felt to confront the sheer volume of responsibilities that high-level languages quietly shoulder on our behalf. One example that stuck with me was string termination. I never considered how a program “knows” when a String ends. There are a few conventions, but the prevailing solution is null-termination. Running into this issue opened the door to a broader insight: abstraction isn’t just about convenience; it’s about policy. High-level languages encode decades of decisions about what “sensible behavior” looks like. Natural language does the same, but with far more ambiguity and far fewer guarantees.
Having now confronted the apparent “knowledge loss” that has occurred at the assembly-language level, we wondered if there is an imminent “knowledge loss” concerning even the high-level languages. What might the impact of that look like? Will it someday be considered a niche specialty to even know Java one day, as it is today considered a niche specialty to know assembly?
Why This Matters (Especially Now)
I hope attendees walked away with something like an engineer’s mindset toward natural-language programming.
Not the conclusion that it’s “good” or “bad,” but an appreciation for its tradeoffs:
- Power vs. precision
- Speed vs. determinism
- Convenience vs. control
Natural language, high-level languages, and low-level languages all solve different problems, and they all fail in different ways. Understanding why is part of growing as an engineer.
Join the conversation
If you’re interested in conversations like this:
Join our Discord to stay connected between sessions and come to the next C3 meetup to build, question, and learn alongside the community!
We host C3 regularly at our new Blue Ash office, and new faces are always welcome.
