Why Learning Assembly Language Still Matters

Why Should You Learn Assembly Language?

It’s worth learning assembler if you want to:

• Understand how computer programs work, delving into details at all levels, down to machine code.
• Develop software for tiny embedded systems, such as 4-bit microcontrollers.
• Grasp what lies beneath the hood of high-level programming languages.
• Create your own compiler, optimizer, JIT runtime environment, virtual machine, or something similar.
• Explore, debug, or secure computer systems at the lowest level. Many security vulnerabilities only surface at the machine code level and can only be addressed from this level.

There’s no need to learn assembly language if your goal is to speed up other programs. Modern optimizing compilers handle this task very effectively, and it’s unlikely you’ll beat them.

Who Produces the Best Assembly Code?

Why is it nearly impossible to outperform a compiler? Consider this: it’s obvious that you can’t beat a computer at chess, even if you play better than the creator of the chess program. The same applies to optimizing compilers. However, instead of playing with chess pieces, an optimizing compiler operates with contextual factors.

In modern processors, almost nothing that affects performance can be discussed in isolation from context. The same combination of a dozen assembly instructions can execute at drastically different speeds (thousands or even millions of times faster or slower), depending on a wide array of diverse factors.

1. Are the data you’re accessing currently loaded in the cache or not? How about the assembly instruction combination itself?

2. If neither the data nor the code are in the cache, is the processor quietly moving them there, assuming that they will be accessed soon?

3. What instructions were executed immediately before our current sequence? Are they still in the pipeline?

4. Have we reached the end of the current virtual memory page by any chance? Because, heaven forbid, half of our instructions might end up on a new page, which, just our luck, is currently swapped out to disk. But if we’re fortunate and the new page is in physical memory, can we access it through the TLB buffer? Or will we have to navigate to it using the full address and page tables?

5. Are all the necessary page tables loaded into physical memory? Or have some of them been swapped out to disk?

6. Which processor is executing the code? A budget i3 or a powerful i7? Sometimes budget processors have the same instruction set as powerful ones, but advanced instructions are executed in several steps rather than in one.

And all of this is just the tip of the iceberg—a small part of what you’ll need to consider and analyze when trying to outsmart the compiler.

There is a myth that programs written in assembly language run ten times faster. This myth dates back to the 1970s when compilers generated code so inefficiently that every respectable programmer had a blacklist of forbidden language constructs.

When our colleagues from the past were writing programs, they either kept this blacklist in mind and refrained from typing problematic constructs, or they set up a special preprocessor that converted the source code into a lower-level, trouble-free representation in the same language. Fifty years have since passed. Compilers have matured, but the myth remains.

Even today, you might occasionally come across a rare individual who can write code faster than a compiler. However, it takes them so much time that it’s hardly practical. Additionally, to optimize like this, you’d need to know the entire set of processor instructions by heart.

Additionally, since you’re manually refining your code, there’s no compiler to back you up or help catch the bugs that you inevitably create while writing a program.

Furthermore, your assembly code will be non-portable. This means that if you want your program to run on a different type of processor, you will have to completely rewrite it to create a version tailored to the instruction set of that other processor. Naturally, you will also need to be thoroughly familiar with those instructions as well.

Ultimately, you will spend dozens or even hundreds of times more time than if you had relied on an optimizing compiler, and the result will most likely be slower rather than faster.

Sometimes, an optimizing compiler generates assembly code with seemingly incomprehensible logic. However, don’t be quick to blame the compiler for being inefficient. Let’s examine an example.

When you write something in C like x = a*2 + b*3, you might naturally expect to see an assembly instruction that multiplies the variable a by two. However, the compiler knows that addition is cheaper than multiplication. Therefore, it doesn’t multiply a by two but instead adds it to itself.

Moreover, when looking at b, the compiler might determine that b + b + b is preferable to b*3. Sometimes, triple addition is faster than multiplication, and sometimes it isn’t. In other cases, the compiler might conclude that computing (a + b)*2 + b is faster than the original expression. Or even ((a + b)<<1) + b.

If x is used only once and in conjunction with a couple of lines of subsequent code, the compiler might not compute x at all and simply substitute a*2 + b*3 in place of x. Even if x is used and the compiler encounters something like y = x – b*3, it can optimize these calculations to y = a + a, marveling at your extravagance in terms of computational complexity.

Thoughts like these inevitably lead you into a complex maze of alternative options. You need to evaluate all of them to choose the best one. However, even after doing this, the assembly code generated by the compiler is likely to run faster than yours.

By the way, if you’re using GCC or Clang, enable the optimization options for SSE, AVX, and any other features your processor supports. Then sit back and be amazed as the compiler vectorizes your C code in ways you never imagined.

What Programs Can’t Be Written in Assembly?

There aren’t any. Anything that can be done on a computer can also be done using assembly language. Assembly language is the textual representation of raw machine code, into which all programs running on a computer are translated.

If you wish, you can even write a website using assembly language. In the nineties, C was quite a reasonable choice for this purpose. By using something like CGI BIN, a web server could invoke a program written in C. The website received requests through stdin and sent results back to the browser via stdout. You can easily implement the same principle in assembly language.

Why would anyone do that? You must be a masochist to go through such an ordeal. When you’re programming in assembly language, you encounter these kinds of challenges.

