Tuesday, 18 August 2015

Jolie 1.4.1 released

Jolie 1.4.1 has been released. This is a bugfix release, including fixes to the HTTP protocol and connection management. Download it from the Jolie download page.

Tuesday, 16 June 2015

Jolie 1.4 released

Jolie 1.4 has been released. This is a feature release, including support for the new syntax of Internal Services (see the docs and the post on non-distributed microservices) and Local Locations. There are also many fixes to the HTTP extension, improvements to the embedding engine for Javascript programs, and improvements to the support tools jolie2java and wsdl2jolie.

Thursday, 30 April 2015

Jolie 1.3 released

Jolie 1.3 has been released. This is a stabilisation release: much effort has been put into improving the implementation of the interpreter and its extensions, and in extending our test suite for backwards compatibility.


  • Empty bodies for Request-Response inputs have been made optional.
  • Performance improvements to communications with embedded Javascript services.
  • gwt-dev.jar has been removed, as it is no longer needed (this reduced the size of a Jolie installation to a third).
  • Fixed a bug that prevented using HTTPs with the default settings (SSLv3 is no longer the default).
  • Improvements to the jolie2java tool, which now correctly compiles access methods to root values.
  • Many fixes to how charset encodings are handled, especially with respect to UTF-8.
  • Bugfix: invoke@Reflection did not use runtime type checking correctly.
  • Internal refactoring of HTTP and HTTP-based protocols to share the basic underlying logic, e.g., error handling.
  • Fetching WSDL documents no longer prints debug messages on screen.
  • Some API cleanups in the standard library (e.g., NetworkService).
  • Improvements to handling GWT messages.

Wednesday, 1 April 2015

Jolie to support groundbreaking +aaMS, *aaMS, picoservices!

With the advent of microservices, it was clear to us in the Jolie team that it was time to reinvent everything there is about computing. We call this initiative XaaMS: X as a MicroService. But what is X? Today, we can share some of our most exciting plans for the future.

X as +: +aaMS

How many times it happens that you have to make some additions, e.g., x = 3 + 2, in your programs? Additions in current programming languages are painfully slow, as they are executed locally and risk to be run sequentially in case you do not have enough CPU cores. To address this problem, the next version of Jolie will run every addition on the cloud!

From now on, whenever Jolie is run, it will start a cloud cluster on Amazon to run your additions. Anytime a sum has to be calculated, Jolie will contact a cloud node to run the sum remotely and then wait to receive the result. In this way, all your additions can be efficiently parallelised and take advantage of modern cloud computing!
When possible, the Jolie interpreter will use multiple cloud nodes for the same addition, and then decide later which cloud node computed the best result using an advanced (patent-pending) heuristics.

Rigorous scientific testing (patent pending) has shown us that the perfect number of cloud nodes to support each Jolie program is exactly 100, so that is our unchangeable default.

X as *: *aaMS

Multiplications will also be run on the cloud! This is beautifully crafted on top of our +aaMS innovation. Suppose that you have to compute:

x = 6 * 7

Instead of running it locally, we split the multiplication into additions, using a new procedure we invented that we call "Multiplication Cloudification":

x = 6 + 6 + 6 + 6 + 6 + 6 + 6

Observe that, as strange as it may seem at first, the two operations yield the same result (we are currently trying to publish this important result in a math journal, but we are encountering disbelief)! Now that we have additions, we can split them and run them in parallel in the cloud.
For example, from above, we get the following additions that we have to do:

6 + 6, 6 + 6, 6 + 6, 6 + 0

We get the following results from our cloud nodes:

12, 12, 12, 6

Now we contact our cloud nodes to do the following additions, in parallel:

12 + 12, 12 + 6

We get:

24, 18

We finally contact our 100 cloud nodes to sum 24 and 18 in parallel, pick the best result, and after a mere thousand years of round-trip communications we get:


which is what this example is all about.

