A Brief History of Epsilon

The work that resulted to what today is Epsilon started sometime in October 2005. This entry provides a summary of the most important milestones…

First steps

In the context of the ModelWare project we needed to design and implement a language tailored to the task of model composition/merging. Starting from an existing ANTLR OCL grammar, we started implementing the concrete syntax of the language. Soon we realized that the merging language was indeed two languages: a general-purpose model management language that provided features such as model navigation and modification, and a task-specific language that provided rules for performing model element comparison and merging. Using ANTLR grammar inheritance we were able to separate the two languages. The result was – what we called back then – the eXecutable Object Language (XOL) and the eXecutable Merging Specification Language (XMSL).

The first versions of the languages run-times supported only MOF 1.4 models (using the Netbeans Meta Data Repository – MDR) as tools like Poseidon and ArgoUML could export UML models in this format (XMI 1.2). To experiment with other modelling languages, we implemented a reflective tree-based editor based on MDR (which proved to be a waste of time when we discovered that EMF had been providing such an editor for a long time).

Moving to Eclipse

Initially, we moved to Eclipse because we were looking for a quick way to implement editors with syntax highlighting and facilities that would allow us to execute XOL and XMSL programs in a user-friendly way. However, moving to Eclipse also allowed us to experiment with the Eclipse Modeling Framework (EMF). To support both EMF and MDR without duplicating code we implemented a set of interfaces that would later on evolve to what we now call the Epsilon Model Connectivity (EMC) layer.

Realizing the potentials for a full-scale model management platform

Model merging involves three sub-tasks: model comparison, transformation and merging. Thus XMSL supported 3 types of rules: matching-rules, transformation-rules and merging-rules. Following the same technique that allowed us to separate XOL from XMSL we decided to split XMSL into a comparison language, a transformation language and a merging language that was built atop both of them. Having four languages instead of the one that was originally intended started making us realize the potentials for a platform of integrated model management languages that would build on a common OCL-based model navigation and modification language.

We decided to name the platform Epsilon, standing for Extensible Platform for Specification of Integrated Languages for mOdel maNagement. XOL and XMSL were accordingly renamed to EOL (Epsilon Object Language) and EML (Epsilon Merging Language). Similarly, the new transformation and comparison languages were named ETL (Epsilon Transformation Language) and ECL (Epsilon Comparison Language).

More languages…

In addition to EML, ECL and ETL, three more languages have been developed atop Epsilon: EVL (Epsilon Validation Language) that targets model validation, EGL (Epsilon Generation Language) for model to text transformation and EWL (Epsilon Wizard Language) for in-place model transformations.

Today Epsilon is a framework with comprehensive support for all the major tasks that are involved in a model-driven development process.

This entry was posted in Uncategorized. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s