The Java Virtual Machine Specification / Edition 2

Paperback (Print)
Used and New from Other Sellers
Used and New from Other Sellers
from $1.99
Usually ships in 1-2 business days
(Save 96%)
Other sellers (Paperback)
  • All (16) from $1.99   
  • New (4) from $47.44   
  • Used (12) from $1.99   


The nucleus of the Java(TM) 2 platform, the Java(TM) virtual machine is the technology that enables the Java 2 platform to host applications on any computer or operating system without rewriting or recompiling. The Java virtual machine is also responsible for the compactness of applications targeting the Java 2 platform, and is the basis for its security capabilities.

This book was written by those directly responsible for the design and implementation of the Java virtual machine, and is the complete and definitive specification for the technology. It is an essential reference for writers of compilers for the Java programming language and implementors of the Java virtual machine. This second edition specifies the newest version of the Java virtual machine and provides a fascinating view into the inner workings of the Java 2 platform.

In this book you will find comprehensive coverage of the class file format, the hardware, operating system, and implementation-independent binary format for compiled code. The authors fully describe the instruction set of the Java virtual machine. You will find an entire chapter of examples that demonstrate how to compile code written in the Java programming language into the instruction set of the Java virtual machine. In addition, the book presents a discussion on the vital topic of Java virtual machine threads and their interaction with memory.

All in all, this comprehensive, detailed, and methodical presentation provides the information necessary to implement your own fully compatible Java virtual machine.


Written by two original members of Sun's Java team, this book provides comprehensive coverage of the Java virtual machine. For experienced Java programmers, this second edition brings the specification of the Java virtual machine up to the Java 2 platform, v1.2. A new chapter details the format of each Java virtual machine instruction and the operation it performs.

Read More Show Less

Editorial Reviews

Ray Duncan

The Guts of Java

If you find the Java scene confusing, it's probably because the term Java is brandished in so many contexts: the Java programming language, the Java application framework, Java development tools, JavaScript support in HTML browsers, the Java applet tags that were added to HTML, network-distributable Java applets, stand-alone Java applications, and last but not least, Java pseudocode and the Java virtual machine (JVM) that runs it. The Java book market is equally confusing -- publishers are in a panic, and are rushing out Java books by the wheelbarrow-load with (for the most part) little attention to quality or any overall strategy.

Here at ERCB, we've received at least a dozen shelf-feet of Java books for review from various publishers, but on close inspection many of them are merely warmed over C/C++ programming books by the usual stable of C/C++ programmer-authors. Since mass-market Java programming tools are such a recent phenomenon, very few of the books are based on serious Java programming experience or address the development of non-trivial, non-toy applications. Still fewer address topics beyond the basic Java programming language or delve beneath the surface of the Java application framework -- in fact, this is the first one I have seen that provides any substantive information about Java pseudo-code and the virtual machine at all.

The first part of The Java Virtual Machine Specification is composed of a somewhat redundant overview of the Java programming language, a introduction to the Java Virtual Machine architecture, and a detailed description of the Java class-file format. The body of the book is devoted to the Java virtual machine opcodes, which are discussed one at a time with their binary representations, stack effects, side effects, exception conditions, and miscellaneous programming notes. The last section covers compiling Java source code to pseudocode, with examples, as well as threads, locks, and some Sun-JVM-specific pseudocode optimizations (which amount to self-modifying opcodes).

Technologically, this is an important book. But as its title indicates, it was designed to be a specification, not a tutorial, so it's tough sledding for the most part and it will be useful mainly as a reference. The hands-on, blow-by-blow description of implementing and debugging a Java Virtual Machine on a mainstream CPU has yet to be written (although I wouldn't be too surprised to learn that Andrew Schulman is already working on it!). The sections of The Java Virtual Machine Specification concerned with code compilation and especially code validation are quite interesting, however, and are well worth your time.