X as Pico

Recent business surveys suggest that the more microservices you have in your microservice architecture, the better! For this reason, the next version of Jolie will introduce the outstanding concept of Picoservices! Picoservices are launched from the command line, for example

jolie --pico 1000 program.ol

will launch Jolie with a thousand (!) picoservices, which are a special kind of microservices. What do picoservices do? Nothing! That is the beauty of it. They are microservices finely optimised to be hanging around and consume as little resources as possible (but still convincing, in a business sense).

Thanks to our lightweight picoservices, we are able to have microservice architectures that scale up to thousands of picoservices (if not millions!). Your business competitor will not be able to keep up!

Sunday, 29 March 2015

Jolie 1.2.1 released

Jolie 1.2.1 has been released.


  • Introduction of UriTemplate, a new experimental service in the standard library for handling URI Templates.
  • Bugfix: HTTP could silently omit content when trying to send a non-binary value when a binary format was required.
  • Bugfix: joliec can now compile courier processes.
  • Bugfixes to handling of basic values and implicit type conversions.
  • Bugfix: fix a race condition on input streams from the console in the Console library service.

Friday, 27 March 2015

Jolie 1.2 released

Jolie 1.2 has been released. This release brings many important feature, stability, and performance enhancements.


Jolie 1.2 comes with many performance improvements. Early tests (some of which performed on the Jolie website itself) show an increase in throughput of up to 100% in scenarios with heavy loads, thanks to the following changes:
  • Jolie processes are now executed over a virtualisation layer that runs them using a cache of parallel workers.
  • Many synchronisation locks on data structures have been made more granular, reducing lock retention among processes.
  • Improvements to the networking stack, including multiple concurrent selectors (as in, e.g., Project Grizzly), better usage of I/O streams, and buffer caching.

Language Features

Inline trees

Jolie now supports inline trees as a new form of expression. For example, the following series of assignments

x.a = 1;
x.b = 2;
x.c[0] = 3;
x.c[1] = 4

can now be simply written as:

x << { .a = 1, .b = 2, .c[0] = 3, .c[1] = 4 }

Since they are expressions, inline trees can be used as parameters for operation invocations, for example:

    "select * from users where id = :id" { .id = 5 }
)( result )

Provide-until choices (experimental)

Provide-until choices have been introduced as a useful way of providing a series of operations until another certain operation is invoked. For example, the following code make the operations read and write available until either the operation logout or timeout is invoked.

    [ read(request)(response) { response = /* ... */ } ]
    [ write(request) ] { /* ... */ }
    [ logout() ]
    [ timeout() ]

Provide-until blocks are still experimental and will likely be improved in the future.

Branch code for input choices now optional

The code of a branch in an input choice can now be omitted, implicitly meaning that it is empty (nullProcess). For example, the following code

[ logout() ] { nullProcess }
[ timeout() ] { nullProcess }

can now be written as:

[ logout() ]
[ timeout() ]

Framework Improvements

  • Full character set enforcement in all parts of Jolie (important for multiplatform environments).
  • Predefined charset UTF-8 for XML-RPC, SOAP, JSON-RPC protocols.
  • Customisable charset for HTTP and SODEP protcols (default remains UTF-8) and the I/O  services (FileService, IniUtils).
  • --charset parameter to parse Jolie programs in encodings different from the system default.
  • Introduction of the new Converter service (base64 conversion, charset conversion).
  • Major HTTP protocol improvements (HEAD request, better chunked-mode parsing, correct URI/URL handling).
  • Fixed use of file paths containing blanks.
  • JSON parser fixes (nested arrays).
  • Some DatabaseService improvements (new close() call, error handling).
  • Fixes to the UNIX domain sockets support ("localsockets" medium).
  • XML-RPC protocol improvements (e.g., base64 support).
  • Fixed execution of sequential processes.
  • The SemanticVerifier component now reports errors correctly.
  • Introduction of a new experimental Reflection service for language reflection.

