5 comments about IBM PC Assembly Language and Programming (5th Edition).

1. As a computer science student with 20 years of programming experience, I encountered Peter Abel's book (Fifth Ed.) published by Prentice Hall while taking an Assembly Language programming class.

   It is, bar none, the single worst computer language and programming resource I have ever had the misfortune to encounter. Not only does it lack critical details about methodology, it fails to include comprehensible explanations about the examples already provided. If it were simply that it was incomprehensible it might still be acceptable as a resource later on when clearer and more concise means of learning the subject are used. But this book contains more out and out flaws than the Beta release of Windows XP. Many of the programs included as examples of a concept in action DO NOT WORK. In fact, there are serious operative flaws in them. Further, several of the questions do not match the terminology found in the text, there are more typos and omissions in this book than in the average High School newspaper and actually learning anything useful and productive from this book alone would take an IQ higher than 180.

   If someone has years of programming experience IN ASSEMBLY, then it would probably make sense. As an aid to teaching the subject, not only does Mr. Abel miss the mark, he doesn't even aim in the right direction. For a student, this book is the academic equivalent of a twenty car freeway pile-up. Avoid it at all costs.




2. This book is not recommended to anyone who just started learning assembly, as they're very hard to understand.
   For beginners, I would highly recommend "80x86 IBM PC AND COMPATIBLE COMPUTERS (Volumes I & II)" by Muhammad Ali Mazidi, which also covers the subject thoroughly.



3. While not perfect for the beginning x86 assembly language programmer, Abel's text is an excellent overview of the basic and intermediate concepts of x86 assembly. This text covers many of the commands of the x86 instruction set and is an excellent introduction to learning about various BIOS and DOS interrupts. Herein lies a slight problem with the text. Relying too heavily on the "old world" of DOS and Windows 95/98 (and possibly - depending on your system - Windows 2000), this text often takes for granted that you are running on an older Microsoft-based x86 system. As long as you can overcome this compatibility "hurdle", this text is an excellent source for learning about x86 assembly. It covers the topic of machine code, which is of prime importance for those who are interested in writing assembler and compilers (and for writing succinct assembly), and also has copious notes on all the instructions taught in the text.



4. First, please understand that I purchased this book for a college class in assembly, but I am also a programmer with 15 years professional experience, and some of material is not new to me. I have read a great number of programming books, and with that said, this book has little value beyond reference. It makes brief mention of advanced concepts I am trying to learn, and then jumps elsewhere. The examples are hard to follow, and often to not provide instructions on recreating them. I am purchasing another book to supplement this class, as I will never learn the material from this book.



5. This book is a required text in an undergrad class on Assembly Language that I was taking. I found this book to be too difficult for a beginner simply, not because of the sophisticated concepts introduced here but because of the errors and lack of explanation. The latter half of the book is essentially like a reference and provided no explanation most of the time. Even for the example programs given in the text, there was not sufficient explanation. I also found that most of the programs (particularly in the latter half) do not work at all. I could fix a few bugs in some programs to make them work, however, this is a time consuming effort. Unless you have a really good instructor who can help you with the bugs and explanation of the code, I will not recommend this book. While I struggled with this book and managed to get an 'A' grade, I would look elsewhere if I had to do it all over again!

2 comments about 68000 Family Assembly Language Programming (Pws Series in Engineering).

1. deseo saber mas sobre estos procesadore



2. Clements demonstrates that the 68000 assembler language is a very logical and clean one. With none of that segmented memory nonsense of the 1980s Intel architecture. Having a flat address space makes your coding far simpler. Perhaps you might not appreciate this from a reading of Clements, if you have never had any experience with the other chip set. But those who have will certainly thank Motorola.
   
   As this review is written in 2005, the 68000 family is still selling well. It has a heavy presence in embedded microcontrollers and real time systems, for example. So if your company wants you to code in the 68000, the book is still germane.

1 comments about 80X86 IBM PC and Compatible Computers: Assembly Language, Design, and Interfacing Volumes I & II (4th Edition).

