Ballerina en un vistazo (9): comparativa con Java

Ballerina es un lenguaje de programación dependiente de la JVM diseñado para la nube. Lanzado por WSO2, pensado para simplificar la creación de servicios distribuidos, con soporte nativo para protocolos como HTTP, WebSocket y gRPC.

Java por su parte es un lenguaje de propósito general, orientado a aplicaciones empresariales, móviles, web y backend.

Comparativa Ballerina y Java

Aspecto	Ballerina	Java
Objetivo	Diseñado para aplicaciones distribuidas, integración de servicios y sistemas cloud‑native.	Lenguaje de propósito general, orientado a aplicaciones empresariales, móviles, web y backend.
Extensión	.bal	.java
Paradigma	Mezcla de imperativo, declarativo y orientado a servicios; nativo para APIs y microservicios.	Principalmente orientado a objetos; soporta programación funcional desde Java 8.
Tipado	Estático y fuerte, con soporte para tipos opcionales, uniones y estructuras de datos integradas.	Estático y fuerte. El compilador detecta errores en tiempo de compilación.
Relación con la JVM	Aunque puede interoperar con Java, no depende de la JVM; tiene su propio runtime optimizado para servicios distribuidos.	Corre directamente sobre la JVM, lo que le da portabilidad y acceso a un ecosistema enorme (Spring, Jakarta EE, etc.).
Tipo ejecución	Compilado para crear un bytecode ejecutable por la BJVM.	Compilado para crear un bytecode ejecutable por la JVM.
Ejecución	$ bal run programa.bal	$ javac Programa.java $ java Programa
Ideal para	Si tu foco es microservicios, APIs y aplicaciones distribuidas en la nube.	Si buscas estabilidad, soporte empresarial y ecosistema robusto, es la mejor opción.

Comparando lenguajes: Ballerina y Java

El clásico programa de "Hola, mundo" en Ballerina y Java.

En Ballerina:

holamundo.bal

import ballerina/io;

public function main() {
    io:println("Hola, mundo");
}

En Java:

HolaMundo.java

public class HolaMundo {
    public static void main(String[] args) {
        System.out.println("Hola, mundo");
    }
}

Un programa que muestre el uso de funciones como parámetros (funciones de orden superior).

En Ballerina:

funciones.bal

import ballerina/io;

function sumar(int a, int b) returns int {
  return a + b;
}

function aplicar(int a, int b, function (int, int) returns int fn) returns int {
  return fn(a, b);
}

public function main() {
  int result = aplicar(10, 20, sumar);
  io:println(result);
}

En Java:

Funciones.java

import java.util.function.BiFunction;

public class Funciones {

    public static int sumar(int a, int b) {
        return a + b;
    }

    public static int aplicar(int a, int b, BiFunction<Integer, Integer, Integer> fn) {
        return fn.apply(a, b);
    }

    public static void main(String[] args) {
        int result = aplicar(10, 20, Funciones::sumar);
        System.out.println(result);
    }
}

Trabajar con tipos, deacuerdo al tipo de entrada.

En Ballerina:

tipos.bal

import ballerina/io;

function printValueType(any value) {
  if (value is int || value is float || value is decimal) {
    io:println("El valor es Numero");
  } else if (value is string) {
    io:println(string`El valor es String, y es este ${value.length()} characters long`);
  } else {
    io:println("No se puede identificar el tipo.");
  }
}

public function main() {
  printValueType(10);
  printValueType("Esta es una cadena de caracteres");
}

En Java:

TipoDeValor.java

public class TipoDeValor {

    public static void printValueType(Object value) {
        if (value instanceof Integer || value instanceof Float || value instanceof Double) {
            System.out.println("El valor es Numero");
        } else if (value instanceof String) {
            String str = (String) value;
            System.out.println("El valor es String, y es este " + str.length() + " characters long");
        } else {
            System.out.println("No se puede identificar el tipo.");
        }
    }

    public static void main(String[] args) {
        printValueType(10); // Integer
        printValueType("Esta es una cadena de caracteres"); // String
    }
}

Paso de parámetros y argumentos.

En Ballerina:

parametros.bal

import ballerina/io;

