Eclipse Dirigible is an open source project that provides Integrated Development Environment as a Service (IDEaaS) as well as runtime containers integration for the running applications. The environment itself runs directly in browser and therefore does not require additional downloads and installations. It packs all the needed components, which makes it self-contained and well integrated software bundle that can be deployed on any Java based Web Server.
Target applications built with Dirigible are atomic yet self-contained cloud based modules that cover end-to-end vertical scenarios. These applications comply with the Dynamic Applications concepts and structure.
The overall process of building Dynamic Applications lies on well-known and proven principles:
In-System Development - known from microcontrollers in business software systems. The major benefit is working on a live system where all the changes made by a developer take effect immediately, hence the impact and side-effects can be realized in a very early stage of the development process.
Content Centric - known from networking, in the context of Dynamic Applications it proclaims that all the artifacts are text-based models and executable scripts stored in a generic repository (along with the related binaries, such as images). This makes the life-cycle management of the application and the transport between IT landscapes (Dev/Test/Prod) simple and straightforward. In addition, a desired effect is the ability to setup the whole system, only by pulling the content from a remote source code repository, such as Git.
Scripting Languages - programming languages written for a special run-time environment that can interpret (rather than compile) the execution of tasks. Dynamic languages existing nowadays as well as the existing smooth integration in the web servers make possible the rise of the in-system development in the cloud.
Shortest turn-around time - instant access and instant value became the most important requirement for the developers, that's why it is the major goal of our tooling.
In general, a Dynamic Application consists of components, which can be separated in the following categories:
Data Structures - the artifacts representing the domain model of the application. There is no intermediate adaptation layer in this case; hence all the entities represent directly the database artifacts - tables and views.
Entity Services - domain model entities exposed as web services, following the modern Web 2.0 patterns and scripting language capabilities.
Scripting Services - general purpose services for utilities, custom modules and extensions.
User Interface – pattern-based, generated user interfaces, as well as custom forms and reports based on the most popular AJAX frameworks or any other used by the developer.
Integration Services - in the real world there are always some external services that have to be integrated into your application - for data transfer, triggering external processes, lookup in external sources, etc. For this purpose Dirigible provides capabilities to create simple and dynamic routing services following the Enterprise Integration Patterns guidance
Documentation - an integral part of any application is its documentation. Dirigible supports authoring documentation content in the widespread wiki (confluence) format.
Dirigible architecture follows the well proven principles of simplicity and scalability in the classical service-oriented architecture.
The design-time and the runtime components are well separated. They interact with each other through a dedicated repository where the only linking point is the content itself. At design-time programmers and designers use the Web-based integrated development environment based on the Eclipse Remote Application Platform (RAP). Leveraging this robust and powerful framework the tooling can be easily enhanced using well-known APIs and concepts - SWT, JFaces, OSGi, extension points, etc.
The Repository is the container of the project artifacts. It is a generic file-system like content repository built on a relation database (via JDBC).
On top are the Dirigible's containers for services execution depending on the scripting language and purpose - Rhino, jRuby, Groovy, Camel, CXF, etc.
The runtime can scale independently by the design time part, and even can be deployed without design time at all (for productive landscapes).
Depending on the target cloud platform, Dirigible can be integrated to use the services provided by the underlying platform.