Browse Books

Reviewer: Maurice S. Elzas

This book presents a practical guide for the use of Eclipse, an open source environment intended to provide a uniform and integrated platform for the development of applications using Java, Extensible Markup Language (XML), and unified modeling language (UML), through the Eclipse modeling framework (EMF). These technologies may be expanded through the Eclipse tools project, allowing future use of the framework for other programming vehicles, such as C and C++. Part 1, which contains four chapters, provides a brief introduction to the background and philosophy of the Eclipse open-source software development project and to its elements. It also discusses the EMF itself, and explains the general ways in which it can be used. The rest of the book then proceeds to the core of the matter: a mixed tutorial/reference manual for the reader who wants to use the framework for software development purposes. Part 2, which also contains four chapters, demonstrates the way to define models in EMF, based on the four main vehicles that the framework can host: Ecore (the core model in EMF, on which everything else is based), Java, XML, and UML. Part 3 (chapters 9 to 12) concentrates on the ability of EMF to generate Java code from the elements of a model, which the reader learned to build in Part 2. Classes, attributes, references, operations, methods, factories, and packages are discussed and explained using examples. The actual use of the generator is introduced, and is illustrated with a more elaborate example that takes the user through the whole procedure from the model to the generation of code. Part 4, which includes two chapters, approaches EMF from the viewpoint of its capabilities as a runtime framework, using the example introduced at the end of Part 3. Finally, Parts 5 and 6 form a complete reference to the EMF application program interfaces (APIs). The book ends with two appendices (one on UML notation, and the other elaborating on the examples that were used), followed by an index that is, unfortunately, far too limited. Although the authors have clearly worked hard to make their book as readable as possible, it is best used as a gentle reference manual, and is mainly recommended to the reader who wants to actually use EMF. It will be interesting to see, in the coming months or years, how much support Eclipse will sustain in the industry, since Sun has unfortunately decided to stay with its own Net beans, and is looking for others like Oracle and Borland to jump in. Could the C++ tool for Eclipse make IBM and Microsoft join forces__?__ Online Computing Reviews Service

Reviewer: Jeff Ellis Smith

Eclipse has collected enormous momentum, becoming a de facto modeling and integrated framework. The lessons learned in this book are easily followed, with an example that is used to bring each chapter together. I would recommend this text as a reference for those seeking a deep understanding of the use of Eclipse patterns and modeling, with respect to Java programming. This book introduces a user interface and development environment, tool interoperability, a plug-in, and a Java application code generation framework based on unified modeling language (UML) models. The text is presented in graduated levels, ranging from overview to implementation. The book is targeted at the Java developer looking for guidance in how best to exploit the Eclipse modeling framework (EMF), and also serves as a reference. The first part of the book begins with an overview of the open source Eclipse project, broken into segments covering the platform, Java development tool, plug-in development environment, and tool and technology. The equivalence between modeling and programming is portrayed by showing Eclipse's unification of Extensible Markup Language (XML), Java, and UML through creation and editing (directly or through import/export from tools) of Ecore (the model used to generate EMF models). EMF.edit, the facility for model viewing/editing, is presented to demonstrate the fundamentals of the user interface development and command framework for model modification. Code generation is described in every overview chapter, but is summarized with a purchase order example, generated to or from annotated Java, XML schema, or Rational Rose, that is used to describe subsequent extended concepts. An Ecore meta-model (including a core described in terms of itself) is presented in the next part, "Defining EMF Models," to set the stage for the element-level description of model equivalence presented in the next three chapters. These chapters delve into the Java source/annotation, XML, or UML needed by the EMF to describe the core model. For instance, an Ecore package maps to a Java interface, XML schema, or UML package. This part underscores the ability to work at the model level of choice, while retaining the mapping to the Ecore. "Using the EMF Generator" is the third part of the book, which begins by describing the patterns EMF uses to generate Java interfaces and implementation classes (and how to customize these generated classes for behavioral code), for different types of model elements, to expose the relationship between a model and its affected code. Next, EMF.edit insight is provided by describing the patterns (and associated functionality) used to generate edit and editor EMF model plug-ins. The control of model, edit, and editor implementations using generator pattern selection is followed by a description of the template-based code generation process, graphical user interface (GUI), and command line tools. The code generation section is brought together by extending the purchase order application used as an example in earlier chapters, and by implementing a model and editor with typical program features, namely, volatile attributes and custom data types. The purchase order example is further extended to include partitioning into a multiple package design, and using concurrent editing in multiple instance documents. Having described the model definition and code generation process, the last logical part describes how to perform client and EMF.edit programming using the EMF runtime framework, with the same purchase order example using features (namely, object creation, persistence, serialization, and adaptation) of the EMF reflective application programming interface (API). The rest of the book is more of a reference, with parts describing the EMF and the EMF.edit API. While this book is an excellent introduction and reference to using the Eclipse framework for Java programming and modeling, I have a few comments. The book ends after the reference section, rather than summarizing or projecting Eclipse's future. The lessons learned in this book could have been applied and projected against other languages for the uninitiated reader (for instance, the author has used Eclipse with Perl). The Eclipse framework is an excellent integration environment for programming languages other than Java, with lots of plug-in support. Also, it is possible that the book's example fragments might be someplace on the Internet, but they are not easy to find. A CD or Web site would have been a good addition, to help readers to better follow the three purchase order examples. Online Computing Reviews Service