Customer Reviews

Assembly Language for Intel-Based Computers (4th Edition)

5 star:		(26)
4 star:		(16)
3 star:		(5)
2 star:		(4)
1 star:		(9)

 

 

This is a review for the Fourth Edition of Assembly Language for Intel-Based Computers by Kip Irvine. This book has just been released.

I teach Assembly Language at a community college, and have used the third edition with much success. Matter of fact, I was so impressed by it that when Dr. Irvine asked if any of the current teachers who'd registered at his site wanted to review the fourth edition, which was still being written, I volunteered. The fourth edition is an organizational improvement on an already well-written book.

The first nine chapters cover what I need to teach for an introduction to Assembly Language, required by Computer Science departments for a major in that field. Engineering programs can teach introductory hardware using it as well, with the emphasis on different chapters.

The book starts with basic concepts of data representation and number-base conversions and moves on to the Intel IA-32 processor architecture. By the time we start to actually discuss Assembly Language in Chapter 3, the student understands why Assembly works the way it does. That's no small feat.

Unlike many Computer Science books purported to be for beginners, this one really is written for students near the beginning of their studies. It's aimed at those who have taken maybe one previous programming class. Dr. Irvine has a knack for reducing a very complex topic to its elements and explaining those elements so they're easily understood.

It's possible to learn Assembly Language using this book alone, not taking a formal class, even though the text isn't really designed to be a Teach Yourself program. Assembly Language is a rather difficult topic, so the student would have to be very motivated.

Instead of having a series of review questions at the ends of the chapters, this book has section reviews. This focuses the student on what was just read, reinforcing a smaller amount of data, so it sticks more easily. Students have access to answers to odd-numbered questions. For teachers who prefer to have students look in the textbook for the answers, the even-numbered questions cover material similar to what's asked by the odds. There are programming exercises at the ends of chapters, too.

The author maintains a web site for the book. There are sections for students who use the book and parts just for teachers. Odd-numbered problem answers are on the students' site. Security is maintained at the teachers' site. When I logged in, I found sample tests, PowerPoint presentations, and FAQ's, to name but some of it.

Rather than describe the contents of the book further, I'll give you the author's website. He has the complete table of contents posted, as well as a few sample chapters. Take a look for yourself. [URL].

I'm going to enjoy teaching from the Fourth Edition of Assembly Language for Intel-Based Computers. I feel like I have a well-organized book that covers what I have to teach, so I don't need to design my course around several textbooks. There's plenty of supplemental material on the website, which saves me lots of my most precious commodity - time.

This is a good starter book, but recognize that it focuses on DOS and does not "thoroughly cover assembly language for Intel-based computers" as the back jacket claims. No reasonably-sized book could do that.

The book description states that it is "Designed for students and professionals interested in learning the basics of operating systems and architecture in the context of a microprocessor." Although the book covers some of the critical topics necessary for operating systems programming on the Intel Architecture, e.g. I/O, segmentation, interrupts, it fails to do so adequately, and it omits discussion of protection, paging, and privileged mode instructions, to name three among many. I grant that you could learn enough to understand the basics of real-mode DOS, but not any of the Windows flavors, OS/2, nor the varieties of Minix/Linux.

That being said, it *is* a good book to learn Intel assembly from, and if you want to do OS programming then get the manuals from Intel's web site (downloadable in .pdf form). You may still find the DOS focus distracting, but you'll have everything you need.

... and don't think you'll find it all in one book. Intel's manuals alone are over 1500 pages.

I have recently completed a university course in Assembly Language programming. The instructor opted to use this book as the text for the course. First, the book is riddled with typos that are serious errors which can confuse a student into a state of mindless frustration. I would like to write a lengthy review, but for the sake of brevity, I can tell all in the few words that follow. In short, I shelved the book during the duration of the course and read "Peter Norton's Assembly Language Guide." I received a 4.0 (A) in the course which others who continued using the Irvine book struggled to make a passing mark. If all the errors are corrected in the text, this might be a worthwhile reference, but as it stands, it's more damaging than helpful. No offense intended for the author, just a bit of constructive criticism.

This reviews the FORTH edition published July 25, 2002

