From Node.js to Quarkus

A JavaScript Dev's Painless Path to Java Backend Bliss

Hey JavaScript folks! Ever felt the itch to explore backend development beyond the Node.js realm? Maybe you've heard whispers of Java's robust ecosystem but thought it was too complex or verbose? Well, get ready for a pleasant surprise. Enter Quarkus, the supersonic, subatomic Java framework that's surprisingly friendly to JavaScript developers like you.

In this article, we'll take a stress-free stroll into the world of Quarkus. We'll ditch the Java jargon where we can, focus on the core concepts, and get you up and running with a truly impressive feature in minutes – DevServices. Think of it as magic for your development workflow.

Why Quarkus for JavaScript Devs?

As JavaScript developers, you love speed, efficiency, and a smooth development experience. Quarkus ticks those boxes, and then some more. Think of Quarkus extensions like `npm packages` – you add what you need.

• Blazing Fast & Efficient: Quarkus is built for speed. It rocks incredibly fast startup times (milliseconds!) and low memory consumption, thanks to its ahead-of-time compilation and optimized architecture. Imagine your backend apps starting up almost instantly!

• Developer Joy: Quarkus embraces developer productivity. It has hot-reloading (just like `nodemon` or hot module replacement in your JS frameworks!), a fantastic CLI (similar to tools like `create-react-app`), and features like DevServices that simplify development setups.

• Java Ecosystem Powerhouse: Tap into the Java ecosystem and libraries. Need a specific database connector, messaging system, or security library? Java's got it, and Quarkus makes it easy to integrate.

• Cloud-Native Ready: Quarkus is designed for modern cloud environments and microservices. It's perfect for containers, Kubernetes, and serverless deployments.

Painless Installation - Super Speedy Setup with SDKMAN!

Let's make the setup even easier. We'll use SDKMAN! to manage Java versions and install the Quarkus CLI. This is going to be incredibly smooth.

