CoCompose Readme This is the readme file for the CoCompose tool, which is a prototype tool for the CoCompose design language made for my MSc. project. This readme file will be updated with each version of the tool.

Project information

This software is available under the terms expressed in the GNU General Public License, Version 2, which can be found here. In the development of the CoCompose Tool, two other software packages have been used:

• The Apache Xerces 2 XML parser library.
  Source: http://xml.apache.org/xerces2-j. This software is available under the Apache Software Licence, which can be found here.
• The Visualizing Graphs with Java (VGJ) graph drawing library.
  Source: http://www.eng.auburn.edu/department/cse/research/graph_drawing/graph_drawing.html. This software is available under the GNU General Public License, Version 2, which can be found here.

Important notes

• The latest version of CoCompose can be found here.
• CoCompose has been made using version 1.3.1 of the JDK. It may not work well under older versions of Java.
• You need the CoCompose.Xerces.zip archive as well to run CoCompose. Download and unpack it to the same directory as you unpacked this archive to.
• The java binary must be in your PATH variable in order to run CoCompose.bat.
• The javadoc binary must be in your PATH variable in order to run MakeDocs.bat. MakeDocs.bat can be found in the source archive. Download and unpack it to the same directory as you unpacked this archive to.
• The jar binary must be in your PATH variable in order to run MakeJar.bat. MakeJar.bat can be found in the source archive. Download and unpack it to the same directory as you unpacked this archive to.
• Fixes that were needed in the source of the VGJ package in order to reuse it for CoCompose are listed here.

Changes

Changes since 5 December 2003 (version 0.1.19)

• Optimised the DetermineFormsVisitor class to not apply the full process each time.
• Removed the option to flatten breadth-first. All flattening, including one-level only, is done through the FlattenVisitorDepthFirst class. The FlattenVisitor class has been marked as deprecated.
• Fixed bug #1: Java Inheritance implementation generator creates double "implements" clause. The JavaImplementationGenerator class did not scan correctly for an existing "extends" or "implements" clause in insertInheritance().
• New example models added: Breakout game.
• The JavaImplementationVisitor class now removes duplicate "import" statements.
• Fixed bug #3: Default part of solution pattern sometimes applied twice. The Model class did not clone the AppliedPatterns properly. Extra logging is done in the FlattenVisitorDepthFirst class to monitor the state of the model's AppliedPatterns. A new toString() method has been introduced on the AppliedPatterns class to achieve this.
• Fixed bug #4: Migration of implementation constraints fails when trying to reuse a solution pattern that has been flattened away. Introduced the isCopiedFrom() and getLastCopiedFrom() methods on the AbstractConcept class to achieve this.

Changes since 19 November 2003 (version 0.1.18)

• Fixed the Proxy composite.
• Updated implementation generators for JAsCo and SEESCOA (cleanup and new options possible for JAsCo).
• NullConstraint class updated.
• InheritanceConstraint class added.
• Solved a bug in implementation generator constraint checking: if there's no role part for a certain concept, the constraints of that role part are not checked. Now an exception is thrown when no suitable rolepart can be found for a concept. The ImplementationGenerator class and the CompositeFormConstraintsVisitor class have been adapted to reflect these changes.
• Added a copyAttributes() and updateAttributes() method to the ConstrainedConcept class.

Changes since 31 October 2003 (version 0.1.17)

• Added code generation back-end for JAsCo. See also http://ssel.vub.ac.be/jasco.
• Added superclass target language support for reuse of super-language implementations and implementation generators. A language is a sub-language of another language if it provides all the implementation forms available in the super-language and if all the implementation generators are reusable. This information is stored in the "superlang.properties" file. The CoCompose, FlatteningOptionsVisitor, Model, Composite and Concept class have been adapted to reflect these changes.
• Java backend updated: ProtectedMethod and ImplementationMethod removed (according to UML 2.0), ConstructorMethod replaced by PublicConstructorMethod and PrivateConstructorMethod, StaticMethod and StaticInstance added.

Changes since 22 October 2003 (version 0.1.16)