1. most definately not a book for the beginning assembly language programmer. that said, this is one of the most detailed and informative books on the subject i have every had the pleasure of finding, purchasing, and reading.

   the book travels deep into the electronic architecture of the humble pc and teaches you how to do things you never even knew could be done. it covers parallel port and serial port interfacing, memory architecture, graphics programming, and just about every other facet of the pc that there is in a very comprehensive and satisfying manner.

   i have purchased 9 books so far published by prentice hall, and all were superb. i whole heartedly recommend to EVERYONE that if you ever need to know about something and want a book, see what prentice hall has on the subject FIRST. the quality and quantity of information and the layout and design in their publications are second to none.

   if assembly language programming were a religion then this is my bible, and the authors and publishers are my gods.

5 comments about Linux Assembly Language Programming (Prentice Hall Open Source Technology).

1. 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.



2. I'll admit, the title is more than a bit misleading. The book is written for an introductory course in assembly language programming, and that's what it does. All the assembly is in intel syntax, no AT&T, which is what is predominantly used in linux programming. However, it is good at what it is meant for. It teaches the reader about assembly language, and how the operating system works. I found it to be an extremely easy introduction, and I believe knowledge I've gained from it will allow me to move on toward more extensive programming. I've used C and assembly for many years on my own, and I found things in here which made much more clear the reasons behind some of the 'fluff' in my open source programming projects.



3. 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.



4. 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.



5. 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...

5 comments about Microprocessors: From Assembly Language to C Using the PICI8FXX2 (Electrical and Computer Engineering Series).

1. I just want to clarify for anybody considering this book that the book's examples are compatible 'as is' with the Hi-Tech PICC18 compiler. The supplemental website (www.reesemicro.com) contains a ZIP archive of modified book examples that are compatible with both the Microchip MCC18 and Hi-Tech PICC18 compilers. The compiler differences are hidden in an include file, so the modified book examples that are compatible with both compilers are practically identical to the examples in the book. The reviewer below (Mr. Estrade) contacted me, and he had attempted to compile the book's original examples with the MCC18 compiler. (I am the author of this book, and unfortunately to post this I had to assign a number value for the review - so I chose a '3' since it was in the middle of the range).



2. Unlike other PIC books which covers on assembly language only, the assembly language + C language approach in this book is pretty good. It helps to enhance the understanding of programming PIC from low to high level.
   
   I think this book is focusing on programming, rather than building the hardware circuitry such as button debounce, voltage regulator etc. Therefore, I would recommend this book to reader who already has knowledge in building PIC or other microcontroller circuitry. Indeed, the author covers almost all the essential functions in PIC, such as I2C, UART, timer, which I think it helps beginner who used to write in assembly language, to move on to programming in higher system level. For advanced programmer who has practiced the functions mentioned above and integrate all of them into a system, perhaps you won't find this book to help a lot.
   
   Dissapointedly, almost all the topic covers are more toward PIC16 than PIC18 which is more powerful. I expected to learn some powerful features such as USB, TCP/IP to be run on PIC18.
   
   One more opinion, isn't Microcontrollers a more suitable term to be used in the book title instead of Microprocessors?



3. they sent this book within two or three days, I really admire their shipment service



4. This is a good book for a collage student who does not know much about the pic. This is not a good book for experimenters, it is not an easy read, but it is very detailed on it's subject matter.
   If you are a beginner this book is not for you, it does not go into any detail of the code, either in assemble or C code, it does have lots of theory on machine code which I haven't used in 15 years.
   This book is good for the engineering student, but there are friendlier books on the pic out there.



5. This is a good hard-back book. The text is very understandable and very interesting for a great price!

No comments about Applying PIC18 Microcontrollers: Architecture, Programming, and Interfacing using C and Assembly.

5 comments about OpenOffice.org Macros Explained.

