Good morning and good afternoon from all of you uh who are joining today's session and thank you for joining this session.So in this session, I'm going to discuss in detail about uh what is cloud native programming language looks like and what are the different challenges that we are facing as well as how we can overcome those using different um approaches, especially using the ballerina programming language as it specialized in these areas.

So let's quickly uh go to the introduction section. Uh So in this session, I'm going to discuss about um as I said earlier, uh basically the cloud native aspects as well as how Bara is going to help with that. So uh just to give me a quick background and uh where I am coming from, I am working as a uh team member of Bella development team as well as I work for WSO two which is uh middle application development company. So since with the experience of the Beera programming language, I will relate to all these things uh with the best practices and what are the best approaches on trying or when implementing applications to the cloud. So when discussing the things. Let's first look at the definition, what is cloud native? So this definition is taken from the CNC of definition. So it is all about uh empower the organization. So uh give them the required capabilities to build and run applications in the environments, especially the dynamic environments like the public, private and hybrid clouds. So it is more about it, it contains a lot of different things and we have to consider so many different things.

Um mostly like the containers, microservices, how the infrastructure looks like and the especially the API S event driven stuff. So there are so many things to consider if you are developing applications for the cloud. So having said the definition, let's look at the history also a little bit.

So application development has changed over the last couple of years in many different ways and especially uh in the earlier days, like a couple of decades ago, we had monolithic applications that means one large applications which are doing uh so many different uh things in one single application.

And the the developers used the VOOL approach to develop the applications and also in the deployment uh they are using, they were using physical servers mostly. And then after that, uh the different architecture came into the picture that is the entire like like different um tires introduced to the application architectures. And also more H I process were uh used to develop the applications and the deployment mostly happened on the virtual service.

And then uh nowadays, what we are talking is about cloud applications. That means instead of one large monolithic app, we will have multiple micro services which serve the same process but is many single small services which we call microservices. And they then the deployment happens in the containers and also practices are uh using mostly for the development process as it provides very scalable and agile uh approach for the application development and also cloud support, that sort of approach uh very in a very native way.

So then the next challenge is when developing applications is like how to select different uh technology stack or what are the best possible uh programming languages or other technical uh stacks technology tools that we can use for the cloud native application development. And in today's world, there are so many different programming languages and each and every of them are serving different purposes. So then it's a matter of selecting the right programming language or right technical solution just to go ahead with the uh application development.

So it can be double op practices or function oriented practices, data oriented things. And also there can be different uh categorization of the technologies like front end technologies, backend technologies, things like that. So it's very important to select the right set of languages, technologies and tools if you want to achieve this success state of the cloud sharing. So uh out of these things, how we can select the right set of tools and architecture to proceed with. That's the main challenge.

And also uh it's all about abstractions because uh in microservices or the cloud environments. Uh but we are mainly dealing with this data in his, in the history. We usually had things called uh R PC where we move code around. But nowadays, we are not doing it because of the security concerns and other things instead what we are moving around is data. And since it is not one large monolithic application will have to coordinate with different microservices and that coordinations happens in terms of data.

So that, so that means we need to have better ways of representing the data. So representing means we need to define the shape or the format of the data. And also we need to think about how we can separate code from the behavior or the data from the code. Uh That means uh in monolithic applications, it's in one single application, we are different responsibilities are handled by one large application. So it's very important to have uh sep separation of data without having uh other parties being accessing the data. So it's very important to have that separation from the code. But in um cloud application, so in like microservices, we are dealing only about small part like a small portion of the functionality using it within each microservice. That means we don't need to worry too much about the different boundaries or uh separation of data from the behavior.

So what we need is we need to represent data properly. So that uh the data oriented approach is the most uh most suitable one rather than the object oriented approach because we don't need to bind data into the behavior in the microservices approach. And also the manipulation of data, which is also an important aspect. When we talk about the enterprise applications, we need to uh extract the information and we need to convert into different formats or different representations and uh extract some meaningful information out of the or derive some da data out of the existing information like that we need to manipulate data.

And the other important thing is how we communicate data. So since it's a combination of uh collection of microservices which are working together or which are working to achieve one single purpose, so we need to have better communication mechanisms and better ways to communicate data.

