Thursday, December 15, 2011

What is EGL and why should I care?

Every time a proposed or new programming language comes along the inevitable question is: 'do we really need another programming language?'. In my humble opinion unless it does something significantly different from other programming languages then the answer is usually no. So what makes EGL different from other programming languages such that it is worth taking a look at?

EGL is often described as a 4GL. When EGL was only accessible in the context of IBM products and was a closed black box this view was reasonable. However, the current Eclipse implementation is not just the rehash of that closed system in an open source arena; it is a completely generalized and extensible framework for expressing domain specific concepts in a programming language together with an extensible compiler/code generation framework. EGL the progamming language itself actually only provides a syntax and compiler for creating and validating instances of the EGL meta model; the real meat is in the code generators which read these models to produce code. Furthermore any code generator can be extended to add new progamming model elements, or change existing code generation patterns without affecting the original generator. New generators can be written to target runtimes that may not exist today. A good example a new generator would be one targeting an Objective C runtime instead of Java or Javascript. An example of an extended generator would be one that was built upon the base Java generator but was extended to also understand how to map user interface application concepts to an Android runtime framework.

This approach of a defining models and mapping them to runtime using a Model Compiler may seem familiar to some as classic Model Driven Development (MDD). In many ways this is true. However the point of EGL is to do everything in the programming language, including the modeling itself, so that one never has to edit the generated code. In other words, the model IS the code. Futhermore, the tools within the EDT project also provide debugging in terms of EGL, not the generated code though that is always possible as well.

What the EDT project is really about is providing a programming language infrastructure in which the low level 'assembler' languages generated are the well established runtime languages of the given target platform instead of the bytes codes of a VM or hardware. The current functionality of EDT 0.7.0 just released is really just one implementation aimed at the domain of Web 2.0 based client/server business applications where the target runtime platforms are browsers for the client and JEE based services. Other choices can be made and extensions to the current choices can and will be added.

EGL is not meant to replace existing languages and frameworks. It is instead meant to leverage what already exists and to be molded onto whatever comes in the future. This can be done because EGL itself is a 'meta' language in relation to something like JavaScript in a way similar to the relationship between traditional 3GL languages and the assembler they generate. What is different here compared to other 4GLs that generate 3GL code is that the programming models surfaced to EGL programmers are extensible and the code generation that maps those programming models to real runtime is also completely extensible.

