关键的要点Ballerina是一种新的编程语言和平台，其目标是轻松创建跨分布式端点集成和编排的弹性服务。Ballerina .970已经发布，有望在2018年底实现其1.0进程的语言稳定性。现在，Ballerina托管在这里，包括包管理、依赖项管理、版本控制，以及在Ballerina Central为连接器和注释提供的全局托管注册表。Ballerina的设计原则侧重于将集成概念转化为一种语言，包括网络感知类型系统、序列图语法、并发工作器、“DevOps就绪”和环境感知。Ballerina是一种通过简化api集成来简化微服务编程的方法。Ballerina是三年前由来自WSO2的架构师创建的，以应对他们在构建与EAI、ESB和工作流产品的集成时遇到的挑战。关于芭蕾舞演员 Ballerina

开发一种新的编程语言和运行时堆栈是不常见的。Ballerina的诞生源于项目负责人在处理集成项目时遇到的挫折，这些项目越来越多地破坏了开发人员围绕编辑、构建、测试和重复的流程。

基于配置的集成产品，如面向esb的Apache Camel和Synapse，面向BPM的Camunda和Bonitasoft，都有一个复杂的生命周期，其中必须部署服务器、配置连接器、用XML编写逻辑，并使用XPath完成数据操作。这并不能创造良好的开发体验，因为工作流和集成很难编辑、阶段和测试。

另一种选择是使用通用编程语言，如Java和JavaScript，在这些语言中，通过使用任何生命周期工具链都可以获得敏捷性，但是开发人员负责编写集成语义。Spring之类的框架提供了一种抽象来帮助集成，但通常仍然需要YAML、XML和多个独立的编码文件来实现简单的集成。

Ballerina的目标是通过简化编写跨分布式端点集成和编排的弹性程序，来填补集成产品和通用编程语言之间的差距。

Ballerina试图同时提供敏捷性和集成简单性。为了实现这一点，Ballerina将语言、集成语法和环境部署构造打包到一个代码文件中，该代码文件被编译成二进制文件，在VM中可执行，然后通过智能感知语言服务器和ide调试器成为开发人员工具链的一部分。

Ballerina将自己描述为:“Ballerina是一种编译的、事务性的、静态的、强类型的编程语言，具有文本和图形化语法。Ballerina将分布式系统集成的基本概念融入到语言中，并提供了一种类型安全的并发环境来实现具有分布式事务、可靠消息传递、流处理和工作流的微服务。

Hello World是什么样子

例如，一个Hello World API服务将被写成一个文本文件并运行“ballerina run”:

// Packages contain functions, annotations and

// connectors. This package is referenced by

// ‘http’ namespace in the code body.

import ballerina/http;

import ballerina/io;

// A service is a network-accessible API. This

// service accessible at '/hello', and bound to a

// default listener on port 9090. `http:Service`

// is a connector in the `http` package.

service<http:Service> hello bind {port:9090} {

// A resource is an invokable API method

// Accessible at '/hello/hi’

// 'caller' is the client invoking this resource

hi (endpoint caller, http:Request request) {

// Create object to carry data back to caller

http:Response response = new;

// Objects have function calls

response.setPayload("Hello Ballerina!\n");

// Send a response back to caller

// Errors are ignored with '_'

// ‘->’ is a synchronous network-bound call

_ = caller -> respond(response);

}

}

芭蕾舞女演员设计原则

Ballerina的语言和运行时被设计用来表示集成流、开发和部署。根据定义，集成流假定与网络绑定的端点进行交互，并且可以将某些构造合并到语言和运行时中以简化开发。

网络感知类型安全

——Ballerina有一个结构类型系统，包含原语、对象、联合和元组类型。网络系统返回具有不同负载类型和错误的消息。Ballerina的类型系统通过基于union类型的方法包含了这种变化。这种类型安全模型在赋值时合并了类型推断，为网络绑定有效负载提供了大量的编译时完整性检查。

any anything; // can be any type

int integer = 0;

float floatingPoint = 0.0;

// constants are final instances of a type

@final float PI = 3.1415926;

boolean b = true;

string hi = "hello";

blob bl = hi.toBlob("UTF-8");

// json is a primitive

json js = {

a: "hello",

b: 5

};

// xml is a primitive

xml x = xml `<ballerina>

<supports>XML natively</supports>

</ballerina>`;

// type inference

var x = xml `<myXML/>`;

// errors are built in types

error e;

string[] stringArray = ["hi", "there"];

int[][] arrayOfArrays = [[1,2],[3,4]];

// union and tuple types

json | xml | string networkResponse;

(string, int) tuple = ("hello", 5);

() n = (); // the empty tuple is "null"

string | int stringOrInt = 5;

// maps are built in

map<boolean> myMap = {"ballerina": true};

// new types can be declared

// a "record" type is a simple structure

type myRecord { string a; int b; };

// records can be converted to/from JSON with error handling

rec | error myRec = <rec>j;

// you can re-declare existing types

type myInt int;

// objects have public and private fields, initialisers and logic