So it's about data. And also the network also plays an important aspect because uh it's not a single application and we need to instruct using network and communicating data across clients and services in various protocols formats is very important. So network is also playing an important role.

And the last but not not least the concurrence also and very important aspect because in in network applications, uh concurrency is something that we can't forget. And also these applications are inherently concurrent. So we need to ensure the concurrency safety as well as we need to see how we can achieve the better outcomes by having concurrent behaviors. So these are the main important things that we have to consider when we are developing applications in the cloud world. So then that is why we thought of coming up with the language called ballerina. So I will go through some of the experience, what are the best practices as well as how we can leverage those things to application developments. So if I quickly introduce what is Ballerina, we started this project in 2016 by WSO two and it's a general purpose program in language. But at the same time, it specialized in solving integration and cloud based problems uh by providing the right set of abstractions and the tools.

So earlier, I talked about network data and concurrency. So those are the things that we need to uh pay attention most in most of the times because those are the key, fun, key things when it comes to application development for the cloud. And also it is an open source project and which is driven by the community right now. And um so wo two came up with this idea because WO two is a open source and C application provided in many different domain integration. Uh and also uh ID T and access management and API S. So we uh we had a lot of problems and we, we face those challenges in cloud native applications. So then that's why we decided to design a new language instead of another DS L which will have more uh more or less limitations. So, so it's an open source project more most importantly. So you don't have to pay anything or you don't have to um do anything to use. It is freely available for anyone to use in the community. And uh it's everyone is part of the community if you are willing to join. So the effort was started in 2016. But the discussions went uh back into like 2010 because we identified the problems and we thought of different approaches of solving the problem. And we found the uh programming language is the best way to solve the problems.

And also, then we released the first version of it in 2019. Uh in between that, we developed so many things and we had multiple iterations on the compiler development as well as uh we worked on many different runtime representations. And then in 2022 we released the current major version which we call the Swan Lake uh which contains a lot of sophisticated features to handle the different aspects of integration and cloud application development. And currently we are doing updates to the So Lake version. And also we are working on the future versions, future major versions uh which will give more and more flexibilities as well as features. So then let me quickly let you know what is actually why we need such a language. So in left end of the screen, you can see the different integration products and technologies uh like ESB B PM, those are very heavy products as well as they serve the purpose. But at the same time, they are not cloud native and also they are mostly associated with some sort of DS L which has different limitations. So when we want to do something complex or something uh different, you will have to get the help of uh extra plugins using different programming languages. So that is the integration products story.

And also on the other end, we have general purpose programming languages which are like Java and Python, not many different kind of programming languages. So they serve for wide spectrum of problems. And at the same time, since the scope is huge, they are not that much focused on this problem or the integration problem. So they are providing the capabilities. But at the same time, it is not that efficient or the developer friendly if we think about this integration and cloud native applications. So the abstractions are not that ideal for this domain. So that is why ballerina stays in the middle. So it provides open all the capabilities like integration products so that you can achieve the same thing using Ballerina. At the same time, it's a programming language which has all the flexibilities like any other language So while staying in the middle, that means uh since we provide the different set of abstractions to deal with different kind of uh challenges that we face in the cloud application development.

So uh it it provides many different flexibilities or many different uh tools and uh approaches for application development. So that's a ballerina story. So let's look at some of the key features which we can leverage in application development uh to make it an efficient development as well as uh efficient runtime behaviors, how we can achieve those. So as I mentioned before, data is one of the key thing in application development in this area. So Valera, we treat data as one of the fundamental thing as well as we design the language in a way that data is treated as a first class citizen. So there are so many different uh data types and also ballerina has record specifically. So you can see these are the records. So you can define any of the uh uh data model that you have in the application using ballerina as it is. So it is very easy to model with the records or whatever other features and also can create very uh we can create custom types very easily to support the application or the real world data model. So it's very uh first class thing in ballerina and its support by a range of uh user, user scenarios. And then the other thing is a flexible type system. So Ballina type system is somewhat flexible in when it comes to different aspects in uh this area.

