The core of Java technology, the Java virtual machine is an abstract computing machine that enables the Java platform to host applications on any computer or operating system without rewriting or recompiling. Anyone interested in designing a language or writing a compiler for the Java virtual machine must have an in-depth understanding of its binary class format and instruction set. If you are programming with the Java programming language, knowledge of the Java virtual machine will give you valuable insight into the Java platform's security capabilities and cross-platform portability. It will increase your understanding of the Java programming language, enabling you to improve the security and performance of your programs.

The author employs a tutorial approach that provides a detailed look into the central workings of the technology and teaches the reader how to write real programs for the Java virtual machine. He describes methods for becoming a better programmer through an advanced understanding of the Java virtual machine and Java technology. Programming for the Java Virtual Machine offers comprehensive coverage of all the major elements of the Java virtual machine--classes and objects, control instructions, debugging, class loaders, compiling the Java programming language, performance issues, security, and threads and synchronization. The book provides an introduction to the Java Virtual Machine Specification (JVMS), with a collection of topics that help programmers understand the Java virtual machine and the JVMS better. In addition, the book features implementations of Prolog and Scheme, a language that runs on top of the Java virtual machine, generating Java virtual machine code as it runs and using a Java virtual machine class loader to load the generated code into the system.

You will find detailed information on such topics as:

• The Java virtual machine verification algorithm

• How Java virtual machine security works, and what it can and can't do

• Using class loaders to incorporate code and dynamically generated code from the Internet, the Java Foundation Classes, database queries, and other languages

• The mechanics of compiling the Java programming language for the Java virtual machine

• Implementing other languages using the Java virtual machine, including Scheme, Prolog, Sather, Eiffel, and regular expressions

Numerous examples illustrate techniques and concepts, and exercises with solutions help you gain practical experience.

0201309726B04062001

Amazon.com® Reader Reviews (Ranked by Helpfulness)

Average Amazon.com® Rating:  Based on 5 Ratings

Slim on content, not an expert tour. - 2000-03-31
Reviewer Rating:
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.

Good Tutorial Introduction to the Java Virtual Machine - 2000-05-23
Reviewer Rating:
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.

Excellent anaylsis and tutorial! - 2000-04-18
Reviewer Rating:
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.

Extremely good book on JVM internals - 2007-04-13
Reviewer Rating:
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.

Decode the JVM Specification - 2006-05-21
Reviewer Rating:
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.

Browse Similar Topics

Top Level Categories:
Programming

Sub-Categories:
Programming > Java