alt Hacker NewsThe compiler was supposed to end programming too
Comments
Nope; the compiler was supposed to end coding; when the word coding referred to taking an abstract program written on paper and translating it to machine code.
Compilers were first called automatic coders.
The word compiling referred to something more like linking: producing an image containing multiple library routines. In other words, similar to compiling an anthology of works into a book.
After compilers, the word coding to changed to writing program code in any language.
Because the tooling for automatic coding also compiled the bits of code into a larger image, the term compiler/compiling came to be used for the coding part also.
While the terms reshuffled, the concrete reality was simply that people worked less in assembly language, not that fewer people worked or that programming ended.
> The spec and the tests become the source
Sufficiently precise spec is called code. It is the compiler story all over again.
Notably absent from the timeline is visual programming, or Rapid Application Development, think Visual Basic. It was all the rage in the 90s, and for some reason, we don't hear much about it today. We used to make fun of Visual Basic and the people using it back in the days, but the reality is that people with little skill could do something useful. Reminds you of something?
Honestly, I don't really understand why we write so much code today when a lot of use cases can be taken care of using templates and moving boxes into place, "low code" and "no code" never really seem to have taken off as much as they could have. That reliance on code was a boon for LLMs by the way, as text is the thing they have the easiest time working with.
My theory is that every project is unique in some way. As in, my CRUD has a little something that makes it different from other CRUD, and that's why it is valuable. You can't use an off the shelf component because no suitable component exists, and you want code because with code, you can express what you want with precision.
But it is also what limits AI. AI is very good at doing what other people did, but you don't want to do like everyone else, so you have to be very precise in what you are asking, and the most precise way of asking things is to write code.
However, when you really want what others did, then AI is really effective: rewrites, ports, decomp, etc... But this is not really programming, it is at best a translation job, and it will never be as good as the original. To make it better, you need to inject something unique, and for that, the best way to do it is with code. Like the translator of a novel who injects elements of his own culture that go beyond the work of the original author, to make up for what can't be literally translated.
> In 1954, IBM said FORTRAN would virtually eliminate coding and debugging.
Only because Fortran was viewed as transcribing mathematical notation, which wasn’t considered coding. Coding originally referred to having to work with numeric machine codes. Programming languages like Fortran removed the need for having to deal with how to encode the program for a specific machine, and to deal with human errors in that encoding process (debugging). It didn’t mean abandoning formal specifications that you can reason about with a high degree of precision.
I also want to take the opportunity to point out the concept of notation as a tool of thought, coined a quarter century later by IBM fellow Iverson in his Turing Award lecture: https://www.recurse.com/blog/58-paper-of-the-week-notation-a...
> It’s 7:40 on a Tuesday morning in 2031, and you haven’t written a line of code yet. You probably won’t today, and that’s fine.
This sounds exactly like all my Tuesday mornings this year, except that I wasn't at work at 7:40
If you can't see the difference between a compiler and an LLM then that's on you.
LLMs are a game changer in a completely different way than compilers. With compilers there is a (roughly, barring optimizations) 1:1 correspondence between input and output. With LLMs you take an idea and it will drive the whole thing from the beginning all the way to the end.
This is unlike anything that we've done so far. It's also strange to focus on programming: LLMs are coming for all information related jobs. If your job is somehow described as 'staring at a screen' then that job is on the line, if not sooner, than later.
If I write a novel, have someone translate it to French and publish it, that's a compiler. If I hand some brief notes to someone who writes the novel for me, that's the llm. These are fundamentally different things.
[delayed]
We do pretty much just use compilers now though. The last time I read dissassembly to fix an issue was at least a decade ago. Even bytecode I rarely look at.
So you're saying that we'll still be coding, but it will be through talking to our agents and only occasionally we will look at generated source? That seems like a pretty big change still.
>The compiler was supposed to end programming too
Bad analogy. The case with AI is not the same.
This is similar disruption that terminals brought. Before terminals, programming was done in the computer room, it was social gathering, many programmers were women, people were debugging printouts on the floor, punching cards together. Then terminals came and everybody crawled into their dark solitary offices, staring at green or yellow phosphor screens of their terminals. Women didn't like it and left.
Yeah, after some thinking I am starting to realize that Linus' take of AI being like compilers is kind of true.
Vibecoding maintainable code requires providing the LLM a specification. It's still coding, but you now have the liberty of just providing the spec as opposed to worrying about syntax. Since they are non deterministic and love to cheat you still need to review though
I think this is the barganing stage of the grieving process
Yes exactly. LLM-assisted coding is just the next layer of abstraction. This has been happening to computer programming for decades. We've always been in search of a way to program in "natural language"
FORTRAN did eliminate a kind of coding. It didn’t eliminate coders. It made a lot more of them, working on harder problems, and the debugging came along for the ride.
This
There's incidental complexity - the essential parts of the problem.
And then there's accidental complexity - stuff you have to do to solve the problem, plus the make-work because you over-engineered it...
Turns out, typing the code by hand was accidental complexity.
Hmm Fortran example is so positive... It means that in 2090s there will still be programmers hired to understand the code created by AI in 2020s
I begin each day with a video call with my agents as we talk through their overnight work and discuss open issues. This feels like the future.
I’ve been dogfooding my own app, which gives a voice, body, and etiquette instructions to any model. (Mostly claude)
Would love any feedback:
"The agent could write refund code all day long. What it can’t do is decide what your company owes a customer whose card has expired..."
In 2031: Why on earth not?
> my guess at a developer's Tuesday in 2031
Hey that was about my last Tuesday.
--
In 2031 you single-handedly maintain 173 million lines of code making up a simple crud app. You're a good programmer, but the previous guy wasn't, and now there's too much code to make it any smaller. Not even your vastly superhuman LLM feels confident to delete any of the code. So the two of you slog along, keeping the thing alive.
In the hypothetical tuesday, the only actual input from a person was from support. So why are they keeping the programmer around?
It certainly democratized it, LLMs will too.
Is this an article about retro future? Because this is basically part of my work reality. I sincerely hope not to have to review pr's in 2031.
Idk where to start
First, it's a bad comparison. Compilers and LLMs/Agents are not remotely comparable.
Second, the example used for 2031 is already outdated in 2026. There is almost no reason to even use PRs anymore [1, 2], and the example question should be easily answered by an agent that has enough context and planning.
1. https://r.rich/blog/ai-native-change-management 2. https://ampcode.com/notes/thats-not-soc-2-compliant
It did. Programming used to mean manual register allocation, and we don't do that any more.
I'm very bored of non-analogous comparisons. Either it comes from a position of dishonesty of lack of thought, both of which are unacceptable.
I remember the uk papers being full of the Last One ads in 1981.
You can try Utilivox. It's a completely free and 100% ad-free platform with fast financial calculators. No clutter or annoying popups at all.
Can we please stop comparing AI with a compiler?
A compiler takes a programming language as input
float x = 3.1;
Has only one translation into assembly. The programming language is well defined (or it should be). If you try to do
float x = '3.1'; you will get an error
However, the human language is not a programming language. It's open to interpretation "create a variable x and assign it 3.1" is not a well defined programming instruction. Is x a number or a string? If it's a number, what's the precision. Etc.
When I went into software engineering in the early 1980s, several people told me that had no future, since programmers would soon be automated away.
I ignored that, in part because I had no other skill I wanted to do 5 days a week, and it's of course been incredibly rewarding.
This time it definitely is different, and maybe the profession moves into a new and very different era. If SWEs will hit harder times and job losses, I don't think we have much standing to complain, given how many professions we have automated away during the last 50 years...
https//utilivox.com
I also looked into the history of software[1] thought a while ago, and the fact is that, setting aside the determinism of compilers, ultimately no matter what tool comes out, programmers will keep arguing about how software should be built
Looking at history, I think LLMs will settle down too. Because, in fact, if you look at the history of software thought, there were actually many people who would have welcomed LLMs.
[1]https://www.makonea.com/en-US/blog/people-who-build-things-t...
Plus SQL, 4GL and a few others that came out over the years :)
Interesting Read.
Agents are more like employees, compilers are more like calculators.
Except, the lived experience today is that I don’t need to program to do my job anymore, and I say this as an engineer with almost 30 years of experience.
I have a pretty negative opinion about LLM's coding abilities (and predictions about how they will improve). But I don't get a lot out of this type of argument. Compilers created a perfect, deterministic, provable abstraction so that we could have 99% of developers no longer know how assembly works and not suffer any consequences. Humans don't have to give up any control or make any quality compromises to deploy them as widely as possible.
If the author is contending that AI models will improve to a point that they actually make no mistakes while coding, and have that same level of reliability, then they're on exactly the same side as AI doom trolls just wearing a different costume.
[flagged]
[flagged]
[dead]
[dead]
[flagged]
Beware! That blog was created a few days ago solely for marketing AI-written books. (Just check the about site: "Sample introduction · Replace this with your personal bio.")
To be honest, I'd be fine with some AI-assisted writing and might even be interested in reading one of those. The scientific sources seem to be researched well, not hallucinated. But asking the author "Alexander Crespo" under a reddit post, to what extent they used AI in writing, results in them blocking you. Makes me think it is more AI-generated than they wanna admit.