For example, uh in API design, one of the key principle is robustness principle. What that means is we have to be very conservative on what we send. That means we have to precisely define what we are sending out from our services so that the other tools like open API generators uh and those things will exactly know what we are, what they are receiving. And as well as they can define the documentation or whatever other things very easily because it's very uh it's defined already what we are sending out. And also the uh other part of this principle is like we have to be liberal on what we accept. That means when we are accessing data from other parties, we have to expect some different uh behaviors like there can be additional data. So we should not be very close or we should not be conservative on what we are receiving. So to support these things, ballerina type system support gives many, many different approaches. So one thing is the openness in the records. So if you can see here, ballerina type system has records as I shown in the previous slide and these records can be either open or closed.

So this is an open record uh where we can have additional fields. So we can effectively use this when we are receiving data. So even if there are some additional fields in the payload, we the system won't break in the run time. And also there is a concept called closed records. You can notice this pipe uh at the beginning and end. That means it will uh exactly define the structure or the uh uh exactly define the shape of this uh data. That means we can have only these two fields and nothing else. And if we d and try to add something, it will uh fail at the compile time. So that means when we are using uh these things to send data out, we know exactly what it contains. So these kind of things are very useful when it comes to the uh api designing and also flexible type system uh provides many different capabilities to represent uh real world data in the way that we model the real data. That means sometimes there can be optional stuff and also there can be uh fields which can have null values or nil in the in the ballerina world. And also unions, sometimes the data can be either one of two different types. So these things are supported by the language. So optional fi is like for example, this country and language are optional fields. Uh So when you are defining a value, you can have, you can either omit it or you can use it.

And also sometimes there are fields which have in uh N value or the null um that means no data. So we can define fields in that way. So even during the compile time itself, we can detect errors if they are uh if you are wrongly, if you are using them in a wrong way. And also union type, that is also important. That means we can um define union of sets using the type system. So uh if the value can be into a string, we can define it in the type itself. And then we can assign either in or a string without any issue. So those are some um flexibilities in the type system. And other thing is uh most important thing is sir uh how we represent different data formats. So in beer, in a like uh any other primitive types which supports by any other language like in flow decimal, we have record types to define whatever the data model you have. And also we have Jason N XML as a first class type. So you don't have to do any conversions casting if you want to access and create JSON values. So you can see we can create many different uh Jason values without any other additional syntax or anything as such. And also we can access data, convert data and uh convert it to record if we need.

Likewise, we can do any of the operations as a first class thing using uh Jason. And also XML is same, we can define XML in line and also we can access them, we can uh do whatever uh con conversion of types with uh easily. Because JN and XML are one of the key things when it comes to network data communication. So with these flexibilities and with these additions, it makes it really simple and easy to write applications which, which deals with these different types. And the other thing is the query support.

So usually we are familiar with SQL like syntax when it comes to query the data, but that is for database. But when we have some set of data in your application, how we can provide easy access or how we can easily construct a different uh sequence by iterating it. So we can use uh for loop or while what kind of similar stuff in other languages. But query languages support in ballerina, it give a lot of other capabilities similar to SQL like syntax. So when you get a sequence, uh you can iterate it using different conditions like via closes and you can define intermediate variables using lit and also you can order and you can limit stuff uh in the re returning value to number of items. And also you can defi select what fields you are interested at out of the existing fields. Likewise, it gives a full capabilities like SQL and you don't need to write complex logic to this sorting or limiting uh condition, checking everything like that. So with one single statement, you can achieve all these things. So this is a part of data and uh data design because it gives very high powerful data manipulation capabilities with this query support. So then other important aspect is network abstractions.

The first part is about data and there are so many other things, but I highlighted a couple of them uh with uh respect to the application development in cloud. And the next important thing is it is network abstractions. So network abstraction means we need to have ways to provide services to other parties to invoke as well as we should have a way to define clients so that we can invoke other services. So those are the two main entities and in ballerina services and clients are we have first class things which are supported by the language itself. So here you can see a service and it was different. It all depends on which listener that we are attaching to it. So here in this case, it is attached services attached which http listener that means this service is an http service. Uh so that within an http service, you know, we need to support uh resource methods like uh get put uh post delete those kind of things. And it closely goes with that terminology. So if you look at this resource function, so resource function is one of the two things that we can have within a service uh service support, remote functions and resource methods. So remote methods means R PC style things. For example, you can, if you are defining a GR PC type service, you can use remote methods. And if you are uh defining a restful style service, you can use resources.

