If you are interested in reactive, non-blocking, and asynchronous Java development, you are likely familiar with Eclipse Vert.x. The project started in 2011 and successfully moved to the Eclipse Foundation in 2013. Since then, Vert.x has undergone nine years of rigorous development and grown into a thriving community. It is one of the most widely used reactive frameworks, with support for multiple extensions, including extensions for messaging or streaming with Kafka or Artemis, developing applications with gRPC and GraphQL, and so much more.
Continue reading Introducing the Red Hat build of Eclipse Vert.x 4.0
DevNation Tech Talks are hosted by the Red Hat technologists who create our products. These sessions include real solutions plus code and sample projects to help you get started. In this talk, you’ll learn about reactive Quarkus and Mutiny from Clement Escoffier and Edson Yanaga.
Continue reading Reactive Quarkus: A Java Mutiny
Java was introduced 25 years ago, and to this day, remains one of the most popular programming languages among developers. However, Java has developed a reputation for not being a good fit for cloud-native applications. Developers look for (and often choose) alternative frameworks such as Go and Node.js to support their cloud-native development requirements.
Why learn another language when you can use your existing skills? Quarkus allows Java developers to leverage their expertise to develop cloud-native, event-driven, reactive, and serverless applications. Quarkus provides a cohesive Java platform that feels familiar but new at the same time. Not only does it leverage existing Java standards, but it also provides a number of features that optimize developer joy, including live coding, unified configuration, IDE plugins, and more.
Recently, Red Hat announced support for Quarkus. With Quarkus, Red Hat advances Java on Kubernetes and bridges the gap between traditional Java applications and cloud-native environments.
Continue reading “Quarkus, a Kubernetes-native Java runtime, now fully supported by Red Hat”
Red Hat Runtimes provides a set of comprehensive frameworks, runtimes, and programming languages for developers, architects, and IT leaders with cloud-native application development needs. The latest update to Red Hat Runtimes has arrived with Red Hat’s build of Eclipse Vert.x version 3.9. Red Hat Runtimes provides application developers with a variety of application runtimes and lets them run on the Red Hat OpenShift Container Platform.
A fluent API is a common pattern throughout Vert.x, it lets multiple methods calls be chained together. For example:
request.response().putHeader("Content-Type", "text/plain").write("some text").end();
Chaining calls like this also allows you to write code that’s a bit less verbose.
With 3.9, you can now create prepared statements and collector queries with the inclusion of
Query in the Fluent API. If you are familiar with JDBC,
PreparedStatement lets you create and execute statements. Moreover, you can run multiple interactions, such as cursor or stream operations.
Continue reading “Red Hat build of Eclipse Vert.x 3.9 brings Fluent API Query”
The supersonic subatomic Java singularity has expanded!
42 releases, 8 months of community participation, and 177 amazing contributors led up to the release of Quarkus 1.0. This release is a significant milestone with a lot of cool features behind it. You can read more in the release announcement.
Building on that awesome news, we want to delve into how Quarkus unifies both imperative and reactive programming models and its reactive core. We’ll start with a brief history and then take a deep dive into what makes up this dual-faceted reactive core and how Java developers can take advantage of it.
Continue reading “How Quarkus brings imperative and reactive programming together”
The latest update to Red Hat Runtimes has arrived and now supports Eclipse Vert.x 3.8.1.
Red Hat Runtimes provides application developers with a variety of application runtimes and enables them to run on the Red Hat OpenShift Container Platform.
With this update, some of the new additions and updates include:
Continue reading “Eclipse Vert.x 3.8.1 update for Red Hat Runtimes”
Our first DevNation Live regional event was held in Bengaluru, India in July. This free technology event focused on open source innovations, with sessions presented by elite Red Hat technologists.
In this tutorial, presented by Edson Yanaga, you’ll learn about reactive programming and why it matters in this new cloud-native era. We’ll use live coding demos to explain how to be reactive and benefit from this brave new streaming world.
Continue reading “DevNation Live Bengaluru: Dreaming of streaming with reactive programming”
The Reactica roller coaster is the latest addition to Coderland, our fictitious amusement park for developers. It illustrates the power of reactive computing, an important architecture for working with groups of microservices that use asynchronous data to work with each other.
In this scenario, we need to build a web app to display the constantly updated wait time for the coaster.
Continue reading “Get started with reactive programming with creative Coderland tutorials”
Quarkus continues its cadence of delivering a release every 2-3 weeks. This latest release (0.17.0) contains 125+ changes that include new features, bug fixes, and documentation updates.
Continue reading “Quarkus 0.17.0 now available”
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”