1. The first eight chapters provide numerous working examples of the core language; including features that I did not find in the help. Numerous bugs and work arounds are demonstrated. New features introduced in OOo 2.0 are mentioned in the text. It might have been helpful in the file section, if the author had provided a reference to the SimpleFileAccess service.
   
   The Developer's Guide for the OOo API is over 1000 pages long. It is, therefore, not a surprise that this book does not provide exhausitive coverage for the internal API. When a topic is covered, however, there are typically complete working examples and descriptive text for the topic. For example, I had trouble inserting and naming my tables until I noticed that the book includes a tip that a text table needs to be named after it is inserted into the document.
   
   Not all topics are covered exhaustively. Again, considering text tables, no method is provided to individually enumerate all cells in a text table. Numerous complicated text table examples are provided, however, including methods to select and copy entire text tables. Although, the author does not provide a solution for every problem that I have needed to solve, there is generally a pointer along the way and a simpler example to get me started. For example, I read about the current controller in the "UNO and the Dispatcher" section. The controller is then used to select things such as tables and cells, but I had to figure out for myself that I could also use the controller to select an entire row or column. The simpler a problem, the more likely it is to be solved.
   
   The book was published before Base was available and it provides no coverage for the Databse capability built into OOo.
   
   In the section on Universal Network Objects, the author provides examples demonstrating how to create and use your own data types in OOo Basic (this should have been in the help. This section also provides simple definitions for things such as Interface, Service, and Context.
   
   After buying the book, be certain to obtain the PDF from the publisher, this is one of the few books that provides the PDF. The PDF is very useful for searching through the text. Although the examples are all available from the publisher as well, I found that it was usually just as easy to copy them from the PDF file to where I need them.



2. I've been playing with openoffice macros for several months after using some VBA over the past few years. Initally it was very difficult. I found this book to be very helpful. The material is DENSE - you will be frustrated if you try to read it cover to cover. My suggestion for those who want to learn OO macros is download the StarOffice manuals (free), download the Xray macro (free), start with Calc macros (easiest) and read the pertinent parts of this book. OO macros are harder than MS Office in the beginning, but I've found that it is now EASIER for me to write a macro in OO.



3. If you want to program OOo macros, then this is about the only book on the market. OOo macro programming is definitely not trivial, therefore, neither is this book. It is big. There are a lot of code snippets and examples, but you will still probably need to go the Macros and API section of the OOo online forum for help when it actually comes time to write your macro(s).
   
   I found the available downloadable PDF to be invaluable when finding specific examples in the book that dealt with a specific call or method. I could search that for a term, and find where is was used in a code example in the printed book. Instructions on downloading the PDF are in the book.
   
   Though the PDF is supposed to be an update of the book, I found no differences.
   
   Documentation for open source products is universally poor, so one NEEDS a book like this. It is value for the money spent.



4. The book is good structured, easy for learning also for persons as me that haven't a good knnowledge of pc programming, but also for those having deep knowledge and pc programming as daily job



5. and nobody has ever told you.
   This books contains everything you need to become a macro-master. Even if you are not so deep founded in programming you will be able to follow the examples and write your own in a few time.
   Well written, the author offer a post-sale service on his web site with updates, errata and a full e-book copy.
   A must have if you need to push your [..]pedal to the metal.

5 comments about 32/64-bit 80x86 Assembly Language Architecture.

1. This is an excellent Assembly book. Fun to read, well organized, to the point, and up to date (vectorization, 64bit processors). While it is primarily a comprehensive reference of the x86 instruction set, it does not withold real-world tips and relevant background information and thereby becomes an invaluable guide to anyone seriously interested in addressing bottlenecks and increasing the quality of his software.
   
   What struck me most about this book, is that it does not present bogus examples in an artificial assembly dialect, but rather provides very short, working code snippets in Microsoft notation whenever appropriate (BTW, I am using GCC inline Assembly in AT&T notation and had no problems using the code). Furthermore, it does not expect readers to engage in pure assembly development (which would be pretty ridiculous nowadays), but shows how, when, and when _not_ to use Assembly language in C and C++ projects.



2. The book is about 500 pages overall, but only about a hundred pages have something readable on them; the rest are opcode tables -- nicely printed, but not terribly instructive. Oh, and the author also takes some space to tell you that he has eight children, and that it's the third book he's written, and that you need to get the other ones, and that he has two brothers, and that his two brothers also write books, and that you'd better get their books too, although they write fiction rather than technical, and so on and so forth, and on, and on, and more donkey diarrhea like that.
   
   OK, back to the essence: by most part the book is a selective reprint of the freely downloadable Intel instruction-set references -- not nearly as detailed, but grouped by function (rather than alphabetically) and with comments/sample code at times. This, especially the grouping, is good, but ultimately does not save the book. Why:
   
   First, a couple of articles' worth of stuff does not make a book -- there's simply not enough original material. Which insufficiency is (second) 'compensated' by padding the book with reference material. Third, and most important: the author has no writing aptitude. If he must write at all, he should team up with a competent technical writer, otherwise there's no hope: this text is disjointed in the highest degree and downright imbecile at times: the guy seems to be oblivious to the fact that words mean something, and that in order to communicate information one has to carefully pick the right ones and assemble them in a meaningful way. For example, BSF, he says, scans for the LSB. Well, the LSB is in position zero and doesn't need to be scanned for! What BSF does is scan in the least-to-most-significant direction for the earliest bit that is set. Which is probably what this dunderbuss thinks he's been saying all along. Now, this is a simple, immediately obvious example (not the worst either: a lot of writing in this book is not simply careless, but downright ungrammatical, incomprehensible). If this is a simple case, what will happen when you get to more esoteric instructions? Go to Intel and download their free books; they're not perfect, but they are decent -- you'll be better off with them.
   
   This is the second book by Leiterman I got; the first one (Vector Game Math Processors) had the same flaws; it's been sitting on my shelf for a couple of years and proved consistently useless. Both books are very attractive visually; the tables of contents appear promising; about one tenth of each book looks like it could contain some value -- but, once you get to it, it's invariably not enough material + lots of padding + piss-poor writing. While I'm at it: the publisher is Wordware, which, as I came to understand now, is a giveaway -- I've not seen one good book from them.
   
   I'm sending this book back.



3. I recommend this book, with caveats. I found all the information I was looking for about Intel/AMD architecure (I was specifically interested in the 64-bit extensions). The charts showing which instructions are implemented on which model processors are a very big plus that probably cannot be found elsewhere. BUT: There are lots of little errors throughout that I could detect because of inconsistencies--I don't know how many more there are that I couldn't detect in material only presented once. Example: pp. 204 & 205 discussion of division, the text has the dividend and divisor reversed from what is shown in the tables. Also, the author tends to spend many pages repeating basic or similar information at great length (for example, treating addition and subtraction separately, repeating all the details) but some more complicated but necessary information is left unsaid (for example: What exactly do the two-stage square root instructions do? What on earth is a partial tangent or a partial arctangent (the discussion makes it seem the latter is just a division operation, which is not likely)? There is a whole chapter entitled "MASM vs NASM vs TASM vs WASM" that really only discusses MASM and certainly gives no useful information on the differences between those assemblers.
   I could go on, but you get the idea. Very useful to have on the shelf, but reads like it was written in a big hurry--could have used a lot of editing.



4. Being rusty with 8086 code I found this book useful for speeding up bits of my C++ with inline assembly. I liked the examples like A&(A-1) to find if just a single bit is set and the comparision in speed between a C++ routine to scan for a bit and the single asm instruction. A complete reference with some good tips.



5. While this book contains a ton of useful information (especially the charts showing which processor families support which instructions), I found so many gramatical, organizational, and techinical errors in the book that they became too distracting. After getting through the first half of the book, I skimmed around through the rest...and everywhere I happened to look I found glaring problems. The text contains many incomplete sentences, confusing attempts at humor (due to poor sentence structure), and serious grammar problems that a good copy editor should have caught immediately. Likewise, I found alot of inconsistencies and errors in the code, explanations, and diagrams...which a technical editor should have caught. When a book is not properly copy-edited or technically-edited, the problem lies with the publisher, not the author. (This is the first and last book I will attempt to read from this publisher.) Bottom line: If you already know Intel assembly language, and you have the time, patience, and knowledge to recognize and wade through all the errors, you might glean some good information. But I can't, in good conscience, recommend this book.

2 comments about Essentials of 80x86 Assembly Language.

1. I received this book in August 2006 from amazon with the assumption it would be as up-to-date as possible since it was just published. Inside the book, it says copyright 2007 --- *six months in the future*. Wow, this book should definitely be the most up-to-date information anywhere, right?
   
   NOT. This book contains ZERO information about SIMD, SSE, etc. No SIMD instructions, no MMX or XMM registers, nothing-at-all. Furthermore, it contains ZERO information about 64-bit opcodes or architecture.
   
   In other words, this 2007 book is intended for programmers who have time-machines and want to send the book to themselves about 15 or 20 years in the past. For that purpose, it is reasonable.
   
   I believe this book is intentionally organized to fake people into buying it on false assumptions. Typically, modern books begin with statements of intended audience and conventions. Then, people who browse the early pages of the book online can understand what they are buying.
   
   True, an advocate of this book could argue the term "80x86" should tell us this is a review of ancient history. However, that is merely a sound-bite cover-story, since they know many other assembly language and CPU/programming books refer to the whole series of 8086 through current Intel/AMD CPUs with this exact term "80x86". For example, "80x86" is the term Leiterman describes these architectures in his assembly language book, which includes architecture and opcodes through SSE3.
   
   And of course, the author and publisher "accidentally" (my foot) forgot to make the table-of-contents, index, and early pages reviewable on the amazon web-site. How convenient! For them.
   
   So, if you have a time machine handy, or only want to code for ancient CPU chips, and you prefer to hide from every efficient and modern feature added to CPU chips over the past decade, this is a simplistic presentation appropriate for total beginners.
   
   Consider yourself warned.
   
   I almost forgot!!! The same author has a seemingly identical book with a title that begins "Introduction to 80x86..." instead of "Essentials of 80x86..." on the amazon site, and scheduled for release on November 30, 2006 (it says). The same tricks seem to apply - they want us to click the "pre-order" button for yet another 80x86 book without table-of-contents, index, etc. Until we have some actual information, we must assume this is another ancient-history book. What's the cliche? Twice burned, shame on me? I say, shame on the author and publisher! To them I say, "make the TOC, index, into pages of your books visible". Frankly, amazon should force these guys to do that.



2. I highly recommend this book. I bought this book not to learn but to review Intel 80x86 assembly language programming. But, I believe it would be an excellent test to learn from. The author provides a working copy of MASM and a Windows Debugger to trace the execution of your code. You can see first hand what your instructions do as they execute. Also, there are PLENTY of hands on programming problems for you to code and run. This gives you the confidence to know that you actually learned something.
   
   A SPECIAL SURPRISE for me was that Richard (the author) provided a whole chapter on FPU assembly language. Something that few texts cover. And the very few that do scarcely touch on the subject. So if you want to learn Intel FPU programming this book is for you. (FPU = Floating Point Unit).
   
   WARNING: This book is NOT an advanced assembly language book. So, if you're looking to learn MMX technology commands and OS programming, this book is NOT for you. The title of the book is ESSENTIALS of 80x86 Assembly Language. It covers the basics of Intel 32-bit flat memory model console programming stilled used today. So, the book is not out of date, it just covers the basics.
   
   I RECOMMEND that before you tackle this book, which isn't very thick, that you go through Jeff Deuntemann's Assembly Language Step by Step. Why? Well, even though Jeff's book doesn't give much hands on experience that Essentials of 80x86Assembly Language does. Jeff's book gives valuable information in novice terms that helps beginners bridge the gap from high level programming languages like C++ and Visual Basic to assembly language. So, I'd buy and read Assembly Language Step by Step before tackling ANY assembly language book on the market. I'd consider Jeff's book Pre-Assembly Language sort of like there are Pre-Calculus books. Then get this book (Essentials of 80x86 Assembly Language) or Assembly Language for Intel-Based Computers by Kip R. Irvine. Both are excellent treatise on the subject.

No comments about An Introduction to 8086/8088 Assembly Language Programming (General Trade).