Customer Reviews

Assembly Language Step-by-step: Programming with DOS and Linux (with CD-ROM)

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

 

 

Like everyone else I've ever met who's looked into learning assembly, I had a little trouble comprehending how everything fit together. I'd heard wonderful things about Duntemann's last edition of Assembly Language: Step by Step, so I decided to purchase the updated linux version. Duntemann's 600+ page book slowly guides the beginner into an understanding of Assembly. Don't be confused by the book's size - this book will NOT make an expert - perhaps not even an intermediate programmer. Instead, this book teachers the basics of assembly and provides a decent background into the workings of computer memory, the cpu, and other concepts that EVERY programmer should know. This book can't be given a higher recommendation for anyone looking to start in assembly - Duntemann has a way of explaining (and re-explaining) through metaphors that enhance comprehension. Anyone who already has a background in this material will be amazed by the extreme explanations ("a whole CHAPTER on hex and binary! "), but it's really the perfect way to pound the knowledge in. By the end of the book, the reader will know so much more about assembly - and how/why it works. Just don't expect to be a highly skilled professional.

What I was looking for: With very little assembly language programming experience, I wanted to start writing assembly language for my linux box.

What I found in Step-by-Step: The best introduction to computer science I've ever read. I'm tempted to recommend the first couple chapters to anyone interested in starting to program- whether assembly or even with a high level language.

What I got: After reading the book I've acquired a solid knowledge base to do assembly in -any- environment...and more importantly, his style of writing didn't kill my fascination and desire to start writing code at the assembly level.

Some of what he gives you is "out-of-date". Your likely to do your assembly language programming under protected mode--whether with Linux or Windows NT/2000. Though this makes a large size of the book "out-of-date" it DOES NOT make it worthless or not worth reading. For me, who had no knowledge of the differences between these memory models before reading the book, it was very useful information to have. I was hesitant of his claims in the 2nd editon that learning real mode would help me with protected, fearing he was covering up an incomplete 2nd edition, but in retrospect I appreciate his coverage, though I'll -never- write assembly code using real mode techniques.

This book gave me the foundation to go in any direction I want to take with assembler. I'm able to read those terse online quick starts for assembly language programming with linux and am off and running.

Excellent foundation, gets you excited about the long learning road ahead. A wonderful place to start.

He doesn't just give you an instruction set and briefly describe the memory model..he gives you everything you need to know to take any instruction set combined with a short description of the memory model and go. This is quite rare and will ensure that his book no matter how "out-dated" will continue to be read and highly appreciated.

I would have given five stars but don't want Duntemann to scratch his plans for a 3rd edition!

This book is great for assembly beginners. The author has a great style of writing that is casual, compelling, at times humorous, and most importantly, honest and instructive. What stymies most newcomers is the lack of explanation of details, which is positively essential when learning assembly, due to its fairly arcane nature. This is where the author shines. Before I read this book, I had difficulty with the concept of memory segments, but Step-by-Step provided an easily understood explanation of what they were, what they do, and how to use them. Another essential tool for the aspiring assembly programmer that is explained in this book is DOS's progam DEBUG. The author devotes enough time on this subject so that you, the programmer can actually utilize some of DEBUG's main features. The book also introduces a few of DOS's and the BIOS's system services that are directly available to assembly programs. Each service that the author discusses is thoroughly covered and shouldn't leave anyone dissatisfied.

Of course, no book can cover "it all" (except maybe the Good Book). You'll need to buy more after this. Just think of Step-by-Step as a "primer" (you couldn't expect to read and understand War and Peace if you can't understand Run-away Bunny). This book is writen by a 30-year veteren of assembly language (among other languages) and of technology and electronics in general. His knowledge is vast and he understands that imposing that vast knowledge on a beginner all at once would be illogical. So, in the authors own words, this book is intended to help you learn how to learn assembly. I'm sure you've heard it before in other tech-book reviews: "You won't be a/n <insert something> wiz once you finish reading this book." But you'll at least get out of the starting-gate with a decent grasp of assembly. A cool feature is that the book contains a CD with an excellent FREE assember called NASM, among various other necessities. The newness of the book is also refreshing (published in 2000).

I'm rating this book with 5 stars because I really believe that it will get a person of moderate intelligence comfortable with beginning assembly coding and assembling/linking. Of course, if you consider yourself a bit more than moderately intelligent, then perhaps an assembly book other than this one will suit you better.

PS- Some prior programming experience would be helpful with your comprehension of the material in this book. What is ABSOLUTELY essential is the FIRM grasp of binary numbers, hexadecimal numbers! Thankfully, the book devotes some time to this topics discussion.

This book filled in a lot of gaps in my knowledge about computers in general as well as introducing me to the world of assembly language. I didn't know how much I didn't know until I read this text.

The book is enjoyable and easy to read. If I had it to do over again, this is probably the first computer programming book I would read. The author really explains the concepts in simple terms that are easy for even a novice to understand. I found parts of the book moving along a bit slowly for my taste, but I was certainly able to reatin all the knowlege.

The first 150-200 pages is mostly background. I found some useful morsels of information through these sections, although I was able to read through them quite quickly. Then there's about 200 pages on assembling for DOS and another 120 pages on assembling for LINUX. All parts of the book are relevant to each other.

If you are new to assembly, or want to fill in some gaps in you knowlege this is a great book to start with. If you have programmed in assembly before, you will probably be disappointed with this book.

