Programs must be written for people to read, and only incidentally for machines to execute. — Abelson and Sussman
Kotlin is a new practical language designed to solve real-world problems. It is based on JVM but there are many differences between Kotlin and Java. Kotlin is a null-safe and concise language with support for functional programming. You can try programming in Kotlin here.
Kotlin coroutines provide an easy way to write highly scalable code, using the traditional style of programming, while avoiding having a thread allocated to each task.
In this article, I focus on code readability and how, in my opinion, coroutines provide a cleaner approach to writing code compared to a reactive approach. I have used Project Reactor to showcase the reactive code; however, the example can be extended to any reactive library, for example, RxJava and CompleteableFuture. Note that coroutine-based code scales as well as code written using a reactive approach. To me, coroutines are a win-win situation for developers.
Continue reading “How Kotlin’s coroutines improve code readability”
This post is the fifth post of my Introduction to Eclipse Vert.x series. In the last post, we saw how Vert.x can interact with a database. To tame the asynchronous nature of Vert.x, we used
Future objects. In this post, we are going to see another way to manage asynchronous code: reactive programming. We will see how Vert.x combined with Reactive eXtensions gives you superpowers.
Let’s start by refreshing our memory with the previous posts:
- The first post described how to build a Vert.x application with Apache Maven and execute unit tests.
- The second post described how this application became configurable.
- The third post introduced
- In the fourth post, we replaced the in-memory back end with a database and introduced
Future to orchestrate our asynchronous operations.
In this post, we are not going to add a new feature. Instead, we’ll explore another programming paradigm: reactive programming.
Continue reading “When Vert.x Meets Reactive eXtensions (Part 5 of Introduction to Vert.x)”
Are you interested in writing cloud-native applications? Want to learn about building reactive microservices? Would you like to find out how to quickly get started with Vert.x, Wildfly Swarm, or Node.js in the cloud with Red Hat OpenShift Application Runtimes? Are you an Enterprise Java developer looking to try new programming paradigms?
To learn about modern application development, join us at Red Hat Summit 2018 for sessions such as:
Continue reading “Red Hat Summit 2018: Getting Started with Modern Application Development”
In my previous post, Introduction to Eclipse Vert.x, we developed a very simple Vert.x application and saw how this application can be tested, packaged, and executed. That was nice, wasn’t it? Well, that was only the beginning. In this post, we are going to enhance our application to support external configuration, and learn how to deal with different configuration sources.
Continue reading “Eclipse Vert.x Application Configuration (Part 2 of Introduction to Vert.x)”
I had the pleasure to present “Eclipse Vert.x for Dj fun and for profit!” at the latest edition of the Jug Summer Camp in La Rochelle, France.
The Jug Summer Camp is a popular developer conference organized by Serli in western France, gathering regional attendees as well as speakers and participants from other French Java user groups.
Continue reading “Jug Summer Camp 2017, Vert.x and collaborative DJ mix”
This year JavaOne 2017 is being held at the Moscone Center in San Francisco, CA during October 1-5, I will be a holding a session for reactive programming covering The Reactive Landscape.In this session, I’m going to explain what does “reactive” mean.
Continue reading “The Reactive Landscape”
Reactive, what an overloaded word. Many things turn out to become magically Reactive these days. In this post, we are going to talk about Reactive Programming, i.e. a development model structured around asynchronous data streams.
I know you are impatient to write your first reactive application, but before doing it, there are a couple of things to know. Using reactive programming changes how you design and write your code. Before jumping on the train, it’s good to know where you are heading.
In this post, we are going to explain 5 things about reactive programming to see what it changes for you.
Continue reading “5 Things to Know About Reactive Programming”