Customer Reviews

Linux Assembly Language Programming

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

 

 

I found this book to be almost completely worthless. Despite previous claims, neither the beginner nor the advanced programmer will have much use for this poorly written disappointment. The book's confusing organization and lack of coherency limits it's value to the beginning programmer while the advanced programmer will find nothing new. Intel's online IA32 manuals provide much better documentation at no cost. While those writing Linux device drivers may find the examples interesting, their money would be better spent on the Rubini book.

Since there are many introductory texts on general Intel assembly programming out there, I expected a book specifically focussed on Linux aspects. This book is rather a first course in assembly language. It does not go deep enough to really get the Reader going with assembly programming under Linux. It is extremely badly structured - the explanation of some instructions is spread over 3 to 4 sections with other aspects constantly interfering and confusing the reader. The worst thing about the book is that it does not even have a short reference on the AT&T assembly syntax which is most frequently used under Linux. Instead, the author just mentions that this syntax exists, remarks that it is "unusual" for programmers used to Intel syntax, and illustrates the difference to Intel syntax with 2 examples. An introduction to using inline assembly with gcc is also missng. For the most obvious application - kernel/driver programming, which requires understanding AT&T assembly code in the kernel -, the book is therefore almost useless. Instead, it comes with a superfluous chapter on DOS assembly programming.

GAS (the Gnu Compiler Assembler) with the AT&T format is what I use, so all the examples felt really short with their NASM syntax. Sorry I didn't bother switching to a different tool, already familiar with the one I use. I suspect that Linux is here in the title to attract wannabe gurus, because the in-depth treatment of the kernel is really light. I recommend Linux kernel internals and the Intel (free) Pentium manuals for a better coverage. If you are novice, then this book may be a way to motivate you to go further in your device driver writer journey. The book doesn't have too many typos/errors and makes up for a pleasant reading.

Not a bad book for an introduction to linux assemly. However if you are looking for floating point or SSE and SSE2 related material then I recommend going to Intels web site and downloading the material. All in all not a bad book, but it was kinda skimpy. Not enough meat to satisfy the taste buds.

this book starts by explaining the binary and hexadecimal numbering systems and does it very well, but it goes downhill after that. it may be useful to people who already know something about assembly language programming, but i found that i had to read and re-read passages to try to figure out what the author was getting at (why don't publishers employ editors?). in the end i just came away with a passive understanding of assembly language programming.

then i discovered "Computer Organization and Design" (COD), by Patterson and Hennessy. If you're a beginner and really want to learn about computer architecture and assembly language programming, get COD, not the book under review.

As other reviewers already mentioned, there's little about this book that is specific to Linux, besides brief mentions about system calls and how the Linux kernel manages memory using paging and doesn't use segmentation (although it did in earlier versions). The syntax used is also that of NASM, which is similar to MASM (Microsoft Assembler) and thus very different from the AT&T syntax used by the GNU tools such as GAS (the GNU Assembler). So don't get it expecting to see a lot of consideration about specific quirks to assembly programming under Linux.

But this would not fit into the book, anyway. It is clearly geared towards beginners: the material is quite basic and superficial, and assumes no previous knowledge of assembly, only a basic C programming background. The second chapter begins by describing the typical fetch-execute cycle of a CPU; this is very superficial and does not take account of pipelining, superscalar execution and other effects present in current processors. But it does give an idea about how the hardware works. Then there are chapters about arithmetic in different bases and binary signed arithmetic, a basic introduction to assembly, machine language, dealing with memory, the stack, and interrupts. Then there is a strange chapter in a book about Linux assembly language programming: DOS programs. It seems that the book was being prepared for DOS but then it became obsolete and the material was reworked to cater to Linux programmers.

Nevertheless, though quite basic and not enough about Linux, it can serve as a quick introduction to assembly programming for beginners. The organization could be better too, but I don't think it's that confusing. A beginner would have to look for other books after this, though, and an experienced programmer would be better off skipping it altogether.

This book is disappointing to say the least.... No reference on AT&T syntax etc. The information presented is rather disparate & lacks coherency, very confusing & difficult to excogitate. As a neophyte, I would like to be able to access all references in a central location, where I can check the assembly command; see it's syntax; look up the CPU instruction; check it's syntax & see how it relates to the register in question, whilst at the same time I want a brief description of the register; what it's name means & what it does; have a list of system call numbers; their descriptions & functions etc. Kernel internals were briefly discussed but left much wanting. Free documentation served me much better. If you know what you want it's all availible online.

I am from Computer science background, and work as a Software Engineer. If you want to understand Intel x86 architecture, this is the best book. Very simple language, small book - covers how Segmentation and paging works giving just enough details explaining all there is know about it. Like wise he covers every subsystem touching the details from the Computer architecture point of view. I have not completed reading the book, but it is an excellent book. Simple and easy to understand language.

If you want to learn Linux internals, this is not the book. Then again there is enough code in Linux kernel which is written in Assembly language and low level stuff.

However, Without the understanding of the architecture of any system, you cannot comprehend the architecture dependent code in Linux kernel, atleast most parts. This book will definitely help you to understand Device drivers, and if you are serious enough you can start to write your own drivers.

Thank you Bob Neveln, Excellent material,
I love this book.

This book was written in very poor style. "Discussions" are very obscure and I've found myself hard to keep up with the author's ideas. I cannot call it a hardware text, neither a software one. It is just a mixed in which many relating ideas are cursorily represented in a style of listing rather than discussion; it confuses rather than clarifies. Many occasions, you will find yourself in a desperate situation to understand what the author talks about. The book slows you down from reading due to its obscurity and disorganized representation. For beginners ??? no, forget about it...

I didn't really find this book useful at all. I mean for one, it's titled as a Linux ASM book, but an entire chapter is focused on DOS assembly.

It's a very disorganized book and I wasn't able to write a single working assembly program using this book. I picked up the following book to get a grasp of assembly:

Assembly Language for Intel-Based Computers

Not Linux specific; examples might not even work in Linux but the book is awesome at explaining the ops, registers and give short examples.

Also jump on comp.lang.asm.x86... very helpful people.