So since this is attached to http listener, which is uh uh restful thing, we can use resource functions. And you can see get post that defines exact verb, a TP web and return types like a normal functions. You don't have to do anything additionally. Even though it's network interaction, it looks like a normal function in any other programming language. So we are too hard to focus only on the business logic, not the rest of the things. So network instructions and handling low level details when it comes to network instructions are not visible to the application developer. If you really want to configure, you can configure those things with additional configuration parameters. But uh to get the work done, you can start with these things and you can customize later on. So that is service part. And then the other important thing is a client client is also uh first classing in the language. So wellness support defining client objects which allows the program to interact with remote endpoint. Uh So then that means we can extract data from different types of clients. It can be a GTP client or graph QL web. So there are so many different client types supported by the language itself and based on the import statement. As well as the defi definition of the client, you can select what sort of a uh instructions that you are going to have.

And also, as you can see here, there's an arrow sign that means it is not a normal function in location. That's how we differentiate network instructions in a program. So in the normal function in locations, what we use is dot notation. But in network instructions, we use error notation. So that by looking at the code itself, we can see, OK, this is a network instruction that we are talking about. And also other important thing is how we combine this network instructions with data. So the data payload, data binding uh or the data binding features of the language will give is giving very flexible way to handle data. If you can see here, uh we are getting some response from an http endpoint. And as soon as you get that thing, you can bind it to a defined record type in the language itself. You don't have to do any conversion casting anything with the data binding features. You can define the structure and directly attached to that and later access the fields. So that is very easy and you don't have to worry too much on how the data conversions. And uh that attaching part is handled, it is handled by the listener itself and then other import that is network part. Uh Actually I just covered object, sorry uh client sensor services only. But there are so many other network concepts which I don't cover here. And other important thing is a concurrency.

So since we are dealing with a lot of microservices, it's very important to pay attention to concurrency details. So concurrency related features are in built into the language as first class things and they map directly into the sequence diagram as well. I will showcase the sequence diagram thing later but uh concurrency means uh things are executing in parallel. So in ball ballerina, we have a concept called strand is the logical thread of control which is assigned to every worker and similar to some other languages, we have named workers as you see here. So they run concurrently with the default worker and get the work done in parallel. As also we have a synchronic function course uh where we can spawn a new uh logical thread when started. So likewise normal uh concurrency constructs are there additionally, there are some other uh things to ensure that reliability as well. So one such construct is transaction. So in enterprise applications, transaction is something that we can't forget about. So most of the time we'll have to deal with transactions when, when we're doing payment or when we want to do have when we want to do some atomic function, definitely we need transactions.

So without defining a lot of additional code blocks, so complex logic transactions can be embedded within this uh transaction block. Basically, if you want to have some transactional behavior, what you want to do is you have to write the logic within this transaction syntax.

So it is very easy. And the rest of the things like retries committing uh roll back and all these things are handled based on the failures automatically in the language. So that is concurrency. And the other important aspect is the concurrency safety net. So usually the concurrency constructs are available in any language, but concurrency safeness is passed to the developer. But in Ballerina, the main goal is we need to achieve the decent level of performance and also decent level of safety by achieve by by considering the cur currency safety.

So we we gave a lot of attention to the concurrency safety without passing it the responsibility to the developer to develop concurrency safety applications. So what we can uh what we are considering here is uh when it comes to network applications, the listener or the service can have multiple threads serving to the incoming request. That is very common thing in a given service, there can be multiple uh threads which serves the incoming requests. And also there should not be any undetected data races uh that can lead to wrong results. Usually what happens is like if developer is doing some mistakes, there can be undetected data races and things will go wrong in the run time. But in Ballerina, we try to do things in the compile time itself and try to achieve that in the compile time itself without uh delaying it to the run time. So like any other languages, we have locking support uh which allows the allows to access the mutable state from multiple threads. And also we have concept called isolated functions.