So what does all of this buy us? Some examples:
  • Common programming language across all application tiers

  • Common definitions of shared components across tiers enabling a DRY (Don't Repeat Yourself) disipline. Typical example is data definitions and validation logic that must exist in both the client and the server and often in batch applications as well.

  • Changes in choices of middleware and frameworks and even runtime platform can be managed by updating the compiler and regenerating instead of being stuck with whatever choice was made at the time. This presupposes that the programming model abstracted the semantics of what the given framework or middleware was doing. Typical examples are things like persistence, remote invocation, transaction management , business rule definition and management, etc.

Is EGL for everyone and every problem? No. However, there are several kinds of situations in which EGL is an ideal solution:
  • Multi-tiered applications which target multiple platform technologies and must integrate with existing investments. Integrating across these technologies using the technologies of the systems themselves is tremendously hard. Even if you get a particular solution to work it is likely the underlying technology choices made to support it will need to change over time. If the solution is done with EGL, it is both easier to program and maintain along with being flexible enough to change the underlying target technologies when the need arises.

  • Common application components which need to deploy to multiple environments

  • Flexibility in using staff in producing code across technology boundaries. This one comes from the fact that the ability to create application components that target a given platform has been limited to those who are proficient in that platform's typical programming language. While it is absolutely necessary to have those people it should not be the case that building a business application requires the platform skills of all the places the application components may be deployed. I have seen kids coming out of college able to build applications deploying to the mainframe right out the gate. I have also seen COBOL programmers able to produce Web 2.0 client server applications. The point is that too often the actual important skill of knowing the business is not accounted for. A technology like EGL allows organizations to leverage that important skill for their new applications.

I hope this blog has clarified somewhat the point of EGL and why it is not just another programming language doing what has already been done. People take their programming language of choice seriously and EGL is not trying to replace those choices. It is simply saying that in today's ultra complicated world there is a need for a way of writing, managing, and maintaining applications at a higher and more productive level of abstraction and that compiler technology has always done this well. Let the best of those skilled in those particular technologies express the best of their knowledge into a model compiler so the rest of the world can take advantage of that knowledge.

In the near future we will be having a place out in EDT for 'Extensions'. These will be examples of how EDT is extended to solve particlar problems of interest to the community. Those that get enough people interested will end up producing sub projects under EDT to bring the given extension to production quality. It is these kinds of projects which will bring out the true nature of what EDT is aiming at.

Friday, December 9, 2011

Differences between EDT and Rational Business Developer

We created a new wiki page to highlight some of the differences between EGL Development Tools (EDT) and Rational Business Developer.  The changes discussed include:
  • EGL Language 
  • Relational Database Access
  • Service Oriented Architecture
  • Generation - Configuration and Invocation
  • IDE
  • Debugging
  • Widgets
  • Moving applications from RBD to EDT
If you have used RBD and notice something missing from this wiki page, feel free to add it so that others can benefit from your experience.


Thursday, December 8, 2011

0.7 is here!

It took a little longer than planned, but the 0.7 release of the Eclipse EGL Web Developer Tools is now available. Visit the Eclipse EGL Development Tools (EDT) page for a list of features, a new Getting Started tutorial, links to samples, and, of course, a link to download.

Big thanks to the developers who put in lots of long hours to get 0.7 out the door. Also, a big thanks to our friends at ClearBlade for helping create the fancy new graphics on the site.


Tuesday, November 1, 2011

0.7 M3 is here!

The third milestone of version 0.7 of the Eclipse EGL Development Tools (EDT) project is now available for download. M3 adds some seriously cool enhancements and is also more stable than M2. However, it is still just a milestone build, so understand that it's not perfect yet. If you run into problems, visit the support page to find links to Bugzilla and to the EDT forum.

As mentioned, there were some really cool things added in M3, both from a tooling and a generation perspective. The tooling is really coming together, and you should have no problem creating a new EGL project, writing some code, and running it. There's also now a WYSIWYG visual editor, which really speeds up the design process for EGL Rich UIs (i.e. EGL parts that compile into JavaScript and execute in a browser). Dojo support is now built-in, giving you 30+ Dojo widgets to use in your EGL applications.

Other noteworthy enhancements:
  1. Debug support for EGL targeted for Java or JavaScript (so, set breakpoints in and step through EGL code using the Eclipse Debug tools)

  2. Improvements to the source editor, specifically content assist (rebuilt from the ground up), formatting, and import organization

  3. Deployment (so, support for deploying EGL UIs and services into a standard web project as Java and JavaScript and deploying to an application server)

  4. SQL/relational database support

For more details on these or for a complete list of new features, see the New and Noteworthy page. Keep your eyes peeled for the 0.7 released (see the planning page) - currently planned for December 2. This release will add additional features and will be even more stable than M3.


Thursday, October 27, 2011

Welcome to the official Eclipse EDT team blog

I would like to introduce myself and this new blog where the team will provide the latest information on the EDT (EGL Development Tools) project on Eclipse. While the our first official release of EDT is still in the works (version 0.7.0 is coming soon!), we wanted to get the communication started to foster a vibrant open-source community for crafting of this technology. Come here to find the status of the project, plans and design discussions, as well as how-to articles.

My name is Tim W Wilson and I am the project lead for the EDT project. For the past decade or so, I have been the lead architect for IBM Rational Business Developer which contained the previous proprietary incarnation of EGL (Enterprise Generation language). 

The movement of this proprietary technology to the open source arena is what the EDT project is all about.  Yet it is more than just moving this technology to a new space. The new EGL is a generalization of this  programming language technology.  EGL is now extensible such that abstract concepts can be added to the language similar to how UML Profiles add semantics to models. The code generation is designed to be easily extensible such that these new concepts can be folded into existing code generators. Plus, a full set of Eclipse-based IDE tools used to create, build and debug EGL applications is also part of the grand scheme.

What is this grand scheme you ask?  Without going into too much detail, the purpose of EDT is to provide a platform for building extensible model compilers where the models and the implementation of the operations on those models is fully specified in a programming language, i.e. the Model is the Code. Approaches like UML and action languages are along similar lines but the new EGL starts as a programming language for everything instead of pictures mixed with code. This together with a highly extensible code generation infrastructure leads to the ability to create domain specific compilers. A good example of how such technology can be used is to be able to target Android, iOS and web runtime platforms all with the same code. (Look for a blog post on that topic in the near future.)

As we put the finishing touches on EDT version 0.7.0, we hope you will download EDT and let us know what you think. We encourage you to provide comments and questions on the eclipse-egl forum.

Remember to check back at this blog. We looking forward to sharing more exciting news about EDT.