In the Preface, the authors comment that "We intend that this specification should sufficiently document the Java Virtual Machine to make possible compatible clean-room implementations." Did the authors attain this goal? As a past implementor of commercial Forth interpreter/compilers and cross-compilers on many different CPUs, I'm dubious. Forth is based on a virtual machine architecture not terribly dissimiliar to Java, but I don't think I could program my way directly to a working JVM that would run any ol' Java applet I found on the Internet, using just the information supplied here. The descriptions of "frames" and the class loading/linking process are a bit too abstract, and the authors take for granted a fairly deep understanding of C++ implementation strategies. Additionally, a number of machine-dependent issues are not mentioned at all. For example, the mapping of Java-level graphic operations onto machine- or system-specific graphic APIs -- and how such calls from the AWT are passed through or around the JVM -- is left completely to the imagination.

Still, this book is the only game in town at this point for developers of Java compilers, JVMs, and Java debuggers.--Dr. Dobb's Electronic Review of Computer Books

Read More Show Less

Product Details

  • ISBN-13: 9780201432947
  • Publisher: Addison-Wesley
  • Publication date: 4/8/1999
  • Series: Java Series
  • Edition description: Second Edition
  • Edition number: 2
  • Pages: 473
  • Product dimensions: 7.50 (w) x 9.00 (h) x 1.10 (d)

Meet the Author

Tim Lindholm, Distinguished Engineer in Java Software at Sun Microsystems, Inc., was an original member of the Java project at Sun. He was a key contributor to the Java programming language and remains the senior architect of the Java virtual machine and the Java 2 runtime environment. He is also the Technical Editor of The Java(TM) Series.

Frank Yellin, Staff Engineer in Embedded and Consumer at Sun Microsystems, Inc., was an original member of the Java project at Sun. He has spent a decade working on the runtime systems for interpreted and compiled languages. Previously he worked at Lucid, where he focused on multitasking, garbage collection, interrupts, and the compilation of Common Lisp.


Read More Show Less

Read an Excerpt


About the Java Series

The Java Series books provide definitive reference documentation for
Java programmers and end users. They are written by members of the
Java team and published under the auspices of JavaSoft, a Sun
Microsystems business. The World Wide Web allows Java
documentation to be made available over the Internet, either by
downloading or as hypertext. Nevertheless, the worldwide interest in
Java technology led us to write and publish these books to supplement all
of the documentation at our Web site.

We would like to thank the Corporate and Professional Publishing Group
at Addison-Wesley for their partnership in putting together the Series.
Our editor Mike Hendrickson and his team have done a superb job of
navigating us through the world of publishing. Within Sun, the support of
James Gosling, Ruth Hennigar, Jon Kannegaard, and Bill Joy ensured
that this series would have the resources it needed to be successful. In
addition to the tremendous effort by individual authors, many members of
the JavaSoft team have contributed behind the scenes to bring the highest
level of quality and engineering to the books in the Series. A personal
note of thanks to my children Christopher and James for putting a
positive spin on the many trips to my office during the development of the

Read More Show Less

Table of Contents


1. Introduction.

A Bit of History.

The Java Virtual Machine.

Summary of Chapters.


2. Java Programming Language Concepts.




Types and Values.

Primitive Types and Values.

Operators on Integral Values.

Floating-Point Types, Value Sets, and Values.

Operators on Floating-Point Values.

Operators on boolean Values.

Reference Types, Objects, and Reference Values.

The Class Object.

The Class String.

Operators on Objects.


Initial Values of Variables.

Variables Have Types, Objects Have Classes.

Conversions and Promotions.

Identity Conversions.

Widening Primitive Conversions.

Narrowing Primitive Conversions.

Widening Reference Conversions.

Narrowing Reference Conversions.

Value Set Conversion.

Assignment Conversion.

Method Invocation Conversion.

Casting Conversion.

Numeric Promotion.

Names and Packages.




Package Members.

The Members of a Class Type.

The Members of an Interface Type.

The Members of an Array Type.

Qualified Names and Access Control.

Fully Qualified Names.


Class Names.

Class Modifiers.

Superclasses and Subclasses.