Monday, 16 March 2015

Jolie on Github

The Jolie source code is now hosted on Github! You can find us here.

Requests and issues can now be discussed through the common Github website and tools. Enjoy!

Wednesday, 18 February 2015

Jolie 1.1.2 released

Jolie 1.1.2 has been released, with lots of stability and performance improvements! Get it while it's hot!


  • Fixed character encoding handling on all HTTP-based extensions (http, https, soap, xmlrpc, jsonrpc).
  • Introduced HTTP compression on all HTTP-based extensions.
  • Introduced HTTP error messages for clients on all HTTP-based extensions.
  • Plenty of other bugfixes and internal improvements in all HTTP-based extensions.
  • Enhanced documentation for the HTTP extensions, especially documented all possible parameters for the http extension under http.iol.
  • Major JSON parsing improvements: introduction of a shared library named "jolie-js" which shares the JSON parser between the HTTP extensions and the Jolie "JsonUtils" module.
  • Bugfixes for localsockets (UNIX domain sockets).
  • Bugfixes in the launcher script for Windows.
  • Fixed a bug on concurrent access to variables in foreach loops.
  • Internal improvements to the networking code of the interpreter.
  • The compression feature from the sodep protocol has been removed. It will be reintroduced in another protocol in the future.
  • Improvements in the transmission of faults using JSON.
  • Fixes resolution of type links in interfaces used in courier inputs.
  • Fixed resource leak when reading .ini files in IniUtils.
  • Fixed a potential internal deadlock when handling persistent input channels.

Wednesday, 28 January 2015

Jolie 1.1.1 released

Jolie 1.1.1 has been released.


  • HTTP Compression Negotation is now supported and enabled by default.
  • The Jolie launcher script now uses the default Java parameters for RAM usage.
  • joliedoc now produces anchor links in documentation files correctly.
  • Bug fixes to the installer, which should now work better on MacOS and Windows.

Monday, 19 January 2015

Jolie 1.1 released

Jolie 1.1 has been released!

This release is the result of more than 500 commits, which contain:

  • almost 30 new APIs in the standard library;
  • more than a hundred bugfixes;
  • almost a hundred improvements to the interpreter and its libraries.

Changelog of major changes

New features

  • Interfaces can now be referenced as constants in courier processes.
  • Programs can automatically access the subdirectories lib and include from the directory they are executed in, respectively for libraries and include files.
  • It is now possible to develop "abstract locations" for input ports, i.e., Jolie extensions that can change at runtime the location of an input port, for example by fetching it from a registry or a configuration file.
  • Tracer. Jolie now supports a "--trace" option that prints all communications on screen (useful for debugging).

Implementation improvements

  • Improved message handling in concurrent communications.
  • Faster shutdown procedure for the interpreter.
  • Better handling of memory deallocation when an embedded service terminates.
  • Improved handling of persistent channels, with a new algorithm for managing timeouts of cached channels.
  • Support for Java 8.
  • Better Windows support (path resolution and JAP files).

New APIs

  • Console management.
  • Database management. Also, support for HSQLDB and DB2 has been added.
  • File management.
  • JSON support.
  • Queue-like data structures.
  • Runtime management of the interpreter.
  • Semaphores.
  • Shell command execution.
  • String manipulation.
  • XML handling.

Improvements to protocols

  • http: default operations can now be assigned to specific HTTP methods (GET, PUT, POST, DELETE, HEAD).
  • http: improved message handling, improved JSON support.
  • json-rpc: better support, general improvements.
  • ssl: bug fixes (applies to all protocols using ssl, e.g., https).
  • xml-rpc: better support, general improvements.

Improvements to tools

  • joliedoc: types can now be documented.
  • joliedoc: bug fixes.
  • jolie2wsdl: bug fixes.
  • wsdl2jolie: bug fixes.