• Concept names can now be imposed upon concepts from solution patterns through published concepts' public names. Note that this only works for concepts within role parts, which are instantiated exactly once. The SolutionPattern class has been adapted to reflect this change.
• The FlatteningOptionsVisitor class now eliminates the option of not flattening a composite when published concepts exist. It also re-checks solution patterns that were validated before if there are published concepts.
• A considerable cleanup of the example models and composite repository has taken place. The semantics of SingleRelation and ManyRelation have been considered and made mutually consistent.
• A naming convention has been introduced that includes "Solution" in the filename of standard solution patterns. This way, confusion with the composite filename in the repository is avoided.
• Solved a bug in the DetermineFormsVisitor class that caused a NullPointerException when no constraints were imposed on a Concept's implementation form.
• The ModelCanvas stores undo snapshots of the Model being edited. Sometimes it tried to store a snapshot while the Model is in an illegal state, which caused a stacktrace to appear. A new clone() operation, called safeClone() has been added to the Model class, which throws an Exception when cloning fails. This way, ModelCanvas can ignore making a snapshot when the Model is in an illegal state.
• Solved a bug that causes nested PublishedConcepts to not be linked to the rest of the model. The bug was caused by not re-checking Composite dependencies: a Composite depends on another Composite if any of its roles are filled by PublishedConcepts of the other Composite. This is checked initially and Composites are flattened in the right order. If a Composite SolutionPattern just replaces one PublishedConcept by another, new dependencies are introduced and the Composite depending on the PublishedConcept cannot be flattened yet. The Composite class now has a method isDependent(), which is used by the FlattenVisitor class and the FlattenVisitorDepthFirst class.
• Solved a bug in the Implementation class that caused PublishedConcept (publicName) renamings not to propagate to embedded implementations.
• Solved another bug in the Implementation class that caused Implementation constraints to not be copied correctly (re. instantiatedBy).

Changes since 14 October 2003 (version 0.1.15)

• Changed the ErrorReporter interface to take a CoComposeException as a parameter.
• Added a constructor to the CoComposeException class that allows for creating a new exception from an old one with just a new message.
• Fixed the insertLinks() method of the Model class to pass on exceptions correctly (information was omitted).
• When generating Java, embedded implementations that make use of Primitive Concepts do not have the necessary import statements included. The GenerateImplementationVisitor and the JavaImplementationVisitor class have been fixed.
• Java code generation now has limited support for JavaDoc comments.
• A bug has been discovered in CoCompose 0.1.14, which causes solution pattern role parts to be incorrectly applied. When a role is filled multiple times, all resulting role part instances are fully interconnected. They should not connect to each other, but only to instances of the other role parts and the default part. The SolutionPattern, Concept and Implementation classes have been fixed to solve this issue: The instantiatedBy property wasn't used everywhere, so separate instances of a role part weren't distinguished correctly.
• Minor code cleanup of the TranslateVisitor class.

Changes since 9 October 2003 (version 0.1.14)

• XML output for the CompositeType class was broken: the relative system path wasn't written correctly. This has been fixed.
• Several text labels in the GUI don't fully display because of size constraints. Most of the time this doesn't form a problem, since it's clear what is meant, but in the case of "Show icon only", this wasn't clear ("Show icon..."). The corresponding ConceptPropertiesDialog class has been fixed.
• Having to enter standard model properties each time you create a new model is cumbersome. A "load from model" button has been added to the ModelPropertiesDialog class to address this.

Changes since 8 October 2003 (version 0.1.13)

• When reading an XML file, spaces weren't trimmed from the various text block properties (comment, specification, implementation). The ModelReader class has been fixed to trim leading and trailing spaces.

Changes since 6 October 2003 (version 0.1.12)

• Whenever a composite role would end up in the middle of a composite, there was no way to select it anymore. The role would be stuck in the middle forever and its properties cannot be edited. This was due to the selection mechanism in the ModelCanvas class. It has now been fixed to select whatever lies on top, not on the bottom.
• The last few distributions contained the sources of the next-generation CoCompose tool suite. Since this code branch is far from working, it is no longer included. A separate distribution branch will be set up as soon as the next-generation tool starts being useful ;-).
• The tool help files were outdated and incomplete. They have been updated to reflect the current tool status. The help remains incomplete, however.