Many people aspiring to learn assembly have been discourage by the high learning barrier of understanding the arcane aspects of language and computer architecture. I was one of them. This book helped me broke that barrier.

As the author said that he set out to write a book that "taught people how to program in assembly language as ther first experience in programming"; the book lives up to that promise.

Unlike many other books that rushes through basic concepts and dives into assembly instruction, the author has great explanations of every concepts in assembly. I especially liked the metaphors approach to describe many difficult concepts.

The NASM assembler and NASM-IDE tools included in the book is another bonus to the book. The author also has a web site to for book errata, links to other great web pages about assembly.

The author dedicated the last 100 pages of the book to Linux programming, and done a decent job at it. I agree with him that the reason he did not choose Windows was that the results from learning and programming windows applications in Assembly is not worth the time. However, I wondered if it would be better that if the author spend that last 100 pages on building something useful with assembly, like a hex editor, so that we get a better feel for the language. He could write a book on programming in assembly for Linux.

But, overall, the book is so well-written, living up to the title: Step by Step - that I didn't even feel any difficulty learning the concepts, as I did in other books.

When all other ASM books fail, this one stands upon the pedastool, boasting its complete and accurate introduction to The Assembly Language. What truly seperates this book from the others is the fact that it dedicates a good portion to discussing how the internals of a computer work, including memory addressing. That in itself will set you on an easy track to understanding ASM and other mid level languages such as C. Out of all the books on Assembly I have read, this one is definately the best for timid beginners.

Last semester, I checked this book out from our school library and absolutely fell in love with it - it's superb. The author Duntemann has a clear, fresh, and very light writing style that's not loaded down with an overabundance of superfluous "geek-speak". Before delving into new concepts, Duntemann tries to get the reader to grasp, in a real world sense, how the concepts apply to the machine.

Considering that universities nowadays spew sizzling venom on the "difficult", "slow", and "forgotten" art of machine language, I've done my research by reading the opinions of what real programmers (who've worked in the industry probably longer than I've been alive) have to say about assembly language -- Every article or column I've read has convinced me that learning assembly language is not only a mechanism to speed up sections of your code, but it's a forgotten goody most programmers today lack, and if you're up to the challenge, coding in assembly is the perfect addition to your "bag of programmer's tricks".

Duntemann's book is perfect for beginners of assembly language, and I do mean beginners. Be forewarned, however: this book will NOT make you an assembly programming pro; it probably won't even knock you into the 'intermediate assembly coder' category, either. This book is a stepping stone to other more detailed books, and if nothing else, it teaches you how to THINK in assembly language, rather than learning the "nuts and bolts" of assembly. AN EXCELLENT BOOK.

If you don't have any programming knowledge then this is a great book to start with. However if you are an experienced programmer trying to learn assembly then you may find this book annoying in certain parts.
The book does not actually go into assembly langauge until you get past a good number of chapters.This may be a good or bad thing depending on the way the reader likes to learn.
Personally I think teaching pc architecture before going into assembly langauge is a good thing but I also believe the author could have saved a lot of space and still got the pc achitecture tutorial through.
The book also covers 3 assemblers MASM,TASM and NASM but sticks with NASM for the most part. It also covers 32 bit assembly in Linux only.
Overall, this is a good book to learn the basics of assembly language but be prepared to spend money on more books e.g "revolutionary assembly language" and "inner loops" if you want to be a good assembly language programmer.

In general, a good introduction to the x86 assembly language although and as somebody already noted, a bit outdated. The use of simple words and analogies makes the reading fluid and enjoyable. However, I feel that too many paragraphs were invested on "Other authors don't do this or that" and "I won't cover it in here because it's too complicated".

On the latter, I can appreciate that writing an introduction to the assembly language is by no means an easy task, but Mr. Duntemann could have devoted a little time to present some concepts about the CPU's protection mechanism (just enough to know what's there) and maybe to expand a bit on the hardware interrupts. The book reference DOS and BIOS interrupts, but only a few. The inclusion of a complete list (maybe as an appendix) will make the book more "self-sufficient".

Dedicating one full chapter (31 pages) to the NASM-IDE is certainly overkill. After all, this book is about the assembly language not the IDE. I think the readers will be better served by looking at the help file included in the CD. Besides, if you are serious about learning assembly language, figuring out how the IDE works should be a piece of cake in comparison.

Regarding the instruction set, good coverage of the most basic mnemonics but a bit light on the flow control ones. Integer arithmetic is covered but no words (no pun intended) on floating point operations (which indeed is a much more advanced topic). Too sparse covering of string related instructions.

As I mentioned in the beginning, a good introduction. This book is a definite buy if these are your first steps towards learning the assembly language.

I was looking for a descent text on assembler and bought this book. It does make things clear and does have good explanations. Unfortunately these explanations come in pieces of 2-3 sentences per page, while the rest of the page is wasted telling us all kinds of computer history and authors personal tales or just stories... all of which I think are completely unnecessary. 9 out of 10 times when I put this book down is because I was tired digging through all this garbage while looking for assembler info.

The good things are that so far this book answers all of the questions I have had from reading similar texts that leave a lot unexplained. The author does know what he is talking about, and it shows in his clear explanations. It'd just be nice if these books wouldn't be so bloated with long discussions and pointless tangents. I don't have time to read a 600 page book when it could have been 300 pages. I would pay twice as much for something similar that sticks to the title on the cover.

Bottom line is, this is a good text, you will know the basics of assembler if you read it, if you can manage to tolerate all the irrelevant babble.