The Class Members.


Field Modifiers.

Initialization of Fields.


Formal Parameters.

Method Signature.

Method Modifiers.

Static Initializers.


Constructor Modifiers.


Interface Modifiers.


Interface Members.

Interface (Constant) Fields.

Interface (Abstract) Methods.

Overriding, Inheritance, and Overloading in Interfaces.

Nested Classes and Interfaces.


Array Types.

Array Variables.

Array Creation.

Array Access.


The Causes of Exceptions.

Handling an Exception.

The Exception Hierarchy.

The Classes Exception and RuntimeException.


Virtual Machine Start-up.


Linking: Verification, Preparation, and Resolution.


Detailed Initialization Procedure.

Creation of New Class Instances.

Finalization of Class Instances.

Unloading of Classes and Interfaces.

Virtual Machine Exit.

FP-strict Expressions.


3. The Structure of the Java Virtual Machine.

The class File Format.

Data Types.

Primitive Types and Values.

Integral Types and Values.

Floating-Point Types, Value Sets, and Values.

The returnAddress Type and Values.

The boolean Type.

Reference Types and Values.

Runtime Data Areas.

The pc Register.

Java Virtual Machine Stacks.


Method Area.

Runtime Constant Pool.

Native Method Stacks.


Local Variables.

Operand Stacks.

Dynamic Linking.

Normal Method Invocation Completion.

Abrupt Method Invocation Completion.

Additional Information.

Representation of Objects.

Floating-Point Arithmetic.

Java Virtual Machine Floating-Point Arithmetic and IEEE 754.

Floating-Point Modes.

Value Set Conversion.

Specially Named Initialization Methods.


Instruction Set Summary.

Types and the Java Virtual Machine.

Load and Store Instructions.

Arithmetic Instructions.

Type Conversion Instructions.

Object Creation and Manipulation.

Operand Stack Management Instructions.

Control Transfer Instructions.

Method Invocation and Return Instructions.

Throwing Exceptions.

Implementing finally.


Class Libraries.

Public Design, Private Implementation.

4. The class File Format.

The ClassFile Structure.

The Internal Form of Fully Qualified Class and Interface Names.


Grammar Notation.

Field Descriptors.

Method Descriptors.

The Constant Pool.

The CONSTANT_Class_info Structure.

The CONSTANT_Fieldref_info, CONSTANT_Methodref_info, and CONSTANT_InterfaceMethodref_info Structures.

The CONSTANT_String_info Structure.

The CONSTANT_Integer_info and CONSTANT_Float_info Structures.

The CONSTANT_Long_info and CONSTANT_Double_info Structures.

The CONSTANT_NameAndType_info Structure.

The CONSTANT_Utf8_info Structure.




Defining and Naming New Attributes.

The ConstantValue Attribute.

The Code Attribute.

The Exceptions Attribute.

The InnerClasses Attribute.

The Synthetic Attribute.

The SourceFile Attribute.

The LineNumberTable Attribute.

The LocalVariableTable Attribute.

The Deprecated Attribute.

Constraints on Java Virtual Machine Code.

Static Constraints.

Structural Constraints.

Verification of class Files.

The Verification Process.

The Bytecode Verifier.

Values of Types long and double.

Instance Initialization Methods and Newly Created Objects.

Exception Handlers.

Exceptions and finally.

Limitations of the Java Virtual Machine.

5. Loading, Linking, and Initializing.

The Runtime Constant Pool.

Virtual Machine Start-up.

Creation and Loading.

Loading Using the Bootstrap Class Loader.

Loading Using a User-defined Class Loader.

Creating Array Classes.

Loading Constraints.

Deriving a Class from a class File Representation.





Access Control.


Binding Native Method Implementations.

6. The Java Virtual Machine Instruction Set.

Assumptions: The Meaning of “Must.”

Reserved Opcodes.

Virtual Machine Errors.

Format of Instruction Descriptions.

7. Compiling for the Java Virtual Machine.

Format of Examples.

