reactive

How Kotlin’s coroutines improve code readability

How Kotlin’s coroutines improve code readability

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”

Share
When Vert.x Meets Reactive eXtensions (Part 5 of Introduction to Vert.x)

When Vert.x Meets Reactive eXtensions (Part 5 of Introduction to Vert.x)

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 vertx-web, and a collection management application was developed. This application exposes a REST API used by an HTML/JavaScript front end.
  • 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)”

Share
Accessing Data – The Reactive Way

Accessing Data – The Reactive Way

This is the fourth post of my “Introduction to Eclipse Vert.x.” series. In this article, we are going to see how we can use JDBC in an Eclipse Vert.x application using the asynchronous API provided by the vertx-jdbc-client. But before diving into JDBC and other SQL subtleties, we are going to talk about Vert.x Futures.

In “The Introduction to Vert.x” Series

Let’s start by refreshing our memory about the previous articles:

  1. The first post described how to build a vert.x application with Maven and execute unit tests.
  2. The second post reviewed how this application became configurable.
  3. The third post introduced vertx-web, and a collection management application was developed. This application exposes a REST API used by an HTML/JavaScript frontend.

Continue reading “Accessing Data – The Reactive Way”

Share
Eclipse Vert.x Application Configuration (Part 2 of Introduction to Vert.x)

Eclipse Vert.x Application Configuration (Part 2 of Introduction to Vert.x)

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)”

Share
5 Things to Know About Reactive Programming

5 Things to Know About Reactive Programming

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”

Share
Technical How-to Books for Developers – Microservices, Design Patterns, .NET, Reactive, Databases

Technical How-to Books for Developers – Microservices, Design Patterns, .NET, Reactive, Databases

Within Red Hat knowledge sharing and collaboration are important.  As a part of that many Red Hatters write books and we get the honor of sharing their knowledge with other developers.  We have 7 more books in queue for the coming year and thought we would share the books you can currently download.

Continue reading Technical How-to Books for Developers – Microservices, Design Patterns, .NET, Reactive, Databases

Share