DEV Community: Hasitha Aravinda

A Quick Introduction to Ballerina: The Network-Aware Programming Language

Hasitha Aravinda — Sun, 04 Jun 2023 06:23:35 +0000

Have you heard of a programming language called Ballerina? As someone who works closely with the Ballerina language design and implementation team, I wanted to shed some light on this relatively young language that has a strong focus on network integration.

Why Ballerina, you ask? It was developed with the intent of making network behaviour a first-class concept within the language, simplifying tasks such as integrating with other services (i.e., HTTP, gRPC, GraphQL, Kafka, etc.), manipulating data, handling network security, and much more.

Here's a "Hello World" service example:

import ballerina/http;

service / on new http:Listener(9090) {

    resource function get hello(string? name) returns json {
        // name is an optional query parameter
        string target = name == () ? "World" : name;
        string message = string `Hello, ${target}!`;
        return {"message": message};
    }

    resource function get greet/[string name]() returns xml {
        // name is a required path parameter
        xml response = xml `<message>Greetings, ${name}!</message>`;
        return response;
    }
}

This service presents two HTTP resources (/hello and /greet/{name}), which produce a response in JSON and XML respectively.

You can check out more detailed examples of Ballerina's use cases in network integration.

Although the Ballerina community is currently small and largely composed of enterprise users, it's growing and openly welcoming to anyone interested in network applications development and integration. You are warmly invited to join us on discord

If you're interested in diving deeper into Ballerina, I've written a blog post covering the basics. We also have more examples for you to explore.

Let me know what you think. I'm excited to hear your thoughts and answer any questions you might have!

Ballerina Identifiers: A Simple Guide for New Developers

Hasitha Aravinda — Wed, 15 Mar 2023 12:07:23 +0000

Identifiers are names we give to elements in our code, like variables, functions, or types, to easily recognize and refer to them.

You'll find identifiers all over your code - for types, variables, functions, and more. Check out this picture showing all the identifiers in a typical Ballerina Service.

Identifiers are everywhere - Source

Picking good identifiers is super important to make your code easy to read and understand. Every programming language has its own rules and guidelines for identifiers, and in this post, we'll dive into how to nail identifiers in Ballerina.

This is a summarized version of my blog post on Ballerina Identifiers - Best Practices and Use Cases. Head over there for more code examples and in-depth info.

✍️ Syntax

In Ballerina, identifiers have a few different syntax options:

Standard Identifier: Starts with an ASCII letter, underscore, Unicode identifier character, or a Unicode code point escaped with \u{XXXX}. It can then be followed by any combination of characters, including digits. Can't use reserved words as they'll cause errors.
Quoted Identifier: Begins with a single quote, allowing keywords and identifiers starting with digits. This helps avoid limitations of the standard syntax.
Character Escaping: Use \u{XXXX} or \<Non-ASCII-CHAR> to include valid Unicode code points in identifiers. Some restrictions apply, as mentioned in the Ballerina Language Specifications.
Qualified Identifier: To refer to elements in another module, use <module-prefix-identifier>:<identifier>. The module prefix must match the import declaration within the source file, and a colon separates it from the identifier without any whitespace.

Let's see some valid identifiers.

Standard Identifier	Quoted Identifier	Qualified Identifier
`name`	`'2invalid`	`my\-variable`
`ageInYears`	`'12345`	`bad\u{21}name`
`sales_tax_rate`	`'if`	`\@hello`
`_isAvailable`	`'order`	`id\ with\ spaces`
`MAX_ATTEMPTS`	`'class`	`id\u{20}with\u{20}spaces`

As you can see, Ballerina identifiers are quite flexible, supporting a wide range of combinations. This flexibility is particularly useful when working with data containing different languages and symbols, as it makes handling domain-specific terminology, non-ASCII characters, and even non-English languages much simpler.

In the following sections, we'll discuss some of the practical use-cases for Ballerina's versatile identifiers.

💡 Few Use-Cases

