4 comments about Assembly Language and Computer Architecture Using C++ and Java.

1. I rank this book at the same level as the Patterson/Hennessy book on computer organization. P/H is more advanced on the hardware side (perhaps too advanced for a first course in this area) but much weaker on the software side. Reis' book is better for a first course. The software that comes with the book is well designed and works well. It allows you to work with the computer at both the machine and micro levels. I've been using the Linux version. Versions are also available for DOS, Windows, Sun Sparc, and Macintosh OS X.



2. This book is the best book I've seen in assembly language/architecture. It's very clear, thorough, and concrete. It is really superb in how it teaches system concepts. And it shows how C++ and Java works, in addition to how computers work. It has a great chapter on the JVM. It also covers the SPARC and the Pentium. By means of the included software, the reader can design, implement, and test new architectures.



3. This is one of the greatest books about assembly you can buy...
   
   I will tell you why:
   
   The most of the books (e.g. 'Assembly Language Master Class' of Wrox) which you can buy about assembly are about topics like 'how to paint a bitmap on the screen', 'how to write to a file', 'how to read a character from the keyboard', and so on.
   
   This is nice if you only want to know some little tricks and learn (nearly) nothing about assembly.
   
   If you want to learn something about assembly buy this book! This book covers nearly everything you can imagine in depth.
   
   The nice thing is that is starts like a typical B.Sc computer science computersystem/architecture class: what are numbers, what's hex, what's binary. What about negative numbers? This is a really nice book for someone without formal CS education which want to jump to that level (and beyond).
   
   It covers number theory (hex/bin/etc), Logic units and ALU, etc. etc. This book covers really everything: Virtual Memory, OO programming in Assembly (yeah read it right), different processor architectures, instruction sets, codegenerating by compilers, writting an assembler (yeah cool! 'an' not 'in') etc. etc.
   
   So: if you are looking for a tips and tricks book look somewhere else. This book starts pretty easy, so a lot of people can read this text, but after you finished this 800 page pounder you will have more insight in low level programming than a typical B.Sc/M.Sc in Computer Science (like me).



4. This is probably one of the best computer architecture books I have ever read. The thing I like about this book is that Reis does not fall into the same trap as other authors and fills the first seven chapters of the book with lessons on what binary and hex is and how to convert between the two. I have always hated when technical authors begin an advanced technical book with freshmen level topics such as number systems. Real does not repeat this typical mistake. He actually teaches advanced topics such as how the JVM actually works, or how to write a simple compiler by using simple examples and that one can build on. He is obviously very knowledgeable, but uses non technical language in order to reach you. Kudos for a job well done Mr. Reis.

5 comments about Assembly Language for Intel-Based Computers (4th Edition).

1. Great book to learn the basics of 16 bit and 32 bit Assembler coding using the 80x86 architecture.
   
   I have picked up a few tidbits that help in my C/C++ code and OS exception debugging on the job.



2. If your like me, and need a few clues in this programming world.
   Then this is a great book for extensive coverage of Assmebly Programming.
   
   It provides an easy to read and stay awake method of learning
   how to code in ASM.
   The examples work great as long as you follow along closely.
   Pick up on the key details and you'll be running in no time.
   
   Be aware that for FPU programming, refer to the online documentation
   portion of the book.



3. Being a college student learning lower level coding techniques, I was intimidated by assembler and learning a language so close to computer level.
   
   While this text is fairly dry, the author gives excellent description and examples to help the reader understand the language. The author is successful at giving detail about the methods involved in coding at various coding language levels and performing the math necessary to succeed at this.
   
   Also, Kip Irvine has very detailed web pages for all editions of this book. Very good tools are available via the CD and the web pages.
   
   Overall, this book is a great tool for the student of assembly.



4. I won't give it 5 stars because I know there are other great books out there. But I will say this it definitely is good for beginners.



