Importance of Assembly Language - What Have I Learned?!

 Assembly Language

Why is this an important language to learn and how does this help in software optimization?


If you're curious why learning Assembly Language in 2025 is no less important than learning all these modern high-level programming languages, you're right where you need to be. As you continue to read on this content, you will understand the reasons why I believe Assembly Language is worth learning!

What is Assembly Language?

Assembly Language is a machine-learning or a low-level programming language that allows you to write programs that can run directly to your Central Processing Unit (CPU); in other words, Assembly Language is just a human-readable mnemonical instructions that allows you to speak to your machine.

Assembly language is platform-dependent, meaning instruction sets may differ depending on your computer's architecture. This language can give you direct access to memory, allowing a better control over your CPU.

Take a look under the hood...

Although Assembly language may be difficult to learn especially when you are used to high-level programming, it is still useful to understand the underlying architecture and how the CPU works. Just imagine when a car breaks down, the only way to fix this is by taking a look under the hood. Being able to drive does not give you full control over your car; but if you want an engine tuning or modification such as improving your engine's exhaust systems or increasing your engine's power, the ability to drive is not sufficient to upgrade your car's performance - just like the learning low-level programming, you will gain flexibility in display control and a more specific data handling!

What have I actually learned?

All thanks to my experiences with our course labs, I have learned various instructions, the concepts of the Assembly Language, CPU's architecture, stacks, registers and conditional instructions. Below are some of the highlights I learned from experiences:

Stack: Assembly follows a First In, Last Out (FILO) stack mechanism. Everything works around the stack pointer. You would need to use mnemonical instructions give instructions to the CPU to control data that is stored temporarily in a memory.

Registers: These are small memory storage areas within the Central Processing Unit (CPU) that are used to store data temporarily.

Mnemonical Instructions: Abbreviated human-readable English words that allow you to specify instructions to run to directly to your CPU.

Is it worth it?

Learning Assembly Language is absolutely worthwhile, as it has given me a better understanding of how programming interacts with the hardware particularly a computer's CPU. As a result, I am now able to explore various ways to optimize my code and find ways to improve its speed.

As I continue learning this language, I am thrilled to deepen my understanding of low-level programming!

References:

(i) https://www.lenovo.com/au/outlet/en/glossary/assembly-language/

(ii) https://www.spiceworks.com/tech/tech-general/articles/what-is-assembly-language/#:~:text=This%20is%20a%20simple%20example,over%20the%20hardware%20is%20necessary.




Comments

Post a Comment

Popular posts from this blog

BATCH 3 | Project Stage 2, Part 3 - Cloned Functions Comparison and Reflection

Image
 Project Stage 2 - Part 3 Cloned Functions Comparison and Reflection Hello everyone! Welcome to Part 3 of this project. If you missed out on the first two parts click the following link down below as they include important details of this project: 1.  Project Stage 2, Part 1: Initial Creation of Clone-Prune Analysis Pass 2.  Project Stage 2, Part 2: Testing, Errors and Fixes Let's Dive In! The purpose of this blog post is to see a comparison between the cloned functions. Let's take a look at the evidence as to why my clone-prune analysis code works by diving into the scale_samples functions where you will find these identified cloned functions being substantially the same in clone-test-prune and being different in the clone-test-noprune files. These clone test files were provided for us and were not created by me.  Clone-Prune Test Files To start, lets take a look at the object dump files for clone-test-prune. As you notice, the functions scale_samples.default, ...
Read more

Lab 01 - Experiments, Calculating Performance and Modifying Code

Image
LAB 01 - Experiments,  Calculating Performance and Modifying Code Hi there! Thank you for taking the time to check out my page.  This blog post will contain some insights derived from experiments and performance calculation outlined in our Software Portability and Optimization course.  Take Note... Just before we dig deep into the experiments and calculations here are the following definitions of the instructions used all throughout the experiment: lda ( Load Accumulator with Memory ): transfer data into the accumulator from memory sta ( Store Accumulator in Memory ): stores data from accumulator to memory ldy ( Load Index Register Y From Memory ): loads the index register Y from memory iny ( Increment Index Register Y By One ): adds 1 to current content in register Y bne loop ( Branch on Result Not Zero ): conditional branch that tests Z flag and loops if Z flag is not on. inc ( Increment Memory By One ): this adds 1 to content in the memory location ldx ( Load Inde...
Read more

BATCH 4 | Clone-Prune Analysis Code Pass On Both Architectures

Image
Clone-Prune Analysis Code Pass On Both Architectures  Pass Works On x86_64 and aarch64 Architectures In this post, I’ll be sharing screenshots of the pass running on the x86_64 architecture. Previously, I focused only on the results from the aarch64 architecture in earlier blog entries. To start, you see a screenshot of my pass successfully built without fatal errors: The steps I took to implement pass on architecture: 1. Created a Clone-Prune Analysis Code Pass on x86_64 architecture. 2. Declared pass factory under tree-pass.h by adding this: opt_pass *make_count_pass(gcc::context *); 3. Registered the pass in passes.def by including this: NEXT_PASS (make_count_pass(g)); 4. Rebuilt the gcc by using make command: time make -j $(($(nproc)*3/2)) |& tee build.log Final Code Used: #include "config.h" #include "system.h" #include "coretypes.h" #include "backend.h" #include "tree.h" #include "basic-block.h" #include ...
Read more