Use of Constants, Local Variables, and Control Constructs.


Accessing the Runtime Constant Pool.

More Control Examples.

Receiving Arguments.

Invoking Methods.

Working with Class Instances.


Compiling Switches.

Operations on the Operand Stack.

Throwing and Handling Exceptions.

Compiling finally.


Compiling Nested Classes and Interfaces.

8. Threads and Locks.

Terminology and Framework.

Execution Order and Consistency.

Rules About Variables.

Nonatomic Treatment of double and long Variables.

Rules About Locks.

Rules About the Interaction of Locks and Variables.

Rules for volatile Variables.

Prescient Store Operations.


Example: Possible Swap.

Example: Out-of-Order Writes.


Locks and Synchronization.

Wait Sets and Notification.

9. Opcode Mnemonics by Opcode.

Appendix: Summary of Clarifications and Amendments.

Index. 0201432943T04062001

Read More Show Less

First Chapter

Chapter 1: Introduction

1.1 A Bit of History

The Java™ programming language is a general-purpose object-oriented concurrent language. Its syntax is similar to C and C++, but it omits many of the features that make C and C++ complex, confusing, and unsafe. The Java platform was initially developed to address the problems of building software for networked consumer devices. It was designed to support multiple host architectures and to allow secure delivery of software components. To meet these requirements, compiled code had to survive transport across networks, operate on any client, and assure the client that it was safe to run.

The popularization of the World Wide Web made these attributes much more interesting. The Internet demonstrated how media-rich content could be made accessible in simple ways. Web browsers such as Mosaic enabled millions of people to roam the Net and made Web surfing part of popular culture. At last there was a medium where what you saw and heard was essentially the same whether you were using a Mac, PC, or UNIX machine, and whether you were connected to a high-speed network or a slow modem.

Web enthusiasts soon discovered that the content supported by the Web's HTML document format was too limited. HTML extensions, such as forms, only highlighted those limitations, while making it clear that no browser could include all the features users wanted. Extensibility was the answer.

Sun's HotJava™ browser showcases the interesting properties of the Java programming language and platform by making it possible to embed programs inside HTML pages. These programs are transparently downloaded into the HotJava browser along with the HTML pages in which they appear. Before being accepted by the browser, the programs are carefully checked to make sure they are safe.

Like HTML pages, compiled programs are network- and host-independent. The programs behave the same way regardless of where they come from or what kind of machine they are being loaded into and run on.

A Web browser incorporating the Java or Java 2 platform is no longer limited to a predetermined set of capabilities. Visitors to Web pages incorporating dynamic content can be assured that their machines cannot be damaged by that content. Programmers can write a program once, and it will run on any machine supplying a Java or Java 2 runtime environment.

1.2 The Java Virtual Machine

The Java virtual machine is the cornerstone of the Java and Java 2 platforms. It is the component of the technology responsible for its hardware- and operating systemindependence, the small size of its compiled code, and its ability to protect users from malicious programs.

The Java virtual machine is an abstract computing machine. Like a real computing machine, it has an instruction set and manipulates various memory areas at run time. It is reasonably common to implement a programming language using a virtual machine; the best-known virtual machine may be the P-Code machine of UCSD Pascal.

The first prototype implementation of the Java virtual machine, done at Sun Microsystems, Inc., emulated the Java virtual machine instruction set in software hosted by a handheld device that resembled a contemporary Personal Digital Assistant (PDA). Sun's current Java virtual machine implementations, components of its Java® 2 SDK and Java® 2 Runtime Environment products, emulate the Java virtual machine on Win32 and Solaris™ hosts in much more sophisticated ways. However, the Java virtual machine does not assume any particular implementation technology, host hardware, or host operating system. It is not inherently interpreted, but can just as well be implemented by compiling its instruction set to that of a silicon CPU. It may also be implemented in microcode or directly in silicon.

The Java virtual machine knows nothing of the Java programming language, only of a particular binary format, the class file format. A class file contains Java virtual machine instructions (or bytecodes) and a symbol table, as well as other ancillary information.