type myObj object {

public { string x; }

private { string y; }

new (string a, string b) {

x = a; y = b;

}

function getY() {

return y;

}

};

// enumerations are union types:

type aOrB "A" | "B";

aOrB myEnum = "A";

aOrB compilationError = "C"; // this won't compile due to type checking

// streams are first-class types

stream<obj> str;

// futures are built in types for asynchronous activities

future<string> f;

// functions are types and support lambda expressions

function (string, int) returns (string) func =

(string x, int i) => (string) { return "lambda"; };

序列图-

Ballerina的底层语言语义是通过建模独立的各方如何通过结构化的交互进行通信而设计的。随后，每个Ballerina程序都可以显示为它的端点流的序列图，包括同步和异步调用。序列图反映了设计人员和架构师是如何思考和记录互连系统的。Ballerina的语法结构允许任何工具或系统推导出序列图，并且开发人员在编写Ballerina代码时的思考方式鼓励强交互最佳实践。与Ballerina一起提供的智能感知语言服务器以序列图的形式提供服务，例如VS代码中异步调用端点的服务视图:

这个图来自于一个源文件，例如:

import ballerina/http;

import ballerina/io;

import ballerina/runtime;

@http:ServiceConfig {

basePath:"/quote"

}

service<http:Service> AsyncInvoker bind {} {

@http:ResourceConfig {

methods:["GET"],

path:"/"

}

getQuote (endpoint caller, http:Request req) {

// ‘endpoint’ declares a connection to a networked location.

endpoint http:SimpleClient nasdaqServiceEP {

url:";

};

io:println(" >> Invoking service asynchronounsly...");

// 'start' allows you to invoke a function or client

// connector action asynchronously. This is a remote

// invocation that returns without waiting for response.

future<http:Response | http:HttpConnectorError> f1

= start nasdaqServiceEP

-> get("/nasdaq/quote/GOOG", new);

io:println(" >> Invocation completed!"

+ " Proceed without blocking for a response.");

io:println(" >> Check for response availability...");

// ‘await` blocks until the previously started

// async function returns.

var response = await f1;

io:println(" >> Response available! ");

match response {

http:Response resp => {

string responseStr = check resp.getStringPayload();

io:println(" >> Response : "

+ responseStr);

_ = caller -> respond(resp);

}

http:HttpConnectorError err => {

io:println(err.message);

}

}

}

}

并发工作者

——Ballerina的执行模型由称为工作者的轻量级并行执行单元组成。worker使用完全非阻塞策略，其中没有函数锁定正在执行的线程，比如等待响应的HTTP I/O调用。这些语义说明了序列并发性，其中工作人员是独立的并发参与者，它们不共享状态，但可以使用消息进行交互，类似于分布式系统在网络上传递消息的方式。Workers和fork/join语言语义抽象了底层的非阻塞方法，以支持更简单的并发编程模型。

import ballerina/io;

function main (string... args) {

worker w1 {

int i = 100;

float k = 2.34;

// Pass variables to w2

(i, k) -> w2;

json j = {};

// Receive a message from w2

j <- w2;

}

worker w2 {

int iw;

float kw;

any vW1;

// Receive a message from w1

vW1 <- w1;

(iw, kw) = check <(int, float)>vW1;

json jw = {"name":"Ballerina"};

// Send a message to w1

jw -> w1;

}

}

DevOps就绪

——在过去的15年里，一门语言提供的相关工具集的最佳实践和期望不断发展。现在，除非一种语言包含单元测试框架、构建系统、依赖管理和版本控制，以及共享可重用代码模块的方法，否则它还不能被采用。Ballerina将所有这些子系统作为其核心分布的一部分，这样就不会有社区漂移的风险，当生态系统需要在一种语言之上构建工具，而不是在该语言内部设计工具时，就会发生社区漂移的风险。

Ballerina的包管理、依赖关系和版本模型是基于Docker、Elm和NPM的学习。虽然可以构建和运行单独的Ballerina源文件，但是包(模块)只能作为项目的一部分构建，而项目是由Ballerina管理的。每个项目都有自己的依赖项缓存，并且所有的包都根据semver规则进行版本控制。严格的规则限制了从中央注册中心导入包的应用程序的依赖冲突。

$ tree

/

.ballerina/ # Dependencies downloaded and cached locally

Ballerina.toml # Defines project build intent

my.package/ # Any folder is a package

RouterService.bal

tests/

RouterTests.bal

$ ballerina build

Pulling dependencies…

ballerinax/http [central.ballerina.io -> home repo] [====>] 56/56

ballerinax/rpc [central.ballerina.io -> home repo] [====>] 98/98

ballerinax/twitter [central.ballerina.io -> home repo] [====>] 79/79

Building binaries…

something.bal ⇒ target/something.balo

something.bal ⇒ target/something.balo

something.bal ⇒ target/something.balo

Running tests…

Test <mytest> ⇒ RUNNING … SUCCESS

Test <mytest> ⇒ RUNNING … SUCCESS

Test <mytest> ⇒ RUNNING … SUCCESS

Generating deployment artifacts…

