Virtual Machine Design and Implementation in C/C++ (With CD-ROM)

Rating:
Summary: Truly Inspiring
Review: Blunden's "Virtual Machine Design and Implementation in C/C++" inspired me to write my own VM, and that is far more than I can say for other books. This book is so well written that it changed the way I thought and I felt enlightened. This is one of my all time favourite books - period. On *any* subject.

If you're a computer engineer or are intimately familiar with computer architecture or VMs, you will probably be disappointed because you'll cover ground you're already familiar with. But for everyone else, be prepared to stay up all night reading. You WON'T be able to put this book down!

Blunden starts at the very beginning of designing and specifying a virtual machine, then justifies his design choices and discusses alternatives. He presents the design and implementation of the HEC VM *System* - not just a VM. You'll go all the way here: assembler, debugger and the kitchen sink. If you're mystified at how assemblers, debuggers, compilers, abstract/virtual machines work - or even real computers and indeed operating systems, then you'll LOVE this book.

Blunden covers memory management in detail early in the book, and discusses instruction set architecture in detail. He covers the HEC runtime and the way opcodes are interpreted and executed. Then he discusses the design and implementation of an assembler and debugger. HEC's compiled assembly files/object code files/executable program files are dissected and studied in detail, along with HEC's entire instruction set and its format. System interrupts are treated in detail. Interfacing with the host system and using the TCP/IP networking facilities available there is discussed and illustrated with code from the HEC VM. You could build a sophisticated VM like the Java Virtual Machine from what you'll learn in this book. Even if you don't find HEC itself very exciting, the concepts you'll learn by following the book and studying HEC will stick in your brain and inspire you when you design and write your own systems; virtual machine, operating system, assembler, debugger, or whatever.

Even if VMs are only somewhat related to what your project is - such as an operating system or assembler, debugger and linker - you WILL find this book inspiring and packed with readable and useful information and insights.

The title is a little misleading however - there is no C++ to speak of in this book, save for a couple of pages toward the end. (Typical dishonesty from marketing and sales types). It's all C.

Rating:
Summary: Should be more synchronized with recent development
Review: I am more or less dissapointed with this book's contents, largely because I expected a bit more modern treatment of the subject.

What greatly dissapointed me was that the author doesn't compare his VM against others, which is quite a pity because there are modern languages interpreted using VMs like Java, Perl, Python and many more. This and some more facts suggest that the author is not in sync with current development in the field.

An another surprise for me is that the VM introduced is register oriented. I don't quite understand and agree with the arguments behind this choice, as opposed to stack based VMs. The author explains about computer processors that utilized the stack based architecture in the past that were outperformed by register based CPUs, thus they are not manufactured anymore. Which is a misleading fact, because registers of a VM are located in memory arrays, and suffer from the same efficiency penalties as the stack does.

Targeting a register based VM is much more difficult than with stack based VMs, but the author doesn't take attention to this fact. More precisely, he doesn't say a word about generating code for his VM aside from a simple assembler, that is explained at great lengths in a separate chapter, which I find somewhat uninteresting and off the topic, because only a few people really write code for VMs in assembler.

The book contains lots of code listings, that the author comments on well. The language used is much more C than C++, which is a pity in my opinion, but hey, the programming tastes differ.

What is worth noting, the author doesn't go beyond a naive one-large-switch VM implementation, which is not to blame, but it would be appreciable if the author noted some optimization techniques for VMs like direct-threading, inline-threading and just-in-time compiling.

Bill Blunden is overproductive in some areas, for example he tends to describe on a number of pages techniques like threading, but in the end only to explain that the VM doesn't contain any thread support at all.

In the end, I enjoyed some parts of the book, as it contains some notes about computer science history. But I can't avoid the feeling that the author got stuck in '80s and is not aware of the recent development.

I do not say that the book is bad, it just didn't fit me.

Rating:
Summary: Excellent, and well-rounded, introduction
Review: I really appreciate Blunden's approach to the material. The books offers an outstanding overview of system software material that the other books fail to mention. For example, not only does Blunden offer a debugger for his own virtual machine, but he also explains debugging on Intel and provides a working example.

Macro assemblers are another one of those little-explored regions of computer science that Blunden dives into head first. All the gory details are analyzed and nothing is left to the imagination of the reader or as homework exercises.

