Programming for the Java Virtual Machine (Anglais) Broché – 22 juin 1999
|Neuf à partir de||Occasion à partir de|
- Choisissez parmi 17 000 points de collecte en France
- Les membres du programme Amazon Prime bénéficient de livraison gratuites illimitées
- Trouvez votre point de collecte et ajoutez-le à votre carnet d’adresses
- Sélectionnez cette adresse lors de votre commande
Description du produit
Quatrième de couverture
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.
Biographie de l'auteur
Joshua Engel is a programmer, computer scientist, and acknowledged expert in the Java virtual machine. He is Chief Software Developer for Knowledge Bus, Inc. (www.knowledgebus.com) During his extensive programming career, he has worked with dozens of programming languages and even designed a few of his own.
Aucun appareil Kindle n'est requis. Téléchargez l'une des applis Kindle gratuites et commencez à lire les livres Kindle sur votre smartphone, tablette ou ordinateur.
Pour obtenir l'appli gratuite, saisissez votre numéro de téléphone mobile.
Détails sur le produit
Si vous vendez ce produit, souhaitez-vous suggérer des mises à jour par l'intermédiaire du support vendeur ?
Meilleurs commentaires des clients
Un problème s'est produit lors du filtrage des commentaires. Veuillez réessayer ultérieurement.
When we are used to be Java developers, it is enriching to go over the Java code lines and to know how those lines are interpreted.
This book explains in details how the Java instructions proceed. Besides it demystify the miracle of "write once, run anywhere" by explain the mechanism of the Java Virtual Machine.
I was not a Java expert when I began reading it; I could say that it helps me to understand the back office of my programs.
Commentaires client les plus utiles sur Amazon.com
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.
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.
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.
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.