Ballerina's design prioritizes Unicode support in identifiers, making it easy for programmers to use non-ASCII characters, domain-specific terminology, and non-English languages in their code.
Writing Person record in different languages - View Source Code
Ballerina's flexible identifiers can be extended to support JSON values with special characters in the keys, making it easier to create matching identifiers that simplify data access and manipulation without complex transformations. This approach can be applied to other use-cases as well. Watch this video where I demonstrate working with JSON in Ballerina, showcasing how simple it is to handle such scenarios.
Working with JSON Data with Special Characters in Keys - View Source Code
In Ballerina, use a single underscore _ to ignore unneeded values in certain contexts, but note that it only works for non-error values, as ignoring a value that could contain an error generates a compiler error.

Ignoring Values - View Source Code

💡 Naming Conventions

Identifiers can be used in different language contexts, and depending on the context, there are generally accepted best practices for naming identifiers.

Identifiers Everywhere, But not a single one descriptive

Use descriptive identifiers to improve code readability.
- Find a balance between length and clarity. This balance takes time to master.
Avoid abbreviations, except for widely-known ones.
Consider context and relevant conventions:
- camelCase - for function/method names and parameters, variables (local, module level, configurable, etc.), record fields, and more.
- PascalCase - for Type Definitions, Classes, Enums, etc.
- UPPER_SNAKE_CASE - for Constants.
- kebab-case - for Service and Resource path segments.
Understand the difference between public and non-public identifiers:
- Choose public identifiers carefully for exposed APIs (service or client).
Be prepared to deviate from guidelines for specific requirements (e.g., OpenAPI/GraphQL/gRPC contracts) or when using non-English words, where camelCase or PascalCase may not apply.

🚀 Identifier Scopes

Ballerina identifiers have their own rules depending on the scope they're in. There are two main scopes: module-scope (usable in the module and, if public, outside too) and block-scope (limited to the block they're in). You can use the same name for both scopes within the same symbol space, but be careful not to overlap block-scoped ones with the same name or you'll get a compile error. For more info, check out my original post!

🎉 Summary

Well, that's a wrap on our quick dive into Ballerina identifiers! I hope this discussion helped you learn a new language feature and gave you the confidence to handle special characters with ease. Remember, don't complicate things; use Ballerina for quick development. Maybe you can consider Ballerina for your next DIY integration.

Don't forget to check out my original blog post for more detailed explanations and code examples. Also, visit the ballerina.io website, as it has a lot of great resources to help you learn Ballerina.

You can meet Ballerina developers here.

Keep exploring, and happy coding with Ballerina!

Simplify Ballerina Workflow on GitHub with setup-ballerina Action

Hasitha Aravinda — Mon, 20 Feb 2023 17:09:46 +0000

The post covers the use of the setup-ballerina GitHub Action to automate the installation of the Ballerina (Swan Lake) distribution in the GitHub Action environment.

The following code block shows how you can configure the GitHub Action to build your Ballerina project. You can find a working example of this in this repository.

The setup-ballerina GitHub Action v1 release requires a mandatory input of the Ballerina Swan Lake distribution version in the form of "Swan Lake channel" as listed in the bal dist list command. i.e. 2201.3.0, 2201.3.2, etc. This will install Ballerina on workflow environment and bal command is added to the PATH.
This action is supported on Ubuntu, MacOS, and Windows, and facilitates easy integration of Ballerina into your GitHub workflow.
After you install Ballerina command, you can use run to execute the bal command.

With the introduction of setup-ballerina, users now have the option to choose between ballerina-action and setup-ballerina for using Ballerina in their GitHub Actions workflows.

This provides greater flexibility and choice for users, allowing them to choose the option that best suits their specific workflow needs. A comparison of the two options can help users make an informed decision based on factors such as Architecture and full bal command support.

GitHub Action	`setup-ballerina`	`ballerina-action`
Architecture	Composite Actions	Docker container
Supported Ballerina Versions	Swan Lake	1.x and Swan Lake
Full `bal` Command Support	Yes	Limited to `bal build` and `bal push`

In summary, setup-ballerina provides more flexibility and full bal command support. The choice of which action to use ultimately depends on your specific needs and workflow requirements.

Originally, setup-ballerina was one of my pet projects that have now been officially part of the Ballerina platform.