[Java Colombo Meetup] The better java for Java microservices developers

Better java for Java microservice developers
Sanjiva Weerawarana, Ph.D.
Ballerina Product Manager
Founder & Consultant, WSO2
Founder, Chairman & Chief Architect, Lanka Software Foundation
sanjiva@weerawarana.org
Java Colombo Meetup; November 05, 2019; Colombo

Agenda
• Motivation
• How is Ballerina different?
• What are some good entry use cases?
• Status & future work
11/5/19 2

Why do we need yet another language?
• Digital businesses are all about the network
– Disaggregation is the norm
– Applications compose functionality, often 3rd party SaaS
• Minimalization of computing
– Deployment: Hardware 🡪 VMs 🡪 Containers 🡪 Serverless
– Architecture: SOA 🡪 Microservices 🡪 Functions
• Technology for integrating smaller pieces is fundamental
– Servers 🡪 sidecars 🡪 code
– Middleware is dead; middleware is everywhere
11/5/19 3

Spectrum of languages from systems to glue languages
• Assembly
• Rust, C
• C++
• Go, Java, C#
• Ballerina
• TypeScript
• Python, JavaScript
• PowerShell, Bourne shell, TCL, AWK
11/5/19 4

Design goals for Ballerina
• Provide abstractions for networking
• Use sequence diagrams as the visual model
• Minimize cognitive load
• Leverage familiarity
• Enable a semantically-rich static program model
• Provide a complete platform, not just a language
• Allow multiple implementations, based on different runtime environments
11/5/19 5
https://blog.jclark.com/2019/09/ballerina-programming-language-part-1.html

Language basics: Hello world
import ballerina/io;
public function main (string name) {
worker w1 {
io:println ("Hello ", name, " from worker w1");
}
worker w2 {
io:println ("Hello ", name, " from worker w2");
}
io:println ("Hello ", name, " from default worker");
}
11/5/19 6

Language basics: Listeners & Services
import ballerina/http;
public listener http:Listener staffServer = new (9090);
@http:ServiceConfig {
basePath: "/institutions"
}
service InstitutionsService on staffServer {
@http:ResourceConfig {
methods: ["GET"],
path: "/"
}
resource function listAll (http:Caller caller, http:Request req)
returns error? {
json[] list = getInstitutions();
check caller->ok(<json>list);
}
}
11/5/19 7

Language basics: Client Objects
http:Client hc = new ("http://localhost:9090");
public function main() returns error? {
http:Response hr;
hr = check hc->post (“/hello”, data);
json jr = <@untainted> check hr.getJsonPayload();
return jr.uuid.toString();
}
11/5/19 8

Ballerina by Example
11/5/19 9

How is Ballerina different?
• Network in the language
• Sequence diagrams for programming
• Structural, open by default typing
• From code to cloud
• Batteries included
• Developer first
11/5/19 10

Programming the network
• BSD sockets
– Network connections are just byte streams
• Stubs & skeletons
– Offers RPC experience that hides network details
• Network realities
– Unreliable, latent, event driven, concurrent, unsafe, data not objects
• Most languages do not address networking aspects
– Left to libraries and now to sidecars
– That means no static verification possible
11/5/19 11

Ballerina network abstractions
11/5/19 12
Service
Service
Service
Dispatche
r
Listener Client
Service
(Caller)
Client Object
(Callback)
Serviceresource
method
Service
remote
method
Client Object

Service & client typing
• Network interactions are governed by
– Application protocol
– Data types
– Message sequencing
• Type system captures these to make this explicit to the programmer
– Goal is to make network interactions be type checked like local function calls are
– For services, currently done thru annotations
– Planning to use session types for message sequencing
11/5/19 13

Outbound resiliency
• Network interactions
– Can fail intermittently
– May require alternate paths
– May require controlled failure management
• Programmers need to use techniques like
– Load balancing, failover, bulkheading
• Ballerina platform components build these in
– Automatic retry
– Failover
– Load balancing
11/5/19 14

Non-blocking & asynchronous
• All I/O in Ballerina is non-blocking at execution thread level
– No need for callbacks – programmed synchronously as if blocking
• Asynchronous calls received via services
– Services act as event handlers
– E.g. Websocket client registers a service to receive async messages received from other end
11/5/19 15

Service concurrency
• Resource methods are concurrently invoked for each incoming message
• Services are stateless
– Session state is possible
• Dispatchers are responsible for invoking resources on its own strand
11/5/19 16

Network safety & security
• Data coming over the network is by default considered tainted
– Must be cleaned before given to a taint-sensitive user, or taintedness propagates
• Detected and flagged at compile-time
• @tainted and @untainted annotations
– E.g. cannot inadvertently insert tainted data to a database
• Safety: Authentication and authorization are part of all listeners and clients
• Planning to build in letsencrypt.org to HTTP services
11/5/19 17

Error handling
• Errors are first class values in Ballerina
– Not part of any other value
• Function returns union with error type to indicate errors
– function post (json data) returns string|error
• Errors must be handled
• Errors that are “unhandleable” are panics
11/5/19 18

Sequence diagrams
• Often used to explain behavior of concurrent scenarios
• Ballerina uses sequence diagrams for network interactions and concurrency
• Debugging with the diagram in VSCode will be released soon
11/5/19 19

Concurrency
• Workers
– Workers are concurrent bits of code
– Workers can communicate with each other via message passing
– Statically type checked for deadlock-free execution
• Currently limited, future more flexible with session types
– Parallel actors in sequence diagram
• Strands
– Logical threads of execution that runs a strand of workers - a call stack
– Created by a named worker
– Run independently until blocked due to worker to worker interaction
– Represented by futures
11/5/19 20

