Can you tell an assembly language when you see one?

Assembly programming is nowadays seen as niche at best. And more often than not as needlessly meticulous, demanding, and wasteful even for its niches.

Assembly is hard. It is unfriendly. Programming in assembly language is slow and error-prone. This is conventional wisdom.

Unfortunately, these days this wisdom is mostly nurtured by people who have little or no idea of what modern assembly languages look like. Assembly programming didn’t stay in the 50s, it evolved along with high-level languages incorporating structural, functional, and objective-oriented programming elements. It plays well with modern APIs and DOMs. It is, of course, conceptually low-level but you can build rather high-level abstractions on top of it as well.

In fact, I’m not even sure that anyone can easily tell assembly code from some high-level code without googling. Can you?

Read in full here:

This thread was posted by one of our members via one of our news source trackers.


Corresponding tweet for this thread:

Share link for this tweet.

1 Like

Saw this and thought of you two @ohm and @dwaynebradley :nerd_face:

1 Like

I guessed right and all of them :sweat_smile:

I don’t believe Oleksandr’s conclusion to be right, though.

Assembly programming is not necessary all about processor instructions and registers anymore. […]

It might not be about processor instructions and registers, but it needs to be close. That is the first paragraph from Wikipedia:

In computer programming, assembly language (or assembler language), often abbreviated asm, is any low-level programming language in which there is a very strong correspondence between the instructions in the language and the architecture’s machine code instructions.

So, while some languages can look a lot like an assembly language, an actual assembly language needs to be about instructions and registers.

I wouldn’t want to program in either. :sweat_smile:


1000% with you on this one :joy:


I was writing assembly for the 6502 processor (Apple II and similar computers) back between 1993 and 1996 but truthfully, I don’t care about it at all these days.

Compilers can handle it. Plus there are some super strange gotchas a human couldn’t easily deduce, like it’s actually faster to XOR a register on itself to set it to zero, compared to just… you know, setting it zero directly?

After I stumbled upon several such dysfunctional peculiarities, I gave up.


I played around with 6502 assembly back around 1985-86 while in high school and just went “nope, nope, nope!” :joy: I am really glad that there are folks out there that DO want to dig down at that level though and build it into the compilers that we get to use every day so a HUGE thank you to those folks! 🙇🏻‍♂


The 6502 is so fun though! Now x86, THAT’S a horror, lol.