The VM that the book focuses on, the "HEC" virtual machine, should be easy to understand for both beginners and professionals. Along the way, Blunden explains his design decisions and justifies his methodology in term of his primary architectural goals.

Well done, Blunden!

Rating:
Summary: Not an advanced book.
Review: I was extremely disappointed with this book, especially as it received so many positive reviews here on Amazon.

To begin with, this book is billed for intermediate to advanced programmers. This book has little to offer for an "advanced" programmer. However, it's not bad for an advanced beginner to intermediate reader. The concepts discussed are simplistic. Only one short chapter is dedicated to the actual virtual machine. Blunden devotes more pages to discussion of basic data structures like symbol tables and hash tables than he does to his virtual machine. His biggest chapter is devoted to implementing a macro assembler for his machine. A discussion I would expect in a book on compiler design, but which I found somewhat unwelcome here.

His coverage of virtual machines leaves much to be desired. The two primary topics that interested me, multi-threading and garbage collection, aren't even covered. Blunden describes them as complex topics, and therefore he leaves them out of his virtual machine. Since the reason I read books is for discussion of "complex" topics, this feels more like a cop-out than a design decision to me.

If you read his code, please don't try to emulate his coding style. He describes data types that he never uses, choosing instead to reimplement concepts every time he uses them. He exports public members of C++ classes, uses descriptive function arguments like "ptr", and spends a lot of time talking about optimizing things that don't really require optimization. (Loop unrolling your debugging statements?) He switches to C++ halfway through the book, but fails to take advantage of any of C++'s strengths. I almost get the feeling his editor told him that his book would sell better if he listed C++ in the title.

I'm sure Blunden is a smart man, so I'll give him the benefit of the doubt and assume that his assembly language background is peeking through. But if your interest is virtual machines, I suggest one of the many good books on the Java VM. If your interest is compilers, stick with the Dragon book, or check out Allen Holub's book if the Dragon book is too rigorous. If you're looking to learn C or C++, look elsewhere.

Rating:
Summary: This is an odd book
Review: It reads like the personal diaries of Bill Blunden as he endeavors to build the HEC virtual machine. The best aspect of this book is that Mr. Blunden has done a decent amount of investigations into the process of building a VM. He describes all of the components of his VM with abundant detail and clear writing. The HEC VM is more of a toy than a commercial VM, but its design is informative. Mr. Blunden also gets credit for included error handling in his code. Too many other books skip error handling "to save space". This book also happens to be one of the only VM books I've found that is not about the Java VM (which is a stack machine as opposed to a register machine like HEC).

Unfortunately there are several problems with the book. The biggest problem is confusion about its target audience. In many places the book appears to be written for totally inexperienced developers while at other times it assumes a decent amount of existing knowledge. For example, the book describes that disk access is slower than RAM access, what a debugger does, provides lots of details and code examples of simple data structures like dynamic arrays, etc. At the same time the book assumes good working knowledge of the C, C++, and Java languages, an understanding of file I/O, and other concepts. How many developers know C/C++ and Java but don't know what a debugger is for?

The next problem with the book is the actual code. It has many security problems such as unsafe strcpy and scanf usage, too many unnecessary preprocessor macros (created for unconditional code blocks that are only used once), and strange C style C++ code (classes that are passed their own data members).

The final issue is the book's personal diary style. Some people may enjoy this, but I did not. The book is filled with little sections labeled "Rant" where Mr. Blunden goes off on something. In a strange section about the future of computers he comes up with this: "Imagine how a government could use this kind of tool to repress its citizens by instituting behavior modification on a national scale." And what does this have to do with building a VM? If I wanted a novel I'd buy one (or write one in an Amazon review :)

If you are a C/C++ developer and want details about building a VM, this book gets very slow and you will end up skipping 30 to 60 percent. If you are an inexperienced developer, however, the example code may be over your head. In the end, I'd say this book is best suited for new developers (or even non-developers) who want background information about computers and virtual machines, but don't care about using the example code. The book would be a 3 to 3.5 star for someone like that.