For the sake of security, the Java virtual machine imposes strong format and structural constraints on the code in a class file. However, any language with functionality that can be expressed in terms of a valid class file can be hosted by the Java virtual machine. Attracted by a generally available, machine-independent platform, implementors of other languages are turning to the Java virtual machine as a delivery vehicle for their languages.

1.3 Summary of Chapters

The rest of this book is structured as follows:

  • Chapter 3 gives an overview of the Java virtual machine architecture.
  • Chapter 4 specifies the class file format, the hardware- and operating system-independent binary format used to represent compiled classes and interfaces.
  • Chapter 5 specifies the start-up of the Java virtual machine and the loading, linking, and initialization of classes and interfaces.
  • Chapter 6 specifies the instruction set of the Java virtual machine, presenting the instructions in alphabetical order of opcode mnemonics.
  • Chapter 7 introduces compilation of code written in the Java programming language into the instruction set of the Java virtual machine.
  • Chapter 8 describes Java virtual machine threads and their interaction with memory.
  • Chapter 9 gives a table of Java virtual machine opcode mnemonics indexed by opcode value.

1.4 Notation

Throughout this book we refer to classes and interfaces drawn from the Java and Java 2 platforms. Whenever we refer to a class or interface using a single identifier N, the intended reference is to the class or interface java.lang. N. We use the fully qualified name for classes from packages other than java.lang.

Whenever we refer to a class or interface that is declared in the package java or any of its subpackages, the intended reference is to that class or interface as loaded by the bootstrap class loader (§5.3.1). Whenever we refer to a subpackage of a package named java, the intended reference is to that subpackage as determined by the bootstrap class loader. The use of fonts in this book is as follows:

  • A fixed width font is used for code examples written in the Java programming language, Java virtual machine data types, exceptions, and errors.
  • Italic is used for Java virtual machine "assembly language," its opcodes and operands, as well as items in the Java virtual machine's runtime data areas. It is also used to introduce new terms and simply for emphasis.
Read More Show Less


The Java(TM) virtual machine specification has been written to fully document the design of the Java virtual machine. It is essential for compiler writers who wish to target the Java virtual machine and for programmers who want to implement a compatible Java virtual machine. It is also a definitive source for anyone who wants to know exactly how the Java programming language is implemented.

The Java virtual machine is an abstract machine. References to the Java virtual machine throughout this specification refer to this abstract machine rather than to Sun's or any other specific implementation. This book serves as documentation for a concrete implementation of the Java virtual machine only as a blueprint documents a house. An implementation of the Java virtual machine (known as a runtime interpreter) must embody this specification, but is constrained by it only where absolutely necessary.

The Java virtual machine specified here will support the Java programming language specified in The Java(TM) Language Specification (Addison-Wesley, 1996). It is compatible with the Java platform implemented by Sun's JDK(TM) releases 1.0.2 and 1.1 and the Java(R) 2 platform implemented by Sun's Java(R) 2 SDK, Standard Edition, v1.2 (formerly known as JDK release 1.2).

We intend that this specification should sufficiently document the Java virtual machine to make possible compatible clean-room implementations. If you are considering constructing your own Java virtual machine implementation, feel free to contact us to obtain assistance to ensure the 100% compatibility of your implementation.

Send comments on this specification or questions about implementing the Java virtual machine to our electronic mail address: To learn the latest about the Java 2 platform, or to download the latest Java 2 SDK release, visit our World Wide Web site at For updated information about the Java Series, including errata for The Java(TM) Virtual Machine Specification, and previews of forthcoming books, visit

The virtual machine that evolved into the Java virtual machine was originally designed by James Gosling in 1992 to support the Oak programming language. The evolution into its present form occurred through the direct and indirect efforts of many people and spanned Sun's Green project, FirstPerson, Inc., the LiveOak project, the Java Products Group, JavaSoft, and today, Sun's Java Software. The authors are grateful to the many contributors and supporters.