Changes since 23 September 2003 (version 0.1.11)

• The XML output functionality has been updated recently, but still had a few flaws. The SAXWriter class has been updated to write correct tags now. Also, the relative system path functionality has been moved the Model class.
• The composite dependency check done by the OrderCompositesVisitor class was broken (I keep thinking Java can do dynamic typing for some reason...).

Changes since 31 July 2003 (version 0.1.10)

• Since the EDU.utwente.CoCompose.lang.FreeNode class has been removed, the 0.1.09 version of the Composite and Concept classes stopped working. However, the old Concept class was still included in version 0.1.10, so the whole thing stopped working(!!). The Concept class has been repaired in this updated 0.1.10 version (the old 0.1.10 has been taken offline and shot ;-)).

Changes since 26 May 2003

• Found a bug in the 0.1.09 version of the Model class re. adding and removing links/edges. This bug no longer exists in the 0.1.10 version.
• Changed the SAXWriter API. It now uses a parameterless constructor and no longer links to the DTD file (allows for moving files around without fatal errors).
• Cleaned up superfluous import statements in the EDU.utwente branch.
• Switched to the Eclipse 2.1.1 development platform with JDK 1.4.1.
• Version 0.1.09 was defunct - all functionality run within a separate thread was broken, because java.util.Iterator was used instead of the old API. This version reverts to the 0.1.08 source. The fixes of 0.1.09 are included.

Changes since 14 May 2003 (version 0.1.09)

• Removing concepts on which implementations depend caused a ConcurrentModificationException. This is now solved.
• EPS output didn't work under Redhat Linux 9. The ModelCanvas class has been updated to solve this problem.
• Removed bug in Java and ConcernJ implementation generators that caused Java method headers to be wrongly extracted from ConcernJ implementations.
• The FlattenVisitorDepthFirst class didn't always respect the order in which solution patterns were given for composites. The order is now treated as a priority list heuristic. During flattening, first choice is using implementation generators, next are the solution patterns in the given order.
• Changed the composite type loop check in the FlatteningOptionsVisitor class to a solution pattern loop check.

Changes since 28 April 2003 (version 0.1.08)

• Added the FlattenVisitorDepthFirst class. This flattening visitor returns the first path from the flattening tree and saves snapshot visitors at branch points. A snapshop visitor can be resumed to get the next path in the flattening tree. Which path is the first path is determined by the order in which solution patterns are given for the composites: the solution pattern on top of the list will be tried first. The existing visitor used a breadth-first algorithm, which is more suitable to do per-level flattening.
• The log pane is now again displayed when a translation process step is started: this used to freeze the Java VM for MacOS X, but now the translation thread waits one second for the GUI thread to recover and then starts.
• Added a Search option to the model window, which should make browsing a flattened model (= spaghetti) easier. PLEASE note: I've had quite a few comments on the 'spaghetti' that results from flattening not being very clear and design-level. It is not, because it represents the parse-graph of the translation and should be machine-readable. Still, it is displayed by the tool to demonstrate the translation process. Browsing a flattened model is necessary to check whether the translation process works as it should (tool testing).

Changes since 7 March 2003 (version 0.1.07)

• Optimised reading of implementation generators from composites.
• Optimised flattening process to reuse determined flattening options.
• Replaced static solution pattern cache by a dynamic cache that is kept per model and branches along with model branches (clones along). NOTE: The solution pattern cache is never saved to file along with the model, so flattening should always be done within one CoCompose session! (if you close CoCompose, the cache is lost and a saved, half-flattened model will not flatten further correctly)
• Added the ConstructorMethod concept form for Java and SEESCOA implementation generators.
• Solved a bug in the SolutionPattern class and the Implementation class that caused Concept implementations to be wrongly adapted during flattening.

Changes since 11 December 2002 (version 0.1.06)

