Introduction

The old, somehow abandoned Assembler programming comes to light again: “machine code to machine code and assembler to the assembler.” In the context of re-baselining electronics, particularly developing new CPUs in Europe, engineers and software developers need to familiarise themselves with this niche yet omnipresent technology: every code you write, compile, and execute goes directly or indirectly into machine code.
Besides developing new products and the related need for compilers and tools, the assembler language is essential to generating compact, rapid implementations of algorithms: it gives software developers a powerful tool of absolute control over the hardware, mainly the CPU. To put it a bit tongue-in-cheek, you never know what the future holds. If the machines take over, we should at least speak their language.

Assembler programming applies to specific groups of tasks and algorithms. Using pure assembler to implement, e.g., a user interface is possible but not advisable. Nowadays, assembler programming is commonly integrated with high-level languages and is part of the application's code, responsible for rapid, efficient data processing without higher-level language overhead. This applies even to applications that do not run directly on the hardware but rather use virtual environments and frameworks (either interpreted or hybrid) such as Java, .NET languages, and Python.

It is a rule of thumb that the simpler and more constrained the device is, the closer the developer is to the hardware. An excellent example of this rule is development for an ESP32 chip: it has 2 cores that can easily handle Python apps, but when it comes to its energy-saving modes, when only the ultra-low power coprocessor is running, the only programming language available is assembler; it is compact enough to run in very constrained environments, using microamperes of current and fitting only a few hundred bytes.

This book is divided into four main chapters:

• The first chapter introduces students to computer platforms and their architectures. Assembler programming is very close to the hardware, and understanding those concepts is necessary to write code successfully and effectively.
• The second chapter discusses programming in assemblers for constrained devices that usually do not have operating systems but are bare-metal programmed. As it is impossible to review all assemblers and platforms, the one discussed in detail in this chapter is the most popular: AVR microcontrollers (e.g., Arduino Uno development board).
• The third chapter discusses assembler programming for the future of most devices: the ARM architecture. This architecture is perhaps the most popular worldwide, as it applies to mobile phones, edge- and fog-class devices, and, more recently, to the growing number of implementations in notebooks, desktops, and even workstations (e.g., Apple's M series). Practical examples use Raspberry Pi version 5.
• The last, fourth chapter describes in-depth assembler programming for PCs in its 64-bit version for Intel and AMD CPUs, including their RISC capabilities, such as SIMD instruction sets and their applications. Practical examples include (among others) the merging of assembler code with .NET frontends on Windows. You can find the names of this architecture x86-64, AMD64 or Intel 64. In this book, we refer to it as x64.