5. Several years ago, I was tasked with teaching assembly language programming at the college level. Having never taught the class before and having to deliver the course on short notice and not having the opportunity to select the book, I suffered from a few pangs of mild trepidation. Those fears were unfounded; this is the book that others had selected and all things went smoothly.
   The topics are introduced in a sensible and developmental manner. Starting from the most basic of operations that are executed inside a processor and proceeding to explanations of what assembly language is; Irvine does an excellent job of setting the stage. The inclusion of the Microsoft MASM Assembler makes it a complete package and detailed instructions on how to use it appear in chapter 4. The coverage of the various features of assembly language programming is thorough, there was nothing that I felt was left out.
   Although I have yet to teach assembly language programming again, this book or a subsequent edition is the one I would select as a text.

No comments about The IDA Pro Book.

5 comments about Professional Assembly Language (Programmer to Programmer).

1. I recently had to port an assembly language program written in Microsoft assembly language (MASM) to Linux (GNU AS). This book saved alot of time by helping me to: (1) understand the differences between MASM & GNU AS, (2) efficiently compile a mixture of "C", inline assembly and pure assembly, and (3) use gdb to debug my port. Each chapter covers a topic in depth with numerous examples that include step-by-step walk throughs with gdb. Anyone who's interested in programming in assembly language on Linux will find this book a very useful reference and a great value. Highly recommended!



2. User level: Intermediate
   It's AT&T style, Linux, Intel based.
   He is an expert in explaining. Well organized Buy it and give it a start.
   I'am reading it now for the second time. Absolutely Recommended.



3. I'd just ditched windows in favor of an Ubuntu system and I wanted to do some assembly language programming. This book was exactly the ticket.
   
   The book explores a comprehensive introduction to assembly on Linux. Another reviewer objected to the word "Professional" in the title. Admittedly, this book is not an advanced guide, being aimed instead at those just getting into assembly. But the book is not for novice programmers, per se. The tutorial begins with a pretty quick overview of assembly language and its place in the programming milieu, then gives some information on the IA-32 platform and architecture. After that, you get an introduction to the tools you'll be using in the book, and then you're programming. It's fast, but not too fast and from that it's pretty obvious that the "Professional" is referring not to techniques or subject matter, but to the target audience -- professionals or relatively experienced programmers getting into practical assembly for the first time.
   
   For me, I've found the book to be absolutely perfect: competently written, exploring the toolset I find most interesting, and promoting free software and Linux. Moreover, the knowledge I'm gleaning will be practically useful, I believe, an any OS running on the IA-32 platform. Windows uses different tools, and the opcode syntax is different, but it's not night and day -- more like late morning/early afternoon. The processor concepts and knowledge transfer cleanly.
   
   If you're not running Linux or have access to a Unix-like system (Cygwin on Windows would probably do fine) then this book isn't for you. Also, if processor concepts are absolutely novel to you -- e.g., you think a register is something used to make change at a checkout line -- or you're still learning about for-loops or think HTML pages are "programs", then this book won't make you happy.
   
   But if you want to delve into assembly quickly and you like working with Linux or Unix, this is your ticket. Highly recommended.



4. This book should not carry the word Professional in the title - it is basic - very basic at best. This book is all about the Intel architecture - e.g. Intel processors. The target audience for this book - as stated in the introduction - is C/C++ programmers interested in converting their (Linux) C/C++ programs to assembly language. Consider this book if you know nothing of assembly language and you want to play around with it in a Linux on Intel hardware environment. Do not buy this book if you are interested in writing anything more advanced than simple hello world real mode apps. More specifically - do not buy this book if your are interested in writing IA-32 protected mode code - none of those things are covered in the book.



5. Although this book is mostly ok, there are two main problems: 1) it makes mistakes critical to the understanding of the material, 2) it is terrible for reference. An example of a critical mistake is when he writes "sall" (shift arithmetic left) in example code, and then refers to it as "call" (call a function) in the following text. I found around 5 such errors in the first read...some errors were so bad that they did not make _any_ sense.
   
   Secondly, the tables of instructions are scattered and incomplete. Some instructions are only mentioned in the paragraph text and often have incomplete listings of modifiers and which data they operate on. It is also impossible to find _anything_ in the index. Most of the instructions are completely missing from the index and so are other important things like assembler directives.
   
   My projection: you will read this one time (or maybe twice) and then get a better reference book to sit on your shelf.

