API Programming Doesn't Need To Be Hard

APIs are the expressions of the capabilities of organizations for all to use. For example, map APIs express Google’s map capabilities, payment APIs express PayPal’s business, while AI APIs express AI expertise for Google, Amazon, Microsoft, and others. There are a lot of these APIs around, counting in the tens of thousands, and serving millions of requests. 

APIs are also the unit of reuse for the cloud. Just as most precloud-era applications were built reusing libraries, most cloud-native apps are built by reusing APIs in their implementation. Connecting and recombining those capabilities would be invaluable to startups. A startup could go to market faster using  services such as SendGrid®, Twilio, Stripe, Lob, and so forth. Often this involves making their APIs work together. 

Furthermore, by connecting and recombining those capabilities, we can build digital experiences that enhance customer’s lifestyles (e.g., one app to manage all our finances or a new app to entice consumers to order your furniture). Some of these ideas can lead to the next startup, to change the world, or to the next Google. For example, regulations like PSD2 (a European regulation for electronic payment services) and FHIR-based health care APIs are revealing interesting data through APIs, thus creating opportunities to build apps and startups around those results. For instance, using PSD2 APIs, we can build an app that manages all finances in one place or build an app that moves money around to optimize the returns. 

The possibilities are endless. This ability to connect and recombine APIs is a superpower! Standing on the APIs built by giants, you will do more and can literally program the world. 

Programming with APIs is harder than it should be

Creating, connecting, and recombining APIs (or in other words, programming APIs) is not as easy as it should be. With existing tools (e.g., Java) this leads to:

• Programmers spending a lot of time transforming data
• Long, unmanageable, plumbing-code construction
• A lot of time reading through APIs docs 

Current IDEs do a lot to make it easy to use libraries, but where is the IDE for the Cloud that lets you manage APIs just like libraries? Running and managing your APIs is more complex (e.g., navigating Kubunetates correctly, ensuring high availability (HA), scale, and forging build pipelines). Unfortunately,  developers end up spending so much valuable time wrestling with these details instead of creating value. 

Enter Choreo

Our solution is Choreo: a low-code cloud IDE for creating, managing, and composing APIs with a twist. It lets you write code and low code simultaneously. You can write the application’s logic visually with low code, with code, or switch back and forth as you see fit. I bet you do not believe me—going from code to low code and back at will is a hard problem. Yes, it took us five years, but we nailed it. You can find how we did it at the article Simultaneous low code and pro code. 

Why does simultaneous code and low code matter?  Because it gives us the best of both worlds. We can use low code to start, get a lot done, and then switch to code where we can handle the details. Or, we might revert to code when we face a bug. This lets us keep all the advantages of code, such as the ability to check in to Github, the ability to take a diff, to run code analyses, run a CI/CD pipeline, etc. We think of Choreo as a tool that makes good programmers even more productive, getting things done in minutes!  

Let's see Choreo in action. The following code periodically calls a Covid data API, extracts data, and sends me an SMS. In the following figure, you can see the low code view and code side by side, and if you change one, the other changes. Note that this only took me less than five minutes to build.

That is not all. With Choreo, you can just write the code, and we do the rest (e.g., Kubernetes deployment, HA, scale, build pipelines, etc.), so you do not have to. You will have a production grade app running with all the cloud-native engineering best practices. 

Choreo provides a cloud-based, end-to-end development environment to create, test, debug, run, and manage three types of cloud-native applications: services, APIs, and integrations. A graphical editor, predefined templates, and built-in wizards provide a seamless no-code and low-code experience. 

Finally, the APIs exposed by each application type and external API endpoints can deploy, discover, and consume each other in the Choreo marketplace. Choreo provides complete application lifecycle management using professional DevOps pipelines (defined using GitOps), taking the artifacts, and deploying them into Kubernetes.

There is still more 

Unlike other low-code solutions where the source code is effectively a black box, with Choreo, enterprises get lock-in free, low-code that they control. Choreo stores the generated open-source Ballerina code in GitHub. Users can clone the Git repository and take the code offline, edit it using freely available open source tools, and run it in any preferred environment, including on your laptop.

Choreo also offers deep observability capabilities matched by few other iPaaS (integration Platform as a Service) offerings on the market. These capabilities enable developers to view observability data at both design time and runtime to troubleshoot issues. In addition, observability data collected is fed into an analytical engine to provide analytics as shown in the following figure.

Artificial intelligence (AI) built into Choreo guides the user through the development experience. First, Choreo learns from historical activities and performance behaviors with AI-assisted development to anticipate most of a developer's needs. Then, as developers code, it pushes the boundaries of AI to provide performance feedback, code completion, anomaly detection, and data mapping. For example, the following figure shows how an AI algorithm can forecast the performance of your code as you change it. 

For instance, if you put an API call inside a loop, the performance forecast goes downhill, and you will realize the mistake while writing code, not while testing it or in production. 

Conclusion 

APIs, if you know how to tame and harness them, are a superpower. Choreo is a Cloud IDE that is built to make API creation, management, and composition a breeze while giving you literally every tool you need. You can create new APIs or compose one in minutes. 

It is the ideal place for innovating on top of APIs, letting you go from ideas to working apps fast, without you having to become a system expert. The step towards programming the world begins with Choreo (http://wso2.com/choreo). It gives you so much power, and remember, with great power comes ...