• Solved a host of bugs(!) that caused overlapping default parts to not flatten correctly. This also included a new namespacing scheme, which records the whole path of namespaces introduced, separated by an '_'.
• Solved a bug in the DetermineFormsVisitor class that caused preliminary reduction to 0 permutations to not throw an exception.
• Identifiers can now contain the '[' and ']' character to support array types.
• Partly implemented the SEESCOA SCSS testcase: only the util package has been implemented as required for the Storage component. Note that this is work in progress and will probably be finished around August 2003!
• Solved a bug in the SolutionPattern class that caused incorrect composite roles to be found and linked during flattening.
• Moved to Together 6.0.1 for better integrated development.
• Added support for the SEESCOA component language. This triggered some refactoring in the implementation pattern plugins as well.
• Added support for refreshing/updating composites from the composite repository.

Changes since 10 December 2002 (version 0.1.05)

• Worked around a bug in the Hotspot JVM 1.3.1 for MacOS X that caused the virtual machine to hang when the logging panel was shown and another thread was started right after another. The logging pane is not automatically shown anymore.
• Solved a bug that caused locating files in the current directory to fail on MacOS X.

Changes since 24 October 2002 (version 0.1.04)

• Solved several bugs which caused concept implementation constraints to point at invalid concepts or to become lost at all during flattening.
• Solved bug in which a Model object could not retrieve a PublishedConcept object by its local name and namespace.
• Solved bug in which the "Select all" function got disabled by error.
• Added post-processing feature for determining concept forms, in order to apply target language specific naming conventions. A plugin class called translate.<Language>FormsPostproc is being executed after determining concept forms, if it exists.
• All concepts can now be referenced at in embedded source code using the tagged representation (<ConceptName>). The tags will automatically be kept up to date during editing and translating.
• Updated the existing case and added a new one. Also defined a new low-level composite which allows for modelling of instances (objects or attributes and other variables).

Changes since 3 September 2002 (version 0.1.03)

• Removed all 'setResizable(false);' statements from the dialogs, so that the dialogs display well under Linux too.
• The JavaImplementationGenerator and the JavaInheritance classes have been updated.

Changes since 16 August 2002 (version 0.1.02)

• Fixed bug in the ConcernJImplementationVisitor class and the JavaImplementationVisitor class that prevented the Primitive concept form from being implemented.
• The ImplementationPattern class was renamed to the ImplementationGenerator class. This change has been further propagated to other classes.

Changes since 11 August 2002 (version 0.1.01)

• Fixed bug that caused links in progress to not be drawn.
• Fixed bug that caused links, when selected separately, to be undeleteable.
• Cancelling a link in progress can be done by right-clicking the mouse.
• The ImplementationPattern class is now called the ImplementationGenerator class. This change has been propagated to all other classes as well.

Changes since 6 July 2002 (version 0.1.0)

• Added the tool help files.
• Included .tar.gz packages as well.
• The ModelFrame class now disables/enables menu options and buttons when appropriate.
• Added undo and redo option to the ModelCanvas and the ModelFrame class.

Changes since 5 July 2002

• Enhanced undo and redo option in the ModelCanvas class to support undoing of moving as well.

Changes since 4 July 2002

• Moved the EDU.utwente.CoCompose.translate.lang package to the plugins directory as the translate package to make target language support development easier.
• Added dependency loop detection to the OrderCompositesVisitor class.
• Updated the MessageDialog class to split long messages over two lines.
• Updated the ModelVisitor class to suppress a notify() message in thread mode when an Error type CoComposeException occurs.

Changes since 2 July 2002

• Added a specification in CoCompose for the AbstractFactory and Observer composite.
• Added a PublicName attribute to the PublishedConcept class to have a model-wide unique name that can be used for concept implementations and further exporting.
• Introduced the OrderCompositesVisitor class to create an ordered list of all composites in the model based on the composite interdependencies. This list is used for flattening.
• Solution pattern default parts are now applied once for each solution pattern. This was done once for each composite type, but if different solution patterns were used to solve multiple composites of the same type, this caused default parts of some solution patterns to be omitted.

Changes since 1 July 2002

• Updated the ModelCanvas class to calculate the EPS bounds correctly.
• Updated the example models.

Changes since 29 June 2002

