Our connected world is full of events that are triggered or received by different software services. One of the big issues is that event publishers tend to describe events differently and in ways that are mostly incompatible with each other.
To address this, the Serverless Working Group from the Cloud Native Computing Foundation (CNCF) recently announced version 0.2 of the CloudEvents specification. The specification aims to describe event data in a common, standardized way. To some degree, a CloudEvent is an abstract envelope with some specified attributes that describe a concrete event and its data.
Working with CloudEvents is simple. This article shows how to use the powerful JVM toolkit provided by Vert.x to either generate or receive and process CloudEvents.
Continue reading “Processing CloudEvents with Eclipse Vert.x”
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)”
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
In “The Introduction to Vert.x” Series
Let’s start by refreshing our memory about the previous articles:
- The first post described how to build a vert.x application with Maven and execute unit tests.
- The second post reviewed how this application became configurable.
Continue reading “Accessing Data – The Reactive Way”
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 was lucky enough to speak at JavaOne 2017 last month. It was my first time there, as both an attendee and a speaker.
I must say I was very much impressed. In particular, during the keynotes, I was happy to see how Java is moving forward, keeping up with the fast innovation pace in the cloud area.
Continue reading “Server-side Kotlin with Eclipse Vert.x at JavaOne”
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”
This is the second session, which I gave at Red Hat Summit; this was an exploration of what is behind the reactive trend. Software is fiction, every season we have a new collection, we all have to follow this and right now, it’s reactive.
Continue reading “Reactive Programming with Vert.x”
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