Browse Books

Reviewer: Marlin W Thomas

Programming languages, Java included, are like baseball. They are arbitrary symbolic systems that create their own universes of rules and actions that are only occasionally constrained by other systems. Just as the Official Rules of Major League Baseball brings baseball into existence by defining what baseball is, the Java language specification institutionalizes Java. Reviewing the Java language specification is, therefore, akin to reviewing the Official Rules. Since the specification creates Java, its nature as the definer of the language constrains the reviewer. The authority of the authors is beyond dispute because they were so instrumental in inventing and developing the language and because what they write constitutes what is Java. One can, however, discuss the quality and order of the presentation while summarizing the substance of the book and evaluating its usefulness to target audiences, and one can describe the balance that the book strikes in its treatment of such essential language features as syntax, semantics, and pragmatics. It is important to understand what the Java specification does and does not do. The book specifies a language. It does not justify the inclusion or exclusion of language features, nor does it teach the language to the uninitiated. It can be judged solely on the quality of the exposition of the specification, not the specification itself. One characteristic of the specification, though, is that it does some teaching along the way. The book does include, by way of illustrating the elements of Java, enough programs to give the reader some training in developing programs, but that is a long way from preparing readers to use Java to solve even the most trivial of problems. The specification can help the reader increase facility with the language by detailing the syntax and semantics of the language elements. The treatment of type names provides an example where both the form of type names and their meaning are treated. But, just as one learns baseball without the rulebook handy, so one learns Java programming without the specification being readily available. Two preliminary chapters open the book. The introduction briefly describes Java, outlines the topics presented, mentions conventions of notation, enumerates what the specification does not include, and concludes with a list of references. Brevity continues with a chapter on grammars that would be more helpful if it had illustrated how the grammatical notation is instantiated in programs. The next 16 chapters treat the elements and rules of Java: lexical structure; types, values, and variables; conversions and promotions; names; packages; classes; interfaces; arrays; exceptions; execution; binary compatibility; blocks and statements; expressions; definite assignment; threads and locks; and syntax. The order of the material is not conceptually sequential. Placing chapters on blocks and statements, expressions, and assignment near the end is questionable because a more reasonable order, based on how programs are composed and how programmers learn, would be for the specification to mimic the narrative of program creation and debugging. The order realized in the specification is abstract and not connected closely enough to human comprehension. The individual chapters, however, are clearly expressed and developed logically with attentiveness to completeness. The chapter on arrays illustrates the strengths of the treatment of the subject. It starts with a narrative definition of arrays and their characteristics, and then proceeds to detail them exhaustively through their grammar. The power of the presentation resides both in the grammar and in the examples that illustrate that grammar. The examples enable the chapter to complement the abstract with the concrete. Of particular usefulness here, as well as throughout the specification, is the inclusion of conditions that lead to errors. One useful service that the specification provides is that it helps programmers understand and then fix errors in code. A useful index item would be an exhaustive list of exceptions and the pages where they are explained. As it stands, the exceptions and errors are embedded in the narrative. Chapter 18 concludes with a grammar for the Java language that, as the authors state, is better suited for implementation than the grammar presented piecemeal in the preceding chapters. This book speaks to several audiences without distorting its voice and unity of purpose: programmers seeking a definitive, authoritative understanding of Java language features; language developers looking for a model of exposition and for suites of features to incorporate; and advanced students learning the intricacies of the language. It focuses on the syntax and semantics of Java, but in providing and explaining details of program code, it treats implementation as well. Online Computing Reviews Service