• Updated the ModelCanvas class to create postscript for PublishedConcepts as well.
• Altered the FlattenVisitor class in order to cope with composites that have both solution patterns and implementation patterns. Formerly this caused an infinite loop.
• Updated the example models.
• The 'Apply all' option in the 'Translate' menu now has a keyboard shortcut (Ctrl-F9).

Changes

Changes since 25 June 2002

• Updated CoCompose metamodel.
• Introduced the TranslateVisitor class to incorporate all translation process visitors (steps) into one visitor.
• Implementation pattern constraints can now refer to several possible concept forms.
• Updated the implementation semantics of the five example low-level composites.
• Updated several dialog windows to have their first control highlighted by default.
• Altered the flattening mechanism to support published concepts in composites.
• Introduced the CompositePartConcept class and the PublishedConcept class.
• Changed the lang package class hierarchy.
• Eliminated the RolePartConcept class and added its functionality to the AbstractConcept class.
• Select is now the first option in the model window.
• Feature has been renamed to Composite.
• Introduced a getImplementationCount() method to the Concept class.
• Changed the FlattenOptionsVisitor class and the FormConstraintsVisitor class to check whether concepts have any implementations regardless of language and only then whether one of those translates.
• Updated the example model ObserverAlt.xml.

Changes since 24 June 2002

• CoCompose now generates a .dmp file when generating code, which contains the internal representation of the implementations just after applying the implementation patterns. This can be used for testing and debugging new implementation patterns.
• Generated implementation files now are automatically written in the system-specific format re. newlines (i.e. DOS or UNIX).
• The background thread in the ModelSpring class now goes to sleep when idle.

Changes since 23 June 2002

• Made the classes in the EDU.utwente.CoCompose.lang package thread-safe.
• Made the ModelCanvas class thread-safe.
• Applied the GNU Public License to this software.

Changes since 22 June 2002

• Changed the ModelVisitor class to execute in a separate thread.
• Introduced the ModelUpdate interface to allow enabling and disabling of the model display during operations on the model.
• Introduced the CoComposeDialog class to facilitate common methods.
• Extended the TextViewDialog class to display HTML as well.
• The ModelFrame class now runs all translation operations in a separate thread.
• Added Tool and API Help options in the MainFrame class.
• Updated the sample implementation patterns to insert Literal implementation (e.g. an import statement) when needed.

Changes since 21 June 2002

• Added CoCompose.ico and CoCompose.png icon files in the distribution package.
• Changed the ModelSpring class to run as a thread in the background. This required changing the ModelCanvas and the AbstractConcept class as well to make them thread-safe to some extent. Note that the model spring algorithm can be enabled in the 'View' menu via 'Toggle scatter'.

Changes since 13 June 2002

• The PositionVisitor class now shows every update when loading positions. Otherwise people may think I'm cheating during demonstrations ;).
• Completed the GenerateImplementationVisitor class.
• Introduced the ConcernJImplementationVisitor class.
• Introduced the JavaImplementationVisitor class.
• Fixed UNIX shell scripts to use a : instead of a ; between paths.
• Introduced an Update button for the concept implementation dialogue ImplementationsDialog.
• Introduced the CoComposeException class for better identification and handling of CoCompose specific exceptions.
• Introduced the JavaImplementationPattern class for standard Java implementation pattern functionality.
• Introduced the ConcernJImplementationPattern class for standard ConcernJ implementation pattern functionality.
• Tuned the logging to use less system resources (this also includes less logging ;)).
• Introduced incremental constraint checking for the DetermineFormsVisitor class to cope with the huge amount of permutations (above 3^18).
• Implemented all example implementation pattern plugin classes.
• Implemented flattening in the FlattenVisitor and the FlatteningOptionsVisitor class.
• Updated the example models and included generated output code.

Changes since 3 June 2002

• Changed the name of the RoleConcept class into SolutionRole.
• Added several icons to the user interface and updated some feature icons.
• Solved a bug that caused the Links to load with the first and last point reversed.
• Updated the CoCompose metamodel.
• Concept forms can now be saved as well. Also added a reset option.
• Increased logging information during determining concept forms.
• The concept form heuristic is now again applied when determining concept forms.
• Started implementation of GenerateImplementationVisitor class.

