Ballerina (programming language)

History

Ballerina was designed by WSO2 to improve productivity for application developers that have to work with distributed cloud-native systems. The designers, who provided enterprise products in the integration space for over 10 years, used their knowledge of the industry when designing the language.^[13][14] Ballerina was first publicly announced in 2017 and version 1.0 was released on September 10, 2019.^[15]

Design

Some key concepts in Ballerina include:

• The network in the language - Ballerina introduces fundamental, new abstractions of client objects, services, resource functions, and listeners to bring networking into the language. ^[16]
• Sequence diagrams for programming - In Ballerina, every program has a corresponding sequence diagram that illustrates distributed and concurrent interactions automatically. ^[17]
• Structural, open-by-default typing - Ballerina has a statically-typed, structural type system that is designed to be network data schema friendly. ^[18]
• Moving from code to cloud - Ballerina brings the entire program execution process to the hands of the developer with extensible metadata that gets compiled to runnable programs for all major cloud platforms. ^[19]
• Automated observability - Ballerina incorporates automatic observability features into the language itself that helps keep track of metrics, logs and tracing. ^[20]

Examples

Hello World Service

import ballerina/http;

service hello on new http:Listener(9090) {

    resource function sayHello(http:Caller caller,
        http:Request req) returns error? {

        check caller->respond("Hello, World!");
    }
}

To start the service, navigate to the directory that contains the `.bal` file, and execute the `ballerina run` command below.

$ ballerina run hello_world.bal
[ballerina/http] started HTTP/WS listener 0.0.0.0:9090

curl http://localhost:9090/hello/sayHello
Hello, World!

^[21]

Workers

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() {
    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 ().
    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

^[22]

gRPC Unary Blocking

import ballerina/grpc;
import ballerina/log;

service HelloWorld on new grpc:Listener(9090) {

    resource function hello(grpc:Caller caller, string name,
                             grpc:Headers headers) {
        log:printInfo("Server received hello from " + name);
        string message = "Hello " + name;

        // Reads custom headers in request message.
        string reqHeader = headers.get("client_header_key") ?: "none";
        log:printInfo("Server received header value: " + reqHeader);

        // Writes custom headers to response message.
        grpc:Headers resHeader = new;
        resHeader.setEntry("server_header_key", "Response Header value");

        // Sends response message with headers.
        grpc:Error? err = caller->send(message, resHeader);
        if (err is grpc:Error) {
            log:printError("Error from Connector: " + err.message());
        }

        // Sends `completed` notification to caller.
        grpc:Error? result = caller->complete();
        if (result is grpc:Error) {
            log:printError("Error in sending completed notification to caller",
                err = result);
        }
    }
}

^[23]

References

Further reading

• Fernando, Anjana, Warusawithana, Lakmal (2020) Beginning Ballerina Programming, Apress (part of Springer Nature)

External links

• https://ballerina.io
• https://github.com/ballerina-platform/ballerina-lang Github repository.