Rating:
Summary: Comprehensive and Detailed
Review: This book describes, in a simple series of steps, how to construct a production-quality runtime system. This includes powerful features like TCP/IP networking, interfacing to native code, and synchronization primitives. Everything that you would expect from a commercial runtime system is presented in explicit detail.

This includes the source code and documentation for a full set of development tools (like a bytecode assembler, symbolic debugger, and binary analyzer).

There is also an extended discussion of how the book's virtual machine can be ported to other platforms. To this end, the author offers a critical path analysis of the development process so that the reader can build their own virtual machine. This is followed by a critical path analysis of the procedures necessary to build an entire operating system!

The author obviously knows what he is doing and is coming from a heavy 80x86 background. There are several points in the book where the author discusses actual hardware implementations of system I/O, paging, and interrupts. You can tell that Barry Brey was the technical editor.

What I liked best was the authors explanation of how object-oriented concepts are implemented in bytecode. Probably the most concise discussion of exceptions, encapsulation, and inheritance that I have ever seen. Cool.

Rating:
Summary: Answers the age old question
Review: this book shows the good example of beginning course book about computer system. However, I am sorry that this big book cannot provide useful information about its title.
If you already know compiler and computer architecture, reading this book make your time wasted.

Rating:
Summary: Quite a entry level book, no much useful information
Review: Though there were several topics that this book covered that I liked, the author (Bill Blunden) seems very confused about many other things. It was obvious that Mr. Blunden's formal education was not in computer science. He would go through lots of trouble to "optimize" protions of code (instruction handlers), making them unreadable, that any decent optimizing compiler could have taken care of. Then he would go and do something silly like passing data (argc and return values) between the VM and native libraries in XML. The 2 cases for using a native library call from VM code are for added speed or to make a system call. The conversion to/from XML adds bunches of overhead where it is needed least.
The author also says nasty things about his experience porting the HEC VM to Linux that don't make any sence (though the publisher seemed to really push the fact that there was a Linux port). He states that the only way to use a shared object library from a Linux program is to include it at compile/link time. This is silly, since under Linux, all shared object libraries are loaded at run time, even those that are specified to the linker (by way of ld-linux.so) (see dlopen(3) "from Solaris" and uselib(2)). Besides, Java does it, so I can't be imposible. The author says nasty things about the documentation of Linux sys-calls and libraries with his distribution in comparison to MSDN. What he doesn't notice is that he has paid for WindowsXP, Visual C++, and MSDN (3 separate products or 2 if MSDN comes with VC++). Under Linux, this was not the case, as all he paid for was a distribution and got the developer's tools and the man pages (specifically sections 2 and 3) as well as the standard OS (as compared with WinXP).
His Linux port of HEC was half hearted, in that he seemed to have bought a distribution (new to him) with the intent to port, while he was used to programming with VC++ for Windows. He claims early in the book to have been an old Unix guy, but I find that hard to believe. I am a Linux programmer. I rarly write anything for any MS OS that is not trivial. I know that if I were asked to, I would have a bunch of learning to do.
Another thing about this book that was annoying was the constant process of going over a topic, seemingly as an included feature (like multi-threading) in the VM, only for him to decide that it would not be added. Because of this, his VM seems weaker to me.
The author also was very anal about not running in Virtual Memory. WHY?? It should be a user choice. He omited the restriction from the Linux port because he couldn't figure out an easy way to find the free memory (parsing /proc/meminfo was too hard, while parsing XML in the dynamic loaded library system was not, no mention of free(1)).
Further, the files on the CD (under linux/ ) are not set to reasonable permissions and he uses shell scripts where Makefiles would normally be used.
Many other things that I didn't like, but I'm tired of typing.
Things that I did like were his coverage of the implementation dynamic binding of functions/methods in object oriented programming and his coverage of 2 versions of exception handling.

Rating:
Summary: Nice for beginners
Review: When I read about this book, I thought it would be *the* reference on virtual machines. Quote from backcover: "Discusses in detail (...) --everything expected from a commercial run-time system". It is true that some interesting features such as multi-threading and garbage collection are *explained*, but NOT implemented. The author writes he wanted to keep things simple. These features are quite important, and also expected from a commercial run-time system. The VM that results is quite simple, and could be easily programmed by any programmer with some experience and insight. For people who are looking for much detail on threads and other interesting stuff, go look for something else.