Translate

lunes, 2 de marzo de 2020

Ballerina un lenguaje pensado para la nube, Parte 2

En el post anterior me quede con muchas ganas de ver código. Pero, si llegaste acá y no sabés de que estoy hablando o no sabés que es Ballerina ve esto: https://emanuelpeg.blogspot.com/2020/02/ballerina-un-lenguaje-pensado-para-la.html

Si queres probar el código que vamos dejando, pueden hacerlo acá : https://play.ballerina.io/

Veamos un poco de código en Ballerina y empecemos con un hola mundo:

import ballerina/io;

public function main() {
    io:println("Hello, World!");
}

Lindo pero, ahora vamos hacerlo en paralelo :

import ballerina/io;

public function main() {

    worker w1 {
        io:println("Hello, World! #m");
    }    worker w2 {
        io:println("Hello, World! #n");
    }    worker w3 {
        io:println("Hello, World! #k");
    }
}

veamos el mismo código en un servidor :

import ballerina/http;
import ballerina/log;

service hello on new http:Listener(9090) {
    resource function sayHello(http:Caller caller, http:Request req) {
        var result = caller->respond("Hello, World!");
        if (result is error) {
            log:printError("Error sending response", result);
        }
    }
}

y ahora de cliente : 

import ballerina/http;
import ballerina/io;

public function main() {
    http:Client clientEP = new ("http://www.mocky.io");
    var resp = clientEP->get("/v2/5ae082123200006b00510c3d/");    
    if (resp is http:Response) {
        var payload = resp.getTextPayload();
        if (payload is string) {
            io:println(payload);
        } else {
            io:println(payload.detail());
        }
    } else {
        io:println(resp.detail());
    }
}

Puff... lo que se puede hacer con un "hola mundo". Primera conclusión, claramente se ve que Ballerina esta ampliamente influenciado por Node y javascript. 

Veamos un objeto : 

import ballerina/io;

type Person object {
    public string name = "";
    public int age = 0;
    public Person? parent = ();
    private string email = "default@abc.com";
    string address = "No 20, Palm grove";
};

public function main() {
    Person p1 = new;
    io:println(p1.age);    
    
    Person p2 = new();
    io:println(p2.age);

    Person p3 = new Person();
    io:println(p3.age);
}

Se ve que las clases se declaran con type y se pueden hacer cosas más complejas : 

import ballerina/io;

type Person object {
    public int age;
    public string firstName;
    public string lastName;

    function __init(int age, string firstName, string lastName) {
        self.age = age;
        self.firstName = firstName;
        self.lastName = lastName;
    }

    function getFullName() returns string {
        return self.firstName + " " + self.lastName;
    }
};

public function main() {
    Person p1 = new(5, "John", "Doe");    
    io:println(p1.getFullName());
}

Ahora podemos ver la influencia de Go. Porque tiene la misma forma de manejar errores, los retorna y sigue la filosofía de que el error es un resultado más : 

import ballerina/io;

const ACCOUNT_NOT_FOUND = "AccountNotFound";
const INVALID_ACCOUNT_ID = "InvalidAccountID";

function getAccountBalance(int accountID) returns int|error {
    if (accountID < 0) {
        return error(INVALID_ACCOUNT_ID, accountID = accountID);
    } else if (accountID > 100) {
        return error(ACCOUNT_NOT_FOUND, accountID = accountID);
    }
    return 600;
}

public function main() {
    error simpleError = error("SimpleErrorType", message = "Simple error occurred");
    io:println("Error: ", simpleError.reason(),
                ", Message: ", simpleError.detail()?.message);
    int|error result = getAccountBalance(-1);

    if (result is int) {
        io:println("Account Balance: ", result);
    } else {
        io:println("Error: ", result.reason(),
                    ", Account ID: ", result.detail()["accountID"]);
    }
}

Y por último un ejemplo de interacción con Java : 

import ballerinax/java;
import ballerina/io;

function newArrayDeque() returns handle = @java:Constructor {
    class: "java.util.ArrayDeque"
} external;

function newArrayDequeWithInitialCapacity(int numElements) returns handle = @java:Constructor {
    class: "java.util.ArrayDeque",
    paramTypes: ["int"]
} external;

public function main() {
    var arrayDeque = newArrayDeque();
    io:println(arrayDeque);
    var arrayDequeWithCapacity = newArrayDequeWithInitialCapacity(10);
    io:println(arrayDequeWithCapacity);
}

No mucho que explicar, de esta manera podemos llamar clases java. 

Conclusión, me gusto!

Toma buenas cosas de diferentes lenguajes y lo mezcla de forma equilibrada. Lo único que le critico es el ";" que no lo veo necesario.  Por lo dicho, vamos a tener que estudiar un nuevo lenguaje :P




Labels: , , , ,