Fly high with this Eclipse cloud development platform

Eclipse Dirigible

Yordan Pavlov
© Shutterstock / Sadovski

Eclipse Dirigible is an open source cloud development platform, providing the right toolset to build, run, and operate business applications in the cloud. In this article, Yordan Pavlov goes over how developers can build and run applications in enterprise JavaScript.

Eclipse Dirigible is an open source cloud development platform, part of the Eclipse Foundation and the top-level Eclipse Cloud Development project. The ultimate goal of the platform is to provide software developers with the right toolset for building, running, and operating business applications in the cloud. To achieve this goal, Dirigible provides both independent Design Time and Runtime components.


Nowadays, providing a full-stack application development platform is not enough. Building and running on top of it has to be fast and smooth! Having that in mind, slow and cumbersome “Build”“CI”, and “Deployment” processes have a direct impact on development productivity. In this line of thought, it isn’t hard to imagine that the Java development model for web applications doesn’t fit in the cloud world.

Luckily, one of the strongest advantages of Dirigible comes at hand – the In-System Development model. Right from the early days of Dirigible, it was clear that it is going to be the platform for Business Applications Development in the cloud and not just another general purpose IDE in the browser. The reason for that decision is pretty simple – “One size doesn’t fit all”! Making a choice between providing “In-System Development” in the cloud and adding support for a new language (Java, C#, PHP, …), is really easy. The new language doesn’t really add much to the uniqueness and usability of the platform, as the In-System development model does!


The goal of the In-System development model is to ultimately change the state of the system while it’s up and running, without affecting the overall performance and without service degradation. You can easily think of several such systems like Programmable Microcontrollers, Relational Database Management Systems, ABAP. As mentioned earlier, Dirigible provides a suitable design time and runtime for that, so let’s talk a little bit about the architecture. The Dirigible stack is pretty simple:

Eclipse Dirigible

The building blocks are:

  • Application Server (provided)
  • Runtime (built-in)
    • Engine(s) – (Rhino/Nashorn/V8)
    • Repository – (fs/database)
  • Design Time (built-in)
    • Web IDE (workspace/database/git/… perspective)
  • Applications (developed)
    • Application (database/rest/ui)
    • Application (indexing/messaging/job)
    • Application (extensionpoint/extension)

Enterprise JavaScript

The language of choice in the Dirigible business application platform is JavaScript! But why JavaScript? Why not Java? Is it mature enough, is it scalable, can it satisfy the business application needs? The answer is: It sure does! The code that is being written is similar to Java. The developers can write their business logic in a synchronous fashion and can leverage a large set of Enterprise JavaScript APIs. For heavy loads, the Dirigible stack performs better than the NodeJS due to multithreading of the underlying JVM and the application server, and using the same V8 engine underneath.


Request/Response API

var response = require('http/v3/response');

response.println("Hello World!");

Database API

var database = require('db/v3/database');

var connection = database.getConnection();
try {
    var statement = connection.prepareStatement("select * from MY_TABLE where MY_PATH like ?");
    var i = 0;
    statement.setString(++i, "%");
    var resultSet = statement.executeQuery();
    while ( {
        response.println("[path]: " + resultSet.getString("MY_PATH"));
} catch(e) {
} finally {


The provided Enterprise JavaScript APIs leverage some of the mature Java specifications and de facto standards (e.g. JDBC, Servlet, CMIS, ActiveMQ, File System, Streams, etc.). Eliminating the build process (due to the lack of compilation) and at the same time exposing proven frameworks (that does the heavy lifting), results in having the perfect environment for in-system development of business applications, with close to “Zero Turn-Around-Time”. In conclusion, the Dirigible platform is really tailored to the needs of Business Application Developers.

Getting Started

  • Download
    • Get the latest release here.
    • The latest master branch can be found at GitHub
    • Download the latest Tomcat 8.x here.

    NOTE: You can use the try out instance, that is available at and skip through the Develop section

  • Start
    • Put the ROOT.war into the ${tomcat-dir}/webapps directory
    • Execute ./ start from the ${tomcat-dir}/bin directory
  • Login
  • Develop
    • Project
      1. Create a project
        1. Click + -> ProjectEclipse Dirigible
    • Database table
      1. Generate a Database Table
        • Right-click New > Generate > Database table
          Eclipse Dirigible
      2. Edit the students.table definition
            "name": "Students",
            "type": "TABLE",
            "columns": [{
                "name": "ID",
                "type": "INTEGER",
                "primaryKey": "true"
            }, {
                "name": "FIRST_NAME",
                "type": "VARCHAR",
                "length": "50"
            }, {
              "name": "LAST_NAME",
                "type": "VARCHAR",
                "length": "50"
            }, {
                "name": "AGE",
                "type": "INTEGER"
      3. Publish
        • Right-click the project and select Publish

NOTE: The auto publish function is enabled by default

      1. Explore
          • The database scheme can be explored from the Database perspective
          • Click Window > Open Perspective > Database
          • Insert some sample data
            insert into students values(1, 'John', 'Doe', 25)
            insert into students values(2, 'Jane', 'Doe', 23)Note: The perspectives are available also from the side menu

REST service

  1. Generate a Hello World service
    • Right-click New > Generate > Hello World
  2. Edit the students.js service
    var students = listStudents();
    function listStudents() {
        let students = [];
        var connection = database.getConnection();
        try {
            var statement = connection.prepareStatement("select * from STUDENTS");
            var resultSet = statement.executeQuery();
            while ( {
                    'id': resultSet.getInt('ID'),
                    'firstName': resultSet.getString('FIRST_NAME'),
                    'lastName': resultSet.getString('LAST_NAME'),
                    'age': resultSet.getInt('AGE')
        } catch(e) {
        } finally {
        return students;
  3. Explore
    • The student.js service is accessible through the Preview vie

NOTE: All backend services are up and running after save/publish, due to the In-System Development

Create a UI

  • Generate a HTML5 (AngularJS) page
    • Right-click New > Generate > HTML5 (AngularJS)
  • Edit the page
    <!DOCTYPE html>
    <html lang="en" ng-app="page">
        <meta charset="utf-8">
        <meta name="description" content="">
        <meta name="author" content="">
        <link type="text/css" rel="stylesheet" href="/services/v3/core/theme/bootstrap.min.css">
        <link type="text/css" rel="stylesheet" href="/services/v3/web/resources/font-awesome-4.7.0/css/font-awesome.min.css">
        <script type="text/javascript" src="/services/v3/web/resources/angular/1.4.7/angular.min.js"></script>
        <script type="text/javascript" src="/services/v3/web/resources/angular/1.4.7/angular-resource.min.js"></script>
    <body ng-controller="PageController">
            <div class="page-header">
            <div class="container">
                <table class="table table-hover">
                        <th>First Name</th>
                        <th>Last Name</th>
                        <tr ng-repeat="student in students">
        <script type="text/javascript">
            angular.module('page', []);
            angular.module('page').controller('PageController', function ($scope, $http) {
                .success(function(data) {
                    $scope.students = data;

“What’s next?”

The In-System Development model provides the business application developers with the right toolset for rapid application development. By leveraging a few built-in templates and the Enterprise JavaScript API, whole vertical scenarios can be set up in several minutes. With the close to Zero Turn-Around-Time, changes in the backend can be made and applied on the fly, through an elegant Web IDE. The perfect fit for your digital transformation!

The goal of the Dirigible platform is clear – ease the developers as much as possible and let them concentrate on the development of critical business logic.

So, what’s next? Can I provide my own set of templates? Can I expose a new Enterprise JavaScript API? Can I provide a new perspective/view? Can I build my own Dirigible stack? Can it be integrated with the services of my cloud provider?

To all these questions, the answer is simple: Yes, you can do it!





This post was originally published in the February 2018 issue of the Eclipse Newsletter: Boot & Build Eclipse Projects

For more information and articles check out the Eclipse Newsletter.


Yordan Pavlov

Yordan Pavlov is an experienced Software Developer with a demonstrated history of working in the computer software industry. He is skilled in Java EE, Cloud Computing, SAP Hana Cloud Platform and Agile Methodologies. Project lead & committer in the Eclipse Dirigible open-source project. Strong engineering professional with a Master’s Degree focused in Computer Science from Technical University Sofia.


Leave a Reply

Be the First to Comment!

Notify of