Assembly is a low-level programming language that's one step above a computer's native machine language. Although assembly language is commonly used for writing device drivers, emulators, and video games, many programmers find its somewhat unfriendly syntax intimidating to learn and use.

Since 1996, Randall Hyde's The Art of Assembly Language has provided a comprehensive, plain-English, and patient introduction to assembly for non-assembly programmers. Hyde's primary teaching tool, High Level Assembler (or HLA), incorporates many of the features found in high-level languages (like C, C++, and Java) to help you quickly grasp basic assembly concepts. HLA lets you write true low-level code while enjoying the benefits of high-level language programming.

As you read The Art of Assembly Language, you'll learn the low-level theory fundamental to computer science and turn that understanding into real, functional code. You'll learn how to:

• Edit, compile, and run an HLA program
• Declare and use constants, scalar variables, pointers, arrays, structures, unions, and namespaces
• Translate arithmetic expressions (integer and floating point)
• Convert high-level control structures

This much anticipated second edition of The Art of Assembly Language has been updated to reflect recent changes to HLA and to support Linux, Mac OS X, and FreeBSD. Whether you're new to programming or you have experience with high-level languages, The Art of Assembly Language, 2nd Edition is your essential guide to learning this complex, low-level language.

Average Customer Review: ( 35 customer reviews )
Write an online review and share your thoughts with other customers.

First off, what is Assembly Language? It is an attempt to make the actual machine instructions more readable to us humans, back when I first learned assembly language on the 6502, I programmed using hexademical instructions, so for example, changing the background color on the good old C64 would be:

$a9,$00,$8d,$21,$d0

Now, this isn't exactly readable as far as code goes, so later I got hold of an assembler, and the above code was written as:

lda #$00
sta $d021

This was suddenly alot more readable, and generated exactly the same code. Onwards assemblers have evolved, including things like macros, local labels, etc. HLA is one such evolution, it contains for example alot of control structures to avoid the need of labels, but that does not mean that you have to use them. For readability, it's lot easier for you to make a function call as:

Foo(1,2,3);

But if you really want to, you can write the code yourself,
push 3;
push 2;
push 1;
call Foo;

Still, this is exactly the code that will be generated by the above Foo(1,2,3), so it's really just a matter of taste.

Likewise, the high-level constructs such as IF... THEN works just the same way:

if(eax == 1) then
endif

could be written by yourself as:
cmp eax, 1
jne Label

But again, this is the same code that the high-level construct will generate. There are most likely situations where high-level constructs may generate code that could be written slightly more efficiently by hand, but it's entirely up to the programmer to use them or not. For beginners in assembly they are likely a godsend, and for experienced programmers they are simply an option.

Now, valid criticism towards this book is that the focus on HLA, although helpful, may also confuse the beginners, since it detracts somewhat from the low-level fundamentals that is the basis of assembly programming. For instance, although excellently explained, the way the stack operates could easily drown in the information sea of HLA's STATIC, VAR, READONLY, STORAGE sections described in the chapter beforehand, and make it hard for a beginner to grasp.

That said, the book still covers all basics of assembly language, from system bus to the individual cpu instructions.
And if you actually read the book, rather than firing up the examples directly, you'll have a good grasp of what these high level constructs do, and how to write your own code without using these constructs if you so please. And do not believe the above reviews stating that this is C-programming rather than assembly, if your programs consist of nothing but function calls then yes it will look like a C-program, but if your program actually does something rather than calls, you will use mov, and, or, add, sub, inc, dec, mul, div, shl, etc. like in any other assembly program, and these instructions are explained perfectly within this book.

The reason I don't give this book 5 stars is simply that I feel the focus on HLA should be mentioned in the books title, like "the Art of Assembly Language using HLA", since people using other assemblers will have to wade through alot of HLA specific content of which they have very little, if any interest.

73 of 80 found the following review helpful:

A Note From the AuthorOct 10, 2007
By R. Hyde "Assembly Programmer"
Well, after four years of reading these reviews, I thought I'd put in my two cents.

One recurring theme you see in all of these reviews is the following: if someone already knows assembly language, they tend to dislike the use of HLA as the teaching vehicle for learning assembly language. On the other hand, if they're a newcomer to assembly language, they tend to like the approach that Art of Assembly uses. Quite frankly, I wrote "Art of Assembly Language" (AoA) for this latter category, not for those who already know assembly language, so I am rather gratified by the response from those who are actually using AoA to learn assembly language.