That means it's a function uh that is concurrently safe if it is uh if, if its arguments are safe, that means we have to pass uh safe arguments and it allows to access a mutable state only through parameters. And also we have a radon type represents immutable values. So with a combination of isolated and radio types, it will give more control to the developer during the compile time just without waiting only for the locks. Usually in other languages, we always depend on locks. But in ballerina, if we combine isolated functions and the red only types during the compile time itself, we can get an idea about what can go wrong or what data iss can occur in the run time. So these are some additional steps taken to uh ensure the safeness as well as uh efficiency of the application developers. And other that is about that is uh so far, what I talked about is the data aspects, network aspects as well as the concurrency aspect. And next things are somewhat additional things to support cloud story. So one such thing is the cloud to cloud support in ballerina. Uh If you look at this. This is a typical service in ballerina written in Ballera. And usually what we do is after writing the program we write well built, we, we do well built uh just to build the artifacts.

But if you combine with the traditional parameter called uh uh communities or example, Docker with the minus minus cloud black, that means we are generating the uh respective artifacts for the deployment as well. So it simplifies the process or the experience of developing and deploying uh to the cloud. Uh You don't have to worry about writing all the ML files uh or other artifacts by manual uh manually. Uh When you issue this command, it will generate whatever the dock fires or cer is artifacts. You can see the generated artifacts here and you can basically apply the com this command directly to deploy it. So there is a cloud dot tunnel where you can change the different parameters uh of the generated artifacts value. But if there's no such TUNEL file, it will go ahead with the default values and generate these artifacts. So it will detect the port numbers and other things uh by analyzing the code itself and it will generate uh the required artifacts. So that's very easy and that will reduce the time taken to uh ship your application into the cloud. And one other thing is like after deploying application and once it is in production, we need to take care about how it is performing and as well as how well it is running and what, what are the problems? Uh what are the erroneous situations, things like that?

So, observable is very important thing. And by default, every ballerina program is automatically observable. That means you don't have to do anything additionally and it is observable by any open telemetry tool. So that means it gives complete control as well as visibility to the performance as well as the behavior to the run time. Uh And uh you don't have to do anything. Uh For example, when it comes to matrix, we, you can connect from ETS or Grafana or if you want to do some tracing, you can use J and if you want to ha have support for logging to monitor logging and other stuff, you can use elastic ST likewise observ comes in with the platform with in the language.

So that means uh it is very easy when we are dealing with production environments. And so far I discuss about basic capabilities of the language as well as the platform. And then let's look at are there additional tools which helps the developers for the designing applications?

So one such thing is the sequence diagram. So as I mentioned before, uh concurrence execution means there can be multiple threads of executions as well as parallel executions. So in Ballerina for every program that you write, you will get a but two syntax uh sequence diagram as well So here you can see this is taken from the VS code. So that diagram capabilities are provided by the VS code plugging. So anytime that you write the program, you get this diagram automatically, you can edit the diagram as well by following these plus signs here and there. And then when you edit the diagram, you get the code and if you edit the code, you get the respective diagram uh without any delay. So it's a real time thing. And with this diagram, there are so many things that we can derive. One thing is like it's very easy to visualize what is happening. So just by looking at this code, sometimes it's very hard to understand what is happening. And when it comes to network applications, there are so many work instructions. And if we try to go through the code, it's very difficult.

But here, just by looking at the co uh diagram, we can understand, OK, there are two more endpoints, Google sheets and jet tub and this application is interacting time to time with these two endpoints and getting some response and then iterating it. And that is it. So likewise looking at the diagram when it is a complex application most uh most of the time, uh it's very easy to get an idea of what's happening. So that is very helpful for visualizing as well as if you prefer to write code, if you prefer not to write code. Uh if you are coming from a different background like the or something like that, then you can easily, if you prefer low code, you can uh edit this diagram as well and then code will be generated. And then the other thing is that when designing an application, uh we need to define not just a single service, we need to think about the rest of the services as well. How these microservice are interacting, what are the uh connection points and uh what are the different technologies so that high level architectural design is very important and ballerina support that as well.

So you can design your, this is taken from the code, you can design your application using this architectural diagram and it gives uh very uh efficient way where you can write applications uh or design applications by just adding components here. So it will generate the respective packages.

