Release Notes for the OTDT version 0.8.18 (beta)

• Compiler
• Wizards
• Editor
• Binding Editor
• Refactoring
• Structure Viewers
• Search
• Execution Environment
  • experimental Java-5 based weaver
• Debugging
• Help and additional Information

Language Definition

The compiler implements the language as defined in the ObjectTeams/Java language specification version 0.8 (OTJLD). The language definition has continuously been revised to precisely specify the language including various corner cases and combinations of features.

Language Implementation

The compiler supports all features of ObjectTeams/Java according to the OTJLD v0.8 (except for those listed in "Known Problems").

Compared to previous releases the compiler support for these language features has been significantly improved:

• nested teams OTJLD § 1.5
  
• aspects of aspects, ie., a role may be played by a role of another team (see OTJLD § 1.2.2(g)-4)

The following features are new in the language:

• callin precedence OTJLD § 4.8
  Callin bindings can now be named, and based on those names, a partial precedence order between callin bindings can be declared.
• scoped keywords OTJLD § A.0.1 can now be enabled via the new preference page of the OT/J Compiler. On this preference page also specific compiler diagnostics can be configured as "ignore", "warning" or "error".
  

Please note a new constraint in the language:

• OTJLD § 4.2(d) callin methods may no longer specify their visibility using public, protected or private. These modifiers were useless and are now prohibited by the compiler.

Status of the Compiler

The compiler is continuously tested using a growing test suite of currently over 1200 test programs. Feel free to have a look at the test status and remaining known problems.

• Test report for recent releases:
  • release 0.8.18
  • release 0.8.17
  • release 0.8.16
  • release 0.8.15
  • release 0.8.13 (OTDTCore-patch only)
  • release 0.8.12 (OTDTCore-patch only)
  • release 0.8.11
  • release 0.8.10
  • release 0.8.9
  • release 0.8.8
  • release 0.8.7
  • release 0.8.6
  • release 0.8.5
  • release 0.8.4
  • release 0.8.3
  • release 0.8.2
  • release 0.8.1
• Known problems

• The first step to developing with Object Teams in Eclipse is creating an "Object Teams Project". A wizard will guide you through that process. It will also add the Object Teams class library (otre.jar) to your project's classpath.
• Having done that, you can start adding classes -- be it regular classes, or team or role classes -- wizards will assist you in creating the classes properly.

• Editing Object Teams source code is supported by an outline view, showing the structure of the edited source file. This includes the Object Teams specific constructs, teams, roles, and method bindings.
• The editor highlights the Object Teams keywords the same way standard Java keywords are highlighted.
• All constructs referencing other code elements are navigable. E.g. you can navigate super(), tsuper(), base() calls, as well as callin and callout bindings.
• Methods in a base class that are bound with a callin binding are annotated with a marker, that allows navigating to the binding declaration (or possibly multiple thereof).
• Code completion is partially supported. You might see some references to internally generated code.
• Semantic highlighting feature (checkbox "mark occurrences") is now fully supported.
• Content assist in the form of templates for specific ObjectTeams/Java language constructs namely with{} and within (Expression){} are available now.

• Supports easy creation of connector definitions using a table based graphical user interface.
• Type bindings can be defined by choosing a provided role type and the desired base type with a type selection dialog.
• Method bindings (either callin or callout) can be established by choosing a role method and a base method from the provided role and base method list respectively.
  • Only appropriate binding kinds are selectable in the corresponding context (callin or callout).
  • Besides the provided role methods, a new role method can be implemented by selecting a provided base method, thus creating a callout binding.
• Parameter and result mappings are definable by typing in an expression in the corresponding text field of the parameter mapping configuration tab.

Refactoring

• Extract Method
• Move Method
• Rename Method
• Rename Project
• Rename Source folder
• Rename Field

The Package Explorer

• provides access to all project artifacts and their structure, i.e. source files, used libraries (jar-files), and other documents. Note that team and role classes are annotated with distinct icons -- showing a small T for teams and an R for role classes. (The same icons are used throughout the IDE, whenever a team or role is visible.)
• By opening the tree-branches, you can peek at the structure of e.g. classes.
• For team classes, there is special support for role files: Role files are separate files and can be shown either logically as member types of the enclosing team or physically as (separate) files in the team package.
• Furthermore, the Package Explorer provides the current context for other operations. The Team- and Role-Wizards, for example, have a pre-set source folder, package and enclosing class when a team is selected in the Package Explorer.

The Hierarchy View

• Object Teams intruduce a new type hierarchy. Besides the normal ("extends") inheritance, there is an additional "implicit" role inheritance, established by role name equality in a team hierarchy. In conjunction with team nesting roles support a controlled form of multiple inheritance.
• The new implicit inheritance has been integrated completely into the standard JDT Hierarchy View. The revised Hierarchy View supercedes the incomplete support which was provided by a specific "Implicit Hierarchy View" in previous releases of the OTDT.

Search

• All aspect oriented languages have some kind of weaving process, where the aspect code is combined with the other (base) code.
• Object Teams programs perform the weaving at application startup time, i.e. at the moment, the program is launched. In order to do this, there is the so-called Object Teams Runtime Environment, that wraps around the standard launching procedure.
• All this is handled transparently using the standard Eclipse "Run" feature. You simply choose to create an Object Teams Application "Run-Configuration" instead of a Java Application "Run-Configuration" and hit the "Run" button to launch your Object Teams application.
• A new "Team Activation" tab in the "Run-Configuration" allows to instantiate and activate teams without modifying the program's source code.
• Teams that cause aspect code to be woven into an application can be added to a program
  • by explicit reference within the program source code or
  • by a configuration file which is mentioned as a parameter to the VM or
  • by adding them via the aforementioned "Team Activation" tab.
  No such configuration is needed for compilation.
• Experimental support for a Java 5 based weaver. The original OT/J-weaver uses the JMangler framework for intercepting classes during class loading. The new version uses the Java-agent concept of Java 5 (JPLIS) instead, which means we will be indenpendent of JMangler. In the future this version will support aspect weaving not only at load time but also while an application is running.
  The launch configuration for OT/J applications contains a new checkbox for selecting the weaver ("Java 5 JPLIS Launching"). Please note, that the new Java 5 based weaver is not yet complete.

Debugging

• A Tutorial (available via the welcome page) guiding through the first steps of using the OTDT.
• Example programs demonstrating key features of ObjectTeams/Java (also via the welcome page).
• Detailed documentation on using the OTDT via the Help Index, including a link to the language definition (which is also bundled).
• Problems that are listed in the problem view are linked (when possible) to a corresponding explanatory entry in the language definition. (Context menu ->"Go to Language Definition").

As an introduction to the OTDT you may watch the following movies (requires a plugin for Shockwave Flash Media):

• Introduction to the Object Teams Development Tooling
• Introducing the Object Teams Development Tooling by Example
• ... more movies will follow.

References

Eclipse 3.0 Release Notes
back to the download page