Counterpoint: I picked it up in high school and I was Not That Bright(tm).
Certainly, some complex instruction-set extensions or sprawling SIMD mnemonics are more challenging that what I was reading in the 90s, but the boogie-man status of assembly is greatly overstated.
The final thesis, that we can-and-should let LLMs micro-optimize assembly into non-statically-verifiable gibberish to save an instruction stacks misunderstandings on top of misunderstandings. Just vapid gold-rush cheer-leading from Wired.
Somehow it got fantasized as being hard.
I would go a step further, eventually we might be able to compile directly from high level prompts into Assembly instead of the high level languages like everyone is doing now.
It is the new coming of CASE tools, just needs to mature a bit more, lets see how far this AI cycle goes.
I am currently only using the core ISA (no compressed instructions, not even the pseudo instructions), and I use a C preprocessor to avoid to get my code locked on the preprocessor of one assembler.
I started to code assembly when I was a teenager as it is not hard: only uncomfortable. Nowdays, with what seems a real global, no IP locks, ISA, RISC-V, it is very reasonable to write directly assembly, as (real and sane) standard assembly is extremely efficient at fighting planned obsolecence.
Only thing which I have come up with is just step through the instructions on the MCU using compiled output from yarpgen, but problem here is that it wont generate code variable enough to test all the instructions, so there are going to be blind spots like i.e. float divisions, SIMD instructions etc.
As for the idea that AI can optimize code better if we give it assembly code, that's called a peephole superoptimizer, and we've known about it for quite some time ([1], which cites the first relevant paper as being from 1987). It's not new, and it's actually been used to improve the peepholes of compilers for quite same time now. The main limiting factor is probably in our ability to prove correctness of the code generated by search algorithms.
[1] https://www.cse.iitm.ac.in/~krishna/courses/2022/odd-cs6013/...
IMO the utter lack of awareness that our abstractions represent a physical machine with real hardware that operates in finite time is why software today is so bad. Our languages are so far removed from the hardware that the CPU and its finite resources simply don't exist for most programmers. Many of the rising generation of engineers have no clue how a CPU works, what a register is, or what the cost of reading and writing to RAM is.
Assembly is not so difficult as to be unapproachable for beginners. Remember, back in the day we all started in assembly and produced a generation of absolutely brilliant engineers and scientists. We all had to understand the physicality of the real machine and we had to make the best we could with very constrained resources.
I'm not a great programmer and don't code full time, but I've done a bit of that 8bit assembler and enjoyed the relatively finite single-focused determinism of it, but I don't know if it has improved my current coding at all.
I suspect doing some Linux systems coding in C might have a bigger effect on connecting the dots between the layers for me.
I am not sure if this is true, given that this is college education and some of the easy part of CS, which is even taught just for fun to (non-CS) engineers.
“It was probably just his imagination, but the display had been a little laggy, he thought. He’d redo the code if he could, he said. But alas, Sawyer and the machine did not speak the same assembly language.”
There's nothing insane about writing games or other programs in assembly language. It takes longer than writing them in C or JS, sure. Debugging them becomes more difficult. Sometimes you can achieve results that way you can't achieve in higher-level languages. But it's not some kind of superhuman wizardry. Assembly language is actually simpler than the higher-level languages. Virtually all videogames for the Nintendo were written in assembly. People have written entire operating systems in assembly.
It's not "brutal". It just takes longer, that's all. People like to set up hierarchies of languages based on what's more difficult, but I think that's kind of juvenile: teenage boy one-upmanship. Solving puzzles is fun, but anybody can learn to solve them.
Assembly-language programs can be beautiful. So can programs in any language. Usually they aren't.
Almost always it involves carefully reading documentation, triple checking everything, mentally imagining the state of the processor, especially concerning whether interrupts can occur or what they would cause.
Having done it a couple of times I, for the first time, really appreciated the abstraction of e.g. C. It made writing code and reasoning about it a lot easier. To be honest, I really dislike the mystique it gets in some circles. In the end it is just another programming language, which just consist of many very small details and limited abstractions.
What I have no doubt about, is that abstractions around Assembly will continue to exist. Maybe LLMs will be really good at writing high performance assembly, but still it will not be something humans really interact with.
helsinkiandrew•3mo ago