This book began as internal project documentation. Kathy Walrath edited that early draft, helping to give the world its first look at the internals of the Java programming language. It was then converted to HTML by Mary Campione and was made available on our Web site before being expanded into book form.

The creation of The Java(TM) Virtual Machine Specification owes much to the support of the Java Products Group led by General Manager Ruth Hennigar, to the efforts of series editor Lisa Friendly, and to editor Mike Hendrickson and his group at Addison-Wesley. The many criticisms and suggestions received from reviewers of early online drafts, as well as drafts of the printed book, improved its quality immensely. We owe special thanks to Richard Tuck for his careful review of the manuscript and to the authors of The Java(TM) Language Specification, Addison-Wesley, 1996, for allowing us to quote extensively from that book. Particular thanks to Bill Joy whose comments, reviews, and guidance have contributed greatly to the completeness and accuracy of this book.

Notes on the Second Edition

The second edition of The Java(TM) Virtual Machine Specification brings the specification of the Java virtual machine up to date with the Java(R) 2 platform, v1.2. It also includes many corrections and clarifications that update the presentation of the specification without changing the logical specification itself. We have attempted to correct typos and errata (hopefully without introducing new ones) and to add more detail to the specification where it was vague or ambiguous. In particular, we corrected a number of inconsistencies between the first edition of The Java(TM) Virtual Machine Specification and The Java(TM) Language Specification.

We thank the many readers who combed through the first edition of this book and brought problems to our attention. Several individuals and groups deserve special thanks for pointing out problems or contributing directly to the new material:

Carla Schroer and her teams of compatibility testers in Cupertino, California, and Novosibirsk, Russia (with special thanks to Leonid Arbouzov and Alexei Kaigorodov), painstakingly wrote compatibility tests for each testable assertion in the first edition. In the process they uncovered many places where the original specification was unclear or incomplete.
Jeroen Vermeulen, Janice Shepherd, Peter Bertelsen, Roly Perera, Joe Darcy, and Sandra Loosemore have all contributed comments and feedback that have improved this edition.
Marilyn Rash and Hilary Selby Polk of Addison Wesley Longman helped us to improve the readability and layout of this edition at the same time as we were incorporating all the technical changes.
Special thanks go to Gilad Bracha, who has brought a new level of rigor to the presentation and has been a major contributor to much of the new material, especially chapters 4 and 5 and the new "Appendix: Summary of Clarifications and Amendments." His dedication to "computational theology" and his commitment to resolving inconsistencies between The Java(TM) Virtual Machine Specification and The Java(TM) Language Specification have benefited this book tremendously.

Tim Lindholm Frank Yellin Java Software, Sun Microsystems, Inc.


--IEEE Standard for Binary Floating-Point Arithmetic, ANSI/IEEE Std. 754-1985. Available from Global Engineering Documents, 15 Inverness Way East, Englewood, Colorado 80112-5704 USA, +1 800 854 7179.
--Hoare, C.A.R. Hints on Programming Language Design. Stanford University Computer Science Department Technical Report No CS-73-403, December 1973. Reprinted in Sigact/Sigplan Symposium on Principles of Programming Languages. Association for Computing Machinery, New York, October 1973.
--Unicode Consortium, The. The Unicode Standard: Worldwide Character Encoding, Version 1.0, Volume 1, ISBN 0-201-56788-1, and Volume 2, ISBN 0-201-60845-6. Updates and additions necessary to bring the Unicode Standard up to version 1.1 may be found at --Unicode Consortium, The. The Unicode Standard, Version 2.0, ISBN 0-201-48345-9. Updates and additions necessary to bring the Unicode Standard up to version 2.1 may be found at


Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star


4 Star


3 Star


2 Star


1 Star


Your Rating:

Your Name: Create a Pen Name or

Barnes & Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation


  • - By submitting a review, you grant to Barnes & and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Terms of Use.
  • - Barnes & reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously

    If you find inappropriate content, please report it to Barnes & Noble
    Why is this product inappropriate?
    Comments (optional)