EGL Development Tools Project

The project has been created. Please visit the project page.

EGL Development Tools Project

The EGL Development Tools project is a proposed open source project under the Tools Project.

This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process) and is written to declare its intent and scope. We solicit additional participation and input from the Eclipse community. Please send all feedback to the EGL Development Tools Forum.

Background

EGL Language Concepts

EGL is a programming language conceptually similar to many common languages that have come before it. The language borrows concepts familiar to anyone using statically typed languages like Java, COBOL, C, etc. However, it borrows a concept from UML (Universal Modeling Language) that is not typically found in statically typed programming language – the concept of Stereotype. In UML, stereotypes are used to tag UML elements with metadata (in this case, metadata refers to information about the UML element, for example, information about a UML element called a "class"). Constraints can be defined by stereotype definitions such that elements stereotyped by the given stereotype must adhere to the defined constraints of that stereotype. Stereotypes in UML are used as a lightweight mechanism to extend the standard modeling concepts. Stereotypes in EGL are essentially the same idea and are used to extend the basic EGL core language concepts.

With most programming languages, source code is either compiled into a standard set of byte codes readable by a VM (Virtual Machine) or the code is compiled into the actual machine instructions for a specific platform. The compilation process usually has at least two major phases:

  1. Conversion of the source code into some intermediate model representation
  2. Generation from that intermediate model to the appropriate byte code (object code) or platform-specific instructions
Typically the set of constructs and concepts a compiler must deal with is a closed set so both steps can be handled by a single processor called the compiler. However, in EGL the set of concepts to be compiled and transformed is extensible. Therefore, in EGL these two steps have been explicitly separated into a compile step (which converts EGL source code to a serializable intermediate model) and a generation step (which takes the intermediate model and generates some other type of source code).

The EGL compiler is responsible for validating and binding the basic core language as well as enforcing the constraints defined by various stereotypes. If validation is successful, the intermediate representation of the source code will be serialized. The EGL generator reads this model and transforms it into runtime source code. The EGL compiler is closed in the same sense as any compiler as it is dealing with a predefined set of concepts. However, the EGL generator is left with the task of transforming the concepts embodied in various stereotypes to actual runtime source code. This is why the generator is separated from the compiler; so that extensible generator frameworks can be built without having to be linked with any particular compiler implementation. New stereotypes can be added and used by EGL programs. The compiler will validate the usage of those stereotypes without any extension to the compiler. However, the generator must be extended to understand these new stereotypes and do the appropriate transformations.

EGL Implementation and Tools

The EGL technology, in its current form, exists today within the Eclipse-based IBM Rational Business Developer (RBD) development tool and provides a programming environment capable of deploying multi-tier application components across different platforms and middleware. EGL code is not executed directly as byte or machine code, but is instead compiled and generated into either Java (e.g. Java-based Web services that access information in databases), JavaScript (e.g. RIAs that utilize Dojo and other JavaScript libraries), or COBOL source code depending on the desired target runtime environment (the generator is sensitive to both resulting source code language and resulting runtime environment in which that code will run). Being able to deploy the same EGL code to multiple environments enables ultimate platform flexibility, and breaks the barrier that today forces use of specific languages when developing for specific platforms.

Portability is especially useful for businesses that currently deploy applications across a wide array of environments ranging from web browsers on client machines, to JEE on mid-tier application servers, to mainframe servers such as CICS or IMS. These environments are constantly changing. New platforms, such as WebSphere XD Compute Grid and others being developed in the Eclipse Runtime Project are emerging. A technology such as EGL allows the creation of applications that are able to be re-hosted across changing runtime environments without changing the source code. Instead changes to the model generators can either apply existing concepts to the new infrastructure or to allow the programmers to more easily apply new concepts on the new platform.

Scope

The scope of the EGL Development Tools project is restricted to:
  • First-class development tools for the EGL language, comparable in scope to the tools provided for the Java language by the Java Development Tools project
  • EGL language parser, compiler and generators, which can be invoked via the tools (e.g. by project builders) or command line (for headless compilation and generation)

Because the EGL language itself (including keywords and syntax) will be managed within the scope of the EGL Development Tools project, we solicit feedback from the community on how best to manage its evolution. A formal community-driven specification process may need to be established to support this function.