Changes since 28 May 2002

• Introduced a new graph layout strategy with the PositionVisitor class.
• Changed the interfaces of a few existing classes to support the new algorithms.
• Implemented the new determine concept forms strategy through the DetermineFormsVisitor class and the FormConstraintsVisitor class. Implementation constraints are now checked as well. Please note that the concept form priority heuristic is not yet used in the new strategy.
• Introduced a visitor pattern for model operations through the ModelVisitor class.

Changes since 7 May 2002

• Changed the versioning implementation to display 0.0.20 instead of 0.0.2.
• Adapted the example models according to the new concept form constraints of the concept implementations. Also included a special Composition Filters based solution.
• Added concept form constraints to the Implementation class. This also changed the ModelReader class. Please note that these constraints are not checked anywhere yet!
• Concept implementation name adaptation has changed, so that only special keywords enclosed in <> are replaced. This changed the Implementation class and the SolutionPattern class. The constraints are also adapted.

Changes since 6 May 2002

• Updated the CoCompose language metamodel.
• Eliminated default part for implementation patterns (can be modelled through solution patterns).
• Forced garbage collection after flattening and determining concept forms in the ModeFrame class to reduce out of memory errors.

Changes since 2 May 2002

• Added a solution pattern alternative for the Observer feature to display handling of design space alternatives in CoCompose.
• The FeatureType class now saves implementation patterns as well. This was a bug causing features to be saved in the repository without their implementation patterns linked.

Changes since 23 March 2002

• Implemented determining concept forms.
• Defined partial implementation pattern DTD to support determining concept forms.
• Implemented user defined heuristic for concept form translation priority.
• Changed flattening implementation to support multiple flattened design alternatives.
• Changed JBuilder Designer constructors back to public level where needed. It turned out that the JBuilder designer needed that in some cases.

Changes since 21 March 2002

• Made JBuilder Designer constructors implementation level.
• Added @see tags with classes where applicable.
• Made all protected items private in the ModelSpring class, since it can't be reused in this form anyway.
• Logging time now in 24 hour format in the ModelFrame class.
• String replacing in the SolutionPattern class has been improved: first all occurrences are gathered, then they are replaced. This is done to avoid replacing already replaced strings.

Changes since 21 March 2002

• Features in feature repository now displayed without .xml extension.
• When applying solution patterns, concept implementations will be updated as well according to roles that were filled in.
• Altered the Implementation class to contain the actual implementation instead of the file name. This is needed, because the implementation must be adapted for each flattening step.
• The ConstrainedConcept class now checks whether the name is set in checkCompleteness().
• Introduced the DefaultUniqueRealm class to support feature type vs. name checking and make model loading more lightweight.
• Default parts of solution patterns are now applied type globally.
• Logging improved.
• checkCompleteness() method overriden in the Feature class to ensure the feature type is set.
• Changed the Model menu in the ModelFrame class to the Translate menu. Menu items have been named after the steps in the Translation Process.

Changes since 19 March 2002

• Introduced a log panel in the ModelFrame class.
• Improved the status display in the MainFrame class.
• Improved the scatter algorithm in the ModelSpring class.
• Implemented the flattening step.
• Changed the DesignModel DTD to support tracking the feature solution pattern from which introduced concepts and features came.
• Multiline labels introduced.
• CoCompose now remembers in which namespace AbstractConcepts were introduced.
• Flattening now split into full flattening or one level flattening.
• EPS font scaling improved.
• The CoCompose ditribution no longer has the classes and doc archive. Both of these can be generated from the src archive (CoCompose.x.y.z.src.zip).

Changes since 18 March 2002

• Updated API documentation and documentation generator.
• Improved the canvas scaling concerning fonts.
• Introduced the Link class as an extension to edges.

Changes since 16 March 2002

