Virtual Machine Design and Implementation C/C++ [Paperback]

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.

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.

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.