5 comments about Assembly Language for Intel-Based Computers (5th Edition).

1. A little surprising that no reviews have already appeared on this 5th edition. The previous editions have been some of the definitive texts on the subject and the author is quite well known.
   
   Anyhow, if you have used an earlier edition, much remains unchanged. Intel has gone to great expense to make its microprocessor family largely compatible as each new generation is released. Here is a thorough description of the assembler commands. Giving examples of how to use each. Along with brief assembler programs that illustrate ideas in a chapter. There are generous numbers of section review questions for the student to tackle.
   
   Plus, how C commands are translated into Intel assembler instructions is gone into at great depth. Takes the mystery out of how compilers work. You can follow the mapping from C-level structures to how they are implemented.
   
   Perhaps surprisingly, there is considerable discussion of MS-DOS. You might have thought it was safely dead and gone. But MS-DOS still is present in many legacy applications. For some jobs, you need to know this stuff.



2. Kip's book is an excellent book suitable for textbook purpose as well as table-reference. If I could I would give it 10 stars.
   
   The way the author progresses the material makes it very easy to follow, and very enjoyable to read.
   
   There is no CD comes with the book. But you can freely download the Visual Studio 2005 Express Edition from Microsoft website.
   
   I have another book, Assembly Language Step-by-step: Programming with DOS and Linux (with CD-ROM) by Jeff Duntemann (Paperback - May 24, 2000). Comparing to Kip's book, that book is almost like a joke (no doubt for Jeff's expertise or authority on Assembly language but the way he put stuff in the book makes you feel somewhat stupid).
   
   Get the book, and enjoy the beautiful binary world with Assembly!



3. I have read a lot of programming text books, but I have never seen so much errata before. My fellow classmates and I are amazed at the amount of errors.
   
   It all started early with the book claiming that George Bool invented the Analytical Engine, instead of Charles Babbage.
   
   We also wonder if the author just cranks out new editions and just adds a few things and doesn't update the rest of the book. It took me awhile to figure out the solution to an assignment, right out of the book, that didn't compensate for newer processors(or any processor in recent history). Actually it seems like it hasn't been changed for 7 years or longer or it's just plain errata. So, I was wondering for a long while why my programming assignment would not work. I finally figured out the book was the reason. Later on there was a programming exercise that required adding to existing code in the book, but when adding lines, it would not work. I would get jump too far errors.
   
   This book could use some better organization too. Simply putting related things together in a chapter is not enough. Yes there is an index and appendices, but the organization in the chapters is poor. Better explanation would be great too.
   
   I guess I am just spoiled by Deitel's books. They are great. Too bad they don't have one on x86 Assembly.
   
   This book was supposed to have a cd-rom disc, but I don't think anyone got one. I sure didn't. The files on the cd-rom are required for the programming assignments to work. Luckily you can download the files off the web site. If you figure out that the files might be on the web site and you go there.
   
   Finally, the binding is weak, I had to re-glue mine within a couple of weeks of receiving a new copy. My professor complained about the binding too. It's too thin(or something) to hold up.



4. Having written many 8086 assembly language programs many years ago, and after having used PPC and SPARC chips for a number of years, I decided to purchase this book to refresh my knowledge of Intel assembler. I was very disappointed in the contents of this book. The title would suggest that the subject matter covered relates to writing Intel assembly language perhaps in a platform agnostic manner, however the book should rather be titled "Assembly Language USING MASM for Intel based computers RUNNING WINDOWS". The book does not even seem to acknowledge that there are other OSs apart from Windows that run on Intel based machines, and also makes use of features and peculiarities of the MASM assembler. If you are looking for a text that will assist you in writing assembler using MASM for Intel based machines running Windows then this is it, otherwise stay well clear, and try to find a text that is less partisan.



5. The books its really step by step have very good example and exercises. It covers basically evreything and has a set of table where they cover all the registers and subroutines. It was really helpful while I was taking the class.

