Architected Futures™

Tools and strategies ... for boiling the ocean

Motivation

Background

The structural framework selected as the runtime environment for the EATS tool suite is EclipseRT. EclipseRT is the label for the collection runtime components and frameworks developed on and around the OSGi version of Eclipse.

Eclipse is a large and complex platform with a significant learning curve, and the move to using it as the base platform for the tool suite was not made lightly. Eclipse was reviewed previously as an IDE and as a platform framework, but the decision was to not pursue either approach at that time. Most of my most recent prior development experience had been on Windows-based PC platforms within a commercial banking business environment. Coding was originally in C and later in C++. In that environment Microsoft's Visual Studio provided a convenient and comfortable IDE. In my post-banking activities and the development of Architected Futures™, my attention shifted towards open-source as a resource set and toward the use of Java. Eclipse was looked at both as an IDE and as a structural base platform on which to develop the target application functionality. As an IDE it seemed overwhelming, cludgy and cumbersome and I found NetBeans an easier migration from Visual Studio. As a target operating environment Eclipse also seemed overly complex and the complexity did not appear to be able to be well hidden (i.e., the platform seemed to want to express itself in an obtrusive manner over the application, rather than simply serving as a hidden framework). In addition, it appeared primarily viable as a foundation for desktop client applications and did not appear to have ready support for web or other server-based operations.

The immediate cause of the decision to return and re-review Eclipse was the migration of the open-source Protégé application to Eclipse as part of the Protégé  v4 implementation. This led to my discovery of changes in the degree sophistication and maturity of the base platform and and an awareness of the new levels of capability being delivered as part of Eclipse’s modeling framework. Both of these factors were felt to be significant in terms of justifying a need to re-evaluate the prior decision to bypass Eclipse as a structural foundation for the Architected Futures™ Tool Suite.

I had been introduced to Protégé at a DCI Enterprise Architecture Conference in 2003 and had used it off and on since that time to investigate ontologies and as an information modeling tool. As my recent work became more entwined in ontological concepts, I again turned to Protégé as a tool for developing specifications in OWL. I was surprised at that point to find that the newest iteration of the Protégé  platform was being re-written and using Eclipse as its foundation framework. However, this opened up the idea that if I wanted to integrate any of my work with Protégé or any of its ancillary facilities that Eclipse might provide some of the binding.

A renewed look at Eclipse led to some of the same past struggles with complexity and obtuse documentation, but it also shed light on some new and evolved aspects of the system that either weren't previously present, weren't exposed or just weren't evident in my prior examinations. Some of these were solutions to architectural problems that closely resembled aspects of solutions that I had addressed myself in custom built, proprietary code as I searched for my own solution to a proper foundation for the tool suite.

However, at this point the OSGi architecture seems to have a growing acceptance within the software industry and Eclipse has a growing, mature family of applications and components that speak well to the successful merge of the two technologies. In addition, Eclipse provides a growing number of component contributions that can be leveraged within the tool suite which would otherwise be very hard to come by and would entail a significant cost to re-develop independently.

Advantages

Advantages of using Eclipse as a foundation framework for an AF tool suite include:

  • Eclipse defines one of the more popular existing open source standard frameworks for Rich Client platforms. This provides the following benefits:
    • Broad familiarity with the conventions used by the platform (although this tends to be more the case with highly technical users rather than with general business users).
    • A variety of books, tutorials and other documentation exists to inform unfamiliar users with the conventions of the platform.
    • A degree of acceptability of the tool suite due to use of a broadly supported open source platform as a base, thus assuming less risk on AF as the sole developer or place from which upgrades, improvements and bug fixes might be derived.
  • The plug-in architecture of Eclipse, based itself on a more global standard of the OSGi Service Platform specification, provides an widely accepted industry standard set of conventions on which the AF tool suite plug-in architecture can be based. This provides the following benefits:
    • It eliminates a big part of the learning curve associated with the AF tool suite technology by allowing technical personnel to leverage their existing Eclipse knowledge in understanding the AF tool suite.
    • It provides an easy to understand pathway for integration of external tools with the AF tool suite elements, and vice-versa.
  • Eclipse presents itself as a platform specific application.
    • Theoretically operating faster in terms of GUI operations if the SWT approach is taken.
    • Provides a more native look-and-feel to the user.
    • Eliminates the need to perform extra Java development work in order to achieve the native look-and-feel.
  • Eclipse is the native home and incubation site for a variety of open source tools that can be leveraged to facilitate the AF tool suite. Of particular value in this realm are modeling, visualization and code generation tools.

Challenges

Add new comment

Plain text

  • No HTML tags allowed.
  • Web page addresses and e-mail addresses turn into links automatically.
  • Lines and paragraphs break automatically.
SystemsThinking