public function main(string... args) {
   if args.length() == 0 {
        io:println("No se proporcionaron argumentos.");
        return;
    }

    io:println("Argumentos recibidos:");
    foreach var arg in args {
        io:println(arg);
    }

    foreach int i in 0 ..< args.length() {
        io:println("Argumento ", i + 1, ": ", args[i]);
    }

    if args.length() >= 2 {
        var num1 = int:fromString(args[0]);
        var num2 = int:fromString(args[1]);

        if num1 is int && num2 is int {
            io:println("Suma de ", num1, " y ", num2, ": ", num1 + num2);
        } else {
            io:println("Error: Los argumentos deben ser números enteros.");
        }
    } else {
        io:println("Por favor, proporcione al menos dos argumentos numéricos.");
    }
}

En Java:

Argumentos.java

public class Argumentos {

    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("No se proporcionaron argumentos.");
            return;
        }

        System.out.println("Argumentos recibidos:");
        for (String arg : args) {
            System.out.println(arg);
        }

        for (int i = 0; i < args.length; i++) {
            System.out.println("Argumento " + (i + 1) + ": " + args[i]);
        }

        if (args.length >= 2) {
            try {
                int num1 = Integer.parseInt(args[0]);
                int num2 = Integer.parseInt(args[1]);
                System.out.println("Suma de " + num1 + " y " + num2 + ": " + (num1 + num2));
            } catch (NumberFormatException e) {
                System.out.println("Error: Los argumentos deben ser números enteros.");
            }
        } else {
            System.out.println("Por favor, proporcione al menos dos argumentos numéricos.");
        }
    }
}

Implementar un pequeño servicio HTTP que escucha en el puerto 8088 y expone dos recursos (endpoints).

En Ballerina:

servicio.bal

import ballerina/http;

listener http:Listener httpListener = new (8088);

service / on httpListener {
    resource function get saludando() returns string {
        return "Programando con Ballerina!";
    }

    resource function get saludando/[string nombre]() returns string {
        return "Hola " + nombre;
    }
}

En Java (con Spring Boot):

SaludandoApplication.java

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;

@SpringBootApplication
@RestController
@RequestMapping("/saludando")
public class SaludandoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SaludandoApplication.class, args);
    }

    // GET /saludando
    @GetMapping
    public String saludando() {
        return "Programando con Java!";
    }

    // GET /saludando/{nombre}
    @GetMapping("/{nombre}")
    public String saludandoConNombre(@PathVariable String nombre) {
        return "Hola " + nombre;
    }
}

Sin Frameworks:

SaludandoServer.java

import com.sun.net.httpserver.HttpServer;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpExchange;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;

public class SaludandoServer {

    public static void main(String[] args) throws IOException {
        // Crear servidor en el puerto 8088
        HttpServer server = HttpServer.create(new InetSocketAddress(8088), 0);

        // Handler para /saludando
        server.createContext("/saludando", new HttpHandler() {
            @Override
            public void handle(HttpExchange exchange) throws IOException {
                String path = exchange.getRequestURI().getPath();
                String response;

                // Si la ruta es exactamente /saludando
                if (path.equals("/saludando")) {
                    response = "Programando con Ballerina!";
                } else {
                    // Si la ruta es /saludando/{nombre}
                    String[] parts = path.split("/");
                    if (parts.length >= 3) {
                        String nombre = parts[2];
                        response = "Hola " + nombre;
                    } else {
                        response = "Ruta no válida";
                    }
                }

                exchange.sendResponseHeaders(200, response.getBytes().length);
                OutputStream os = exchange.getResponseBody();
                os.write(response.getBytes());
                os.close();
            }
        });

        // Iniciar servidor
        server.start();
        System.out.println("Servidor iniciado en http://localhost:8088");
    }
}

Como se ha visto, crear código en Java es más "rústico" o verboso, como lo puede ser la creación de servicios HTTP. Mientras que en Ballerina, al ser un lenguaje más moderno, simplifica bastante el desarrollo, por ejemplo de servicios HTTP.

Finalizando: Ballerina es un lenguaje moderno que facilita el desarrollo y es ideal para microservicios en la nube. Mientras que Java sigue siendo el rey 😀en aplicaciones empresariales.

Enlaces:

https://alquimistadecodigo.blogspot.com/2025/12/ballerina-en-un-vistazo-8.html
https://codemonkeyjunior.blogspot.com/2025/12/ballerina-una-comparativa-con-rust.html
https://codemonkeyjunior.blogspot.com/2025/12/ballerina-un-lenguaje-en-crecimiento.html