When someone sets down to write a book on x86 assembly language, one of the first decisions they have to make is "which assembly language syntax do I use?" The x86 is blessed/cursed with literally *dozens* of different assembly language syntaxes. No matter *what* assembly language syntax I chose, there would have been someone complaining about it. If I'd gone with GNU's as (gas), there would have been complaints about the syntax. Had I gone with FASM, the NASM crowd would have been put off.

Probably the "safe" choice would have been to go with MASM (which the earlier, 16-bit version of the book, used). No doubt, many of the complaints about how I used HLA instead of a different assembly language syntax would have gone away had I done this. The funny part is that MASM is *also* a high-level assembler, having almost all the same high-level control constructs found in HLA. The same is true, by the way, for Borland's Turbo Assembler (TASM). From a language feature point of view, there really isn't much difference between the high-level facilities of MASM, TASM, and HLA. Maybe it's just the name that freaks people out.

Some reviewers have commented that this is the wrong way to teach assembly language. Well, having taught assembly language at the University level for over 10 years, I must respectfully disagree. I've used HLA (before AoA was available) and the students did *far* better in the course. They got much farther along because they were able to apply their HLL programming knowledge to problems early in the course. By the time the course covered the low-level machine instructions, they were doing quite well. The courses I taught with HLA worked *much* better than the comparable courses I taught with MASM. The bottom line is that this teachnique technique has been classroom and laboratory tested. Interested individuals might want to check out my white paper on this subject:

I will make the following observation about AoA: if you already know assembly language, you're probably not going to like the presentation because it's completely different from the way *you* learned assembly and most people seem to think that the only way to learn something is the same way they learned it. On the other hand, if you don't know assembly language and you want to learn it, pay particular attention to those reviews from the people who used AoA to learn assembly language.
Cheers,
Randy Hyde

31 of 33 found the following review helpful:

Excellent book on HLANov 10, 2004
By Jack D. Herrington "engineer and author"
This is truly amazing piece of work on High Level Assembly (HLA). It's important to know what you are getting is a book on HLA because the back cover says, "The most comprehensive guide to assembly language". Which is both hyperbole and factually slightly inaccurate. It's a very, very good book on an assembly language (HLA), but not all assembly languages. Nor should I think there would be a good book that covered all assembly languages, but that's beside the point.

There is some general value in the book that applies to almost any processor. The basics of registers, operations, pointers, the stack and other basics. But as you get deeper into the book it's clear that this is a work on HLA and HLA alone.

69 of 80 found the following review helpful:

Who is this for?Sep 01, 2004
By Nick Veys
I grabbed this book looking for some interesting tidbits. I know a few RISC architectures asm, but never played w/x86, which is what I saw in the flipping through the book. Turns out I didn't flip through it nearly as much as I should have before buying it.

I didn't notice the whole book being geared towards a pseudo-assembly called HLA. High Level Assembly. Looks like x86, but isn't quite. Ok, my fault. So I read on and get a book using a teaching format I personally HATE. The "teach the wrong, but easy way first" then "teach the more correct way later and hope the reader doesn't remember the wrong way" approach. Ugh.

I'm not sure I would recommend this book to anyone. It's expensive and huge, when there are other more compact tomes to learn assembly from.

26 of 29 found the following review helpful:

If you're a beginner, you'll LOVE this bookOct 15, 2003
By James Brodin
I first learned assembly language programming with the 16-bit edition of this book found on the internet. So naturally, I rushed out and bought the hard copy when it became available. My first thought was that "this is not the assembly language I'm used to." This book uses a new type of assembler, a High Level Assembler, for all of the examples. At first, I was completely put off by this approach - it was completely foreign to me. But then I realized that this book was not meant for people like myself who have been programming in assembly for years, instead it was created for people who know a high level language and want to learn assembly. Once I realized this, I began to see this book in a whole different light. The organization is perfect for someone who has a high level language background and is learning assembly for the first time. Although "old-timers" such as myself probably won't find this approach to their liking, I heartily recommend this book to anyone who is learning assembly language for the first time. While I do not have the perspective of learning assembly language using HLA, I am convinced that the author is correct that this is a good approach for beginners approaching the language.

See all 35 customer reviews on Amazon.com