• Added EPS/Postscript functionality to the ModelCanvas, Model, AbstractConcept , FeatureRole and Feature class.
• The button icons have been made smaller and the main toolbar and model frame toolbar now have the same width.
• Set the standard Look and Feel to Metal, which is the default for all platforms. Note that the preferred Look and Feel can always be selected by specifying it as a parameter, e.g. "CoCompose Windows".
• Added a context popup menu to the ModelFrame class that shows when clicking in the canvas.
• Added right-click and shift button handlers to the ModelCanvas class to allow for extended selection functionality.
• Altered the getLabel() method in the ModelCanvas class to display only the integer part of coordinates.

Changes since 14 March 2002

• Altered the ModelCanvas class in order to support Swing.
• Introduced the AngleControl, AngleControlPanel, ViewPortScroller, ViewPortPanel and ModelPanel classes in order to support Swing.
• Removed use of java.lang.reflect.Array by using .length field.
• Extended the MessageDialog class to show additional buttons.
• Introduced DirFileFilter class to use with repository and dialogs.
• All file dialogs have been changed to JFileChooser objects.

Changes since 7 March 2002

• The CoCompose distribution now uses JAR files.
• The control panels in the ModelFrame class can now be dis-/enabled.
• The constraints source and class tree has been separated from the main trees and have been put into the plugins trees.
• The FeatureClass class has been renamed to FeatureType. The FeatureClassReader has also been renamed as FeatureTypeReader.
• The semantics of a solution pattern have altered and the notion of implementation pattern has been adopted in addition. The SolutionPattern and ImplementationPattern classes have been altered/introduced to support this.
• Moved the non-java program directories out of the source tree, so the java classes may be run from a zip or jar file.
• Ported the entire project from JBuilder 3 to JBuilder 5, which uses JDK 1.3.
• Removed extra shortcut text in menu items of the ModelFrame class.
• Improved window sizing in the MainFrame class.
• Introduced new version numbering strategy, starting at 0.0.10.
• Simplified the layout of the About box in the MainFrame_AboutBox class.
• Removed the initModelFrame() method from the ModelFrame class.

Changes since 6 March 2002

• Enabled setting of Look and Feels by accepting the Look and Feel name as a parameter. Check the About Box for available Look and Feels.
• Added the conceptForms() method to the JavaSolutionPattern interface.
• Changed the ConstrainedConcept and FeatureRole class to support marking of objects that violate their constraints.
• Added the Implementation and ImplementationsDialog class to support implementations for concepts.
• Changed the solutions attribute of the Feature class to be a Vector instead of a Set. This way the order is important and it doesn't matter if the same solution pattern is added more than once.
• Changed layout to use Swing components where possible (VGJ is non-Swing).
• Separated the sources, classes and documentation.

Changes since 28 February 2002

• Added an example model describing the CoCompose language.
• Separated the sources, classes and documentation.

Changes since 22 February 2002

• Updated the draw() method behaviour in the Feature class.
• Changed the colours in the RoleConcept class in order to support black-and-white display.
• Implemented part of the flatten() method in the Model class and related methods in other classes.
• Added TargetLanguage attribute to the Model class. Adapted the DesignModel DTD and the ModelFrame class to support this attribute.
• Added flattening functionality to the Feature class.
• Changed the Feature and SolutionsDialog class to accommodate several solution patterns expressed in the same language.
• Added extra comments to all classes.

Changes since 19 February 2002

• Changed the FeatureClass, FeatureRole, ModelReader, FeatureClassReader and ConceptPropertiesDialog class to accommodate for the removal of the TranslationRule mechanism.
• Removed the TranslationRule interface, NullRule class and TranslatingConcept class. The TranslationRule mechanism proved to be redundant.

Changes since 17 February 2002

• Changed the Feature, FeatureClass, ModelReader, ConceptPropertiesDialog class and added the SolutionsDialog class to accommodate the DTD changes.
• The DesignModel and FeatureClass DTDs have been changed to incorporate solution pattern links.
• Changed several import declarations of java.xxx.xxx libraries to java.xxx.* import declarations.
• Added flatten() and translate() methods to the Model class.

Changes since 15 February 2002

• Updated CoCompose logo and about box.

Changes since 14 February 2002

• Changed interface TranslationRule: method translate() is now apply().