• Develop iteratively
• Manage requirements
• Use component architectures
• Model visually
• Continuously verify quality
• Manage change

• Class diagrams
  
•  show some or all application elements
• visually represent and develop
• structures & relationships
  
• for Java classes and interfaces
• develop Java elements directly from class diagrams
  

• Browse diagrams
  
• temporary diagrams to explore application
  
• detail, elements and relationships.
  
• specify a context element to view
• can be converted to
  
• a UML class diagram or
  
• save it in an image file
  

• Topic diagrams
  
• non-editable
  
• a quick show of existing relationships
  
• made by querying the current application state
• queries can be customized
• open multiple copies
• save for future use
  

• Sequence diagrams
  
• show object interactions
  
• focused on sequence
  
• timing of message exchange

• Static method sequence diagrams
  
• non-editable 
• explore the chronological sequence
  
• of messages between Java instances
• more detailed method interplay

• understanding problems
• communicating with interested parties
• preparing documentation
• designing applications

• better understanding of requirements
• cleaner designs
• more maintainable applications.
  

• visualize
• specify
• construct
  
• document the artifacts of an application.
  

• Things
• Relationships
• Diagrams

• Structural things // static elements
  
• the nouns of a model
  
• interfaces
• classes
• components
• uses cases
  

• Behavioral things // dynamic parts
  
• the verbs of the model
• behavior,
• messages exchanged between objects
  

• Grouping things 
  
• used to organize a model.
  
• group semantically related things together
  
• to a certain context.
  
• The only UML defined grouping thing
  
• the package

• Annotational things
  
• further explanations
• comments in the UML
  

• Dependency
  
• a semantic relationship where a change
• to one class might affect another class.
  
• example
• a Bank class depends on an Account class
  
• because it is used as parameter for an operation.
  

• Association
  
• a structural relationship
  
• describes a connection between objects
• maps to class member declaration
  
• For example
• a Customer class with a single association
  
• to an Account class, each Account instance
  
• is owned by one Customer instance.

• The extends relationship
  
• one thing is a specialization of another more general thing.
• maps to the 'extends' keyword in Java.
  
• For example
• SavingsAccount extends an Account class
  

• The implements relationship
  
• maps to the implements keyword in Java.
• a class that 'realizes' operations defined by an interface.
  

• The owned element association
  
• classes that are owned by a package.
  
• // a construct for implementation reasons
  
• and for hiding information
  

• Structural diagrams
  
• show the building blocks of an application
  
• characteristics that do not change over time
• objects, attributes, operations, and relationships.
  
• Examples
• component diagrams
• class diagrams and
  
• deployment diagrams.
  

• Dynamic behavior diagrams
  
• how applications responds to requests
  
• or otherwise evolves over time
  
• by showing collaborations among objects
  
• and changes to the internal states of objects.
  
• Examples
  
• use case diagrams and
  
• activity diagrams.
  

• Interaction diagrams
  
• a subset of behavior diagrams
  
• focused on the exchange of messages
  
• within a collaboration
  
• // a group of cooperating objects
• Examples
  
• sequence diagrams

This new Java feature is introduced here, to provide a
background to the use of annotations in the Eclipse Modeling
Framework.

Eclipse Modeling Framework (Addison Wesley, 2003)

http://www.awprofessional.com/titles/0131425420

"EMF is a Java framework and code generation facility for
building tools and other applications based on a structured
model."

EMF helps you rapidly turn models into efficient, correct,
and easily customizable Java code. While, modeling systems
are usually very expensive, EMF is intended to provide the
same benefits at a low cost of entry.

What is Modeling?

When we think of modeling we generally think of UML or
Unified Modeling Language, the de facto  standard for
modelling, with it's different Class, Collaboration, State
and other sorts of diagrams.  Essentially each aspect of
an object or data oriented system is represented pictorally
by a diagram. A translator program can then translate this
diagram into corresponding code.

The EMF model achieves it's modest cost by only developing
a small subset of the things that can be modeled in UML.

EMF is focused on modeling only class definitions with their
attributes and relations. This makes full-scale graphical modeling
tools unnecessary.

XMI, XML Metadata Interchange

While EMF uses XMI or XML Metadata Interchange as its
primary form to create model definitions. Models can be
translated into that form in different ways.

XMI Form Changing

• Create the XMI document directly, in an XML/Ttext editor
• Export the XMI document from a modeling tool such as Rational Rose
• Annotate Java interfaces with model properties
• Use XML Schema to describe the form of a serialization of the model

Creating XMI or XML Schema, will appeal only to XML specialists
familiar with XMI and XML Schema. Exporting from a Rational 
product is an option, perhaps as a way of sharing the product of a
few seats at a corporation that  have Rational, with a larger body
working on Eclipse.