Futures
• Futures represent strands
• Type is the return type of the worker running in the strand, including any errors
• A named worker defines a variable of type future<T> where T is the return type of
the worker.
• Futures are first-class - so can be passed as parameters etc.
11/5/19 21

Concurrency
11/5/19 22
function foo () {
worker GetScores {
io:print("Got scores");
}
worker GetStats {
io:print("Got stats");
}
io:print("Other work");
}

Ballerina type system
• Not object oriented: OO is wrong model or network distributed applications
– Network transparency doesn’t work
– Can’t send code over the network
– Object serialization/deser causes tight coupling
• Type system works as a schema too
– Describes shape of a value - structural types
– Types are just sets of values - semantic subtyping
– Allows for choice of A or B - untagged unions
– Extensibility - open records
• Data binding is just a type cast
– Mutability complicates things a bit
11/5/19 23

Ballerina type system
11/5/19 24

Just two data structures
• Ballerina has two fundamental data structures
– lists: ordered list
– mappings: mappings from strings to values
• Two ways to type mappings
– records (both open and closed)
– maps
• Two ways to type lists
– tuples
– arrays
• Exact match for JSON
11/5/19 25
“It is better to have 100 functions
operate on one data structure than to
have 10 functions operate on 10 data
structures.”
Alan J. Perlis

Code to cloud
• In the old days ..
– Write code, compile and run it on a server (hardware)
• Now ..
– Write code, build, create Docker image, put into K8s deployment, run, observe
• Yet ..
– Today’s process is fractured and caught up lots of YAML
11/5/19 26

Build service to Docker image
11/5/19 27
import ballerina/log;
import ballerinax/docker;
@docker:Expose {}
listener http:Listener helloWorldEP = new(9090);
@docker:Config {
name: "helloworld",
tag: "v1.0"
}
basePath: "/helloWorld"
}
service helloWorld on helloWorldEP {
resource function sayHello(http:Caller outboundEP,
http:Request request) returns error? {
http:Response response = new;
response.setTextPayload("Hello World from Docker ! n");
check outboundEP->respond(response);
}
}
% ballerina build docker.bal

Ballerina service to K8s deployment
11/5/19 28
import ballerina/config;
import ballerinax/kubernetes;
@kubernetes:Service {
serviceType: "NodePort"
}
@kubernetes:Ingress {
hostname: "abc.com"
}
listener http:Listener helloWorldEP = new(9090);
@kubernetes:Deployment {
livenessProbe: true,
image: "kubernetes:v.1.0"
}
basePath: "/helloWorld"
}
service helloWorld on helloWorldEP {
@http:ResourceConfig {
methods: ["GET"],
path: "/config/{user}"
}
resource function getConfig(http:Caller outboundEP, http:Request request, string user) returns erro

Pluggable to any deployment environment
• Annotations are processed by compiler extensions
• Extensions can take control of codegen process and generate whatever it wants
• Goal is to allow these extensions to come from Ballerina Central
11/5/19 29

“Batteries included” standard library
• HTTP
• HTTP/2
• WebSockets
• WebSub
• AMQP
• MQTT
• (S)FTP(S)
• NATS
• Kafka
• gRPC
• XML
• JSON
• OpenAPI
• Sockets
• JWT
• OAuth2
• OpenTracing
• …
11/5/19 30

Developer first
• Structured documentation using Ballerina flavored markdown
– Code is read far more than its written
• Testing framework
• Module management, sharing, publishing, pulling via Ballerina Central
• IDE plugins for VSCode and IntelliJ IDEA
– Using Language Server Protocol
• Observability (metrics, tracing, logging) with Open Tracing
11/5/19 31

What are some good entry use cases?
• BFF services
• Data services
• (with the Java impl) Java microservices
• Easiest to write K8s services
• Integration developers
• CLIs that incorporate network services
• Infra as code (ala Pulumi)
• Microgateways
• Language to learn to code in
11/5/19 32

Interoperating with Java
11/5/19 33
import ballerinax/java;
public function main() {
handle jRuntime = getRuntime();
int availableProcessors = getAvailableProcessors(jRuntime);
io:println(availableProcessors);
}
function getRuntime() returns handle = @java:Method {
// If the Ballerina function name is same as the Java method name, the following attribute is not needed
name: "getRuntime",
class: "java.lang.Runtime"
} external;
function getAvailableProcessors(handle jRuntime) returns int = @java:Method {
name: "availableProcessors",
class: "java.lang.Runtime"
} external;

Status
• 1.0 released
– Based on 2019R3 language spec
– jBallerina compiles to Java bytecodes
– VSCode & Idea plugins based on language server
– Ballerina central
– Tools for testing, documentation, OpenAPI, gRPC
• 100% open source
– https://github.com/ballerina-platform
– Spec under CC
• https://ballerina.io/
11/5/19 34

Future work
• Parametric typing
• Service typing
• Transactions, both local and distributed
• Improved concurrency safety
• Language integrated query
• Streaming data and streaming query
• Declarative data transformation
• Improved configurability
• Long running execution
• …
• Implementation: nballerina with LLVM
11/5/19 35

Summary
• Ballerina is an attempt to build a modern industrial grade programming language
for the future with lots of network endpoints
• Type system is designed to make network data processing easier
• First class network services along with functions/objects
• Framework to encourage more secure code
• Fully open source and developed openly
11/5/19 36

[Java Colombo Meetup] The better java for Java microservices developers

More Related Content

What's hot (13)

Similar to [Java Colombo Meetup] The better java for Java microservices developers (20)

More from Ballerinalang (20)

Recently uploaded (20)

[Java Colombo Meetup] The better java for Java microservices developers