@docker - complete 1/1

@kubernetes:ingress - complete 3/3

@kubernetes:svc - complete 3/3

@kubernetes:deployment - complete 1/1

SUCCESS

$ ballerina run

Service ready at

$ ballerina run kubernetes

Service ready at

环境感知

——Ballerina及其组件旨在在分布式、事件驱动的架构中使用。随后，在Ballerina中编写的每个服务都驻留在环境中，可能还包括其他服务、遗留服务、服务网格、协调器、API网关、身份网关、消息代理和数据库的。

Ballerina的语言和注释有意地具有环境意识，将这些其他组件视为语法对象，还将关系视为修饰过的注释。通过让语言和构建系统在环境上意识到围绕我们的服务的其他组件，我们可以在CI/CD之前生成基本的工件代码，对网络绑定的有效负载执行数据和完整性检查，以及作为Ballerina二进制文件的一部分而依赖于预包但尚未部署的组件。

Ballerina附带了将服务连接到不同组件(如API网关、消息代理和身份服务器)的注释。此外，Ballerina还包含了一些可定制的注释，这些注释指出了应该如何打包服务以进行部署。生态系统供应商可以添加他们自己的注释和编译器扩展，作为构建过程的一部分来生成准备部署的工件。通过在与源代码相同的文件中添加这些注释，开发人员能够维护流，从编译器获得快速增量构建，并获得语言服务器智能感知来定义服务如何集成到其环境中。

例如，hello world服务可以转换为调用一个不可靠的外部REST端点和断路器，并让编译器生成Kubernetes部署工件:

// Packages contain functions, annotations and

// connectors. This package is referenced by

// ‘http’ namespace in the code body.

import ballerina/http;

import ballerina/io;

// A connector to a REST endpoint with a circuit

// breaker that will be compiled into the service

endpoint http:Client homer {

targets : [{url:";}],

circuitBreaker: {

failureThreshold:0,

resetTimeMillies:3000,

statusCodes:[400, 404, 500]

},

timeoutMillis:500

};

@kubernetes:Deployment {

image: "demo/home-demo",

name: "homer-demo"

}

@kubernetes:Service {

serviceType:"NodePort",

name:"homer-demo"

}

service<http:Service> hello bind {port:9090} {

hi (endpoint caller, http:Request request) {

// The ‘check’ operator will propagate any error

string name = check homer -> get (“/quote”);

http:Response response = new;

response.setPayload("Hello Ballerina!\n");

_ = caller -> respond(response);

}

}

芭蕾舞女演员(Ballerina)中央

Ballerina已经进入 beta central.ballerina.io ，这是一个中心，共享的注册中心，发现可重用的代码包，并将它们组装在由开发人员构建的服务中。

任何人都可以创建一个账户，并且可以免费使用，遵循的模式与DockerHub共享图片的方式类似。

Ballerina包可以包含函数、连接器、注释(比如部署所需的注释)、枚举、对象和记录。

包遵循/模型。在Ballerina Central中为每个用户和组织定义了组织名称。开始创建包并将它们推到Ballerina Central的方法很简单，开发者可以这样做:

// Create a project with a package

// Subfolders are packages

ballerina init

// Search local repositories and Ballerina central for packages

ballerina search

ballerina pull <org-name>/<package-name>

// Push your packages up to Ballerina Central

// Kicks off an oAuth authorization flow in your browser to

// obtain a CLI key that is installed onto your system

ballerina push <org-name>/<package-name>

芭蕾舞女演员的状态

Ballerina团队已经发布了0.970，这是该语言的类型系统、并发语法和连接器结构的重大发展。此外，这个版本还引入了对服务器连接器的支持，对JSON和XML的内置原语，对Docker和Kubernetes的注释支持，以及流SQL语法。在过去的一年里，大约有100个贡献者做出了15000个承诺。芭蕾舞女是ASL 2.0许可。

项目提交者推出了Ballerina.io作为芭蕾舞女演员的新家。执行芭蕾舞演员服务包括一个操场,100例为学习语言,和导游展示如何学习与一个完整的集成开发人员工作流程,其中包括建立一个IDE,编写代码,开发集成单元测试、构建、部署到码头工人和Kubernetes,可观测性与跟踪或度量工具。

接下来是什么?

Ballerina正在致力于1.0的稳定性，他们想要3-5年的语言稳定性和向后兼容性。我们的目标是在2018年底之前实现1.0长期稳定版。与此同时，WSO2承诺在今年夏天提供商业支持，包括为虚拟机增加补丁机制。

开发人员可以期待每月发布一次改进，今年余下时间的重点将是构建LLVM实现的原型，稳定标准包库，增加对带有Ballerina Central的生态系统的采用，以及包含有状态的服务。

鼓励开发人员在这里了解更多信息，他们可以下载SDK和二进制文件。芭蕾舞团还将在7月举办他们的第一次芭蕾舞表演，这是一个为期一天的学习活动，将其作为实体和虚拟活动提供。开发者可以在这里注册。

本文：

（此处已添加圈子卡片，请到今日头条客户端查看）