1. Install SDKMAN! (if you don't have it):
SDKMAN! is a tool to manage multiple SDKs (Software Development Kits) on your machine, including Java and the Quarkus CLI. If you don't have it installed yet, it's super easy:

Open your terminal and paste this command:

curl -s "https://get.sdkman.io" | bash

Follow the on-screen instructions after running this command. You'll likely need to open a new terminal or run source "$HOME/.sdkman/bin/sdkman-init.sh" to initialize SDKMAN in your current shell.

Verify SDKMAN installation: In your new terminal, type:

sdk version

You should see the SDKMAN! version displayed if it's installed correctly.

2. Install Java with SDKMAN!:
Now that you have SDKMAN!, installing Java is a breeze. We recommend a recent LTS (Long-Term Support) version like Java 21. In your terminal, run:

sdk install java 21-tem

Explanation: This command tells SDKMAN! to install Java version 21 Eclipse Temurin (formerly AdoptOpenJDK). SDKMAN! will handle downloading and setting up Java for you.

3. Install Quarkus CLI with SDKMAN!:
With SDKMAN! installed, getting the Quarkus CLI is just as easy:

sdk install quarkus

Explanation: This command uses SDKMAN! to install the Quarkus Command Line Interface (CLI). SDKMAN! will download and set up the Quarkus CLI for you, making it available in your terminal.

4. Create your Quarkus app with Quarkus CLI:
Now that you have the Quarkus CLI installed, you can use it to create a new project. In your terminal, run:

quarkus create app code-with-quarkus

Explanation: This command uses the `quarkus create app` command to generate a new Quarkus application project named `code-with-quarkus` in a directory also named `code-with-quarkus`.

5. Navigate into your project:

cd code-with-quarkus

That's it! You've installed Java and the Quarkus CLI using SDKMAN! and created your first Quarkus project. See how simple that was?

DevServices Magic: Database in a Snap

Now for the cool part – DevServices. Imagine you need a database for your application during development. With traditional setups, you'd have to install, configure, and run a database server manually. Quarkus DevServices automates this for you! It's pure development magic.

Let's add a PostgreSQL database to our project using DevServices.

1. Add the PostgreSQL extension:
In your project directory, run:

quarkus extension add quarkus-reactive-pg-client

Explanation: This command uses the `quarkus extension` command to tell Quarkus to add the `quarkus-reactive-pg-client` extension. This is the recommended Quarkus extension for reactive PostgreSQL connectivity. Quarkus is smart enough to know that if you add a database extension and you're in development mode, you probably want a DevService!

2. Run your Quarkus app in Dev Mode:

quarkus dev

Watch the magic happen in your terminal output! You'll see Quarkus automatically start a PostgreSQL database in a container using Docker (make sure you have Docker Desktop running).

...
INFO [io.quarkus.devservices.docker] (Quarkus DevServices) Pulling docker image: postgres:15.5-alpine
INFO [io.quarkus.devservices.docker] (Quarkus DevServices) Starting docker container for image: postgres:15.5-alpine
...
INFO [io.quarkus.hibernate.orm.runtime.dev.HibernateDevServicesProcessor] (Quarkus DevServices) Dev Services for Hibernate ORM started.
...
INFO [org.acme.GreetingResource] (Quarkus Main) Started in 1.234s
...

Boom! You have a running PostgreSQL database, ready for your application, without any manual setup. When you stop your Quarkus app (`Ctrl+C`), DevServices will automatically stop the database container too. Clean and simple.

A Quick Code Example: Hello Database!

Let's write a tiny bit of Java code to interact with our PostgreSQL database. Don't worry, it's not as scary as it sounds. If you've worked with TypeScript, Java's syntax will feel somewhat familiar.

1. Open `src/main/java/org/acme/GreetingResource.java`. This is a simple REST endpoint Quarkus created for you.

2. Modify the code to this:

package org.acme;import jakarta.inject.Inject;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
import org.eclipse.microprofile.config.inject.ConfigProperty;

@Path("/hello") 
public class GreetingResource {

@Inject
@ConfigProperty(name = "quarkus.datasource.reactive.url")
String dbUrl;

@GET
@Produces(MediaType.TEXT_PLAIN)
public String hello() {
return "Database URL from DevServices: " + dbUrl;
   }
}

We're injecting the database URL using `@ConfigProperty`. Quarkus automatically configures this thanks to DevServices. Think of `@Inject` like dependency injection you might see in frameworks like Angular or NestJS.

The `/hello` endpoint now returns the database URL. `@Path` and `@GET` are annotations that define this as a REST endpoint, similar to decorators in some JS frameworks.

3. Test it out! Open your browser or use `curl` and go to `http://localhost:8080/hello`. You should see something like:

…
Database URL from DevServices: vertx-reactive:postgresql://localhost:36609/quarkus?loggerLevel=OFF
…

Congratulations! You've just used Quarkus DevServices to spin up a database and access its connection details in your application, all with minimal effort.

Node.js vs. Quarkus: A Quick Glance

When considering Quarkus as a JavaScript developer, it's helpful to understand how it compares to Node.js in key areas. One of the most striking differences is startup time. While Node.js is known for its relatively quick startup, Quarkus takes this to another level, boasting excellent startup times in milliseconds. This speed advantage is particularly noticeable in cloud-native environments and serverless functions where rapid scaling is crucial.

Another significant distinction lies in memory footprint. Node.js applications generally have a moderate memory footprint, which can grow as applications scale. Quarkus, on the other hand, is designed for low memory consumption. This efficiency is a major benefit for resource-constrained environments and for optimizing application density in cloud deployments.

In terms of ecosystem, both platforms are rich, but cater to different strengths. Node.js boasts a vast and vibrant JavaScript-centric ecosystem, perfectly suited for front-end heavy applications and real-time web services. Quarkus, however, taps into the massive and diverse Java ecosystem. This provides access to a wealth of mature and robust libraries for virtually any backend need, especially in enterprise contexts.

The programming language is an obvious difference. Node.js primarily uses JavaScript (or TypeScript), languages familiar to front-end developers. Quarkus is built on Java (but also supports Kotlin and Scala). While Java might seem daunting initially, its strong typing and mature tooling can be advantageous, and for JavaScript developers comfortable with TypeScript, the transition to Java can be smoother than expected.

Finally, consider the typical use cases. Node.js excels in web servers, APIs, and real-time applications. Quarkus shines in microservices, backend systems, enterprise applications, and cloud-native architectures. While there's overlap, Quarkus's strengths are particularly aligned with building robust and scalable backend services in Java's mature and extensive ecosystem.

Next Steps and JavaScript Comfort Zone

This is just scratching the surface of what Quarkus can do. But hopefully, you can see how easy it is to get started and how powerful features like DevServices can be.

To make your Quarkus journey even smoother as a JavaScript developer:

• Explore JavaScript-friendly extensions: Quarkus has extensions for things like RESTeasy (JAX-RS) for building APIs (similar to Express.js in some ways), and even experimental support for running JavaScript code within Quarkus.

• Focus on the CLI and Dev Mode: Quarkus's CLI and Dev Mode are your best friends for rapid development and experimentation. The hot-reload is incredibly fast!

• Think "Components" (Extensions): Quarkus is all about extensions (components). Want to use Kafka? Add the Kafka extension. Want to use GraphQL? Add the GraphQL extension. This modular approach, similar to `npm packages`, is very efficient and keeps your core application lean.

• Consider TypeScript as a Bridge: If you like the type safety of TypeScript, you might find Java's strong typing and tooling comfortable. Quarkus can be a great way to explore this world.

Quarkus might seem like a leap from your JavaScript comfort zone, but it's a surprisingly welcoming and productive platform. With its speed, developer-friendly features like DevServices, and access to the vast Java ecosystem, it's definitely worth exploring. Give it a try, and you might just find your next favorite backend framework!

What do you think? Are you tempted to try Quarkus? Try using Quarkus with your favorite IDE! Also, tell me what you'd like to learn next about Quarkus as a JavaScript developer.