Customer Reviews

The Art of Assembly Language

5 star:		(22)
4 star:		(4)
3 star:		(2)
2 star:		(4)
1 star:		(3)

 

 

Some of the above reviews have claimed that this book does not teach "real" assembly language, and that it uses 'c'-like wrappers instead of pure assembly instructions. This is a misconception most likely caused by these reviewers lack of knowledge, and/or failure to read the book of which they have submitted a review.

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.

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

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.

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.

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.

The author seems adamant that learning assembly using HLA is the best way to go. He is entitled to his opinion. I only wish the title of the book made this explicit.

I am an experienced programmer looking to learn x86 assembly.
(1) When you run WinDbg on executable code and encounter a crash, the debugger displays x86 assembly, NOT HLA. The fact that there are several chapters in this book dealing with HLA before one comes across a pure x86 assembly chapter was a huge disappointment.
(2) The INTEL manuals describe instructions in x86 assembly, NOT HLA.

So I am supposed to read several chapters in the book dealing with HLA macros before I learn true assembly?

This book was a disappointment to me and I consider the money spent to be a waste. There are other assembly books available that teach true x86 assembly right from the start. Sure, there are concepts like text output which are difficult for a beginner to understand, but the other authors provide libraries that abstract away the details while still teaching true x86 assembly.

In fact, given that there have been quite a few reviews through the years stating that readers found the title misleading, the author should have renamed the upcoming edition to "The Art of Assembly Language using HLA" to clarify the contents of this book.

I will call it unfortunate for not reading the reviews on Amazon before buying this book. As another reviewer Nick Veys said "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." And as someone else said, it really is the art of High Level Assembly language. Both are absolutely true.

That was the real problem I faced after going through a few chapters. And when we reach the 7th chapter, the author says "This chapter discusses "pure" assembly language control statements...".

There it is, if you are looking for the traditional assembly language, this book is not for you. This book deals with something called High Level Assembly. And if you want to know what this HLA is, this is the right book for you. If you have any prior programming knowledge with any of the high level language, then better you avoid this HLA and proceed directly to some `pure' assembly. Because, the path you are taken to the assembly is through some `nor-assembly-nor-high level' kind of all new language. The author's intension is not to cheat you, but to teach you assembly. And at the end there will be lot of stuff you don't want to keep in your head but you could not help but to keep. This problem arises because, to teach assembly, the author uses two medium; one, the English language and the other, a new computer language.

I won't recommend this book for those who want to learn assembly (not HLA) straight away (and not through another computer language).

But, if you are a HLA fan, assume that I have given 5 stars.

A year ago I grabbed a copy of Jeff Duntemann's Assembly Step By Step book. I was very disappointed with the fact that his book concentrated on 16-bit DOS programming and, frankly, didn't teach very much assembly language. I'd heard of Randall Hyde, anyone who wants to study assembly and searches on the internet for information on assembly has heard of this guy. He has quite a reputation as an "assembly guru". So I got a copy of The Art of Assembly Language. The thing I like about The Art of Assembly is that it gets you programming right away. I don't want to read a couple hundred pages before I can do anything useful.

This book concentrates on writing console applications in assembly language. The advantage to this approach is that console apps are easy to write and are portable between Windows and Linux ('portable assembly'! Who woulda thunk that?) At first I was disappointed that this book doesn't cover graphics under Windows. However, the CD-ROM that accompanies the text contains several hundred additional pages of documentation (in PDF and HTML form) that talks about Windows programming in assembly language; the author's web site contains even more information about Windows programming. As that material is a bit complex and lengthy (almost as many pages as the 900+ pages in The Art of Assembly Language) I can understand why it didn't appear in this book in the first place.

If you've got Assembly Step By Step by Jeff Duntemann, you'll definitely want to get a copy of this book. It's a great follow-on book to Assembly Step by Step. If you don't have Assembly Step By Step, I'd recommend going straight to The Art of Assembly Language, it covers lots more material, the information density is higher, and the signal to noise ratio is higher. Duntemann claims his book is for beginners who don't know any programming languages at all, whereas The Art of Assembly expects the reader to know at least one high-level programming language. So if you're trying to learn assembly language as your first programming language, you might want to choose Assembly Step By Step; on the other hand, if you already know a high-level language like C or Visual Basic, you'd probably do better with The Art of Assembly Language.

I started reading assembly language by looking at object output from various C compilers. I learned a fair amount by writing gradually more complex programs and reading the corresponding assembler. But eventually I wanted a concept-driven perspective to help me understand more of the whys and wherefores. So I turned to Randall Hyde because I'd read two other books of his, Write Great Code: Volume 1: Understanding the Machine and Write Great Code, Volume 2: Thinking Low-Level, Writing High-Level. Vol. 2 inspired me in particular because its contents matched the subtitle well, and the book led me in a very likely direction for my interests.

I blithely assumed Art of Assembly would take things a step further, but it is not that book. It covers High Level Assembly, a software package of Hyde's invention that probably makes it easier for high-level language programmers to adapt to assembly code. The reader could learn enough HLA, Hyde proposes, to write low-level assembly directly. I think this point is questionable, and easily lost on some number of readers who are drawn in by the title. Not because it can't be done, but because most people adopting technologies on the go don't have the time or the need for small first steps into a complex, technically demanding topic. And why would you do this with HLA anyway, when you could immediately start doing this with C and the proper compiler switch?

The technical discussion is sometimes overwrought, as if to assuage the nervous reader that things are ok. I found this style distracting, sometimes to the point of irritation. The technical understanding expected also appears quite uneven, as if much of the book was cobbled together from technical notes with lots of brainstorming marginalia. One minute we're looking at each element of a simple HLA program, then adding and noting unsurprising "new concepts." The next minute we're reading a very brief overview of the Intel 80x86, then a table of acceptable operands to the mov instruction. Then back to HLA and its control structures. Where are we going? The question came up more than a few times for me throughout the book.

This book could benefit from some sentence editing and section re-ordering, yes. But it mostly needs a clear, singular vision on teaching the subject at hand, and principles to guide that vision with exceptions only when straying off-course is the only way to make an essential point.

I think the bulk of objections I have read from others could be removed by two means. One, clarify who the audience really is. It can't be both serious programmers and people who need to be told where the Start button is on a Windows machine, or how to get to a command-line console. If the book is meant to address someone with non-academic experience on a computer, why not start with object code they can generate with a simple compiler switch? To me that's much easier that learning a sugaring language, then eventually working one's way down an arguably broader path. Two, call this book what it is: it is a guide to learning HLA. That really belongs in the title of this book.

I'm on a quest for a good book about assembly. I teach reverse engineering classes and many of my students ask what the best way to learn assembly is. Some day a decent book on Intel Assembly will be written, but that day is not today. Skip this book if you want to do anything mildly resembling real-world assembly. Paul Carter has a much better assembly book that is freely available for download. (Google "Paul Carter")

I think this book would be much more appropriate if it was titled "The Art of High Level Assembly." The current title borders on false advertising.