Ballerina (programming language)#Hello World

Ballerina was first publicly announced in 2017 and version 1.0 was released on September 10, 2019.{{Cite press release|url=https://www.globenewswire.com/news-release/2019/09/10/1913510/0/en/Ballerina-Reinvents-Cloud-Native-Middleware-as-a-Programming-Language-Puts-ESB-on-the-Path-to-Extinction.html|title=Ballerina Reinvents Cloud-Native Middleware as a Programming Language|website=GlobeNewswire|date=10 September 2019 |access-date=2020-09-16}}

Ballerina is a general-purpose language with a familiar syntax along with a direct graphical representation of the code in the form of sequence diagrams. It has fundamental abstractions designed to make integration problems easier to program.{{cite web |last1=Ratnayake |first1=Dakshitha |title=Ballerina Swan Lake: 10 Compelling Language Characteristics for Cloud Native Programming |url=https://www.infoq.com/articles/ballerina-cloud-native-programming/ |website=InfoQ |access-date=1 March 2022}} Ballerina was designed by WSO2 to improve productivity for application developers that have to work with distributed computing. It is easy to write and modify and is suitable for application programmers.{{Cite news|url=https://thenewstack.io/ballerina-an-api-first-programming-language/|title=Ballerina: An API-First Programming Language|last=Jackson|first=Joab|work=The New Stack|access-date=2018-06-11|language=en-US}}{{Cite news|url=https://www.zdnet.com/article/ballerina-a-language-of-integration-of-technology-and-the-arts/|title=Technology and the Arts: Celebrating Ballerina, a computer language of integration|first=Tom|last=Foremski|date=2019-03-01|access-date=2019-07-14}}{{Cite news|url=https://www.theserverside.com/blog/Coffee-Talk-Java-News-Stories-and-Opinions/Ballerina-language-promises-to-improve-app-integration|title=Ballerina language promises to improve app integration|first=George|last=Lawton|date=2018-11-01|access-date=2019-07-23}}

The designers, who provided enterprise integration products for over 10 years, used their knowledge of the industry when designing the language,{{Cite news|url=https://blog.jclark.com/2019/09/ballerina-programming-language-part-0.html|title=Ballerina Programming Language Part 0 - Context|last=Clark|first=James|access-date=2020-09-16|language=en-GB}}{{Cite news|url=https://blog.jclark.com/2019/09/ballerina-programming-language-part-1.html|title=Ballerina Programming Language Part 1 - Concepts|last=Clark|first=James|access-date=2020-09-16|language=en-GB}} says WSO2 director and Ballerina founder James Clark.

The regular Hello World program:

import ballerina/io;

public function main() {

io:println("Hello World!");

}

To execute the above program, place the source code in a .bal file and provide the path of the file to the bal run command.

$ ballerina run hello_world.bal

Hello World!

The service version of the Hello World program:

import ballerina/http;

service /greet on new http:Listener(9090) {

resource function get . () returns string {

return "Hello World!";

}

}

Services are executed in the same manner, except they don't terminate like regular programs do. Once the service is up and running, one can use an HTTP client to invoke the service. For example, the above service can be invoked using the following cURL command:

$ curl http://localhost:9090/greet

Hello World!

{{cite web |url=https://ballerina.io/learn/by-example/hello-world-service.html |title=Hello world service |author=Ballerina Team |date=16 September 2020 |publisher=ballerina.io |access-date=16 September 2020 |archive-date=16 September 2020 |archive-url=https://web.archive.org/web/20200916185848/https://ballerina.io/learn/by-example/hello-world-service.html |url-status=dead}}

import ballerina/http;

service on new http:Listener(9090) {

resource function post factorial(@http:Payload string payload) returns http:Ok|http:BadRequest {

int|error num = int:fromString(payload);

if num is error {

return {body: "Invalid integer: " + payload};

}

if num < 0 {

return {body: "Integer should be >= 0"};

}

int result = 1;

foreach int i in 2 ... num {

result *= i;

}

return {body: result};

}

}

$ curl http://localhost:9090/factorial -d 5

120

import ballerina/graphql;

service /stocks on new graphql:Listener(4000) {

resource function get quote() returns StockQuote {

return {

ticker: "EXPO",

price: 287.5,

open: 285,

prevClose: 285.5,

low: 276.25,

high: 297

};

}

}

type StockQuote record

$ curl -H "Content-type: application/json" -d '{"query": "{ quote { ticker, price } }" }' 'http://localhost:4000/stocks'

{"data":{"quote":{"ticker":"EXPO", "price":287.5}}}

The generated sequence diagram is a canonical representation of the source code. The two representations can be used interchangeably. The diagram support is provided through the Ballerina VS Code plugin. The following are a couple of such generated sequence diagrams, compared with its associated code.

A sample program for retrieving and processing COVID-19 data:

File:Working-with-data-code+diagram.png

A sample program for creating a report out of pull request data retrieved from GitHub:

File:Consuming-services-code+diagram.png

The language provides support for working with JSON values. The builtin type `json` is defined as the following union: ()|boolean|int|float|decimal|string|json[]|map

import ballerina/io;

public function main() returns error {

// Syntax for `json` object values is very similar to the syntax of JSON

json person = {name: "John Doe", age: 25};

// Serialized `json` values conforms to the JSON specification

io:println(person);

// The fields of the `json` value can be accessed as follows

string name = check person.name;

int age = check person.age;

}

Docker and Kubernetes artifacts required for deploying the code to the cloud can be generated when building the code. Values required for these artifacts are derived from the code. Additionally, one can override these values as well using the Cloud.toml file. To enable generation of the cloud artifacts, the users can use the cloud build option in the Ballerina.toml file. Use docker to generate just the Docker image and the Dockerfile and use k8s to generate Kubernetes artifacts as well. Minimal sample config TOML files would look something like the following:

Ballerina.toml file:

[package]

distribution = "2201.0.0"

[build-options]

cloud="k8s"

Cloud.toml file:

[container.image]

repository="bal_user"

name="greet"

tag="v0.1.0"

import ballerina/http;

import ballerina/lang.'int;

import ballerina/io;

// Workers interact with each other by sending and receiving messages.

// Ballerina validates every worker interaction (send and receive)

// to avoid deadlocks.

public function main() {

@strand {thread: "any"}

worker w1 {

int w1val = checkpanic calculate("2*3");

// Sends a message asynchronously to the worker `w2`.

w1val -> w2;

// Receives a message from the worker `w2`.

int w2val = <- w2;

io:println("[w1] Message from w2: ", w2val);

// Sends messages synchronously to the worker `w3`. The worker `w1` will wait

// until the worker `w3` receives the message.

w1val ->> w3;

w2val -> w3;

// Flushes all messages sent asynchronously to the worker `w3`. The worker

// will halt at this point until all messages are sent or until the worker `w3`

// fails.

checkpanic flush w3;

}

// A worker can have an explicit return type, or else, if a return type is not mentioned,

// it is equivalent to returning ().

@strand {thread: "any"}

worker w2 {

int w2val = checkpanic calculate("17*5");

// Receives a message from the worker `w1`.

int w1val = <- w1;

io:println("[w2] Message from w1: ", w1val);

// Sends a message asynchronously to the worker `w1`.

w1val + w2val -> w1;

}

worker w3 {

int|error w1val = <- w1;

int|error w2val = <- w1;

io:println("[w3] Messages from w1: ", w1val, ", ", w2val);

}

// Waits for the worker `w1`to finish.

wait w1;

}

function calculate(string expr) returns int|error {

http:Client httpClient = check new ("https://api.mathjs.org");

string response = check httpClient->get(string `/v4/?expr=${expr}`);

return check 'int:fromString(response);

}

{{cite web |url=https://github.com/ballerina-platform/ballerina-distribution/blob/master/examples/worker-interaction/worker_interaction.bal |title= Worker interaction |author=Ballerina Team|date=16 September 2020 |publisher=ballerina.io}}

{{Reflist}}

• Fernando, Anjana, Warusawithana, Lakmal (2020) [https://www.apress.com/gp/book/9781484251386 Beginning Ballerina Programming], Apress (part of Springer Nature)

• {{Official website|ballerina.io}}
• {{GitHub|ballerina-platform}}

{{Programming languages}}

Category:2017 software

Category:Programming languages created in 2017

Category:Scripting languages

Category:Dynamically typed programming languages

Category:Statically typed programming languages

Category:Concurrent programming languages

Category:High-level programming languages

Category:Free software projects

Category:Cross-platform free software

Category:Articles with example code