5 comments about The 8051/8052 Microcontroller: Architecture, Assembly Language, And Hardware Interfacing.

1. This guy REALLY knows his stuff, and the book is so easy to follow. I have NEVER done assembly programming, and didn't know ANY of the syntax. After a couple of chapters, I was programming in it like I had been doing it for years. The way the author lays things out makes it a breeze to learn how to open up the world of 8051/8052. I *loved* the book, and I use it as a reference ALL THE TIME.
   
   Thanks Craig!!!!!!!
   
   Josh



2. Overview
   Mr. Steiner's writing is very clear--opening complex topics that I previously struggled to grasp. His prose is plain and easy to digest. This is a great tutorial and reference all in one.
   
   Introduction
   "The 8051/8052 Microcontroller" is broken into several sections including Architecture, Assembly Language, Hardware & Single Board Computer, Development Tools, Hardware Interface and Software Examples, and Reference & Appendixes. Each section covers the topic well with the strongest sections being Architecturee and Assembly Language. These sections provide an excellent method for "wading in" to gradually understand the concepts including special function registers (SFRs), memory--internal and external, timers, serial IO, and interrupts as well as helping raeders to understand and use assembly language in their projects.
   
   What's Good
   The book is targeted toward people who have some programming experience and understand basic logical constructs and it hits its target well. As a seasoned Windows programmer, it was simply a matter of reading through the text for me to understand most of the concepts on the first reading. I was riveted because I was understanding so much of it. Craig does a great job of not assuming you have certain foundational knowledge. I found myself at certain points in the text asking the question in my mind "yes, but what about...", only to moments later realize the text is explaining exactly what I was wondering about. Very well done.
   
   For years I have struggled to learn assembly language for the sake of gaining a better understanding of computer architecture. This is the first time that it "clicked" for me. I get it and can now write code using Assembly. Now, I will be using C for my projects for the most part because it asbtracts certain aspects of writing the code that are arduous when done in Assembly, however, understanding Assembly has really helped me to see exactly what is going on.
   
   What's Bad
   There is really nothing bad about this book. It is not only a good text for deepening in your understanding of the 8051/8052 architecture, but is an excellent reference to keep on your shelf when you need to recall some specific details.
   
   That being said, I would have liked to see a section dedicated to building and/or simply using a pre-built chip programmer. This is really not a criticism because the book is really comprehensive. For me to understand at a practical level, though, it would be helpful to learn how to take the most basic elements (the MCU, crystal, capacitors, etc.) and place them on a circuit board and see them work with code that I've just downloaded to the MCU.
   
   The section on the SBC is really good, but it feels to me like it abstracts an important part of embedded system development--assembling the parts. I want to see how things work outside of the context of a development board. Maybe Craig will add a chapter dedicated to building a basic system from parts and a programmer in the next edition.
   
   Conclusion
   "The 8051/8052 Microcontroller" is an excellent book to use to get started as well as a great reference. I have several other 8051 books including "Programming and Customizing 8051 Microcontroller" by Predko, "C and the 8051" by Schultz, and "Embedded C" by Pont. They all have their good points, however, Steiner's book brings things together in a way and doesn't assume much about the reader's base knowledge and gave me many "aha" moments I hadn't experienced with the others. If you want to learn the 8051/8052 microcontroller, buy this book!



3. Well written and complete technical books are hard to come by; this is one of them.
   After reading this book one will have no troubles programming and applying the 8051/8052 MCU. I found no other books were necessary.



4. I have found this book to be very interesting as it was written by someone who learned the 8051/52 by doing in both hardware and software. Get this book!



5. This book is a very nice example of how to write a technical book on a reasonably complex subject without making any assumptions that the reader knows anything. I had never touched an 8051/8052 prior to this and haven't written any assembly since college. To give a point of reference, I have desigend a few reaonably simple applications on PIC processors (1 8bit and 1 16 bit) prior to being assigned a project on an 8051. After reading this book I realized a whole new level of understanding of things I was fumbling around and getting done, but never really quite grasped the down and dirty detail. I'd been designing my applications in c because I was convinced ASM is too dry and too hard.
   
   Craig leads you down the garden path and before you know it, you actually feel like you should be doing certain things in assy rather than in C. Also, I've gotten a little vision of how things work in the background quite a bit better than before.
   
   Good job! I'll recommend it to others transitioning to this device.
   
   I thouroughly enjoyed this read.

