×

Status message

This proposal has been approved and the Eclipse Dirigible project has been created.

Dirigible

Basics
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 community. Please login and add your feedback in the comments section.
Parent Project: 
Background: 

Dirigible project came out of an internal SAP initiative to address the extension and adaptation use-cases related to SOA and Enterprise Services. On one hand in this project were implied the lessons learned from the standard tools and approaches so far and on the other hand, there were added features aligned with the most recent technologies and architectural patterns related to Web 2.0 and HTML5. This made it complete enough to be used as the only tool and environment needed for building and running on-demand applications in the cloud.

Scope: 

Full development lifecycle of on-demand applications leveraging In-System Programming Model and Rapid Application Development techniques:

  • Database modeling and management;
  • RESTful services authoring using various dynamic languages;
  • User interface – pattern-based generation as well as custom forms and reports;
  • Injected services;
  • Role based security;
  • External services integration;
  • Testing;
  • Debugging;
  • Documentation;
  • Extensions management;
  • Operations and monitoring;
Description: 

Overview

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.

Dynamic Applications

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.

Architecture

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.

Why Here?: 

The natural choice of a project like Dirigible targeting development scenarios in favor of the open-source community and at the same time to be respected by the enterprises is the Eclipse Foundation.

Recent initiatives and projects related to the cloud development scenarios, such as Orion, Flux and Che, makes Eclipse the most viable organization in this context.

The Web IDE, part of Dirigible is based on the strong foundation of Eclipse projects, such as Equinox, SWT, JFaces, Remote Application Platform (RAP), Mylyn, etc.

Project Scheduling: 

The full set of features is planned for contribution by Q2 of 2015.

Future Work: 

Planned functionality:

  1. Improvement of JavaScript debugger using Web Sockets
  2. Continuous improvements on WYSIWYG HTML Editor
  3. Integration of Orion/Flux/Che Java Editor
  4. Focus on Java for In-System Programming
  5. Externalize pluggability for Repository implementations (no-SQL, etc.)
  6. Form-based editors for the project's artifacts (data structures, extensions, service definitions, etc.)
  7. Build-your-own-Dirigible - update site, target platforms, features separation, etc.

Community efforts:

  1. EclipseCon Talks
  2. Blogs, Twitter, Youtube, etc.
People
Source Code
Initial Contribution: 

The initial contribution is to be completed by the end of 2014.

Source Repository Type: