Customer Reviews

Virtual Machine Design and Implementation C/C++

5 star:		(6)
4 star:		(1)
3 star:		(2)
2 star:		(4)
1 star:		(4)

 

 

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.

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.

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.

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.

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.

A vanity book that no decent publisher should print.
Material about the stated subject is so outdated to be laughable.
Otherwise filled with totally irrelevant, ill-informed, pretentious material. Mostly useless code listings.

I was very dissappointed that this book does not really cover anything more than basic topics that one could get (better and more thoroughly) from a standard computer textbook.

Examples: 1) no discussion of how garbage collection works and tradeoffs [just a list], 2) no discussion about alternatives for coding the main instruction execution loop, 3) no discussion of how to implement a VM that is object aware [the subjects in chapter 8 talk about how to simulate objects in HEC - not at all the same thing], 4) no practical discussion on how to implement threading, locking, simultaneous access, etc. 5) no discussion about how to implement a VM with exception handling [again, there is talk about simulating it with HEC - again, not the same thing].

The discussion of multitasking exemplifies my problems with this book. Here are some quotes: "The bottom line is that I really didn't feel like I had a good way to implement multitasking at the virtual machine level. ... The only decision that seemed to make sense was to abandon simulated multitasking and design the HEC virtual machine to execute as a single-threaded task."

And with that, multithreading is dispatched without any help to the serious VM implementor. Similar dissmissive comments can be found regarding GUI, garbage collection, and stack machines.

I'm sorry, but I do not consider "it was too hard, so I decided not to," to be a valid excuse for an author.

Basically, the book is a discussion of a toy project invented by the author: the HEC. Unfortunately, the HEC is strictly 1980's technology.

Under no circumstance should you purchase this book to learn Java or the Java VM more thoroughly.

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.

If you are a beginner on computer technology, this book may provide some good information. Otherwise it is little value for a professional programmer. The book also can be much shorter. Don't know why it list all those source code. Kind of wasting paper.

Wordware and Bill Blunden know how to make a great book. The writing is clear and direct, without becoming dry and boring. The examples are practical, and the coding conventions are easy to understand. Bill puts everything across in a way that doesn't insult programming experts, but that any amateur could understand.

This book doesn't just cover virtual machines. It's a great book for anyone who wants to learn more about computer science in general. Bill explains how interrupt vectors work, how debuggers and assemblers work and how to make your own, the ins and outs of memory management and garbage collection, and how processors operate. It's all here.

The virtual machine featured in this book (the author's own 'HEC' program) is deftly constructed, and Bill rationalizes every part of the design process. What's good about register based virtual machines as opposed to stack based ones? Once again, he covers it all.

And, yes, his virtual machines does everything too. He even goes into working with TCP/IP, graphics, and so on. This isn't a featherweight virtual machine that adds numbers.. this can be used as an enterprise scale runtime engine!

Virtual machines are rather important these days. The whole of Java operates on a stack based virtual machine. And the entire underbelly of Perl 6 (currently in development) is a register based virtual machine called Parrot. If you want to be at the forefront of modern machine theory and technology, you need to be up to date with virtual machines. Even .NET operates as a virtual machine. If you're a Comp Sci graduate, or even just a freelance programmer, you need to know this stuff!

Even if you're already an expert and know all there is to know about virtual machines, this book is a fun read. I cannot do anything but wholeheartedly recommend this book. I've read hundreds of programming books over the years.. and this is by far the best.