5 comments about The Art of Assembly Language.

1. This book is 900+ pages of outstanding material on what is really an art - assembly language programming. The author, a university professor, has done what so many other authors have failed to do: take a complicated subject and break it down into easy-to-digest pieces. More importantly, it's written in clear, understandable language. Although not for the faint hearted - you really have to want to learn assembly language programming - the serious student should have no problems. What's really neat (IMHO) is that the author's proven system - called High Level Assembler (HLA) - is used throughout the book. HLA, although slightly different from 'regular' assembler, is easy to learn and very, very logical. The CD-ROM included with this book contains the HLA, the HLA library of routines, all of the source code in the book and over 50,000 lines of sample code. Again, if you want to learn assembly language, this is "the" book you should have in your library!!!



2. I am familiar with writing true assembly language programs for microcontrollers. Granted, while they are very different than PC processors, the fact is that HLA leaves something to be desired. It may have the power of assembly, but it doesn't have the feel. It should have been titled 'The Art of HLA' which would have still sounded good, but would have also given the customer a hint about what is inside the book. I'm going to keep it, but I'm not happy with the product.
   
   True assembly is beautiful with respect to form, as there is little abstraction between you and the machine. This way there is no incongruencies between what you want it to do and how you say you want it done.



3. My goal in reading an assembly book is to eventually learn fasm. I must say, after reading the first 2 chapters of this book, I am very disappointed! I definitely REGRET the fact that I paid for this book before looking into it further. I have a working knowledge of C++ and I must say, HLA looks more like C++ than fasm code. I can only surmise that the good ratings this book has gotten are from people who haven't seen traditional assembly code, and are convinced that its "assembly" or are actually interested in learning HLA. For a more traditional lesson in assembly I would recommend Assembly Language Step-by-Step Programming with DOS and Linux ISBN: 0471375233
   
   Although I have skimmed through the entire book, it is true that I have not entirely completed this book. I am in fact a bit nervous about the idea of finishing it. I however, am going to finish it. If I feel that the book has enlightened me to the ways of assembly through some profound psychological trickery, I will let people know at Random-Seed.net



4. Well, after four years of reading these reviews, I thought I'd put in my two cents.
   
   One recurring theme you see in all of these reviews is the following: if someone already knows assembly language, they tend to dislike the use of HLA as the teaching vehicle for learning assembly language. On the other hand, if they're a newcomer to assembly language, they tend to like the approach that Art of Assembly uses. Quite frankly, I wrote "Art of Assembly Language" (AoA) for this latter category, not for those who already know assembly language, so I am rather gratified by the response from those who are actually using AoA to learn assembly language.
   
   When someone sets down to write a book on x86 assembly language, one of the first decisions they have to make is "which assembly language syntax do I use?" The x86 is blessed/cursed with literally *dozens* of different assembly language syntaxes. No matter *what* assembly language syntax I chose, there would have been someone complaining about it. If I'd gone with GNU's as (gas), there would have been complaints about the syntax. Had I gone with FASM, the NASM crowd would have been put off.
   
   Probably the "safe" choice would have been to go with MASM (which the earlier, 16-bit version of the book, used). No doubt, many of the complaints about how I used HLA instead of a different assembly language syntax would have gone away had I done this. The funny part is that MASM is *also* a high-level assembler, having almost all the same high-level control constructs found in HLA. The same is true, by the way, for Borland's Turbo Assembler (TASM). From a language feature point of view, there really isn't much difference between the high-level facilities of MASM, TASM, and HLA. Maybe it's just the name that freaks people out.
   
   Some reviewers have commented that this is the wrong way to teach assembly language. Well, having taught assembly language at the University level for over 10 years, I must respectfully disagree. I've used HLA (before AoA was available) and the students did *far* better in the course. They got much farther along because they were able to apply their HLL programming knowledge to problems early in the course. By the time the course covered the low-level machine instructions, they were doing quite well. The courses I taught with HLA worked *much* better than the comparable courses I taught with MASM. The bottom line is that this teachnique technique has been classroom and laboratory tested. Interested individuals might want to check out my white paper on this subject:
   
   I will make the following observation about AoA: if you already know assembly language, you're probably not going to like the presentation because it's completely different from the way *you* learned assembly and most people seem to think that the only way to learn something is the same way they learned it. On the other hand, if you don't know assembly language and you want to learn it, pay particular attention to those reviews from the people who used AoA to learn assembly language.
   Cheers,
   Randy Hyde