This text addresses the needs of students who can write programs in a high-level language and wish to learn assembly language for the Intel family of microprocessors. The forth edition contains an abundance of new material. The author introduces 32-bit protect-mode programming using the Microsoft Windows platform and he delays coverage of 16-bit real-mode programming using the MS-DOS platform until chapter 13. Only MS-DOS programming was covered in the previous edition. Each section contains review questions and each chapter ends with a summary and several programming exercises. The author clearly describes each concept and uses excellent diagrams and code examples throughout the text. Several new topics have been added to this edition such as graphics programming in both Windows and DOS applications.

The early chapters present an overview of the Intel IA-32 architecture and cover the principles and techniques of programming Windows console applications in assembly language. The author has encapsulated the details of the Windows application interface in his 32-bit library, which the students use throughout the first 10 chapters. This allows the students to focus on learning and using the instruction set to create solutions to the programming problems. The details of his library routines are revealed in Chapter 11. Chapter 12 covers assembly language routines that can be called from a high-level language. Both 32-bit and 16-bit C/C++ compilers are used in the examples. The remaining chapters (13 through 17) cover 16-bit real-mode MS-DOS and BIOS programming in much the same way as was done in the third edition, but many more example programs have been added.

A CD-ROM accompanies this text and contains the complete Microsoft Macro Assembler (MASM 6.15), Microsoft's 32-bit and 16-bit Linkers, all example programs from the text, the source code for the author's 32-bit and 16-bit link libraries, and many more useful files. Chapter 17, Advanced Topics, is contained on the CD-ROM and is not printed in the textbook.

The author's web site ... contains an abundance of support material which he keeps current. Most useful are a list of corrections to the textbook, updates to the files contained on the CD-ROM, and the answers to the odd-numbered Review Questions. There are instructions for installing the assembler, configuring and using various integrated development environments, and links to other useful information such as the MASM 6 manual set and the author's e-mail address. Five chapters from the textbook are posted on his site for your review. Professors can access a password-protected area that contains answers to all of the review questions, solutions to the programming exercises, and a set of PowerPoint slides for use in the classroom.

Assembly language is much easier to learn when protect-mode is covered before real-mode. Early use of flat addressing allows coverage of segmented addressing to be delayed until the students have learned the complete instruction set. Flat addressing also makes it easy to locate run-time errors. The addresses contained in the Windows run-time error dialog box corresponds with the addresses in the linker's map file and the assembler's list file. The topics flow better when the simpler Windows interface is covered before the more complex interrupt service routines of MS-DOS and BIOS.

I have successfully used the previous edition of this textbook for several semesters. Including techniques for protect-mode programming in the forth edition provides the additional information most often requested by students. This review is based on material I received from the publisher as a reviewer.

Irvine's book attempts to cover Intel assembly language for computers either running DOS or a DOS emulator. If you have programmed before in languages such as C/C++, Java, or VB, this is an excellent first book. The CD that is included in the book supplies, among other things, libraries coded by the author providing functions for various types of IO, setting text color, clearing the screen, etc. Using these functions, Irvine first introduces you to data representation, basic elements of assembly language, manipulation of registers and runtime stack, and iteration. Then, he moves onto advanced arithmatic and procedures. After he has covered the basic means of manipulating data and writing programs with assembly, he exposes in the last three chapters the real bones of the language: system interrupts, video mode programming, BIOS, and the like so that use of the libraries becomes unnecessary. Thus, the sequence of the book is ideal if you understand the fundamentals of computer programming but are unfamiliar with assembly language.

However, if you have not programmed before, Irvine's book might give you an awkward understanding of the language. You would probably be better off with something that focuses more on system interrupts and real-address programming initially, instead of bringing it up at the end. The order of the book makes sense if you have a basic knowledge of programming because it first forms analogues with concepts you are already familiar with, and then introduces the core aspects of interacting with the system which were previously hidden in his libraries. However, if this is all new to you, a book that gives a greater understanding of computer architecture and doesn't use his libraries would be more suitable.

While the DOS slant may have bothered some, I prefer that he focused on one OS rather than trying to cover all of them. In addition, the CD that came with the book included a DOS emulator for Linux. I'd also like to add that this is one of the most up-to-date assembly language books I've seen. Overall, I'd recommend it if you've programmed before, but are new to assembly.

If you have coded in assembly before or are studying the book within a classroom environment then buy this book. The author expertise on the subject of assembly coding is excellent.