Annotations Strike Again

Providing annotating Java interfaces is a practical option for Java
programmers.

But in the general sense, this is about translation. The real promise
of EMF is to provide a modeling method that can be used to generate
code.

Getting Back to the Model

Given an EMF model, an EMF generator can generate a corresponding
set of Java implementation classes. Editing the generated classes will,
in the general case, cause a regeneration in the corresponding model. 

Primary Benefit of building an application Using EMF

While EMF, is a modeling tool that will grow in sophistication, it most
important utility, may be that it provides a foundation for interoperability
with other EMF-based tools and applications.

EMF Fundamental Frameworks

• EMF //  generation and runtime support
  
• EMF.Edit // undoable model editing
  

Tutorial: Generating an EMF Model

http://help.eclipse.org/ganymede/topic/org.eclipse.emf.doc/tutorials/clibmod/clibmod.html

EMF & OMG's MOF // Ecore

The OMG Object Management Group have a modeling
system called MOF or Meta Object Facility. EMF started
out as an implementation of the MOF specification. 

EMF has since evolved into a highly efficient Java
implementation of a core subset of the MOF API.
To avoid confusion, the MOF-like core meta model
in EMF is called Ecore.

//  MOF 2.0,  proposes a similar subset called EMOF or Essential MOF
// with small differences between Ecore and EMOF. EMF can transparently
// read and write serializations of EMOF.

Defining an EMF Model

In IBM's "Eclipse tutorial, a model is started on a  single class.

It's Easy in UML

You draw the class diagram as shown above, press a button
and the code is generated for you!

XMI

  <ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
      name="library "nsURI="http:///library.ecore" nsPrefix="library">
<!-- below you see the the class def and the two attributes -->
    <eClassifiers xsi:type="ecore:EClass" name="Book">
      <eStructuralFeatures xsi:type="ecore:EAttribute" name="title"
          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
      <eStructuralFeatures xsi:type="ecore:EAttribute" name="pages"
          eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EInt"/>
    </eClassifiers>

  </ecore:EPackage>

Annotated Java

Our third option as Java programmers, is to provide a Java
interface with model annotations that can be used by the
EMF generator. The Eclipse Tutorial supplies the following
code.

Partial Java Code
// from the Eclipse Documentation

  /**
   * @model
   */
  public interface Book
  {
    /**
     * @model
     */
    String getTitle();

    /**
     * @model
     */
    int getPages();
  }

The @model tag may be followed by with. additional details.
To make the page  read-only where a set method is not
created, the following would be added to the annotation.

Example
// from the Eclipse Documentation

  /**
   * @model changeable="false"
   */
  int getPages();

XML Schema

  <xsd:schema targetNamespace="http:///library.ecore"
      xmlns="http:///library.ecore" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <xsd:complexType name="Book">
      <xsd:sequence>
        <xsd:element name="title" type="xsd:string"/>
        <xsd:element name="pages" type="xsd:integer"/>
      </xsd:sequence>
    </xsd:complexType>
  </xsd:schema>

The Generated Java

  public interface Book extends EObject
  {
    String getTitle();
    void setTitle(String value);

    int getPages();
    void setPages(int value);
  }

A point to note, the extension is of EObject. This is the
EMF equivalent of java.lang.Object and is the base of
every EMF class.

The implementation class that is created is reminiscent
of the output of the CORBA and RMI generators.

  public class BookImpl extends EObjectImpl implements Book
  {
    ...
    protected static final int PAGES_EDEFAULT = 0;
    protected int pages = PAGES_EDEFAULT;

    public int getPages()
    {
      return pages;
    }

    public void setPages(int newPages)
    {
      int oldPages = pages;
      pages = newPages;
      if (eNotificationRequired())
        eNotify(new ENotificationImpl(this, Notification.SET, ..., oldPages, pages));
    }
    ...
  }


EMF Practical

We can detour to the IBM site to trace through a practical
tutorial that is listed there. 

EMF Tutorial Site
// Eclipse site

http://help.eclipse.org/help33/index.jsp?topic=/org.eclipse.emf.doc/tutorials/slibmod/slibmod.html

• Java Messaging Service
• Concurrent Versioning System
• Web Services
  

Diagram of Model II Architecture

Browser --request--> Controller Servlet
                        |
                       ( instantiates bean)
                               |
                                v
             Bean Controller <--data access--> DataSource/EIS
                                |    
                                v
Browser <--response---   JSP View
 
 

Variation of a Model II JSP Architecture

// different component accesses data source. Bean is more a 'result carrier' then a controller.