Rating: 
Summary: Excellent!
Review: 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.
Rating: 
Summary: Bummer!
Review: The book is mostly about the HLA, and, to tell the truth, who cares about it. Years ago I'd downloaded Randall Hyde's first assembly book (the 16-bit one): it was an oustanding job, and owing to its free availability doubly remarkable; it was markedly better than every single assembly book commercially available then; it's a shame no publisher took it up then. I still have a printout of it -- boy, was it a labor of love: clear, well illustrated, extensive, thoughtfully structured. Then, with the advent of the 32-bit OSes, I was hoping for an update of this book -- nothing more than that, mind you; but now, the author got carried away and invented this High-Level Assembly (HLA), which is a pile of wrappers that make assembly look like C, sorta (thus "high-level"). Hmmm, sorry, if I want a C-like syntax, I will use a C compiler (there's nothing rare about those these days.) I'm sure this HLA thing was fun to design; I'm sure the author had a good time playing with it -- but when you need assembly, you need it bare bones; the book should have been such a bare-bones assembly in the 32-bit, protected world. Yet this book isn't it, so, I'm sorry to say, I don't know what it's good for, I definitely don't care for the HLA one bit. I have a lot of respect for the author, but I gotta be honest: I can't recommend this book. If you need to learn the 32-bit Intel x86 assembly, there are, imo, better books now (I forget the author though, it's fairly recent), plus search the net, plus visit assembly journal.org etc; after all, 32-bit assembly isn't that terribly difficult if you know the basics. In fact, it's simpler than the older, real-mode variation thereof. Now, if you happen to be an HLA enthusiast, then it's a great book of course...
Rating: 
Summary: Worth a lot more than the price
Review: This book certainly fills a huge gap. Assembly language at its lowest level has always been a strange and unwelcoming monster. The very requirement, that one has to learn a lot of low level I/O stuff before one can even print his/her name on the screen turned many bright minds off. The instant reward effect and the freedom of choice that HLA gives is simply Godsend. Once you fully grasp the concepts (that this book explains so well) I think its very hard to confuse HLA's high level facilities with x86 code. You only need to read it carefully and seriously, because the book ALWAYS explicitly distinguishes between HLA's control structures and x86 instructions. I am certainly prepared to invest as much time in this book as it takes.
Rating:
Summary: The best there is
Review: This book has been available for free download on the Internet for some time now. Many people have learned asm by reading this book. The book was brought to print due to the high demand of people wanting it so they wouldn't have to print it out and put it in a binder somewhere. I highly recommend it. If you want to make sure this book is for you, do a quick Google on the title and you'll find the PDF version along with all the source code no problem. I can almost guarantee you that you'll still buy the book :)
Rating:
Summary: Finally, A Book That Really Teaches Assembly
Review: This is the first book I've ever read that has made assembly language programming understandable. The HLA assembler that comes with this book is a Godsend. I have tried to learn assembly using NASM and MASM in the past, they were too confusing. The HLA assembler that this book uses made learning assembly language easy. The HLA assembler is one of best things about this book. I figure if I can learn assembly language with The Art of Assembly Language, then anybody can learn with this book. I also like the fact that everything in the book works for Windows and Linux. The other thing worth mentioning is all the documentation that appears on the CD-ROM with this book. What a great resource!
Rating:
Summary: Excellent book on HLA
Review: 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.
|