5. I'll be very brief: this book is wholly useless. It isn't the technical expertise of the author or his writing that make it so -- Mr Hyde is an intelligent and accomplished man; his writing is good as always. What makes this book a complete and immediate failure is that it IS NOT ABOUT ASSEMBLY LANGUAGE in the sense that most people think what (the) assembly language is (the title is a blatant misrepresentation, or, at best, a disingenuous, self-serving play on the fact that there's no FORMAL assembly standard in existence).
   
   The author concocted some sort of intermediate-level, C-like language, which he called HLA (high-level assembly), and _this_ is what this THICK book is about, at least the most of it. This language is built on top of MASM, but it isn't MASM (by MASM I mean the language syntax, not assembler program from Microsoft).
   
   Why in the world would one spend one's time learning this language? When one needs to learn PC assembly, today, for all practical purposes it means one thing: MASM. Unixes use different assemblers, but so long as you're writing for an x86 processor, moving from the MASM assembly syntax to, say, Intel assembly syntax is no big deal. A book on x86 assembly language should be based on MASM -- or, at least, something equivalent and more or less standard, if not de jure, then de facto. HLA is neither standard, nor widely used; nor can I think of anything it *would* be useful for.
   
   This is a well-written but self-indulgent book that no one needs, a literary white elephant. I hope the author will recover his senses, trash HLA, and publish a second edition based on the good old bare-bones MASM assembly. (Either that, of the title should be changed as suggested above ;-)

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

1. This book appears to be good for true beginners. It is, however, quite large and for its size still chooses to put some important details "out of scope". Its choice to remain with NASM, even in the Linux world, is a little frustrating and limits the books use.
   But it is an easy read, and does cover the most basic stuff (such as computer design, file formats, etc).



2. This book will teach you how to program in Assembly
   
   No doubt about that. But it WILL put you to sleep.
   
   If you can endure lengthy explainations
   then you may find this book useful.
   And you can always pick up little things from different sources.
   This is a great alternative source.
   
   Otherwise check out:
   "Assembly Language for Intel-Based Computers (4th Edition)"
   
   For a more fast paced, easier to understand method of coding ASM programs.



3. This book was excellent! It starts with the basics and works you though the steps required toward working with Assembly. Even if not programming,. it gives great insight on understanding the inner working of the processor and memory. A definite must for those interested in debugging the Intel processor.



4. The first couple hundred pages review number bases, computer architecture, and for the most part answer that perplexing question, how does a computer work? The author then covers assembly language in DOS, which is kind of outdated but still very informative. At the very end of the book the author covers assembly language in Linux. Even if you are not looking to learn assembly language I recommend this book. It is very informative and a must have for any programmer.



5. At page 151, author said "That's why I began at the real beginning, and took 150 pages to get to where the other guys start."
   
   That is really true, 150 pages wasted!!!
   
   The author is trying to be funny, but actually made it look even worse.
   If you are interested in assembly language, there are several online tutorials which are actually much better than this book.

5 comments about Write Great Code, Volume 2: Thinking Low-Level, Writing High-Level.

1. I earned my Computer Science degree several years ago. During my studies I learned languages like Assembly, Modula-2, C and C++ and even a little VB in a computer graphics class. I learned quite a bit about how computers work at the binary level and even got into some Electrical Engineering topics.
   
   As you might expect, I don't use any of those languages in my career today. It's all Java, LotusScript, and other high-level languages for me these days. I rarely find myself shifting bits or thinking about logic gates. Does this mean my CS degree was a waste of time? Absolutely not. Although it would have been nicer if I had been learning Java... :-)
   
   It's not the languages I learned that gave the education its value. It's the algorithms, patterns and logic that have come to my aid again and again. An understanding of what's going on inside the computer can be very helpful at times. That's why I was so interested in reading Randall Hyde's book: Write Great Code, Volume 2: Thinking Low-Level, Writing High-Level.
   
   This book teaches the following concepts (Chapter 1 excerpt):
   - Why it's important to consider the low-level execution of your high-level programs
   - How compilers generate machine code from high-level language (HLL) statements
   - How compilers represent various data types using low-level, primitive, data types
   - How to write your HLL code to help the compiler produce better machine code
   - How to take advantage of a compiler's optimization facilities
   - How to "think" in assembly language (low-level terms) while writing HLL code
   
   The general goal of this book is to teach you how to think like a compiler so you can anticipate what the compiler will do with your code. Randall Hyde is also the author of The Art of Assembly Language. It would be an understatement to say he has a good handle on this subject. Chapter 3 goes into detail on 80x86 assembly for the HLL programmer while chapter 4 looks at the Power PC. Chapter 5 looks at compiler operation and code generation. This chapter gave me major flashbacks to compiler class.
   
   In chapter 9, the author includes a great discussion of arrays and how they are handled by various languages. Another topic, in chapter 12, that I found very interesting was the discussion of variant data types. (Us LotusScript developers mustn't forget to use 'Option Declare.') Chapter 15 includes a description of various types of loops and hammers home the importance of coding efficient loops.
   
   We spend so much time these days trying to abstract everything and think at a high-level. That's all fine and good but we can make better high-level decisions by understanding the low-level workings of compilers. Readers who are experienced developers with a genuine interest in writing quality code will get a lot out of this book. I especially recommend it for career developers who didn't have the benefit of formal Computer Science training.
   
   At the end of the book is a teaser for the next book in the series: Write Great Code, Volume 3: Engineering Software. In this book, Hyde will discuss "personal software engineering" and will focus on craftsmanship, art, and pride in workmanship. I'm looking forward to that one too.



2. Back in "the day", you really couldn't write high-level code without at least some exposure at some point to lower-level code, like Assembler. Now, you can pretty much be completely ignorant of what happens in your Java or VB code "under the covers". But that doesn't mean you can't benefit from understanding how your compiler turns your readable code into machine-readable operations. Randall Hyde does an excellent job in explaining all this in his book Write Great Code Volume 2: Thinking Low-Level, Writing High-Level.
   
   Contents: Thinking Low-Level, Writing High-Level; Shouldn't You Learn Assembly Language?; 80x86 Assembly for the HLL Programmer; PowerPC Assembly for the HLL Programmer; Compiler Operations and Code Generation; Tools for Analyzing Compiler Output; Constants and High-Level Languages; Variables in a High-Level Language; Array Data Types; String Data Types; Pointer Data Types; Record, Union, and Class Data Types; Arithmetic and Logical Expressions; Control Structures and Programmatic Decisions; Iterative Control Structures; Functions and Procedures; Engineering Software; A Brief Comparison of the 80x86 and PowerPC CPU Families; Online Appendices; Index
   
   This is the type of book that will really excite you if you're wondering why a nested if statement performs differently than a case statement. Hyde explains basic compiler theory, and applies that to how your compiler of choice decides on optimization strategies. It's impractical to get a program optimized for all factors, like code size and speed, but there are reasonable trade-offs as well as compiler options you can use to prioritize one factor over another. You also don't have to be completely conversant with Assembler in order to work through this book. He uses a number of high-level coding examples from various languages (like C, C++, and Pascal) that should be understandable to most any IT developer. He then shows the translated code at the assembler level and explains why a particular compilation might be good or bad (depending on your requirements). Once you start to understand how (and why) your compiler "optimizes" your code, you can make more intelligent choices as far as programming constructs. There is often a dozen ways to do something, but a few of those ways will be far more efficient at the machine level than the others.
   
   If you're writing a program that runs in a second or two, these techniques may not necessarily have an immediate practical application for you. But that hour-long program may have the same underlying problem as your first program, and it could be that a slight change in program structure at your end could dramatically reduce the run time. This is one of those books that most serious software developers should have sitting on their shelves...



3. The first 100 pages of this book were fantastic for concepts. After that, there were numerous code listings of various dialects of assembler that were each several pages in length. The premise is that you should learn to read assembler so that you can write better high level code. However, there is no tutorial on what the various assembler keyword instructions mean. This book feels like it was slapped together because it was the long overdue volume two in the series, and has so many references to the first volume that you practically need to own both. There is not enough on Java (or OO in general) as the reader's high level langauge of choice, and far too much on Pascal.



4. In this RAD time when anybody who knows drag-and-drop can proudly claim himself software developer, this is the unique book for true, serious, and hardcore programmer that writes native codes. I completely agree that, in order to write efficient and optimized code, you not only need to understand what your compiler can do for you,but also you should know, at least for a minimum level, what you can do for you compiler. In this regard, this book does an excellent job explaining the magic your compiler does for you and what you can do to become part of the magic. As such, I highly recommend this book to any serious programmers.
   
   The only thing I don't like about this book is that it appears to be giving too much space to HLA, which I suspect is a widely accepted assembly dialect that was actually used in any real-life project. And I just feel it is a waste of my time trying to understand and catch up with this HLA language. This results in my taking one star off with the final rate of 4 stars.
   
   Other than that, this is indeed a very good book.
   
   In a previous reivew, it is complained that Java is not touched. This is understandable while it really doesn't seem to be a problem to me. Java after compiling is translated into bytecode that has to be executed on the virtual machine. I guess that is really beyond the intended scope of this book, which is related to the world of native codes that after compiling can be directly executed by the machine.



5. How Software Works would also be a great title for this volume. Any high level construct you can think of is analyzed in-depth at a low level. This is great for those interested in reverse engineering or writing cleaner code.
   
   This book is language and hardware neutral. Languages from Pascal to C++ to Visual Basic are covered on hardware from x86 to RISC to embedded systems. No matter what language you code in the innards are laid out for you. The author does a masterful job of the idiosyncrasies of different languages seamlessly without dwelling on the trivial. This book is heavy on assembled code, compilers, and interpreters. It's an absolutely great collection of everything you wanted to know about how software works that you really can't find elsewhere in a single volume.
   
   Although the subject matter is probably dry for some, I found this book surprisingly easy to read due to the clarity of the writing. This is at least as good, or better than volume one. With that said, there are a number of references to volume one, and I do recommend reading volume one first unless you have a solid background in computer architecture.

5 comments about Learning UML 2.0 (Learning).

1. Excellent book. Entertaining, not distracting with formal details or innecessary stuff that only appears in the UML specification. This book will give you excellent practical insight on the stuff that matters in the day to day development using UML.



2. I found the presentation pragmatic, readable, and practical.
   It is easy to pick a UML Diagram type you want to use and start reading, drawing.
   UML is a straight forward notation and these authors presents it as such. (Perhaps because it is straight forward many other authors seem to make their UML exposition much more complex than it needs to be).



3. I liked this book better than "UML 2 for Dummies". I thought "Learning UML 2.0" was more concise and had more illustrations per page of the UML diagrams being introduced.



4. I found this book to be largely readable and comprehensible. The writing style is fluid and the book is laid out well. One notable omission is a quick reference chart -- but the chapters are well laid out enough and short enough that I don't think it will be much of an issue in practice. I recommend this one.



5. I've read a couple of other books that talk about UML, but they seem to just skim the surface and try to talk simple to you. This book is truly for someone who wants to learn about UML and how to use it properly.
   
   I recommend reading through the whole book once quickly and then go back and read it again carefully. I believe that's the best way to learn the details presented in this book.