You can see in this example where it has a multiple packages. So this is taken from Google Cloud, uh GCP demo standard demo and we converted it to the ballerina language. And you can see the this is automatically generated as well as you can start the application development from the send by designing the different services. You can see this is a GR PC, this is a GTP service and this service is connected to these two services. Likewise, you can define the connection points and the code will generated based on this package definitions. So that is architectural or more high level view. And the next one is uh data mapping, which is also unavoidable thing when it comes to application development. And also when we need, when we need to deal with complex data, you have to transform them, you have to uh convert it to different types or you have to map it into different fields, things like that. So the data mapper, visual data mapper is a easy tool where we can map fields and also we can map multiple fields into one field as well as if you want to add some intermediate logic before mapping uh before having the final value. For example, you can combine these two by some other concatenating field and then you can have the final value here. So when you do the visual mapping using this tool, the respective code is automatically generated for the mapping function that is one other important thing.

And also other thing is like service design. When it comes to single service, we need to de design it uh based on the best practices as well as the proper API is very important. So this will give us very like similar to swagger editor view, you can edit it, uh you can add resources and even within resource you can edit by adding uh parameters, return types. And basically, it's about defining your service. So that capability is there so that you can easily define the service uh similar to HT restful design. Uh we have graph cable designer as well. So if you want to define design a graph cable application that support is also there. And then the next one is uh the next thing that I want to discuss is uh I so far discussed a couple of things, uh some important areas. And at the same time, I said, well is a language but it is not a language only. It's a platform that means we have the escort plug in for the tooling aspects and the editing capabilities and graphical capabilities. And also we have we have separate tools to work with different and network related API S. So these protocols and also converters, graph QL, graph Q schemas and open API converters GR PC schemas, things like that is very convenient with the bar here like on and also API doc generation and test framework is there with the bain platform, you can generate the API documentation using one single command and also test framework.

Is there like any other language you can test integration test or unit test and also mocking capabilities are there with the test framework so that you can mock certain endpoints and mm test uh using the test framework. And also we have a standard library that means for all the protocols dealing with network intru actions like HGTPGRPS, the graph QL or web. So webs up the list goes on and we have support for almost every protocol uh so that you can easily use them. And also we have extended library which is more or less kind of a connectors uh connectors for applications uh third party applications as well as utility functions sometimes. Uh so like databases and maybe uh Google sheet connectors, github connectors, things like that. So that extended library contains a huge list of um connectors for different end points so that you can easily interact with the different kind of applications. And also we have Ballerina Central, which is a module sharing platform. So if you are familiar with Mervin Central in Java, this is something similar to that. If you want to share your piece of code with the rest of the world or with your organization members with some limited restricted access, you can use Ballerina Central and publish your package and then others can import that into the their source code and then it will get downloaded into your local system and work with your application.

So that's about the ecosystem or basically the platform aspects of the language. So it's not just a compiler and also as I said before, ballerina is a uh community driven language and we highly encourage uh you all to join with us. Uh if you want to use ballerina as well as if you want to involve in the internal development as well. So since it's open source, anyone can join and help with the development as well. So we have different channels Discord, Taco Flow, Twitter, JT and so on. So, feel free to join with us. And uh we would like to uh see some of you in the community in future. So that is all about today's session. Thank you for joining with us and hope that will help to uh design applications in the cloud environments. Thank you. So there's one single question, how we can compare go language, uh go language that can be compared to ballerina in terms of an integration language and why ballerina is better? So yeah. Uh so the goal language is also having similar kind of concepts, abstractions and so on. Uh when we, we don't need to direct if we directly compare it's about the abstraction. So and also the visual capabilities. So with the visual capabilities and design capabilities and also with the abstractions for data as well as the concurrency, as well as the network aspects, we can give more flexibility as well as more design capabilities. Uh when we develop applications using ballerina.

Otherwise it's more or less the same because both of our programming languages and go support uh many wide spectrum of things but also can use for that. But at the same time, we highly focus or optimize in the integration as well as cloud native environments. So I hope I answered the question if you have any other questions I can answer. If not, I can wind this up uh as the time is out