The book also comes with a CD that has Microsoft's Assembler and many other useful assembly editing tools (no problems here).

But, what is the problem with this book?.

Well, the author is too much of an expert and has overlooked the fact that some of us out here are not. The author does not fully explain the book's code examples until you have reached later chapters.

For instance, after following some lines of code from the book's program examples and finally getting to grips with what the code is actually doing, the comments for the next line of code says "this operand instruction must be performed in a certain way". Yeah, but why?

In addition, some of the example programs will only work on FAT 16 operating systems. Unfortunately for me, these were the programs that I really wanted to run, but cannot because like most people, who use FAT 32, cannot deal with the routine of partitioning their operating system to FAT 16.

I don't know about you, but when I am trying to figure out what is happen with memory allocation, I usually draw a diagram to help me get a visual representation of what is going on with memory.

The book does have some diagrams to help the reader see what is happening in memory, but, too few and needs more.

This was the second textbook on Assembly Language that I have used in college, and it is definitely above average. There are a lot of examples given, and the chapters are grouped fairly well. The author gives a short tutorial on how to use both the Microsoft MASM and Borland TASM compilers and debuggers, as well as a decent include library to use. He starts with the basics, and moves into database manipulation. A good book overall.

I have to agree with James L. Johnson in that this book has many mistakes, and would recommend "Peter Norton's Guide to Assembly Language for the PC". Although the price is a bit steep for an assembler, it might be worth getting as this is the only book that comes with a so-called free assembler.

One more reason why this book is not worth getting, is that you have to use the Author's own library files to get some examples working which is not a way to learn Assembly. I must say if you do not want to spend any money on learning assembly language. check out the author's webpage, he has some great links to Assembly Language Tutorials and Resources.

This book has a good opening. When I learn a programming language, I want to see a sample program as soon as possible. This book provides such a sample program immediately after a short introduction to hardware concepts. This sample program loads registers, changes their contents, and dumps them. One can type the program in, see how it works, and gain a good confidence for further reading.

The library procedures provided by the author are helpful for learning and debugging. Usually, programs in assembly languages are difficult to debug, and their execution is hard to track, even if debug software is used. For programs in high-level languages, one can easily insert into them input and output statements to track their execution. For assembly language, writing such statements may be harder than writing the program itself. With these library procedures, especially those for data input/output, one can easily track the execution.

The 4th edition of this book emphasizes programming in 32-bit protected mode. In this mode, flat memory addresses are used. Students do not have to convert a 16-bit segment-offset address into a 20-bit address. This tremendously simplifies the addressing concepts and eases the learning. This book does cover 16-bit real-mode in later chapters when students are more ready for it.

A good textbook must be easy for reading as well as for reference. This book has both features. It starts with short explanations, uses excellent diagrams, and discusses comprehensive applications for every topic covered. Topics are well classified into fundamentals and advanced, 32-bit Windows programming and 16-bit DOS programming, protected mode and real-address mode, etc. Important aspects of assembly language are all included, systematically organized, and well indexed.

A very competent introduction to assembly programming, regardless of the platform, but great because it can probably be used with your personal computer. After a quick install off the included CD, you'll be coding and assembling your own programs in no time.

A background with digital systems is helpful - I am a computer engineering student, and I was already more than familiar with two's complement, AND, OR, and other logical operations. These topics, working with binary, are essential to assembly. However, though the book uses them a lot, it also explains them at the beginning, so pay attention.

It's very interesting all the Windows-specific things it covers: the author doesn't neglect the fact that Microsoft's assembler is by far the most used PC assembler out there, and goes into lots of MASM-specific topics. What's great, however, is that amongst the platform-specific ideas are general ideas that will work well in any assembly situation; that's an advantage of assembly, that it's so low-level it's very similar on different platforms.

I took an embedded systems class after taking the class that used this book. I felt very confident in my assembly ability, even though the embedded systems class was not using Intel processors, but PIC processors from Microchip.

By the way... I wonder if most textbooks are rated according to a student's experience in the class. Did the guy who rate this book down very low simply have a bad teacher who was really hard on his class, and then looked for problems with the book? Personally, I didn't find the lack of a debugger that bad, since I was understanding assembly pretty quickly right off the bat thanks to this book and my teacher's clear explanations.