• Your productivity is lower than if you were working with a high-level programming language.
• Your code lacks any structure, making it difficult for other developers to read.
• You’ll have to write a lot of lines. And where there are more lines, there are more potential bugs.
• The state of Secure Coding here is quite bleak. Writing secure code in assembly is the most challenging. In comparison, coding in C makes you feel much more at ease in this regard.

Yes, everything can technically be written in assembly language. However, it’s not practical today. It’s better to write in C instead, as it’s likely to be safer, faster, and more concise.

Of course, knowing assembly language gives you a significant advantage over programmers who don’t. But before exploring those advantages, remember one simple thing: good programmers know assembly language, but almost never write in it.

What Advantages Does Assembly Language Offer Programmers?

To write efficient programs (in terms of speed and resource conservation), you need to understand the assembly language of the hardware you’re targeting. Knowing assembly language helps you see beyond the apparent simplicity and conciseness of high-level functions, allowing you to understand what each function ultimately becomes: either a couple of assembly instructions or a lengthy sequence intertwined with loops.

If you work with high-level languages like C, make sure to learn how to read and understand assembly code. Even if you don’t see yourself writing in assembly anytime soon (and honestly, not many do), having knowledge of assembly will be beneficial.

Being proficient in assembly language can be a great asset for debugging. By mastering assembly, you’ll gain an understanding of what happens under the hood of high-level languages, how computers execute tasks, and why a high-level compiler sometimes doesn’t behave as expected. You’ll be able to identify the roots of these issues and understand how to fix them.

Sometimes, you just can’t figure out what’s causing a bug until you go through the assembly code step-by-step in a debugger.

Here’s a subtle hint: some employers like to see the word “assembler” on your resume. This tells them that you’re not just skimming the surface, but are genuinely interested in programming and digging deeper.

Should You Start Learning Programming with Assembly Language?

There are benefits to learning programming from the ground up. However, assembler is not the very bottom. If you want to start from the very basics, begin with logic gates and digital electronics. Then, experiment with machine code. Only after that, dive into assembler.

From time to time, you might feel like you’re dealing with nonsense. However, you’ll gain valuable knowledge for your future career, even if it involves only high-level languages. You’ll learn how exactly a computer performs the tasks it does.

However, I wouldn’t recommend starting with assembly language and lower-level layers. Everything mentioned in the previous two paragraphs is easier to understand when you start with a high-level language. This way, you’ll achieve the desired results faster than you might lose interest.

At some point, you really should get acquainted with assembly language, especially if you’re programming in C. I doubt that you can become a well-rounded C programmer without knowing assembly. However, starting with assembly is not recommended.

How Does Knowing Assembly Make Learning Other Languages Easier?

Assembly language is vastly different from high-level programming languages. Therefore, the saying “The experience you gain in one language can be easily transferred to another” doesn’t hold true for assembly language.

If you start with assembly language, after mastering it and deciding to learn a new language, you’ll have to start from scratch. I remember a classmate from school who learned assembly, wrote a game, and won a competition with it. However, he struggled to get comfortable with C when we were in university.

What sets assembly language apart from high-level languages? In assembly, variables are simply memory locations. There are no int or char data types. There are no arrays either!

In this context, you’re dealing only with memory, and it’s not like working with a high-level language. You might place a string in a certain memory area, forget about it, and later access it as if it were a number. The program will still compile, but it will crash at runtime, and it won’t be a gentle crash with a polite error message.

In assembly language, there is no do..until, no for..next, and no if..then. Instead, it only provides comparison operations and conditional jumps. Strictly speaking, there aren’t even functions.

However, by studying assembly language, you’ll understand how functions, loops, and everything else are implemented. The difference between passing a parameter “by value” and “by reference” will become self-evident to you. Additionally, if you program in C but struggle to fully grasp how pointers work, learning about registers and relative addressing will show you that understanding pointers is not difficult at all.

It’s best to start with C. It’s a convenient language for learning the basics: variables, conditions, loops, logical structures, and more. The experience you gain from studying C can be easily transferred to any other high-level language, whether it’s Java, Python, or another one. Also, understanding assembly language becomes easier once you have a grasp of C.

Is Knowing Assembly Language Programming Profitable?

If you visit HH.ru, you’re unlikely to find any job listings with the word “assembler” in the title. However, every now and then, a company might be urgently seeking a wizard-like expert who understands the inner workings of computers so profoundly that they can dominate the operating system at will. An expert who can (1) patch the system without access to the source code and (2) intercept and manipulate data streams in real time.

Some of this deep magic—though the need for such magic is becoming increasingly rare—can only be implemented in a very low-level programming language.

I heard about a company that is looking for someone to develop a new platform for high-frequency trading. The idea is that if you receive market data faster than your competitors and make decisions quicker, you can rake in enormous amounts of money.

“When you’re dealing with quotes that have to pass through the entire TCP/IP stack, it’s too slow,” says the team from this firm. That’s why they have a solution that captures traffic at the Ethernet level, directly within the network card, which is equipped with customized firmware.

These folks have taken it a step further. They’re planning to develop a device for filtering Ethernet traffic using FPGA. Why? To capture stock quotes at the hardware level, thereby saving precious microseconds of trading time and ultimately gaining a slight, very slight edge over competitors. C language wasn’t suitable for them. Even assembly language didn’t fit the bill. So, these guys are essentially etching their program directly onto the silicon!