Customer Reviews

Programming for the Java™ Virtual Machine

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

 

 

The first five chapters of this book provide an introduction to programming in "Java assembly language" using the assembler included on the CD-ROM. This introduction does a good job of explaining the JVM instructions, but could have used more exercises to help the reader learn and practice using more of the instructions. Additionally, the chapters, appendices, and index could have been better organized so that I didn't have to keep flipping through pages to find the syntax and semantics of instructions.

The remainder of the book explores various areas such as verification, debugging, the class file format, security, and most importantly, compiling Java and other languages into JVM code. Mostly, this material is a tutorial introduction to information provided in the Java Virtual Machine Specification, but there is some original material in the chapters devoted to compiling Scheme and Prolog.

Be aware that this book contains numerous errors; you'll want to grab the errata list from the Addison-Wesley website.

Together with author's reference implementation in CD, this book is a "must" tutorial for anyone who wants to translate other languages (scheme, prolog...) into java bytecode. It starts with discussions of jvm and bytecode, and then gives deep anaylsis of java the language from the viewpoint of bytecode. From this, reader gains significant insight on how to code in java the best way.

Although the book can expand more on its scheme->java implementation, I find it a very good starting point for any serious work. I wholeheartedly recommend the book to anyone interested in java and its jvm.

This is truly a classic that will live on for years. This is a good read even for people who aren't into Java. The VM concepts are well explained here, and the text is surprisingly easy to read, given the heavy nature of the subject. The JVM versions have moved on, but this covers the basics very well, and is an excellent starting point for anyone who wants to know what a Virtual Machine is about under the covers.

Although this book gives some useful insights on compiling other languages into JVM bytecode, it doesn't present any revolutionary concepts. It is not an expert or comprehensive reference by any means and wastes way too many pages on explaining the syntax of the oolong language rather than the workings of the JVM itself. For instance the bytecodes generated and the behaviour of the 'finally' clause in isolation is explained, but not in conjuction with exceptions which it is most commonly used. Unfortunately, like so many other Java references, it resorts to wasting pages on printing Java APIs (in particular the security APIs) when Javadoc in html form is so much more efficient to read.

Having said that, the section on verification is interesting and the book itself does spark the imagination of what is possible (and what is not) with JVM bytecode.

Java programming language can be visualized as being composed of 2 components
1. Java Compiler - Compiles the java programs we write to byte-code in .Class format.
2. Java Virtual Machine (JVM) - Executes the byte-codes that is in .Class format.

This essentially means that the JVM only cares about the byte-codes, and not about the high-level language that was used to program it. As you can see, this seperation of concerns opens up a lot of possibilities like
1. You can write a java program and compile to byte-code
2. Directly write byte-codes
3. Write code in some asssembly language and assemble it to byte-codes
4. Write code in an interesting scripting language like Ruby or Python and compile it to byte-codes.

All paths lead to the same destination; JVM can run the resulting byte-codes. The possibilities are endless if you have this understanding. In fact, there are more than a 100 languages that compile to java byte codes at present.

In this book, the authors intention is to get you started with the JVM features and how you can write programs that can be executed by the JVM. In the process you will learn the following...
1. What is inside the class file: An assembly language called Oolong, whose mnemonics closely resemble the class file op-codes is used to explain this concept. The author has clearly done an excellent job in decoding the JVM spec for this purpose.
2. Class loading: Loading classes into class area, statics etc are well explained in this section.
3. Byte-Code verification: A very important topic that is addressed only at a shallow level here. This is acceptable, as the intention of this book is an introduction to get you started and not as a reference for the JVM.
4. Compilling other languages to byte-code: Languages like scheme and prolog are used as examples to show how to compile other languages to byte-codes
5. Security in the JVM

If you are one among those who want to learn JVM, but not patient enough to digest a spec, then this book is for you. But, if you are a determined person who wants the full details of the JVM, then you should be typing in "The Java(TM) Virtual Machine Specification (2nd Edition)" in the Amazon Search box.