I can't believe it's already December and 2024 has almost passed. That means it’s time to take a look back at the articles that Red Hat Developer published this year and showcase a few of the best.
Programming languages, frameworks, and application runtimes are usually hot topics for developers, and this year is no exception. Java, JavaScript, and Node.js continue to be dominant forces in web development. Quarkus, the Kubernetes-native Java framework, is also thriving thanks to its strong community support; the project recently celebrated its 1,000 contributor milestone.
The 10 most popular languages and runtimes articles of 2024
Many articles we published this year focused on the impact of AI (artificial intelligence) and LLMs (large language models) on the deployment process. Other popular topics included running Node.js at the edge, using external databases with Quarkus, and the Shenadoah garbage collector.
Without further ado, here are the standouts.
#10: Apply generative AI to app modernization with Konveyor AI
By Syed M Shaaf and John Matthews
Get an overview of Konveyor AI (Kai), an open source tool that uses generative AI to shorten the time and cost of application modernization at scale. Kai integrates LLMs with static code analysis to facilitate code modifications within a developer's IDE, helping transition to other modern programming languages and frameworks efficiently.
Using a retrieval-augmented generation (RAG) approach, Kai enhances LLM outputs with historical code changes and analysis data, ensuring context-specific guidance. This method is model-agnostic and does not require model fine-tuning, making Kai a versatile tool for large-scale modernization projects.
This unique approach helps shorten the time and cost of modernization at scale. As a developer, you can view a list of issues in your IDE that need to be addressed to migrate to a new technology, and Kai will work with an LLM to generate the required source code changes.
This article includes a video demo showcasing the migration of the Java EE CoolStore application to Quarkus using Konveyor AI.
#9: Run Node.js applications on the edge with RHEL and Fedora
As the cost to performance ratio of small computer systems improves, more and more enterprises are moving from simpler IoT systems to deploying devices that can do more processing at the edge. As part of this transition, these edge devices start looking a lot more like servers in existing IT infrastructure. As a result, managing them as such becomes not only feasible but more cost effective.
This is the first of a three-part series on using Node.js at the edge. Part 1 introduces you to the hardware and software for the Node.js-based edge example and explains some of the details for laying the foundation for deploying the application by building and installing the operating system using Fedora IoT. Subsequent parts of the series dig into how to improve the deployment of that application to make it both easier to deploy and manage.
Read it here: Run Node.js applications on the edge with RHEL and Fedora
#8: Connect a Quarkus app to an external SQL Server database
Quarkus is a full-stack, Java-based framework for building, deploying, and running applications, including building and deploying applications in containers without manually creating YAML files. It offers a zero-configuration database container using its dev services feature, enabling rapid development and testing. However, having an external database for your application is vital for regulatory compliance. It brings benefits such as isolation, a simplified development workflow, and independence from the development environment.
This article centers on a fictitious company called Pedal, an e-commerce application platform with a microservices architecture for listing and selling bicycles.
In this tutorial, you’ll build the Pedal bike service, using Quarkus to retrieve all listed bikes from the database. You’ll gain valuable insights into using an external database with Quarkus, understanding dev services, configuring data source features, and linking the Pedal application to an external Microsoft SQL Server database.
Read it here: Connect a Quarkus app to an external SQL Server database
#7: Getting started with MongoDB and Quarkus: Beyond the basics
A previous article, Getting started with MongoDB and Quarkus, explained how to leverage MongoDB from within a cloud-native application written in Quarkus. It takes you through the process of developing a sample application from scratch, introducing a few Quarkus extensions that help speed up the development process and remove friction when it comes to deploying the containerized application to Kubernetes.
This follow-up article iterates on the example application by guiding you through the following tasks:
- Perform a Quarkus version upgrade for your application.
- Add Entity <=> DTO (data transfer object) mapping.
- Introduce a service layer.
- Switch to the repository pattern for data access.
- Add an auto-generated REST resource.
- Switch to managed MongoDB Atlas instance.
Read it here: Getting started with MongoDB and Quarkus: Beyond the basics
#6: Connect a Quarkus app to an external PostgreSQL database
The fictional Pedal e-commerce application makes another appearance in this article, which helps you integrate Pedal’s external PostgreSQL database with one of its Quarkus microservices deployed on Red Hat OpenShift.
The Java application uses the Quarkus microservice framework and Spring to serve a web front end and a representational state transfer (REST) service. It also connects to a PostgreSQL database and SQL Server database.
Hosting this Quarkus application’s PostgreSQL database externally provides several advantages, including automated backups, robust data persistence, extensive maintenance tools, and more straightforward scaling. Using external databases also reduces the operational burden on your application’s development team.
Read it here: Connect a Quarkus app to an external PostgreSQL database
#5: Introduction to the Node.js reference architecture: Wrapping up
This article wraps up an 18-part (!) series examining the Node.js reference architecture. Drawing on real-world experience from teams at Red Hat and IBM, this series presents recommendations on what components to use when building Node.js applications and guidance for how to be successful in production with those components.
The final installment reflects on the topics covered and offers a look at what's coming next from the Node.js reference architecture team.
You can dive into the series from the beginning, or save yourself some clicks and download the e-book version: A Developer's Guide to the Node.js Reference Architecture
Read it here: Introduction to the Node.js reference architecture: Wrapping up
#4: How to use Java container awareness in OpenShift 4
Take a journey into containerized Java. After JDK 8u191+, there is a paradigm shift where Java applications are container-aware, meaning the JVM can detect container limits and impose those limits. This is a great feature when doing a deployment inside Red Hat OpenShift Container Platform 4 using Red Hat’s OpenJDK images and associated images.
In this article, you'll explore the usage and implications of container-aware Java application deployments, and learn how to use this to your advantage for fully containerized deployments.
Read it here: How to use Java container awareness in OpenShift 4
#3: A beginner's guide to the Shenandoah garbage collector
This article presents a quick introduction to Red Hat's Shenandoah, a high-performance, low pause-time garbage collector. Shenandoah's key characteristics include:
- Location-based garbage collection
- Not generational-based
- Operates in 3 or 2 concurrent phases
- Supported on Red Hat's OpenJDK 1.8, OpenJDK 11, OpenJDK 17, and OpenJDK 21
- Compacts concurrently
- Goal of <10ms pauses
You'll also find helpful recommendations for when to use Shenandoah and when not to use it.
#2: How to use LLMs in Java with LangChain4j and Quarkus
As a Java developer, diving into the world of AI might seem intimidating, but it's not! This tutorial is your gateway to use the power of LLMs through the integration of LangChain4j and Quarkus.
LangChain4j is a Java library specializing in natural language processing (NLP). Using LangChain4j with Quarkus, a cloud-native, container-first framework, you'll develop a tool proficient in analyzing and summarizing the content of blog posts.
#1: Speed up Java application startup time with AppCDS
Our most popular article in the languages and runtimes category, this post explains how application class data sharing (AppCDS) can help reduce startup time of your Java application.
Application startup time for OpenJDK apps can be important for cloud use cases. Start/stop cycles are much more frequent for an application deployed in Kubernetes because configuration changes usually result in a new deployment—a.k.a. restart—of the application. Often, changing something as simple as an environment variable results in redeployments. The time it takes until the application is ready to handle requests matters.
In our example, we achieve a startup time as low as ~440 milliseconds or ~47% faster than the corresponding startup time without AppCDS. The actual numbers will vary depending on the precise deployment and resource configuration in use as well as on the nature of the application itself. Nevertheless, AppCDS is an OpenJDK feature well worth looking into.
Read it here: Speed up Java application startup time with AppCDS
Learn faster with hands-on labs, a developer sandbox, and more
Our catalog of learning paths, interactive labs, e-books, and cheat sheets is designed to help you improve your skills as a developer. The Developer Sandbox for Red Hat OpenShift is a great place to learn how to apply application-based solutions with Java, Kubernetes (OpenShift), Quarkus, and JavaScript.
Java
- Download the latest edition of Java in a Nutshell by Benjamin J. Evans, Jason Clark, and David Flanagan: This book is designed to help you get the most out of versions through Java 17, with examples that show how to take advantage of modern Java APIs and development best practices.
- How to deploy a Java application on Kubernetes in minutes: In this learning path by Don Schenck, you will create a set of microservices and move an example application into a container using the Source-to-Image (S2I) feature.
- Expose Java application metrics using Micrometer: Micrometer is a metrics instrumentation library designed for Java-based applications. This learning path by Alex Soto Bueno shows you how to create a Quarkus application that uses the Micrometer library to expose metrics and tie it into Prometheus for monitoring and alerts.
- Explore the Red Hat build of OpenJDK and Red Hat JBoss Enterprise Application Platform.
Check out our full archive of Java content.
Quarkus
- Download Quarkus in Action: This book by Martin Stefanko and Jan Martiska teaches you how to use Quarkus to build resilient, scalable applications. Building on an example car rental application, you’ll explore technologies that integrate with Quarkus to provide functionalities integral to modern applications.
- Read Quarkus for Spring Developers: Eric Deandrea provides an introduction to Quarkus, with a special eye for helping those familiar with Spring’s conventions make a quick and easy transition.
- Developing OpenShift applications with Java and Quarkus: Create, test, and deploy Java code to OpenShift in a seamless development workflow using Quarkus, which lets you write data-driven applications using a variety of data sources with just a few lines of code.
- Build and deploy a Quarkus application to OpenShift in minutes: This exercise by Ian Lawson demonstrates how you can go from an initial app idea to prototype code in as little as five minutes using Quarkus, Podman Desktop, and the no-cost Developer Sandbox for Red Hat OpenShift.
- Deploy a Quarkus application to the Developer Sandbox with JetBrains IDEA: Ready to deploy a Quarkus application to OpenShift? If so, are you using JetBrains IDEA? In this learning path by Andre Dietisheim, you will get to know how the JetBrains plug-in assists you in deploying a Quarkus application as well as its unique features.
- Learn about the Red Hat build of Quarkus.
Find even more in our Quarkus content archive.
JavaScript and Node.js
- How to deploy full-stack JavaScript applications to the Developer Sandbox for Red Hat OpenShift: Red Hat OpenShift is a Kubernetes distribution that makes it easy to deploy and scale applications in the cloud. Don Schenck shows how to deploy a full-stack JavaScript application in an OpenShift cluster.
- Develop cloud-native Node.js applications with Express.js: Here, Lucas Holmquist provides an introduction to cloud-native development with Node.js. It covers cloud-native concepts and technologies, including health checks, metrics, building containers, and deployments to Red Hat OpenShift.
- How to get started with large language models and Node.js: Michael Dawson walks you through how to access a large language model using Node.js and LangChain.js. You’ll also explore LangChain.js APIs that simplify common requirements like retrieval-augmented generation (RAG).
- Essential AI tutorials for Node.js developers: If you're not sure how you fit into the AI space as a Node.js developer, check out this curated list of AI tutorials from Lucas Holmquist.
- Explore our Node.js topic page.
- Discover the potential of AI and Node.js.
Browse our Node.js and JavaScript topic tags for more.
The rest of the best
We'll be back with more content for tech practitioners in 2025. In the meantime, don't miss the rest of our 2024 year in review:
Last updated: December 20, 2024