Jetzt eintauschen
und EUR 0,10 Gutschein erhalten
Eintausch
Möchten Sie verkaufen? Hier verkaufen
Der Artikel ist in folgender Variante leider nicht verfügbar
Keine Abbildung vorhanden für
Farbe:
Keine Abbildung vorhanden

 
Den Verlag informieren!
Ich möchte dieses Buch auf dem Kindle lesen.

Sie haben keinen Kindle? Hier kaufen oder eine gratis Kindle Lese-App herunterladen.

Virtual Machine Design and Implementation C/C++ [Englisch] [Taschenbuch]

Bill Blunden
4.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)

Erhältlich bei diesen Anbietern.



Produktinformation

  • Taschenbuch: 500 Seiten
  • Verlag: Wordware Publishing Inc.; Auflage: Pap/Cdr (März 2002)
  • Sprache: Englisch
  • ISBN-10: 1556229038
  • ISBN-13: 978-1556229039
  • Größe und/oder Gewicht: 22,7 x 20,1 x 4,8 cm
  • Durchschnittliche Kundenbewertung: 4.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
  • Amazon Bestseller-Rang: Nr. 466.963 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)

Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Produktbeschreibungen

Synopsis

This book begins with a discussion of the theoretical underpinnings of the author's HEC virtual machine and its fundamental design goals, and continues with a section on the implementation of the virtual machine and its debugger. The final section focuses on the HEC assembler, including its interface to the native operating system, interrupts, the assembly language, and how to implement object-oriented constructs. There is also an extended discussion of porting the HEC virtual machine to other platforms. To assist in accomplishing this goal, the author offers a critical path analysis of the development process so that readers can build both their own virtual machine and an entire operating system. The companion CD contains the source code for both the Win32 and Linux ports of the HEC distribution, including the HEC virtual machine, assembler, debugger, and associated development utilities.

In diesem Buch (Mehr dazu)
Einleitungssatz
"In 1965, Gordon Moore predicted that every 18 to 24 months, the number of transistors that could be put on a chip would double." Lesen Sie die erste Seite
Mehr entdecken
Wortanzeiger
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis | Rückseite
Hier reinlesen und suchen:

Eine digitale Version dieses Buchs im Kindle-Shop verkaufen

Wenn Sie ein Verleger oder Autor sind und die digitalen Rechte an einem Buch haben, können Sie die digitale Version des Buchs in unserem Kindle-Shop verkaufen. Weitere Informationen

Kundenrezensionen

5 Sterne
0
3 Sterne
0
2 Sterne
0
1 Sterne
0
4.0 von 5 Sternen
4.0 von 5 Sternen
Die hilfreichsten Kundenrezensionen
2 von 2 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen A good start! 25. Februar 2003
Von "haupz"
Format:Taschenbuch
This is the first book I became aware of that describes in detail many of the important issues one encounters when it comes to building a virtual machine.
Blunden performs a walkthrough and deals with memory management, machine architectures, I/O handling etc. Every single one of the topics is covered in "depth" - to a certain degree, of course, but there are literature lists at the end of each chapter that provide links for further reading.
All in all, the book is very well and clearly written and understandable. Still, two very important issues are not covered in the implementation of the presented virtual machine: garbage collection and thread management are only briefly introduced, but there are no implementation guidelines as can be found for any other topic.
War diese Rezension für Sie hilfreich?
Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)
Amazon.com: 3.1 von 5 Sternen  17 Rezensionen
29 von 30 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen Should be more synchronized with recent development 3. Januar 2004
Von Boris Burger - Veröffentlicht auf Amazon.com
Format:Taschenbuch
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.
21 von 22 Kunden fanden die folgende Rezension hilfreich
1.0 von 5 Sternen Fine points, but none are related to Virtual Machines. 21. August 2003
Von "nategoose" - Veröffentlicht auf Amazon.com
Format:Taschenbuch
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.
20 von 21 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen Not an advanced book. 23. August 2002
Von Amazon Customer - Veröffentlicht auf Amazon.com
Format:Taschenbuch
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.
19 von 21 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen This is an odd book 29. Mai 2004
Von B. Schick - Veröffentlicht auf Amazon.com
Format:Taschenbuch
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.
7 von 7 Kunden fanden die folgende Rezension hilfreich
1.0 von 5 Sternen Nice for beginners 13. August 2003
Von KJ - Veröffentlicht auf Amazon.com
Format:Taschenbuch
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.
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.
Kundenrezensionen suchen
Nur in den Rezensionen zu diesem Produkt suchen

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Thema:
Erster Beitrag:
Eingabe des Log-ins
 

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen
   


Ähnliche Artikel finden


Ihr Kommentar