A few months ago, RoweBots decided to adopt Eclipse as a platform for delivering new tools to our customers, particularly interested in the Europa release. We decided to use Eclipse for all the reasons that you've likely been thinking of, if you are considering doing the same thing:

* open source
* high quality
* broad tools
* many plug in extensions
* great licensing model
* community driven development without one large controlling partner
* many books
* general applicability

Little did we know what we were getting into. The fundamental problem with Eclipse is that nobody has had the responsibility - or at least fulfilled the responsibility - of making it easy for anyone else to learn about it with a specific domain of knowledge in mind.

It is a community of practice where the domain has gotten too broad and it is in the process of developing subdomains but nobody has bothered to organize the subdomains.

The domain of knowledge that I am interested in is deeply embedded systems. When I started my review there were many pieces of Eclipse and Eclipse projects that could help us and our customers but there was no coherence to this information.

For this reason, I'm writing this article as a brief high-level user's guide to embedded Europa projects so that others can make more sense of these projects with far less work than was required on my part.

Our World View
For me, there are two approaches to developing embedded systems and Eclipse embraces both of them. This makes Eclipse incredibly interesting to me in the long term.

The first approach is to rely upon modelling of the system starting with high level models. Decomposing a system in this way provides true benefits in terms of architecture, modularity, and common design patterns.

Then using these models, the system can be generated from standard components using additional custom modules where required. This is where many of us would like to be, but nobody has achieved this in any broad sense.

The second approach is what we would typically see in the field today. Typically we are making additions to existing systems. Developers have mental models and actual documentation of the system in some cases, and they use these models to develop the code.

The development is done via refactoring, from minor to major. Eclipse is great at supporting this type of incremental change and enhancement common in so many programming paridigms today (agile programming, extreme programming, etc.).

In this second approach, testing is done as part of the development. As a matter of fact, most would suggest that the tests should be written before the code changes to ensure that the code does the right things.

Tools are usually used to automate this testing and the testing framework is version controlled along with the new components to ensure that retesting and piecewise testing is possible at any time. The refactoring steps are usually kept small too, ensuring that the system is operational nearly all the time and that it meets users expectations nearly all the time.

Why haven't these two approaches converged into one? The real reason is that the modelling tools and reverse engineering tools are not yet up to the required standards for true component based development. On the front end we have a broad set of diverse models for embedded systems. A few such common models and approaches are:

* UML 2
* SDF
* Puma
* Entity Relationship Diagrams
* Petri Nets and Stochastic Petri Nets
* FEMA
* Fault Tree Analysis

Different industries will want different models and a broad set of models will exist. The automotive industry is working on its own set of models for describing deeply embedded systems in transportation vehicles.

Many also feel that there will be domain specific models such as SDF or Petri nets, which will only work for very narrow domains " maybe even one family of products within a company. All these models will have to work together to offer a coherent view to the developers. Eclipse is ideal for supporting such model development and evolution.

A second major factor inhibiting modelling based programming utilization is that users have to be trained on a unified set of models which can completely describe their system, and only then to the models stop getting in the way and really help the development team.

Don't forget the team is always under time pressure and any modelling tool which cannot fully address the team's needs falls by the wayside quickly. With out of date models, reverse engineering becomes critical, but this feature is generally not as strong as it needs to be to achieve high productivity. In particular, all the comments are dropped off the diagrams in reverse engineering which limits the usefulness of these diagrams.

Eclipse Projects
From this perspective of the evolution of embedded software development and maintenance, we can look at the ways that the Eclipse projects can contribute to the overall framework that presumably will exist by 2020. We can also look at how Eclipse can tribute in the short, medium and longer term.

Now, as we look at the Eclipse projects and frameworks, the power of Eclipse become all the more apparent. It does offer a great deal to developers in terms of refactoring and pattern design methods for developing systems and the support for refactoring approaches and code development are growing.

Clearly the momentum is building for a more model based programming approach, and Eclipse provides a framework for both appraoches as they converge. The basic approach of the various projects are indicated in Table 1, below.

Table 1. Eclipse Europa Projects Release

The Europa Release content relevant to main stream embedded system developers is shown in Table 1. This is what Eclipse offers in the short term. This collection of projects offers a broad set of support for refactoring and model based development but lacks the completeness required for full model based development of embedded systems. The obvious limitations are as follows:

* Testing support for C/C++ is not provided.
* Although support for UML 2 is offered, support for other models like PUMA, SDF, and many others are not supported. In addition to support, they require integration at the model level.
* Buckminster is in its infancy and unlikely to be useful.
* Performance modelling, measurement and display are major holes.

In summary, Eclipse now offers a very good environment for C/C++ embedded development including integration into the target side, but lacks many of the higher level pieces and integration necessary for a full modelling toolset.

In the medium term, expect Eclipse to improve dramatically in the area of modelling of embedded software systems and in the area of ubiquitous support for embedded targets. The framework development for any type of model development, storage, display, update and connection to other models has already been provided.

As the model sets become richer and the models become integrated, our ability to use these tools will improve. Also extension of the testing and measurement tools into the embedded domain are expected and will make a major contribution to the framework.

In the long term, consider the tools and models developed over the past 25 or 30 years for embedded software development and how quickly they evolved and changed.

In fact, few revolutionary enhancements have been made over this time. Look at the new technologies on the horizon and how they might change the world " in particular the growth in computing power and software which deals with uncertain outcomes.

It is highly likely that the tools and models that we have today will be the framework for software development for the next ten or twenty years with the process of transformation and compilation using high level models becoming more dominate over time. Eclipse has the framework that is needed to support this.

Kim Rowe has spent over 29 years developing real-time and embedded signal processing systems for defense, communications, medical and other applications. His company, RoweBots Research Inc. was founded in 1987 and offers DSP Real-Time Operating Systems, DSP Libraries and Eclipse based IDEs for C/C++ as well as consultancy. Kim has a blog " RoweBits that focusses on current issues in multicore processors, multicore DSP implementation, FPGA DSP algorithm implementation, digital signal processors and digital signal controllers, parallel algorithms, heterogeneous architectures and modelling tools for DSP applications.