Description

Initially, application developers will be able to develop, run, and debug EGL-generated Java and JavaScript applications and deploy to a Dynamic Web Project. These capabilities exist today in the EGL Community Edition tool (watch a simple Hello World video).

The generators provided as part of the initial contribution are not designed for extensibility. We propose to work with the community to reimplement the existing Java and JavaScript generators on top of an extensible framework. Once completed, these generators can then be extended to support new runtime environments (e.g. OSGi-based runtimes), or new generators could be created using the extensible framework.

Initial Contribution

Our goal is to provide capabilities that will make the initial contribution immediately useful. We intend to actively develop, refactor, extend, and grow the capabilities (either organically or through integration with other projects) over time.

The initial contribution to the project will come from an existing IBM product, Rational Business Developer. The initial contribution will be functionally comparable to the EGL Community Edition tool.

The following capabilities are planned to be included in the initial contribution:

  • Tools
    • EGL source editing
      • Editor with syntax highlighting, content assist, validation
      • EGL build and deployment descriptor editors (editors to control how EGL source code is compiled and generated)
      • EGL builders (full and incremental)
      • Visual editor for WYSIWYG editing of Rich UI components
    • Project Explorer view integration
      • Integration to show EGL packages and source for EGL projects in Eclipse software development environment Project Explorer view
    • Supporting views and perspectives
      • Outline view showing hierarchy of EGL source
      • Palette view with EGL and user-contributed widgets
    • EGL application debugging
      • Integrates with Eclipse Debugger
    • Deployment capabilities
      • Deployment to Tomcat
      • Deployment of EGL services as REST and/or SOAP Web services
    • Eclipse Data Tools integration
      • Tools to generate EGL from database table or view
      • Tools to validate and view EGL/SQL source
  • EGL code compiler and generators
    • EGL source compiler
    • Java generator targeting JEE environments
    • JavaScript generator
  • Documentation
    • EGL langauge reference and developer guides

Relationship to other Eclipse projects

The basic approach used with EGL is that of model to code transformation. This approach has a lot in common with Model Driven Development (MDD). With EGL, a programmer is using a Domain Specific Language (DSL), in this case EGL, instead of UML directly to represent the “model” of their application. EGL is the DSL. The Eclipse Modeling Project has many elements that could be in support of EGL and vice-versa. In particular EGL has its own implementation of a modeling infrastructure similar in concept to EMF but implemented to be able to scale to the needs of a programming language infrastructure. It is the intent of this project to merge the appropriate elements of existing Eclipse technology into the EGL tool infrastructure but the opposite may also be true.

Legal Issues

IBM may have acquired trademark rights in the names 'Enterprise Generation Language' and 'EGL'. IBM will discuss with the Eclipse Foundation appropriate terms under which to grant or assign rights in those names.

Committers

