www.jolie-lang.org Open in urlscan Pro
130.225.157.67  Public Scan

Form analysis
0 forms found in the DOM

Text Content

 * Home
 * Download
 * News
 * Blogs
 * Docs
 * Vision
   
   
 * About
 * FAQ
 * 
 * 
 * 
 * 
 *  


JOLIE


THE SERVICE-ORIENTED PROGRAMMING LANGUAGE

  Download   Docs   Vision

type HelloRequest {
	name:string
}

interface HelloInterface {
requestResponse:
	hello( HelloRequest )( string )
}

service HelloService {
	execution: concurrent

	inputPort HelloService {
		location: "socket://localhost:9000"
		protocol: http { format = "json" }
		interfaces: HelloInterface
	}

	main {
		hello( request )( response ) { 
			response = "Hello " + request.name
		}
	}
}


Next


THINKING IN SERVICES

Jolie crystallises the programming concepts of service-oriented computing as
linguistic constructs. The basic building blocks of software are not objects or
functions, but rather services that can be relocated and replicated as needed. A
composition of services is a service.

Next


TAILORED FOR MICROSERVICES AND APIS

Jolie is a contract-first programming language, which puts API design at the
forefront. It supports both synchronous and asynchronous communication. Data
models are defined by types that support refinement (in red on the right), and
DTO (Data Transfer Objects) transformations are transparently managed by the
interpreter.

type GetProfileRequestType {
	id:int
}
type GetProfileResponseType {
	name:string
	surname:string
	email:string( regex(".*@.*\\..*") )
	accounts[0,*] {
		nickname:string
		service_url:string
		enabled:bool
	}
	ranking:int( ranges( [1,5] ) )
}

type SendMessageRequestType {
	id:int
	message:string( length( [0,250] ) )
}

interface ProfileInterface {
requestResponse: // Synchronous RPC
	getProfile( GetProfileRequestType )( GetProfileResponseType )

oneWay: // Asynchronous
	sendMessage( SendMessageRequestType )
}
			

Next


BUILT FOR THE NETWORKED AGE

Jolie code is always contained in services, which you can always move from being
local to remote and vice versa, without altering the logic of your programs. A
monolithical application can scale to being distributed by design: if you decide
to distribute a part of it, just take it and execute it in another machine.

PROGRAM YOUR MICROSERVICE SYSTEM

DEPLOY IT IN A SINGLE MACHINE



DEPLOY IT IN TWO DIFFERENT MACHINES

DEPLOY IT IN FOUR DIFFERENT MACHINES


Next


PROTOCOL AGNOSTIC

Jolie is protocol agnostic: your services can exchange data by using different
protocols. Bridging two networks using different protocols is a matter of a few
lines of code. If you need a protocol that Jolie does not support yet, there is
an API for developing new ones in Java.



type HelloRequest {
	name:string
}

interface HelloInterface {
requestResponse:
	hello( HelloRequest )( string )
}

service HelloService {
	execution { concurrent }

	inputPort HelloServiceHTTP {
		location: "socket://localost:9000"
		protocol: http { format = "json" }
		interfaces: HelloInterface
	}

	inputPort HelloServiceSOAP {
		location: "socket://localost:9001"
		protocol: soap { 
			wsdl = "myWsdl.wsdl" 
			wsdl.port = "MyServiceSOAPPort"
		}
		interfaces: HelloInterface
	}

	inputPort HelloServiceSODEP {
		location: "socket://localost:9002"
		protocol: sodep 
		interfaces: HelloInterface
	}

	main {
		// This can now be reached through HTTP/JSON, SOAP, or SODEP (binary)
		hello( request )( response ) { 
			response = "Hello " + request.name
		}
	}
}


Next


STRUCTURED WORKFLOWS

Jolie comes with native primitives for structuring workflows, for example in
sequences (one after the other) or parallels (go at the same time). This makes
the code follow naturally from the requirements, avoiding error-prone
bookkeeping variables for checking what happened so far in a computation. For
example, the following code says that the operations publish and edit become
available at the same time (|), but only after (;) operation login is invoked:

login( credentials )() { checkCredentials };
{ publish( x ) | edit( y ) }





DYNAMIC ERROR HANDLING FOR PARALLEL CODE

Programming reliable parallel code is challenging because faults may cause
side-effects in parallel activities. Jolie comes with a solid semantics for
parallel fault handling. Programmers can update the behaviour of fault handlers
at runtime, following the execution of activities thanks to the install
primitive.

include "console.iol"
include "time.iol"

main
{
    scope( grandFather )
    {
        install( this => println@Console( "recovering grandFather" )() );
        scope( father )
        {
            install( this => println@Console( "recovering father" )() );
            scope ( son )
            {
                install( this => println@Console( "recovering son" )() );
                sleep@Time( 500 )();
                println@Console( "Son's code block" )()
            }
        }
    }
    |
    throw( a_fault )
}


Next


EVERYTHING YOU BUILD CAN BE USED TO BUILD AGAIN

Jolie offers many ways for building complex software from simple services. Even
the deployment architecture of a system can be programmed with native
primitives, generalising common practices. Whatever you build, is again a
service that you can expose; so, it can be reused to build again! Here are some
examples of composition:

Orchestration: an orchestrator is a service that offers functionalities obtained
by coordinating other services with a workflow.

Aggregation: a generalisation of proxies and load balancers, which you can use
to compose and expose the APIs of separate services

Redirection: a generalisation of virtual servers, which hides the actual
locations of services to clients by assigning logical names to services.

Embedding: a generalisation of application servers, which runs other services as
inner components. It enables fast local communications and can even run code
written in different languages than Jolie, such as Java and Javascript (with
more coming)!

Next


REVOLUTIONISE THE WAY YOU DEVELOP WEB APPLICATIONS

Jolie allows for directly programming a web server that is just a service as
everything else in Jolie. You don't need other extra frameworks for
instantiating a web server.

It is possible to directly aggregate other service APIs into a Jolie web server,
thus web GUIs are completely independent from the microservice system they
interact with. We natively support JSON, XML, AJAX, GWT, and other technologies.



Next


SOLID FOUNDATIONS

Jolie comes with formal specifications of its semantics. It is used in Computer
Science research and teaching at several universities around the world.

Next


JOIN US!

Jolie is an open source project, with a growing community of contributors and
users that you are welcome to join. Check out our project news, or have a look
at our contributor blogs.




STAKEHOLDERS AND SUPPORTERS





Copyright (C) 2014-2020 The Jolie Team. This work is licensed under a Creative
Commons Attribution 4.0 International License, except for the code samples,
which are instead licensed under the GNU GPL License (v2). This website is made
with Jolie and is powered by Leonardo.Please contact our webmaster for questions
or comments concerning this website.