The following individuals are proposed as initial committers to this project:
  • Tim Wilson, IBM (project lead)
      Tim is the chief architect of the EGL language and tools within IBM, and is one of the inventors of the technology. Tim will be primarily focused on enabling others to extend EGL to support new target languages and platforms.
  • Tony Chen, IBM
      Tony works as a software engineer for IBM China and has made significant contribution to EGL JSF component and performance. Tony will primarily focus on the EGL SDK (command line compiler and generator).
  • Paul Harmon, IBM
      Paul is the primary developer responsible for the EGL language parser, validator, intermediate representation (IR) and interface with the code generators, and will be primarily focused on improving the extensibility of these components.
  • Matt Heitz, IBM
      Matt leads EGL Java Generator development at IBM, and has been part of the team since its inception in 1999. He is also the lead for the EGL JavaScript Generator, and he created the EGL Test Facility.
  • Ben Margolis, IBM
      Ben has more than 20 years' experience as a writer and programmer and has written two books: SOA for the Business Developer, and Enterprise Web 2.0 with EGL. Ben is overseeing the documentation for the EGL tools and compiler on Eclipse.
  • Brian Svihovec, IBM
      Brian has been actively involved with the design and development of the EGL language, and its Eclipse based development environment, since 2001. His contributions include a significant involvement in the design and implementation of EGL Rich UI support in the EGL language, and being a lead developer on the EGL compiler for the Eclipse IDE.
  • Paul Pilotto, ASIST
      Paul is a software architect and partner within ASIST Belgium and ASIST Luxembourg. He is specialized in transformations from legacy languages to EGL and in that context has made significant contributions to technical solutions for EGL migration and integration projects.
  • Bernd van Oostrum, ASIST
      Bernd works as a consultant at ASIST in Belgium, he is specialized in the implementation and standardization of the EGL development platform. He is the main developer of the ASIST Build Engine, ASIST Naming Tool and ASIST Impact Analysis Tool for EGL.
  • Bart Van Campenhout
      Bart works as a consultant at ASIST in Belgium, he is specialized in the implementation and standardization of the EGL development platform and has made significant contributions to Eclipse plugin development projects for the Integration of EGL.
  • Wim Delen, ASIST
      Wim works as a consultant at ASIST in Belgium, he is specialized in the implementation of the EGL development platform and has made significant contributions to the Eclipse plugins that integrate EGL with Rational ClearCase and SubVersion Apache projects.
  • David Van Herzele, ASIST
      David works as a consultant at ASIST in Belgium, he is specialized in the implementation and standardization of the EGL development platform. He has made significant contributions to Eclipse plugin development projects for the integration of EGL with SCMs, including Rational Team Concert and Rational ClearCase.
  • Eric Nolmans, ASIST
      Eric works as a consultant at ASIST in Belgium, he is specialized in the implementation and standardization of the EGL development platform and has made significant contributions to Eclipse plugin development projects for the integration of EGL with Rational Team Concert and SubVersion Apache projects.
  • Aaron Allsbrook, ClearBlade
      Aaron has been a developer of Eclipse-based products and extensions since 2001 and the initial contribution of the Eclipse project from IBM. His development roles included contributions to the Rational Application Developer web framework tooling, Rational Software Architect model transformation authoring, and Rational Business Developer EGL tooling for documentation and discovery. He participates heavily in the EGL community as a consultant, forum contributor, and creator of EGL TV.
  • John Trevisan, ClearBlade
      John has been a major player with EGL and its predecessor languages for the past 22 years. Over the last few years he has played a concentrated role in the migration to EGL processes, assisting in development of best practices and implementations. Within the Eclipse project he will be focusing on simplifying and improving the EGL tools and capabilities to promote easier adoption of the technology within large enterprises.
  • Carlos Prieto, NEXTEL Engineering Systems
      Carlos is the Development Manager at Nextel Engineering (Application Modernization) focusing on Legacy applications migration to EGL. He has created several tools for legacy applications analysis, code processing and automatic conversion. He will contribute with code focused on better support for migrations and modernizations.
  • Oleg Arsky, Synchrony Systems
      Oleg has been designing and developing products using elegant user interfaces for the past 2 decades. His attention has been drawn to creating simple solutions for complex interactions, particularly around the display and visualization of complex data. Oleg will primarily contribute in the areas of EGL JavaScript generation, layouts, and widgets.
  • Corey Grimes, Synchrony Systems
      Corey is a lead developer on legacy GUI migrations. He specializes in VisualAge Generator for VAST/VAJ migrations to EGL RUI, with particular focus on user interfaces and client-server communication. Corey will primarily contribute in the areas of EGL JavaScript generation, layouts, and widgets.
  • Richard Doust, Synchrony Systems
      Richard has been developing user-interfaces for over 25 years on variety of platforms, using many different programming languages and tools. For the past 12 years he has worked with Synchrony Systems migrating many large, mission-critical legacy applications to new platforms such as Web 2.0 and Java/JEE. Richard will primarily contribute in the areas of EGL JavaScript generation, layouts, and widgets.

Mentors

The following Architecture Council members will mentor this project:

  • David Wiliams, IBM
    • David is the PMC Lead for the Eclipse Web Tools Platform as well as being a member of the Tools PMC. He also leads the Eclipse Foundation's Planning Council.
  • Anthony Hunter, IBM

Interested Parties

The following individuals, organisations, companies and projects have expressed interest in this project:

  • Jim van Dam, HiPeS

Project Scheduling

  • June 2010 – initial proposal on Eclipse.org
  • August 2010 – creation of project
  • December 2010 – delivery of initial contribution

Additional information

To better understand EGL: