Tutorials on foojay.io - Friends of OpenJDK

Getting Started with Exposed: Kotlin ORM Made Simple

Mon, 06 Jul 2026 03:39:00 +0000

Introduction

For quite some time, I have been a huge fan of and fascinated by JetBrains products, tools, and libraries because of their masterful craftsmanship in product creation and their pristine focus on building high-quality developer tools.

Even more excitingly, JetBrains Java Annotated Monthly newsletters have featured most of the technical articles I wrote for Foojay on topics such as Java, Spring, Spring Boot 4, and OpenRewrite.

Recently, one Kotlin Domain-Specific Language (DSL) library caught my attention. I immediately tried converting my existing Spring Boot 4 application from Java to Kotlin using Exposed, an ORM framework for Kotlin. Kotlin SQL Libary

Quarkus Unpacked: Insights from the Foojay Podcast

Tue, 23 Jun 2026 12:36:54 +0000

I recently had the pleasure of joining the Foojay podcast to talk about Quarkus in depth. The conversation covered a lot of ground, from what makes Quarkus different to the practical trade-offs between JVM and native mode. This post captures the key questions and answers from that discussion, lightly edited for readability.{#_quarkus_unpacked_insights_from_the_foojay_podcast}

If you have been following this blog series, note that the third installment on building your own stack with Quarkus is coming next. Consider this a bonus entry that distills the podcast conversation into a format you can read, reference, and share.

Your TLS Stack Is Lying to You About Zero-Copy

Wed, 10 Jun 2026 12:00:28 +0000

The “No Waste Compute” Constraint

When I started designing the Exeris Kernel, I set one non-negotiable rule very early: no waste compute. That rule sounds like a performance slogan until it starts killing otherwise normal design decisions.

I had already banned ThreadLocal, moved context propagation to Scoped Values, and pushed more of the runtime into explicit off-heap ownership. The idea was simple: if the hot path is supposed to stay outside GC pressure, then memory shape and lifetime cannot be treated as incidental details.

How to Develop AI Agents Using BoxLang AI: A Practical Guide

Tue, 12 May 2026 12:52:39 +0000

AI agents are transforming how we build software. Unlike traditional chatbots that just answer questions, agents can reason about what tools they need, decide when to use them, chain multiple actions together, and remember what happened earlier in a conversation.

In this tutorial, I’ll show you how to build a real-world AI agent using BoxLang AI — the official AI framework for the BoxLang JVM language. We’ll build SupportBot, an e-commerce customer support agent that can look up orders, check inventory, issue refunds, and answer questions grounded in your knowledge base.

Explore Spring AI SDK – Amazon Bedrock AgentCore – Part 3

Sun, 10 May 2026 09:09:00 +0000

In Part 1 and Part 2 , we explored the Spring AI SDK and Amazon Bedrock AgentCore features, including the agentcore runtime starter and integration of agentcore memory. In this article, we will explore the integration of AgentCore built-in tools, including the Browser and Code Interpreter features.

Repository containing the companion code for the tutorial. Go to GitHub {#https://github.com/bsmahi/simple-spring-boot-agent}. Built-In Tool Browser

The use case I am trying to build here is for the given URL; it navigates the entire website and retrieves the content and gives key points and the summary of the page using the AgentCore Browser tool.

BoxLang AI Deep Dive — Part 7 of 7: MCP — The Protocol That Connects Everything

Thu, 07 May 2026 21:51:08 +0000

BoxLang AI 3.0 Series · Part 7 of 7

The AI ecosystem has a tool problem. Every framework has its own way of defining tools, every agent has its own way of calling them, and every integration requires custom code on both sides. An agent built in Python can’t easily use tools built in Java. An MCP server written for Claude Desktop can’t easily be consumed by a BoxLang agent without a custom adapter.

UCanAccess: The Modern Pure-Java Bridge to Microsoft Access

Wed, 06 May 2026 08:44:00 +0000

Microsoft Access databases are everywhere. Decades of .mdb and .accdb files silently power spreadsheets, small business applications, and legacy data stores across organizations of all sizes. Yet for Java developers, connecting to these files has historically meant wrestling with native Windows libraries, ODBC bridges, and platform-specific hacks.

UCanAccess puts an end to that. It is an open-source, pure-Java JDBC driver that lets you read and write Microsoft Access databases (.mdb and .accdb) just like any other SQL database — no native drivers, no Windows dependency, no friction.

BoxLang AI Deep Dive — Part 6 of 7: Memory Systems & RAG — Building AI That Remembers

Tue, 05 May 2026 15:10:15 +0000

BoxLang AI 3.0 Series · Part 6 of 7

A chatbot with no memory isn’t a conversation — it’s a series of isolated queries. Every message starts from scratch. The user has to re-explain who they are, what they’re working on, and what was just said. It’s exhausting, and it signals that the AI isn’t really listening.

Memory is what separates a useful AI application from a toy. BoxLang AI ships with one of the most comprehensive memory systems in any AI framework — 20+ memory types across two major categories, vector embedding support for semantic retrieval, 30+ document loaders for RAG pipelines, and a per-call identity routing system that makes multi-tenant applications safe by default.

BoxLang AI Deep Dive — Part 5 of 7: One API, 17 Providers — The Provider Architecture Deep Dive

Wed, 29 Apr 2026 16:38:08 +0000

BoxLang AI 3.0 Series · Part 5 of 7

Vendor lock-in is the silent killer of AI projects. You pick OpenAI, build everything against the OpenAI API, and then GPT-5 launches at three times the price. Or a competitor launches a model that’s faster for your use case. Or you need to self-host for compliance. Or your client is on AWS and wants Bedrock.

Every time the answer to “can we switch providers?” is “it would take months,” something went wrong architecturally.

BoxLang AI Deep Dive — Part 2 of 7: Building a Production-Grade AI Tool Ecosystem

Thu, 16 Apr 2026 09:27:15 +0000

BoxLang AI 3.0 Series · Part 2 of 7

Function calling is where most AI frameworks look deceptively simple on the surface and turn into a mess underneath. You define a tool, pass it to the LLM, and when the LLM calls it — who handles the lifecycle? Who fires observability events? Who serializes the result? Who resolves the tool by name when the only thing you have is a string?

BoxLang AI Deep Dive — Part 1 of 7: The Skills Revolution 🎓

Tue, 14 Apr 2026 11:50:53 +0000

This article is part of our 7-part deep dive on building production-ready AI systems with BoxLang.

BoxLang AI 3.0 Series · Part 1 of 7

Every AI framework eventually hits the same wall: your system prompts start drifting. Agent A has a slightly different version of the SQL rules than Agent B. The tone policy on your support bot is three weeks behind the tone policy on your documentation bot. Someone copy-pasted the wrong version. Nobody noticed.

JC-AI Newsletter #15

Fri, 20 Mar 2026 07:56:01 +0000

Over the past two weeks, the field of artificial intelligence has continued its remarkable pace of advancement. As AI becomes increasingly woven into the fabric of daily life, shaping how we work, communicate, and make decisions, it is both timely and valuable to step back and understand the broader trajectory of this technology. Whether the developments around us feel promising or challenging, one truth remains clear: AI is not simply leaving. It is here to stay, and understanding its evolution is essential from many perspectives.

Language Learning Flashcard System - Part 1

Tue, 17 Mar 2026 16:39:58 +0000

My native language is Spanish. I’ve been learning (and butchering) English my whole life. But at some point, I felt confident with English and wanted to learn Japanese. Big mistake. This is a totally different beast: three writing systems (Hiragana ひらがな, Katakana カタカナ and Kanji 漢字), a completely different grammar, no relation whatsoever with European languages… I needed help. And tools to learn. And one of them is Space Repetition System based apps.

JC-AI Newsletter #14

Tue, 03 Mar 2026 15:11:53 +0000

Two weeks have passed and a lot have been happening on the field of artificial-intelligence.

Two weeks have passed and a lot has been silently yet visibly happening in the field of artificial intelligence. This newsletter brings interesting developments, including Dario Amodei’s (Anthropic) view on the progress achieved in the LLM field and his response to the utilization of these models for specific kinds of military purposes, as well as OpenAI’s response to it. Aside from the fact that development may follow more sigmoids instead of exponential progress, it is important to have awareness of utilization across branches. Does prompting and clarifying the goal influence agent responses, and if so, how? How far are we from reliable robotics applications? How much bias is introduced when clinical data is being analyzed?

Personal Branding Tips for Java Developers

Thu, 26 Feb 2026 10:28:58 +0000

The software development industry is more competitive than ever. Being a strong technical expert is essential, but on its own it is often not enough to grow your career or open new opportunities.

In this short, practical talkDIY Technical Marketing, Real World Tips For Building A Successful Developer Brand , delivered at Jfokus 2026 conference , Payara Community Manager Dominika Tasarz-Sochacka explores why personal branding matters for developers and how even small, intentional actions can make a real difference over time.

From “Crypto AI” to general AI: Do AI agents dream of electric langoustines?

Mon, 23 Feb 2026 18:11:54 +0000

A Blade Runner riff for a world where the lobster ships paid endpoints while humans still argue about the roadmap.

The shift that matters for agent commerce - From “Crypto AI” to general AI

Today, you can search the web all day and never see an invoice.

That happens because you are not the paying client.

The commerce runs through ads, affiliate deals, and platform incentives, so results often optimize for who pays, not for what you asked for.

Unikernel: Profiling and Troubleshooting JVM on Nanos Unikernel

Wed, 11 Feb 2026 13:50:41 +0000

Profiling a Java Application Running Inside an Unikernel with JProfiler

Unikernels are often associated with minimalism and tight resource control.

But can we profile a Java application running inside a unikernel using a standard JVM profiler?

The answer is yes.

In this guide, we will walk step by step through profiling a Quarkus

application running inside a Nanos unikernel using JProfiler and
IBM Semeru JRE 25 (OpenJ9).

No special hacks. Just standard JVM tooling.

JC-AI Newsletter #13

Thu, 05 Feb 2026 21:12:12 +0000

Two weeks have passed, and it is time to present a new collection of readings that may shape developments, utilization or ideas in the field of artificial intelligence in 2026.

While significant activity characterizes the AI field, many unresolved research, design, and implementation challenges continue to impact progress. Future advancement depends heavily on understanding the nature of these challenges to approach probabilistic problems from the appropriate directions. This JC-AI newsletter features insightful interviews with key figures in the field, enabling readers to ask the right questions and compare visions of an ‘uncertain future’ against current capabilities to maintain a grounded perspective.

Bootstrapping a Java File System

Thu, 29 Jan 2026 01:44:32 +0000

So what does file system mean to you? Most think of file systems as directories and files accessed via your computer: local disk, remotely shared via NFS or SMB , thumb drives, something else. Sufficient for those who require basic file access, nothing more nothing less.

That perspective of file systems is too limited: VCS repositories, archive files (zip/jar), remote systems can be viewed as file systems, potentially accessed via the same APIs used to for local file access while still maintaining security and data requirements. Or how about a file system which automatically transcodes videos to different formats or extracts audio metadata for vector searches? Wouldn’t it be cool to use standard APIs rather than create something customized? Definitely!

Announcing bx-ldap: Enterprise LDAP for BoxLang

Tue, 16 Dec 2025 17:01:13 +0000

We’re excited to announce the release of bx-ldap, a comprehensive LDAP module that brings enterprise-grade directory access to BoxLang! This module goes above and beyond traditional CFML LDAP implementations, offering modern features like connection pooling, event-driven programming, multiple return formats, and a clean, intuitive API.

Note: bx-ldap is a premium module available exclusively to BoxLang +/++ subscribers.

🎯 Why?

Whether you’re integrating with Active Directory, OpenLDAP, or any LDAP-compliant directory service, bx-ldap makes it simple and powerful. From basic queries to complex directory operations, this module handles it all with grace and performance.

Java developer's guide : Sync Rules & Stop CI Failures

Tue, 16 Dec 2025 15:53:28 +0000

Hola Java developers! 👋

Welcome back. In Part 1 , we installed SonarQube for IDE in IntelliJ. You are now catching those nasty NullPointerExceptions and Optional.get() risks before they leave your keyboard.

But… you are not working alone. You are part of a team pushing code to a repo full of XML configs, DTOs, and Services.

Here is the nightmare scenario: You spend all day refactoring your Spring Boot service. It looks perfect. You run your tests. They pass. You push it to Git. You grab a coffee. ☕ And then… FAIL. 🔴

Spring Boot 4 - OpenTelemetry Guide

Wed, 10 Dec 2025 09:09:58 +0000

In my previous article , I outlined a comprehensive list of features introduced in Spring Framework 7 and Spring Boot 4.

In this series of articles, we will explore these features in detail using a pragmatic approach. In this second article, I will dive deep into integration of Observability framework i.e., OpenTelemetry with SpringBoot.

As an architect and developer, when I engage in system design—whether it involves monolithic architecture, microservices, or contemporary cloud-native applications—I have made the integration of observability patterns utilizing open-telemetry tools a standard practice. Through observability, we can monitor application behavior via metrics, logs, and traces that we trigger

BoxLang RSS : Full-Featured RSS/Atom Feed Module for BoxLang

Tue, 02 Dec 2025 11:19:11 +0000

We’re thrilled to announce the release of bx-rss, a comprehensive RSS and Atom feed module that brings powerful syndication capabilities to BoxLang ! Whether you’re building a content aggregator, publishing a podcast, or exposing your application’s data as feeds, bx-rss makes it incredibly simple.

Thanks To Ray Camden

I just want to thank you to Ray Camden for his contributions to this module. Thanks Ray! You rock!

Why bx-rss?

In today’s interconnected web, RSS and Atom feeds remain crucial for content distribution and syndication. From blog posts and news articles to podcasts and video channels, feeds power how content flows across the internet. The bx-rss module brings enterprise-grade feed capabilities to BoxLang with an elegant, easy-to-use API.

From Spring Boot To Jakarta EE 11

Fri, 28 Nov 2025 08:11:53 +0000

If you’ve been living in the Spring ecosystem, you’re used to fast project setup. Spring Initializr gives you a sleek interface, some starter dependencies and a running project within minutes. Now you’re moving to Jakarta EE, where do you begin?

In this blog, you’ll see how Spring developers can create Jakarta EE applications with the same ease they’re used to from Spring Initializr.

Let’s be honest: Spring Boot abstracts away so much of the setup pain that you forget it’s even there. You don’t worry about the underlying servlet container, dependency versions or deployment descriptors, as Spring Boot handles it all.

Micrometer & Prometheus in Spring Boot: Kafka Burger Orders

Fri, 14 Nov 2025 10:13:03 +0000

👨‍💻 GitHub: https://github.com/vinny59200/dukeburger

🔵⚪⚪⚪⚪⚪⚪⚪⚪⚪⚪⚪

This guide shows how to use Micrometer and Prometheus in Spring Boot to track a custom metric for a Kafka-driven Burger Orders app. You’ll post a burger order to a REST endpoint, publish it to Kafka, consume the topic, and increment a counter for all “DukeBurger” orders. Copy the snippets, run, and you’ll see your metric on /actuator/prometheus.

JC-AI Newsletter #9

Wed, 12 Nov 2025 15:21:12 +0000

Fourteen days have passed, and it is time to present a fresh collection of readings that could influence developments in the field of artificial intelligence.

This newsletter focuses on examining how AI enhances productivity through enterprise studies, tutorial, agentic system architecture, GraphRAG, evaluating risk methodologies in agentic systems, and the security challenges arising from increased AI-LLM adoption. This edition of the AI newsletter includes a compelling discussion between six of the most influential leaders in artificial intelligence, along with additional content.

JC-AI Newsletter: Easy Access to Expanding Challenges

Tue, 04 Nov 2025 18:13:33 +0000

A few months ago, I launched the AI Newsletter to provide a minimally biased perspective on the growing challenges surrounding artificial intelligence.

My primary motivation was and remains to be serving the community not only by showing how to use and access specific services for utilizing Large Language Models, but also by support a deeper understanding of the broader artificial intelligence landscape.

Many of the core challenges that have emerged around LLMs have not been and still not properly addressed, often omitted due to their uncomfortable implications.

Spring Framework 7 API Versioning Explained

Wed, 29 Oct 2025 06:45:53 +0000

In my previous article , I outlined a comprehensive list of features introduced in Spring Framework 7 and Spring Boot 4.

In this series of articles, we will explore these features in detail using a pragmatic approach. To begin, I will deep dive into the API versioning feature introduced in Spring Framework 7.

Any architectural or feature change stems from evolving business requirements, and API versioning is no exception. In today’s app-driven ecosystem, APIs are central to product integration and user experience.

JC-AI Newsletter #7

Tue, 14 Oct 2025 05:35:01 +0000

Fourteen days have passed, and it is time to present a fresh collection of readings that could influence developments in the field of artificial intelligence.

Beyond focused tutorials that can enhance your understanding of AI applications, this newsletter concentrates on Hallucination, Java Code Generation, Testing, Agentic System Architecture and LLM benchmarking methodologies designed to ensure models accuracy and competency in handling complex contextual information.

The world influenced by LLM is changing very quickly, let’s start…

JC-AI Newsletter #6

Wed, 01 Oct 2025 17:18:16 +0000

Fourteen days have passed, and it is time to present a fresh collection of readings that could influence developments in the field of artificial intelligence.

Beyond opinion pieces and Java focused tutorials that can enhance your understanding of AI applications, this newsletter concentrates on Hallucination, Security, RAG and LLM benchmarking methodologies designed to ensure models accuracy and competency in handling complex contextual information.

The world influenced by LLM is changing very quickly, let’s start…

Payara Server Maven Plugin + AI Agent

Tue, 30 Sep 2025 08:43:20 +0000

Managing Payara Server Just Got Smarter

Imagine managing your Jakarta EE applications not just with Maven goals, but by asking natural questions.

With the experimental AI Agent built into the Payara Server Community’s Maven Plugin, you can now query server internals and perform admin tasks using plain English — directly from the same terminal where you build and deploy your applications.

Thanks to this integration, developers can inspect, query and even execute server commands using natural language. It’s a powerful and intuitive way to interact with Payara Server — no need to remember long command syntax or dig through documentation.

Semantic Caching with SpringBoot & Redis

Thu, 07 Aug 2025 06:58:07 +0000

TL;DR: You’re building a semantic caching system using Spring AI and Redis to improve LLM application performance.

Unlike traditional caching that requires exact query matches, semantic caching understands the meaning behind queries and can return cached responses for semantically similar questions.

It works by storing query-response pairs as vector embeddings in Redis, allowing your application to retrieve cached answers for similar questions without calling the expensive LLM, reducing both latency and costs.

Agent Memory with Spring AI & Redis

Wed, 23 Jul 2025 16:34:04 +0000

You’re building an AI agent with memory using Spring AI and Redis. Unlike traditional chatbots that forget previous interactions, memory-enabled agents can recall past conversations and facts. It works by storing two types of memory in Redis: short-term (conversation history) and long-term (facts and experiences as vectors), allowing agents to provide personalized, context-aware responses.

LLMs respond to each message in isolation, treating every interaction as if it’s the first time they’ve spoken with a user. They lack the ability to remember previous conversations, preferences, or important facts.

Spring Cloud Stream for Real-Time Event-Driven Systems

Mon, 21 Jul 2025 13:33:34 +0000

Envision operating a successful e-commerce platform where every moment is crucial. Customers make purchases, adjust inventory levels, process payments, and dispatch shipping alerts—all in real time. In the background, microservices diligently function to guarantee seamless operations. However, how do these services interact effectively, particularly during peak traffic occurrences such as flash sales or holiday shopping events?

An efficient method to execute this use case involves utilizing Spring Cloud Stream (SCS) as the messaging infrastructure. SCS facilitates seamless interaction among microservices, enhancing the system’s responsiveness and scalability. A significant benefit of SCS is that it provides an abstraction layer, allowing developers to transition between messaging technologies such as Kafka or RabbitMQ or Pulsar or Amazon Kinesis without altering their fundamental business logic.

Carbon Aware Job Processing With JobRunr v8

Mon, 07 Jul 2025 09:00:09 +0000

As we produce, mutate, configure, and consume more and more data in various shapes and forms, think: video on demand, AI ingestion and generation of content, Internet of Things always-on connectivity, and more.

The energy consumption of our digital lives have gone up dramatically as well. We rarely notice this, and although multiple organisations put out alarming reports on energy use of data centres, policy makers seem reluctant to act fast.

How to send prompts in bulk with Spring AI and Virtual Threads

Wed, 21 May 2025 09:18:45 +0000

TL;DR: You’re building an AI-powered app that needs to send lots of prompts to OpenAI.

Instead of sending them one by one, you want to do it in bulk — efficiently and safely.

This is how you can use Spring AI with Java Virtual Threads to process hundreds of prompts in parallel.

When calling LLM APIs like OpenAI, you’re dealing with a high-latency, network-bound task. Normally, doing that in a loop slows you down and blocks threads. But with Spring AI and Java 21 Virtual Threads, you can fire off hundreds of requests in parallel without killing your app.

How to Deploy a Vaadin Application as a WAR on Tomcat 11

Mon, 19 May 2025 07:40:43 +0000

If you want to run a Vaadin application on an external servlet container like Apache Tomcat 11, you need to package your application as a WAR (Web Application Archive) instead of the usual executable JAR.

In this post, I’ll show you step-by-step how I did it.

Step 1: Download Tomcat 11

First, download Tomcat 11 from the official Apache Tomcat website . After extracting it to a local folder, you have a clean Tomcat installation ready to use.

Building a Real-Time AI Fraud Detection System with Spring Kafka and MongoDB

Wed, 14 May 2025 14:30:08 +0000

In this tutorial, we’ll build a real-time fraud detection system using MongoDB Atlas Vector Search, Apache Kafka, and AI-generated embeddings. We’ll demonstrate how MongoDB Atlas Vector Search can be used to detect anomalies in a stream of financial transactions by analyzing a user’s transaction history and identifying suspicious behavior based on LLM-generated embeddings.

Our solution will monitor MongoDB Change Streams using the Java synchronous driver, triggering vector searches on each new transaction to detect potential fraud. While this approach works well for our demo, and for many use cases, we’ll also discuss its limitations. Throughout the tutorial, I’ll cover alternative strategies to optimize performance, whether you need higher transaction throughput, faster fraud detection, or a more scalable architecture.

Supercharge Your Jakarta EE Skills with These Must-Read Guides

Wed, 30 Apr 2025 09:49:03 +0000

If you’re working with Jakarta EE — or just starting to explore the power of enterprise Java — there’s never been a better time to level up your skills. Whether you’re building your first servlet, designing secure REST APIs, or diving deep into dependency injection, the Jakarta EE community has been busy crafting an outstanding collection of starter and specification guides to help you get up to speed.

At Omnifish, we’re proud supporters of the open-source enterprise Java ecosystem, and we’re constantly pointing developers toward the best resources. So we’ve gathered up some of the most practical and insightful Jakarta EE guides to help you go from “Hello, World” to production-ready applications with confidence.

Optimizing the Garbage Collector when Migrating Cloud Workloads

Wed, 16 Apr 2025 10:27:49 +0000

You might associate Arm primarily with smartphones and the Java-based Android runtime. However, OpenJDK has supported AArch64 on Linux since 2014— before Arm-based cloud instances were widely available. Fast forward a decade and major cloud providers have their own Arm-based instances like AWS Graviton, Microsoft Azure Cobalt, and others, prompting many organizations to migrate Java workloads from x86 to multi-architecture environments.

A multi-architecture deployment shift allows an organization to be adaptable and choose the architecture with the ideal price to performance ratio. Large independent software vendors, such as Uber, are already making this transition .

Clean your Memory: From Finalize to Cleaner

Mon, 31 Mar 2025 12:30:08 +0000

Garbage collection in Java takes care of memory management, but it does not clean up non-memory resources like sockets or file handles.

Resource leaks may occur without proper management, leading to performance degradation or crashes.

Java’s Cleaner API , introduced in Java 9, provides a modern and efficient mechanism for resource cleanup when objects are no longer reachable.

It addresses the shortcomings of the deprecated finalize() method, offering a predictable and efficient way to manage non-memory resources: so let’s take a short trip on clean memory from finalize to Cleaner API.

Extending Java APIs - Add Missing Features Without the Hassle

Fri, 07 Mar 2025 12:03:57 +0000

The Java API is vast. That’s great, but sometimes a missing method or capability can be frustrating. With Manifold, developers can solve this problem without having to wait for Java to add a feature in a later version. Even more importantly, Manifold provides many such extensions out of the box, making Java better for developers. In this post, we will discuss the extension capability. It lets us change classes in the Java API in a compatible way without risk. If Java adds these APIs later then we can seamlessly switch to them.

Spring Cloud Stream: Demystifying Event-Driven Architecture

Fri, 28 Feb 2025 08:34:32 +0000

Consider a bustling restaurant environment. The kitchen receives a flood of orders, waitstaff dart between tables, and patrons anxiously glance at their watches. Each time a waiter takes an order, he or she must verify it with the kitchen and wait for the kitchen to prepare the meal before attending to another table. This cumbersome method hampers efficiency, leaving the restaurant unable to meet customer demand.

Now envision an alternative situation. Instead of enduring delays, waitstaff enter orders into a centralized system, prompting the kitchen to begin meal preparation immediately upon receipt. As soon as the kitchen prepares the food, waiters receive instant notifications, enabling them to serve customers promptly without any delays. This exemplifies event-driven architecture: a fluid, real-time system where they exchange information asynchronously, promoting scalability and quick responsiveness.

Front End Debugging Part 3: Networking

Thu, 27 Feb 2025 16:34:04 +0000

Network Debugging Powerhouse
Re-Issuing and Modifying Requests
- cURL and Postman
Throttling and Debugging Race Conditions
- Why Throttling Matters:
- How to Use
Managing State with Storage Tools
- Challenges of State Management
Analyzing Request and Response Headers
Debugging in Incognito Mode: Limitations and Best Practices
Connecting the Front-End to the Database
Final Word

Debugging network communication issues is a critical skill for any front-end developer. While tools like Wireshark provide low-level insight into network traffic, modern browsers like Chrome and Firefox offer developer tools with powerful features tailored for web development. In this post we will discuss using browser-based tools to debug network communication issues effectively. This is a far better approach than using Wireshark for the vast majority of simple cases.

Building a declarative API with Spring AOP and SpEL

Wed, 12 Feb 2025 15:57:11 +0000

In this article, we’ll implement a declarative API to perform tasks belonging to cross-cutting concerns, using auditing as an example. We’ll see how SpEL and Spring AOP allow us to easily intercept invocations throughout a code base and perform arbitrary logic in an expressive and non-invasive manner.

A story about legacy

Let’s pretend that we inherited a legacy system. The system is in a dismal state, with every change always at risk of bringing the whole thing down. One day, there is a business requirement to audit a few dozen methods scattered throughout the code base. After every invocation of these methods, we should notify an external system by sending a client id and an operation (1234, "CREATE_USER").

Sliding Window Log Rate Limiter (Redis & Java)

Tue, 04 Feb 2025 12:21:56 +0000

This article is also available on YouTube. Check it out!

The Sliding Window Log is a more precise way to handle rate limiting. Instead of splitting time into fixed intervals like the Fixed Window Counter , it keeps a log of timestamps for each request. This allows it to track requests over a rolling time period, like the last second or minute, without abrupt resets at the end of an interval.

My first steps with Playwright

Thu, 30 Jan 2025 11:58:04 +0000

In my previous company, I developed a batch job that tracked metrics across social media, such as Twitter, LinkedIn, Mastodon, Bluesky, Reddit, etc. Then I realized I could duplicate it for my own “persona”. The problem is that some media don’t provide an HTTP API for the metrics I want.

Here are the metrics I want on LinkedIn:

I searched for a long time but found no API access for the metrics above. I scraped the metrics manually every morning for a long time and finally decided to automate this tedious task. Here’s what I learned.

Project Loom: Structured Concurrency - Java

Wed, 29 Jan 2025 12:12:38 +0000

In today’s era of cloud computing, where high-performance infrastructure is readily available, developers face a complex challenge in achieving efficient concurrency.

While modern technological advancements have brought us closer to solving these challenges, we must adopt a thoughtful, incremental approach to concurrency.

This principle holds especially true as we strive to design scalable, reliable, and easy-to-maintain systems.

One such advancement in this domain is structured concurrency, a paradigm that simplifies concurrent programming by bringing order and predictability to task management.

Make the life of your developer client's easier with smart builders

Thu, 09 Jan 2025 11:49:51 +0000

We often hear the phrase: “Make the life of your client easier”. But, what about the developers? They are the ones who will be working with the code you write. It is important to make their lives easier too.

Despite the target customer of your solution, you’ll be creating code that will be maintained by other developers and, sometimes, it may include you as well. Choosing good approaches and techniques will make their life, or your life, easier probably.

AI-powered Chat Application using watsonx.ai and Spring AI

Fri, 03 Jan 2025 08:31:51 +0000

Generative Artificial Intelligence (Gen AI) disrupted enterprises with the introduction of GPT-4 foundation model by Open AI in the late 2022 to early 2023 triggering big tech to release their own Gen AI platform and foundation models. Among them are Google, Microsoft, AWS and IBM. In this article, we will deal with the Gen AI platform and model of IBM called watsonx and integrate it with Spring AI to create a custom chat application using the IBM Granite Foundation Model.

Front End Debugging Part 2: Console.log() to the Max

Tue, 03 Dec 2024 16:28:40 +0000

Understanding Front-End Logging vs. Back-End Logging
Leveraging Console Log Levels
Customizing Console Output with CSS
Stack Tracing with console.trace()
Assertions for Design-by-Contract
Printing Tables for Clearer Data Visualization
Copying Objects to the Clipboard
Inspecting with console.dir() and dirxml()
Counting Function Calls
Organizing Logs with Groups
Chrome-Specific Debugging Features
Final Word

In my previous article , I talked about why Console.log() isn’t the most effective debugging tool. In this installment, we will do a bit of an about-face and discuss the ways in which Console.log() is fantastic. Let’s break down some essential concepts and practices that can make your debugging life much easier and more productive.

strace Revisited: Simple is Beautiful

Tue, 26 Nov 2024 14:58:28 +0000

Understanding strace and its Origins
- A Look Back: strace and dtrace
- Originating from Sun Microsystems
Technical Functioning of strace
- The Role of ptrace in strace
- Comparing with DTrace
Practical Usage and Advantages
- Ease of Use and Accessibility
- Favored in Linux Environments
strace in Action: A Closer Look at System Calls
- Basic Usage and Output Analysis
- Interpreting System Calls for Debugging
Advanced Features and Tips
- Filtering System Calls for Efficiency
- Exploring a Variety of System Calls
strace and Java: A Special Case
- strace with the JVM
- Allocations and Threading in Java
Final Word

In the realm of system debugging, particularly on Linux platforms, strace stands out as a powerful and indispensable tool. Its simplicity and efficacy make it the go-to solution for diagnosing and understanding system-level operations, especially when working with servers and containers.

In this article, we’ll delve into the nuances of strace, from its history and technical functioning to practical applications and advanced features. Whether you’re a seasoned developer or just starting out, this exploration will enhance your diagnostic toolkit and provide deeper insights into the workings of Linux systems.

Langchain4J Musings

Sat, 23 Nov 2024 13:57:30 +0000

I’m coming relatively late to the LLM party, but I rarely come very early in the hype cycle.

For example, I never bought into blockchain, the solution still searching for problems to solve, nor in microservices, the latest in the cargo cult IT trends. Despite my late arrival at the LLM party, I have been a regular user of LLMs. I use OpenAI for non-controversial questions outside my cone of knowledge, e.g., linguistics or legal; I use GitHub Copilot in my IDE to improve my code.

Spring Boot: Java Template Engine (JTE)

Wed, 13 Nov 2024 09:03:00 +0000

Hello to all Java and Spring enthusiasts. I am the Java Template Engine, a fresh newcomer to the Spring Initializer Ecosystem.

I have gained popularity as a template engine for developing user interface applications that use Java syntax within Spring Boot applications, alongside other engines such as Freemarker, Thymeleaf, Mustache, and Velocity. Many developers widely use Spring Boot, a framework that simplifies Java application development, and incorporating a template engine like mine streamlines the process of creating dynamic and responsive user interfaces.

Front End Debugging Part 1: Not just Console Log

Tue, 05 Nov 2024 14:01:45 +0000

Instant Debugging with the debugger Keyword
Triggering Debugging from the Console
DOM Breakpoints: Monitoring DOM Changes
XHR Breakpoints: Uncovering Hidden Network Calls
Simulating Environments for Debugging
Debugging Layout and Style Issues
- Final Word

As a Java developer, most of my focus is on the backend side of debugging. Front-end debugging poses different challenges and has sophisticated tools of its own. Unfortunately, print-based debugging has become the norm in front-end. To be fair, it makes more sense there as the cycles are different and the problem is always a single user problem. But even if you choose to use Console.log, there’s a lot of nuance to pick up there.

The Art of Full Stack Debugging

Fri, 25 Oct 2024 07:24:06 +0000

Full Stack Development, A Shifting Definition
- The Full Stack Debugging Approach
Frontend Debugging: Tools and Techniques
Debugging Across Layers
Conclusion

Full stack development is often likened to an intricate balancing act, where developers are expected to juggle multiple responsibilities across the frontend, backend, database, and beyond. As the definition of full stack development continues to evolve, so too does the approach to debugging.

Full stack debugging is an essential skill for developers, as it involves tracking issues through multiple layers of an application, often navigating domains where one’s knowledge may only be cursory. In this blog post I aim to explore the nuances of full stack debugging, offering practical tips and insights for developers navigating the complex web of modern software development.

Book Review: Mastering the Java Virtual Machine

Fri, 18 Oct 2024 13:54:49 +0000

Otávio Santana’s “Mastering the Java Virtual Machine” takes readers on an insightful journey through the inner workings of the JVM. As I read this book, I found myself reconnecting with the fundamentals of Java programming while also discovering new depths of understanding.

The book strikes a perfect balance between nostalgia and innovation. It reminded me of my early programming days, while also introducing cutting-edge concepts that are crucial for modern Java development. Santana uses clever technical metaphors to make complex JVM internals more accessible, bridging the gap between theory and practical application.

Deep dive into bits, bytes, shorts, ints, longs, signed, and unsigned with Java

Fri, 18 Oct 2024 13:54:09 +0000

On the Pi4J discussion list, someone recently asked what the best and easiest way is in Java to convert a byte value . In Java, there is no distinction between signed and unsigned bytes, which can be confusing. My book “Getting Started with Java on the Raspberry Pi” contains an explanation about this, and I am happy to share it in this post with some more info and code examples…

Unleashing the Power of Git Bisect

Tue, 08 Oct 2024 08:15:50 +0000

The Essence of Debugging with Git
Setting the Stage for Debugging
Advanced Usage and Tips
Unraveling a Regression Mystery
Final Word

We don’t usually think of Git as a debugging tool. Surprisingly, Git shines not just as a version control system but also as a potent debugging ally when dealing with the tricky matter of regressions.

TornadoVM for RISC-V Accelerators

Thu, 19 Sep 2024 07:50:28 +0000

Takeaways

RISC-V is an open standard instruction set architecture that anyone can use to build new processors and accelerators, for example, for AI.
oneAPI Construction Kit (OCK) is a new framework that allows software developers and system designers to bridge the gap between hardware accelerators and open standards, by enabling a programming system to implement domain specific instructions for modern hardware such as RISC-V accelerators and custom processors.
TornadoVM, a parallel programming framework for Java, can take advantage of OCK to offload and accelerate Java workloads on RISC-V chips. This post shows how to run on RISC-V CPUs with vector extensions.

Introduction

RISC-V is an open standard instruction set architecture (ISA) based on the principles of reduced instruction sets (RISC). RISC-V is freely available under open licences, allowing anyone to design, modify and implement RISC-V processors.

Get recognized for your cloud-native Java development skills

Thu, 29 Aug 2024 16:08:34 +0000

In a world where in-demand skills are critical for job success, security, and progression, it’s vital that we, as developers, ensure we are showcasing our skills to the wider world. This can include qualifications, courses, and badges, all of which help us to advertise our skills and highlight our professional experiences and expertise.

So, to help make this easier (and free!) for Java developers, the Open Liberty team created the first-ever Liberty badge: Liberty Developer Essentials !

Debugging Kubernetes - Troubleshooting Guide

Mon, 26 Aug 2024 16:45:45 +0000

Table of Contents

Identifying Configuration Issues
- Common Causes and Solutions
- Detailed Investigation Steps
Dealing with Image Pull Errors
- Troubleshooting Steps
Handling Node Issues
- Preventive Measures
Managing Missing Configuration Keys or Secrets
Utilizing Buildg for Interactive Debugging
Conclusion

As Kubernetes continues to revolutionize the way we manage and deploy applications, understanding its intricacies becomes essential for developers and operations teams alike. If you don’t have a dedicated DevOps team you probably shouldn’t be working with Kubernetes.

Spring: Internals of @ComponentScan

Tue, 20 Aug 2024 14:48:28 +0000

The @ComponentScan annotation, which is an interface located within the org.springframework.context.annotation package, facilitates component scanning in a Spring application. This allows the Spring Container to automatically detect beans.

Spring automatically identifies Java classes that developers mark with stereotypes like @Configuration, @Component, @Service, @Controller, and @Repository. Developers can annotate the component scan with or without parameters.

You can designate either basePackageClasses() or basePackages() (or its equivalent value()) to identify the specific packages that need to be scanned.

Allocation Profiling in Java

Fri, 09 Aug 2024 08:44:59 +0000

Read in other languages : 中文 Español Português

We often find ourselves in situations when code is not working properly, and we have no idea where to even begin investigating.

Can’t we just stare at the code until the solution eventually comes to us? Sure, but this method probably won’t work without deep knowledge of the project and a lot of mental effort. A smarter approach would be to use the tools you have at hand. They can point you in the right direction.

Failure is Required: Understanding Fail-Safe & Fail-Fast Strategies

Tue, 30 Jul 2024 08:08:33 +0000

Fail-Fast
Fail-Safe
Choosing Between Fail-Fast and Fail-Safe
Redefining Failure
- Data Corruption
- Don’t Fix the Bug
Debugging Failure
- Avoiding Cascading Failure
Hybrid in Production
Final Word

Failures in software systems are inevitable. How these failures are handled can significantly impact system performance, reliability, and the business’s bottom line.

In this article, I want to discuss the upside of failure. Why you should seek failure, why failure is good and why avoiding failure can reduce the reliability of your application. We will start with the discussion of fail-fast vs. fail-safe, this will take us to the second discussion about failures in general.

Mastering Serverless Debugging

Mon, 29 Jul 2024 10:14:26 +0000

Introduction to Serverless Computing
Challenges of Serverless Debugging
Effective Strategies for Serverless Debugging
Debugging a Lambda Application Locally with AWS SAM
Final Word

Serverless computing has emerged as a transformative approach to deploying and managing applications. The theory is that by abstracting away the underlying infrastructure, developers can focus solely on writing code.

Continuous Feedback Free Udemy Course: Additional Coupons Available

Thu, 18 Jul 2024 08:24:55 +0000

We’ve added extra coupons for our free Continuous Feedback Udemy course! We’re glad to see it’s been valuable for some of you.

Introduction to Continuous Feedback

What do you know about the code changes that were just introduced into the codebase?

When will you notice if something goes wrong?

Continuous Feedback focuses on analyzing observability data, namely logs, traces, and metrics. It emphasizes continuous aggregation and processing to detect anomalies, changes, and provide actionable insights for developers.

Wireshark & tcpdump: A Debugging Power Couple

Mon, 08 Jul 2024 14:51:05 +0000

Introduction to Wireshark
- Browser Network Monitors
Installation and Getting Started
Navigating Through Noise with Filters
Deep Dive into Data Analysis
Beyond Basic Usage
- The Basics of HTTPS Encryption
- Methods for Decrypting HTTPS in Wireshark
  - Pre-Master Secret Key Logging
  - Using a Proxy
Integrating tcpdump with Wireshark for Enhanced Network Analysis
The Role of tcpdump in Network Troubleshooting
Final Word

Wireshark, the free open-source packet sniffer and network protocol analyzer, has cemented itself as an indispensable tool in network troubleshooting, analysis, and security (on both sides).

Java: Demystifying The Stream API

Fri, 05 Jul 2024 06:57:34 +0000

In our earlier articles part1 and part2 , we have previously explored the significance of functional programming, Lambda Calculus, as well as various features such as Functional Interfaces, Lambda Expressions, and Method References.

This article delves into a crucial aspect, namely the Stream API, which JDK1.8 incorporated. It also covers how to utilize Lambda Expressions, Method References, and Functional Interfaces within Stream API functions.

So,

Succinctly, In Java, a Stream is a collection of data that developers can process on in a declarative and functional approach.

A Beginner's Guide to IntelliJ Profiler

Thu, 04 Jul 2024 06:26:35 +0000

Read in other languages: 中文 Español Português

Sometimes your app works, but you want to increase performance by boosting its throughput or reducing latency. Other times, you just want to know how code behaves at runtime, determine where the hot spots are, or figure out how a framework operates under the hood.

This is a perfect use case for profilers. They offer a bird’s eye view of arbitrarily large execution chunks, which helps you see problems at scale.

Step up your coding with Continuous Feedback: Free Udemy Course

Tue, 02 Jul 2024 06:57:02 +0000

What do you know about the code changes that were just introduced into the codebase? When will you notice if something goes wrong?

What is Continuous Feedback?

First, let me explain Continuous Feedback. It’s a new dev practice that aims to make practical usage of code runtime data to shorten the feedback loop during development.

OpenTelemetry makes it possible with great library support and a standard spec for tracing, metrics, and more. I truly feel that practicing CF can enhance your development experience, and we decided to share with Foojay the course for free.

Master Your Journey in the School of OpenJDK Migration

Sun, 30 Jun 2024 09:46:03 +0000

Azul has led so many OpenJDK migrations, we could write a book. Like, seriously, we wrote the book . If you prefer more a more visual, immersive experience, welcome to the School of OpenJDK Migration!

The School of OpenJDK Migration is your ultimate resource for mastering OpenJDK migration. Dive into our rich collection of webinars, where OpenJDK experts divulge their secrets, from foundational knowledge to advanced tactics, derived from industry knowledge and professional experience. You’ll leave the course with a blueprint to navigate the complexities of OpenJDK migration with confidence and ease.

Why is Kubernetes Debugging so Problematic?

Thu, 20 Jun 2024 06:37:37 +0000

The Immutable Nature of Containers
The Limitations of kubectl exec
Avoiding Direct Modifications
Enter Ephemeral Containers
- Using kubectl debug
Practical Application of Ephemeral Containers
Security Considerations
Interlude: The Role of Observability
Command Line Debugging
Connecting a Standard IDE for Remote Debugging
Conclusion

Debugging application issues in a Kubernetes cluster can often feel like navigating a labyrinth. Containers are ephemeral by design, intended to be immutable once deployed.

This presents a unique challenge when something goes wrong and we need to dig into the issue. Before diving into the debugging tools and techniques, it’s essential to grasp the core problem: why modifying container instances directly is a bad idea.

Hack a Java application with the debugger

Thu, 13 Jun 2024 04:58:03 +0000

Read in other languages: 中文 Español Português

Back in the day, computer games were different. Not only have graphics and mechanics evolved since, but there’s also one characteristic that doesn’t seem very common in games today: nearly all of them had cheat codes.

Cheat codes were sequences of keys that would give you something extraordinary, such as infinite ammo or the ability to walk through walls. The most common and powerful of them was ‘god mode’ – it made you invincible.

Java: Functional Programming f(x) – Part2

Mon, 03 Jun 2024 17:05:56 +0000

In the preceding article , we explored the significance of Functional Programming, Lambda Calculus, and other related concepts.

In this article, we delve deeper into the essential aspects of Functional Programming, such as…

1. Lambda Expressions 2. Method References 3. Functional Interfaces

And we will discuss about the relationship between each of the features.

JSR 335 has greatly facilitated programming in a multicore environment by introducing Lambda Expressions/closures/anonymous method, and related features.

The TornadoVM Programming Model Explained

Tue, 28 May 2024 11:01:14 +0000

Key Takeaways

TornadoVM offers an API for parallel programming on modern hardware that tackles data parallel, task parallel and pipeline parallel applications.
TornadoVM offers different abstractions to developers to be able to express parallel applications in Java, identify the methods to offload, and dispatch the application on the corresponding accelerators.
Task-Graphs and Execution Plans are the main building blocks of TornadoVM applications, allowing developers to compose complex graphs of computations and interact with the TornadoVM runtime to enable/disable profiling, enable debugging, or enable dynamic reconfiguration to select the best possible accelerators for the compute graphs.

In this blog post, I will explain how developers can start programming with TornadoVM and interact with the TornadoVM runtime.

Learn how to debug unresponsive Java/JVM applications, then reload the fix on the fly, using a hands-on example

Thu, 23 May 2024 07:14:31 +0000

Read in other languages: 中文 Español Português

There are a lot of debugger tutorials out there that teach you how to set line breakpoints, log values, or evaluate expressions. While this knowledge alone gives you a lot of tools for debugging your application, real-world scenarios may be somewhat trickier and require a more advanced approach.

In this article, we will learn how to locate code that causes a UI freeze without much prior knowledge of the project and fix faulty code on the fly.

Task scheduler in Java: background job processing with JobRunr

Wed, 22 May 2024 11:05:04 +0000

What is JobRunr

Task scheduler in Java

JobRunr is an open-source Java library for task scheduling and distributed background job processing. It offers an effortless way to perform background tasks using only Java 8 lambdas.

Whether it is a fire-and-forget , scheduled or recurring job , JobRunr analyzes the lambda and stores the metadata needed to process the job in a database. This simple architecture, with a few other mechanisms, allows a job to be executed on any available server running your application (👋 k8s).

Software Testing as a Debugging Tool

Wed, 15 May 2024 07:43:43 +0000

The Intersection of Debugging and Testing
The Debug-Fix Cycle
Composing Tests with Debuggers
Test-Driven Development
Final Word

Debugging is not just about identifying errors—it’s about instituting a reliable process for ensuring software health and longevity. In this post we discuss the role of software testing in debugging, including foundational concepts and how they converge to improve software quality.

As a side note, if you like the content of this and the other posts in this series check out my Debugging book that covers t his subject. If you have friends that are learning to code I’d appreciate a reference to my Java Basics book. If you want to get back to Java after a while check out my Java 8 to 21 book .

Crowd-Publishing the 10x Java Dev Book

Thu, 02 May 2024 07:17:58 +0000

Java transformed the world of software development as we know it and continues to evolve as a platform and language. Nevertheless, the “enlightenment roadmap ” of a Java developer can be scary. How do you become the 10x Java Developer you always dreamed of becoming?

That’s the question Steve Poole and Olimpiu Pop embarked on to respond. And, what better way to achieve it than to tap into the best resource Java has: its community!

Functional Programming: Revolutionizing Software Development

Thu, 25 Apr 2024 17:43:17 +0000

Mathematics serves as the driving force behind significant advancements in computer science from my perspective. We deeply root the fundamental principles that we utilize in our daily programming tasks and application development in mathematical concepts. I am constantly intrigued by the opportunity to incorporate mathematical ideas into the programming languages I work with as a student of Mathematics.

Many other programming paradigms, like functional programming, take inspiration from Mathematics to address challenges related to concurrency and parallelism. Computing shifts towards utilizing multiple cores and distributed systems, which makes this increasingly important.

Debugging Using JMX Revisited

Thu, 18 Apr 2024 13:02:35 +0000

The Need for Advanced Management Tools in Development
- Introduction to JMX (Java Management Extensions)
  - Understanding MBeans
- Spring and Management Beans
Tooling for JMX Management
- Getting Started with JMXTerm
Leveraging JMX in Debugging and Management
Exposing MBeans in Spring Boot
Final Word

Debugging effectively requires a nuanced approach, similar to using tongs that tightly grip the problem from both sides.

Debugging Streams with Peek

Fri, 05 Apr 2024 08:05:34 +0000

Table of Contents

Understanding Java Streams
- A Simple Stream Example
What is the peek() Method?
- Debugging with peek()
Uncovering Common Bugs with peek()
- Filtering Issues
- Large Data Sets
  - Addressing Side Effects
Limitations and Pitfalls
Final Thoughts

I blogged about Java Stream debugging in the past but I skipped an important method that’s worthy of a post of its own: peek.

Localize applications with AI

Wed, 20 Mar 2024 08:50:29 +0000

Read in other languages: 中文 Español Português

Ever wondered if AI can localize an entire project? In this article, we follow the process end-to-end using the Spring Petclinic as an example. We prepare the project for localization, automate the translation using Python and DeepL, and analyze the results

Whether you are thinking of localizing your project or just learning how to do that, AI might help you. It offers a cost-efficient entry point for experiments and automations.

Run JavaFX on the Windows Subsystem for Linux and More!

Tue, 12 Mar 2024 16:11:56 +0000

What does it take to run standalone JavaFX applications on exotic Linux systems like the Windows Subsystem for Linux or some embedded systems? As you will see, not a lot! Familiarizing yourself with the native libraries required by JavaFX and the font loading process is all that is needed. Then, JavaFX applications can run on them out of the box if you set everything up correctly.

Most graphical Linux systems will automatically come with all the native libraries that are required by Java(FX) as these are pretty standard. Running a standalone Java(FX) application, which has been created with jlink or jpackage for example, on these systems works without having to put in any thought about possible dependencies. However, there are systems where this is not the case.

DTrace Revisited: Advanced Debugging Techniques

Tue, 13 Feb 2024 07:46:04 +0000

DTrace Overview
Understanding DTrace’s Capabilities
Performance and Compatibility of DTrace
- Cross-Platform Compatibility
- Compatibility Challenges on MacOS
Customizability and Flexibility of DTrace
- Adaptability to Various Scenarios
- Examples of Customizable Probes
Real-World Applications of DTrace
- Final Words

When we think of debugging, we think of breakpoints in IDEs, stepping over, inspecting variables, etc.

However, there are instances where stepping outside the conventional confines of an IDE becomes essential to track and resolve complex issues. This is where tools like DTrace come into play, offering a more nuanced and powerful approach to debugging than traditional methods.

API Versioning

Mon, 22 Jan 2024 09:00:23 +0000

In my previous article Evolving your APIs , I mention the main API versioning approaches. During the talk of the same name, I sometimes get some questions on the subject. In this article, I’ll detail each of them.

I assume readers know the reasons behind versioning, semantic versioning, and product lifecycle. If not, I encourage you to read a bit about these themes; in particular, chapter 24 of the excellent API Design Patterns book focuses on them.

Integrate executable Java code in your blog posts, part 2: How to use dependencies

Fri, 15 Dec 2023 10:07:55 +0000

In a previous post, we explained how you can add executable Java code to your posts here on Foojay , by using JDoodle. In this post, you will learn how you can extend this with one or more libraries.

Define Dependencies

To integrate Java code in your post or page that needs dependencies, you need to specify them in the initial div with data-libs.

<div data-pym-src='https://www.jdoodle.com/plugin' 
 data-language="java" 
 data-version-index="4"
 data-client-id="34d6e81ae45d88cdb9fb98fed1415b81" 
 data-libs="mavenlib1,mavenlib2">
 <div data-type="script"><xmp>

 // This is the place to put your Java code

 </xmp></div>
</div>
<script src="https://www.jdoodle.com/assets/jdoodle-pym.min.js" type="text/javascript"></script>

The data-client-id can only be used for the Foojay website! Create your own account on the JDoodle site if you want to use this functionality on another website.

Creating Executables For JavaFX Applications

Fri, 08 Dec 2023 13:46:50 +0000

Here on Foojay, you can already find some great articles on how to create native executables from your JavaFX code:

Let’s take a look in this article at the current state of what can be done with jpackage and GitHub Actions.

All the sources and workflow files used here can be found in the JavaPackageDemo repository .

The Theory of Debugging

Mon, 04 Dec 2023 09:18:49 +0000

In the landscape of software development, bugs are an inevitable part of the journey, and debugging, albeit frustrating at times, is an integral part of the process. There’s no escaping this truth, and the sooner we embrace it, the sooner we can master the art of debugging.

In the next few posts in this series, I will explain the little-known “theory” behind debugging. We all know the practice of debugging (to some degree) but there is also a theoretical underpinning that most of us never learned in University (I sure as hell didn’t). Understanding this theory will help you apply a more methodical approach to problem resolution and will improve your understanding of your code.

Feedback from calling Rust from Python

Wed, 22 Nov 2023 10:32:55 +0000

I got plenty of feedback on my post about Calling Rust from Python :

Many comments mentioned pyo3, and I should use it instead of cooking my own. Thanks to the authors, I checked: in this post, I explain what it is and how I migrated my code.

What is pyo3?

Rust bindings for Python, including tools for creating native Python extension modules. Running and interacting with Python code from a Rust binary is also supported.

Explore project structure with IntelliJ IDEA's Dependency Matrix

Mon, 20 Nov 2023 10:28:01 +0000

In this tutorial, we’ll look at exploring project structure with IntelliJ IDEA ’s Dependency Matrix.

When working with large, complex software projects, we need to understand the dependencies between components in your projects. IntelliJ IDEA has a feature called Dependency Structure Matrix (DSM ), or Dependency Matrix, that can help us with this.

When you are new to a project, the Dependency Matrix can help you get an overview of the dependencies in the project. The Dependency Matrix can also help us get an idea of how hard it will be to split a project, based on the dependencies between components. Finally, it can help us find and untangle cyclic dependencies.

Integrate executable Java code in your blog posts

Tue, 07 Nov 2023 14:49:57 +0000

While developing the Foojay Quickstart Java Tutorial , I was looking for an easy way to integrate runnable Java code examples into the Foojay pages and blogs. That’s when I discovered jdoodle.com . I started by using their online editor, but with this blog I want to show you an even easier method to integrate runnable code here on Foojay.

Integration examples

Single file code

To integrate “plain” Java code in your post or page, use the following syntax and add it as “Custom HTML” widget:

Python "magic" methods - part 2

Fri, 03 Nov 2023 09:15:44 +0000

Let’s continue our exploration of Python’s magic methods in this second part of the series. This part will focus on numbers and containers, i.e. , collections. You can read the first part here .

Python provides the usual containers, e.g., lists, sets, and dictionaries. You can use the following methods when you want to implement your own.

Common methods

Containers have a size. Python defines two methods to implement to return the number of items in a container: object.__len__(self) for the exact size and object.__length_hint__(self) for an approximation. You should use the latter when getting the exact size is computationally expensive.

Python "magic" methods - part 1

Fri, 03 Nov 2023 09:08:42 +0000

Java was the first language I used professionally and is the scale by which I measure other languages I learned afterward. It’s an statically-typed language. Hence, Python feels a bit weird because of its dynamic typing approach.

For example, Object offers methods equals(), hashCode(), and toString(). Because all other classes inherit from Object, directly or indirectly, all objects have these methods by definition.

Conversely, Python was not initially built on OOP principles and is dynamically typed. Yet, any language needs cross-cutting features on unrelated objects. In Python, these are specially-named methods: methods that the runtime interprets in a certain way but that you need to know about. You can call them magic methods.

Not a Single Trace

Fri, 20 Oct 2023 07:06:31 +0000

The Limiting Factor
Strength in Numbers
Example
Magical APIs
Final Word

Your team celebrates a success story where a trace identified a pesky latency issue in your application’s authentication service. A fix was swiftly implemented, and we all celebrated a quick win in the next team meeting. But the celebrations are short-lived. Just days later, user complaints surged about a related payment gateway timeout. It turns out that the fix we made did improve performance at one point but created a situation in which key information was never cached. Other parts in the software react badly to the fix and we need to revert the whole thing.

Debugging Tips and Tricks: A Comprehensive Guide

Mon, 09 Oct 2023 07:12:23 +0000

Rubber Ducking: The Art of Talking it Out
Moving the Goalposts: Redefining the Bug
- The Evolution of a Bug
- The Process of Redefinition
Flipping the Direction: Multiple Angles of Attack
- The Linear Approach to Debugging
Disruptive Environments: Exposing Hidden Bugs
Leveraging Debugging Extensions and Tools
Disconnect and Reconnect: The Power of a Fresh Mindset
Embrace the Challenge: Finding Joy in Debugging
- Strategies to Embrace the Debugging Challenge
Use a Process
Conclusion

Debugging is an integral part of software development.

The Systemic Process of Debugging

Thu, 28 Sep 2023 07:06:14 +0000

The Importance of Issue Tracking
- Avoiding Parallel Work on the Same Bug
- The Value of Issue Over Pull Requests
Communication: Issue Tracker vs. Ephemeral Channels
- Why We Sometimes Avoid the Issue Tracker
- The Role of Daily Meetings
The Role of Testing in Debugging
- Starting with Unit Tests
- Unit Tests vs. Integration Tests
Final Word

Debugging is an integral part of software development. However, as projects grow in size and complexity, the process of debugging requires more structure and collaboration. This process is probably something you already do as this process is deeply ingrained into most teams.

Eliminating Bugs Using the Tong Motion Approach

Fri, 22 Sep 2023 14:53:39 +0000

Understanding the Process of Elimination in Debugging
- The Basics
- Using External Tools
The Power of Unit Tests in Debugging
- Benefits of Mocking Frameworks
The Challenges with Flaky Issues
The Concept of the ‘Tong Motion’
- Applying the Tong Motion to Debugging
An Illustrative Case: Debugging a Server Performance Issue
Wrapping Up

Software debugging can often feel like a never-ending maze. Just when you think you’re on the right track, you hit a dead-end. But, by employing the age-old technique of the process of elimination, and using the analogy of the ‘Tong Motion,’ we can navigate this maze more effectively.

Monkey-patching in Java

Thu, 21 Sep 2023 07:34:22 +0000

The JVM is an excellent platform for monkey-patching.

Monkey patching is a technique used to dynamically update the behavior of a piece of code at run-time. A monkey patch (also spelled monkey-patch, MonkeyPatch) is a way to extend or modify the runtime code of dynamic languages (e.g. Smalltalk, JavaScript, Objective-C, Ruby, Perl, Python, Groovy, etc.) without altering the original source code.

– Wikipedia

I want to demo several approaches for monkey-patching in Java in this post.

Manage Different Java Versions on Your Machine with SDKMan!

Wed, 20 Sep 2023 07:05:16 +0000

So, you’re a Java developer, or maybe you’re aspiring to be one. Either way, you’ve probably faced the challenge of managing multiple versions of Java on your machine. One project requires Java 8, but another needs Java 11, yet another requires Java 17. The open-source library you’re keen on contributing to needs yet another version. What do you do? You start juggling environment variables, and before you know it, your system is a tangled mess of configurations. Not fun, right?

Exposing your data using Spring GraphQL

Tue, 19 Sep 2023 05:25:46 +0000

In this article, we’ll take an introductory look at how we can use Spring GraphQL in our Java applications. GraphQL is a query language (hence the QL) that in conjunction with a framework such as Spring GraphQL can be used to efficiently manage our data, and even reuse existing services.

It has 2 core concepts:

queries: used to define which data should be fetched, and which fields thereof should be included
mutations: used to manage our dataset

It’s an alternative to REST, SOAP, or gRPC, and supports calls over HTTP, WebSocket and RSocket.

Building Real-Time Applications to Process Wikimedia Streams

Fri, 15 Sep 2023 14:33:16 +0000

In this tutorial, developers, solution architects, and data engineers can learn how to build high-performance, scalable, and fault-tolerant applications that react to real-time data using Kafka and Hazelcast.

We will be using Wikimedia as a real-time data source. Wikimedia provides various streams and APIs (Application Programming Interfaces) to access real-time data about edits and changes made to their projects.

For example, this source provides a continuous stream of updates on recent changes, such as new edits or additions to Wikipedia articles. Developers and solution architects often use such streams to monitor and analyze the activity on Wikimedia projects in real-time or to build applications that rely on this data, like this tutorial.

ArchUnit - test your architecture

Thu, 14 Sep 2023 14:09:56 +0000

ArchUnit is a library that allows us to test our architecture (layering/slicing/(naming) conventions, and more).

Why does this matter? It’s all about leaving a legacy and safeguarding it. During the lifecycle of a project, people might shift roles, join the team, … And might not be aware of the conventions within the team/organization.

Testing your architecture is both an aid to ascertain that the architecture is being implemented consistently and also makes it easier for people onboarding to get a grasp of what that agreed architecture is.

The Evolution of Bugs

Tue, 12 Sep 2023 03:34:48 +0000

Memory Management: The Past and The Present
Concurrency: A Double-Edged Sword
The Pervasiveness of State Bugs
Exceptions: The Noisy Neighbor
Faults: Beyond the Surface
Thread Bugs: Unraveling the Knot
Race Conditions: Always a Step Ahead
Performance Pitfalls: Monitor Contention and Resource Starvation
Final Word

Programming, regardless of the era, has been riddled with bugs that vary in nature but often remain consistent in their basic problems. Whether we’re talking about mobile, desktop, server, or different operating systems and languages, bugs have always been a constant challenge. Here’s a dive into the nature of these bugs and how we can tackle them effectively.

Load testing - shoot your application with Gatling

Wed, 06 Sep 2023 09:32:29 +0000

What is load testing?

Load testing entails testing how our application performs under a significant load so we can be certain it behaves as expected when there’s an influx of users.

Or at least so we know what it can cope it, and at what point we might potentially need to take action.

After all, it might not (only) be the code that’s the issue.

This is a process that requires quite a bit of cooperation between testers, developers, and those using it to properly determine the scenarios, and a smooth & swift feedback loop is important to make sure our solutions work properly. And it will likely be some of the most expensive tests given both the people involved and the need for a testing environment that’s representative of the production configuration.

Spring Boot Configuration for Docker Images with Azul Zulu

Wed, 30 Aug 2023 16:14:52 +0000

The Spring Boot Maven Plugin makes creating a Docker image from your application very easy! In this article, we give you some extra tips and examples for configuring Spring Boot to define the Java runtime used in such a Spring Boot Docker image and explain how to add additional environmental options to ease debugging.

For this post, I got the help of DaShaun Carter , Spring Developer Advocate, who immediately jumped in when I raised some questions about these configuration options. Thanks, DaShaun!

Spring Boot Petclinic Project

To illustrate our approach, we’ll use the Spring Boot Petclinic project, a Spring Boot application built using Maven or Gradle, to demonstrate how a Spring Boot project is set up fully and how the code is structured and must be packaged.

Debugging as a Process of Isolating Assumptions

Wed, 23 Aug 2023 08:16:22 +0000

Debugging is an integral part of any software development process.

It’s a systematic hunt for bugs and mistakes that may be hidden in the intricate lines of your code.

Much like a hunter and its prey, it requires a precise method and a set of specific tools.

Let’s delve deeper into the fascinating process of isolating assumptions to effectively debug your code.

Before I proceed with this week’s post if you have friends who are learning to code… I published a new book for Java beginners with no prior knowledge (for learning programming from scratch). Each chapter also has an accompanying video and I think there’s no book quite like it for beginners. I would appreciate spreading the word on this.

Exploring File Storage Solutions in Spring Boot

Wed, 23 Aug 2023 08:07:19 +0000

When building a web application, managing file uploads properly is a common requirement. After receiving, files can be stored in several places: in a file system, in a database or, more commonly, in a cloud storage service.

In this article, we will cover how to store files in a database using Spring Boot and discuss some alternatives.

Introduction

Recently, a fellow developer who I helped in past reached out to me on Slack seeking assistance with handling file uploads in a Spring Boot application. After providing some guidance, I decided to compile this article to assist others facing similar challenges.

Introduction to the Tower Library

Tue, 22 Aug 2023 08:28:33 +0000

One of the components of my OpenTelemetry demo is a Rust application built with the Axum web framework. In its description, axum mentions:

axum doesn’t have its own middleware system but instead uses tower::Service. This means axum gets timeouts, tracing, compression, authorization, and more, for free. It also enables you to share middleware with applications written using hyper or tonic.

– axum README

So far, I was happy to let this cryptic explanation lurk in the corner of my mind, but today is the day I want to understand what it means. Like many others, this post aims to explain to me and others how to do this.

AI-based Images generation with Quarkus and OpenAI DALL.E

Mon, 21 Aug 2023 07:38:07 +0000

In this article, we explore how to integrate OpenAI API with Quarkus. We will create a Quarkus application using the new REST Client Reactive to invoke the OpenAI DALL.E API for images generation.

OpenAI API Overview

Before jumping into the code, let’s explore the OpenAI Create Image API and how it works.

Create Image Request

The body request is made of the following parameters:

prompt: the only required parameter is the description of the desired image (max 1000 characters)
n: number of desired images (from 1 to 10)
size : the size of a generated image (default 1024x1024, also admitted 256x256, 512x512)
other parameters are:
response_format: to specify the response image format (default url, also admitted b64_json)
user: identifier to track user activities.

To authenticate with the API, we’ll generate an API key . We’ll set this key in the Authorization header while calling the API.

Pitest: Do You Test Your Tests?

Tue, 15 Aug 2023 14:32:55 +0000

What is Pitest?

Pitest is a library that helps us do mutation testing.

Mutation testing is a process in which random variations of the code under test are generated.

Hence, our tests will run against variants of the code that we’re intending to test.

If the test fails, the mutation is killed, if it still passes it lives. So in subsequent runs, you will see this mutation once again. Surviving mutations may indicate issues with our test set since application code changes should lead to different end results, and thus to failing tests. So to further reduce the survivors we will need to enhance our test cases and/or add extra.

Can't Reproduce a Bug?

Mon, 14 Aug 2023 07:09:14 +0000

The phrase “it works on my machine” can be a source of amusement, but it also represents a prevailing attitude in the world of development - an attitude that often forces users to prove bugs before we’re willing to investigate them. But in reality, we need to take responsibility and chase the issue, regardless of where it takes us.

A Two-Pronged Approach to Bug Solving

Solving bugs requires a two-pronged approach. Initially, we want to replicate the environment where the issue is occurring; it could be something specific to the user’s machine. Alternatively, we may need to resort to remote debugging or use logs from the user’s machine, asking them to perform certain actions on our behalf.

Working with GitLab Merge Requests in IntelliJ IDEA

Thu, 10 Aug 2023 09:57:10 +0000

In this tutorial, we will take a look at working with GitLab Merge Requests inside IntelliJ IDEA.

When reviewing Merge Requests in a web interface, we don’t have the same support that our IDE gives us, like syntax highlighting and the context within which the code was written.

IntelliJ IDEA has support for reviewing and merging GitLab Merge Requests. These features are available if the IntelliJ IDEA project has a remote that points to GitLab.

Sealed Interfaces & Pattern Matching: Java's Modern Capabilities

Wed, 09 Aug 2023 07:01:51 +0000

Sealed classes in Java are a new feature that provides a way to restrict the classes that can inherit from a superclass or extend an interface. This new language feature enhances the encapsulation and provides more control to developers over their codebase.

In this tutorial, we will explore sealed classes, how to use them to find all subclasses, and how to apply pattern matching in a practical context.

Let’s start with a basic interface definition named Shape.

Starting Apache Kafka on Java 8, Win 10

Mon, 07 Aug 2023 09:39:39 +0000

This is part 2 of a two part series on Starting Apache Kafka Server, Configuring Kafka Topic, and Creating a Core Java Based Kafka Consumer, as also a Core Java Based Kafka Producer.

All this is demonstrated in step-by-step examples. All of this is for Java v8.0, Apache Kafka v3.4 on Windows 10. Part 1 focused on Kafka Consumer and Kafka Producer from the Command Line. This article focuses on the Core Java counterparts. It is important that the reader reads part 1 and completes the example so that the reader has a basic foundation in Kafka.

Temperature, humidity, and pressure in BME280 Sensors with Java

Thu, 03 Aug 2023 07:16:36 +0000

To make it as easy as possible to get started with Java on the Raspberry Pi to interact with electronic components, I started a new section on the Pi4J website with JBang examples .

In this tutorial, I want to show you how you can read the temperature, humidity, and pressure from a BME280 Sensor.

What Is Used?

As explained on the websites of each project:

Pi4J

A friendly object-oriented I/O API and implementation libraries for Java Programmers to access the full I/O capabilities of the Raspberry Pi platform. This project abstracts the low-level native integration and interrupt monitoring to enable Java programmers to focus on implementing their application business logic.

Starting Apache Kafka v3.4 on Win 10

Sat, 29 Jul 2023 07:43:32 +0000

Introduction

This is part one of a two part articles series on Running Apache Kafka Server, Configuring Kafka Topics, and Creating a Kafka Consumer and Kafka Producer.

All this is demonstrated step-by-step example that works from the Command Line.

All of this is for Apache Kafka v3.4 on Windows 10.

Pre-Requisites

Install Java ( v8.0 is used in this Example )
Install Apache Kafka v3.4.0 from the Given Link
Set Java Classpath > Set JAVA_HOME Correctly
UnZIP/UnTAR Apache Kafka Downloaded in (2)
Use a Text Editor like [ Notepad++ ] for Editing

Building for Failure: Best Practices for Easy Production Debugging

Fri, 21 Jul 2023 15:29:09 +0000

Before going into the content of this post, check out my new book which launched last week!

Quite a few years ago I was maintaining a database-driven system and ran into a weird production bug.

The column I was reading from had a null value, but this wasn’t allowed in the code and there was no place where that value could have been null.

The database was corrupt in a bad way and we didn’t have anything to go on.

How to Create an Open Source Pull Request (PR)

Wed, 19 Jul 2023 11:26:23 +0000

In this tutorial, we are going to take a look at contributing to Open Source Software, specifically how to do a pull request (PR).

We will look at forking and cloning the project, making the changes, committing and pushing these changes, creating the pull request, the review and hopefully merge of your PR.

The same process may apply when making contributions to a project at work that you don’t own. In this example, the project is on GitHub. Other Git code repositories may use a similar process.

Dive into the OpenJDK: Top 10 Reads on Foojay.io

Wed, 19 Jul 2023 07:45:04 +0000

Foojay.io is a community platform dedicated to the needs of Java developers (and beyond, e.g., Kotlin) who use OpenJDK and related technologies.

It serves as a central hub for sharing knowledge, resources, and tools related to Java and OpenJDK.

The platform offers a wide range of content, including articles, tutorials, and insights from industry experts and Java enthusiasts.

Whether you’re a seasoned developer or a beginner in the world of Java, Foojay.io provides valuable information and a supportive community to help you navigate and excel in your Java development journey.

GraphQL, JavaScript, Preprocessor, SQL and more in Manifold

Mon, 17 Jul 2023 12:42:59 +0000

We reached the final installment of our Manifold series but not the end of its remarkable capabilities.

Throughout this series, we have delved into various aspects of Manifold, highlighting its unique features and showcasing how it enhances Java development.

In this article, we will cover some of the remaining features of Manifold, including its support for GraphQL, integration with JavaScript, and the utilization of a preprocessor.

By summarizing these features and reflecting on the knowledge gained throughout the series, I hope to demonstrate the power and versatility of Manifold.

How to Share Your Work With a Video or Podcast

Fri, 14 Jul 2023 09:22:11 +0000

Season 2 of the Foojay Podcast has come to an end. Since September of ‘22, 22 episodes where published here on Foojay.

In this article, we want to share some of the experiences of creating such podcasts, but also more generally, how you can share your work in a video with a small (or bigger) budget…

Audio

There is one fundamental rule for the audio: “Garbage in = Garbage out.”

Yes, you can apply many filters and effects in a later phase, but you can’t make a bad recording sound good. You need a clear and good recording as a starting point!

Reactive Programming Made Easy

Fri, 14 Jul 2023 08:47:11 +0000

This article discusses essential features and tools in IntelliJ IDEA for Reactor developers. These include live templates, a dedicated debug mode, and a couple of inspections.

We’ve got all of the project Reactor adepts and enthusiasts out there covered! Whether you’re a seasoned pro or just taking your first steps in the field, IntelliJ IDEA will make reactive coding a breeze. It simplifies the complexities of Reactive Streams, ensuring a smooth and efficient experience for all skill levels.

Enterprise Java Applications With Jakarta EE and Vaadin

Wed, 12 Jul 2023 09:26:07 +0000

Watch this webinar recording to get an overview of the Vaadin framework and learn how to use it to build modern web applications on the Jakarta EE Platform in pure Java, without any frontend framework.

Find out more about the core features of Jakarta EE, like its dependency injection (Jakarta CDI) and persistence (Jakarta Persistence) APIs. Additionally, you will learn how to use Vaadin and Jakarta EE to build responsive web applications that can run on different devices and browsers.

Understanding Security Vulnerabilities: Preventing Attacks

Thu, 06 Jul 2023 12:49:42 +0000

When I was a teenager, our local telephone company introduced a new service - the premium phone calls (AKA 1-900 numbers).

The fun part was that we discovered a workaround to these charges by dialing the sequential local numbers which these 1-900 numbers would redirect to.

If the “support number” for the 1-900 was 555-555 we would dial every number between 555-455 and 555-655 until we hit the jackpot…

Hours were spent dialing these numbers, leading us to make numerous calls for free. This attack is still prevalent today, and it’s called Insecure Direct Object References (IDOR).

Billions of Messages Per Minute Over TCP/IP

Wed, 05 Jul 2023 21:05:08 +0000

Key Takeaways

Data consistency is critical when communicating between software components on different machines to ensure information remains in tact.
Low-latency data exchange requires a different approach than common formats.
Chronicle’s open-source Wire library provides a highly efficient means of marshalling and unmarshalling data for transmission to and from Chronicle Queue.
Recent additions to the library extend its use with TCP/IP communications channels, offering extremely high throughput.
Using Wire across TCP/IP opens up the possibility of Cloud Native deployment of Chronicle-based applications.

Introduction

One of the most important issues when building distributed applications is that of data representation. We must ensure that data sent by a component to a “remote” component (i.e. one that is part of a different process) is received correctly, with the same values. This may seem straightforward but remember that the communicating components may have been written in completely different languages.

Upgrade to Jakarta EE 10 and GlassFish 7: Easier Than You Think!

Tue, 27 Jun 2023 07:29:48 +0000

Upgrading to Jakarta EE 10 from an older version of Jakarta EE or Java EE can be a bit tricky and may require some extra attention to detail. But don’t worry, we’ve got you covered!

In this series of articles, we’ll explain everything you need to know before upgrading to Jakarta EE 10 and guide you to complete the upgrade successfully and in almost no time.

Types of challenges

The challenges with upgrading to Jakarta EE 10 or to Eclipse GlassFish 7 fall into these 3 main categories:

Introducing the Foojay.io Calendar API

Thu, 22 Jun 2023 06:40:22 +0000

We are excited to share that Foojay is growing and offering additional resources to bring the Java and OpenJDK community together on a global scale.

Several months ago, we launched the Foojay Calendar , an interactive platform that allows individuals to propose Java-related and Kotlin-related and any other OpenJDK-related events and add them to the calendar.

All Foojay members are welcome to submit their events. Once reviewed, the event will be included in the calendar.

Building Custom Solutions vs. Buy-and-Build Software

Wed, 21 Jun 2023 14:41:33 +0000

The Challenges of Building a FIX Engine

The first day I was introduced to Financial Information eXchange (FIX) was when I worked at an investment bank in London as a developer.

I was told to write a feed handler to retrieve market data.

Bear in mind that at this time, I knew nothing about FIX, apart from Googling it for about 10 mins on the internet.

With a touch of overconfidence and slight arrogance, I set to work coding a direct socket connection to the remote FIX endpoint, “how hard could it be?”

Exploring Java 21's Intriguing Additions (Part 1)

Tue, 20 Jun 2023 13:40:21 +0000

Introduction:

Java 21 is going to introduce several intriguing additions that enhance the language’s capabilities.

This article aims to discuss a few notable features that stand out, providing an overview of their functionalities and potential use cases.

Character Enhancements:

Character.isEmoji(int codePoint): This method determines whether a character is considered an emoji based on its Unicode properties defined in Unicode Emoji (Unicode Emoji Technical Standard #51 ). For example, executing Character.isEmoji(9203) would return true for the character ⏳, which has the code point 9203.
Character.isEmojiPresentation(int codePoint): Similar to isEmoji(), this method checks if a character has the Emoji Presentation property. It helps identify characters that display as emojis when rendered.

Example:

Manifold vs. Lombok: Enhancing Java with Property Support

Mon, 19 Jun 2023 18:04:59 +0000

Today, we’ll explore an intriguing aspect of Manifold: its property support.

In comparison, we’ll also examine Lombok, a popular library that offers similar features.

By analyzing the differences between these two projects, we can gain insight into their core philosophies and advantages.

Let’s dive in and discover how Manifold’s property support stands out.

As always, you can find the code examples and additional resources for this post on my GitHub page .

Operator Overloading in Java

Sat, 10 Jun 2023 12:19:26 +0000

In this article, we’ll delve into the fascinating world of operator overloading in Java.

Although Java doesn’t natively support operator overloading, we’ll discover how Manifold can extend Java with that functionality.

We’ll explore its benefits, limitations, and use cases, particularly in scientific and mathematical code.

We will also explore three powerful features provided by Manifold that enhance the default Java type safety while enabling impressive programming techniques.

We’ll discuss unit expressions, type-safe reflection coding, and fixing methods like equals during compilation.

Java String Templates Today

Fri, 02 Jun 2023 16:28:25 +0000

In our last article , we introduced you to the Manifold project and how it offers a revolutionary set of language extensions for Java, including the ability to parse and process JSON files seamlessly in Java.

Today, we will take a look at another exciting feature of the Manifold project: string templates.

But before we get to that, some of the feedback I got from the previous post was that I was unclear about Manifold. Manifold is a combination of an IDE plugin and plugins to Maven or Gradle.

Java is Very Fast, If You Don’t Create Many Objects

Thu, 01 Jun 2023 04:45:56 +0000

This article looks at a benchmark passing events over TCP/IP at 4 billion events per minute using the net.openhft.chronicle.wire.channel package in Chronicle Wire and why we aim to avoid object allocations.

One of the key optimisations is creating almost no garbage. Allocation is supposed to be a very cheap operation and garbage collection of very short lived objects is also very cheap.

Does not allocating really make such a difference? What difference does one small object per event (44 bytes) make to the performance in a throughput test where GC pauses are amortised?

Boosting Similarity Search with Real-time Stream Processing

Tue, 30 May 2023 12:42:35 +0000

The goal of similarity search and vector databases is to find similar results to the search query for unstructured data, such as text, images and videos. The unstructured data first is vectorised, and stored in a vector format. There are publicly available tools to create vectors from unstructured data, similarly, there are vector databases to store and perform similarity searches. This is important because of the rising popularity of Large Language Models (LLMs) and their combination with vector databases.

Revolutionize JSON Parsing in Java with Manifold

Fri, 26 May 2023 17:39:19 +0000

Java developers have often envied JavaScript for its ease of parsing JSON.

Although Java offers more robustness, it tends to involve more work and boilerplate code.

Thanks to the Manifold project, Java now has the potential to outshine JavaScript in parsing and processing JSON files.

Manifold is a revolutionary set of language extensions for Java that completely changes the way we handle JSON (and much more…).

Getting Started with Manifold

The code for this tutorial can be found on my GitHub page . Manifold is relatively young but already vast in its capabilities. You can learn more about the project on their website and Slack channel.

Rolling Binary Trees: A Guide to Common Design Patterns in Java

Wed, 24 May 2023 12:55:14 +0000

Introduction

Binary trees are fundamental data structures, ubiquitous in computer science and software engineering. We use them to represent hierarchical data and implement more complex data structures, such as search trees, syntax trees, cryptographic hash trees, space partitioning trees, heaps, and so on. Common binary tree operations include insertion, deletion, traversal, and rotation.

A relatively uncommon and unexplored operation is roll , which modifies the structure of a binary tree in such a way that, when visualized, the newly obtained structure appears to be rolled at a 90-degree angle, either clockwise or counterclockwise. This gives us two variants of the roll operation — clockwise roll (CR) and counterclockwise roll (CCR).

Enriching Kafka Applications with Contextual Data

Thu, 18 May 2023 15:11:22 +0000

Developing high-performance large-stream processing applications is a challenging task.

Choosing the right tool(s) is crucial to get the job done; as developers, we tend to focus on performance, simplicity, and cost.

However, the cost becomes relatively high if we end up with two or more tools to do the same task.

Simply put, you need to multiply development time, deployment time, and maintenance costs by the number of tools.

Kafka

Kafka is great for event streaming architectures, continuous data integration (ETL), and messaging systems of record (database).

Monitoring Event Loops for Blockages

Mon, 15 May 2023 16:42:18 +0000

Chronicle’s open source Chronicle Threads library has a little known feature which is one of the first tools I get from my bag if a client reports that they are seeing latency outliers.

The usual way that a developer will measure their system for latency hotspots is to use a profiler, and modern profilers are amazing; there are numerous commercially available, but I generally find myself using Java Flight Recorder, async-profiler, or honest-profiler. These three are engineered to avoid the safepoint bias , and thus give very accurate results.

Analyzing dependencies in IntelliJ IDEA

Thu, 11 May 2023 09:33:40 +0000

If you’re working on a real world project, you’re probably using external dependencies.

You might need to analyze which dependencies your application uses.

For example, you may want to find out how a particular version of a dependency ended up in your application.

Let’s take a look at how IntelliJ IDEA can help you to analyze dependencies.

We can view our dependencies in the Maven or Gradle tool window.

Here, we can expand dependencies to show their transitive dependencies, or collapse them again.

Spring Boot Debugging with Aspect-Oriented Programming (AOP)

Fri, 05 May 2023 08:19:18 +0000

Aspect-Oriented Programming (AOP) is a programming paradigm that aims to increase modularity by allowing the separation of cross-cutting concerns.

In simple terms, it helps you keep your code clean, modular, and easy to maintain.

We can leverage AOP to debug Spring Boot applications more effectively and seamlessly.

In this post, we will explore how to use AOP to debug a Spring Boot application effectively.

AOP Concepts

Before diving into debugging with AOP, it is essential to understand the core concepts. AOP lets us write code that executes before or after a method. It includes the following common terms:

Creating Scalable OpenAI GPT Applications in Java

Thu, 27 Apr 2023 14:18:45 +0000

One of the more notable aspects of ChatGPT is its engine, which not only powers the web-based chatbot but can also be integrated into your Java applications.

Whether you prefer reading or watching, let’s review how to start using the OpenAI GPT engine in your Java projects in a scalable way, by sending prompts to the engine only when necessary:

Imagine you want to visit a city and have a specific budget in mind. How should you spend the money and make your trip memorable? This is an excellent question to delegate to the OpenAI engine.

Relearning Java Thread Primitives

Tue, 25 Apr 2023 05:26:16 +0000

I’ve coded in Java since the first beta, even back then threads were at the top of my list of favorite features.

Java was the first language to introduce thread support in the language itself, it was a controversial decision back then.

In the past decade, every language raced to include async/await and even Java had some third-party support for that …

But Java zigged instead of zagging and introduced the far superior virtual threads (project Loom) . This article isn’t about that.

Hidden Beauties of Java Enums

Tue, 11 Apr 2023 07:02:08 +0000

Let’s take a look at the power and beauty of what Java Enums can provide…

I also created a video describing the same topics based on this article, so you can follow along combining both the video and this post.

What is an Enum?

Enums are the preferred way to define fixed values you want to use in your code. They are a special type of Java class and contain a group of unchangeable variables.

Cherry-Pick: Move a Commit to a Different Branch

Wed, 05 Apr 2023 13:53:20 +0000

There are several reasons why you might want to move a commit to a different branch.

Let’s take a look at some of them.

Committed to the wrong branch

You’re working on a new feature, but an urgent bug came in.

You fixed the bug and committed the fix, but oops… you forgot to create a new branch for the bugfix!

Now this bugfix is on the wrong branch. How do we fix this? Bugfix commit is on the wrong branch

DevOps For Developers: Continuous Integration, GitHub Actions

Tue, 04 Apr 2023 07:35:12 +0000

I first ran into the concept of Continuous Integration (CI) when the Mozilla project launched.

It included a rudimentary build server as part of the process and this was revolutionary at the time.

I was maintaining a C++ project that took 2 hours to build and link.

We rarely went through a clean build which created compounding problems as bad code was committed into the project.

A lot has changed since those old days.

Writing a Profiler in 240 Lines of Pure Java

Thu, 30 Mar 2023 07:14:46 +0000

A few months back, I started writing a profiler from scratch, and the code since became the base of my profiler validation tools.

The only problem with this project: I wanted to write a proper non-safepoint-biased profiler from scratch.

This is a noble effort, but it requires lots C/C++/Unix programming which is finicky, and not everyone can read C/C++ code.

For people unfamiliar with safepoint bias: A safepoint is a point in time where the JVM has a known defined state, and all threads have stopped. The JVM itself needs safepoints to do major garbage collections, Class definitions, method deoptimizations, and more. Threads are regularly checking whether they should get into a safepoint, for example, at method entry, exit, or loop backjumps. A profiler that only profiles at a safepoint have an inherent bias because it only includes frames from the locations inside methods where Threads check for a safepoint. The only advantage is that the stack-walking at safepoints is slightly less error-prone, as there are fewer mutations of heap and stack. For more information, consider reading the excellent article Java Safepoint and Async Profiling by Seetha Wenner, the more technical one by JP Bempel , or the classic article Safepoints: Meaning, Side Effects and Overheads by Nitsan Wakart. To conclude: Safepoint-biased profilers don’t give you a holistic view of your application, but can still be helpful to analyze major performance issues where you look at the bigger picture.

Watch Area and Renderers

Sat, 25 Mar 2023 07:25:03 +0000

This is it. The debugging book is live . I would really appreciate reviews and feedback!

I also finished recording and editing the entire course .

There are 50 total videos which total in 7 hours… I also recorded additional videos for the two other free courses for beginners and for modern Java .

So keep an eye on those!

Renderers

In today’s video we discuss one of my favorite obscure IDE features: renderers. Very few people are aware of them. I explained them in the past but I feel I didn’t properly explain why they are so much better than any other alternative. This time I think I got the explanation right.

How to Build and Deploy a Real-time Cloud-based Logging System

Fri, 24 Mar 2023 15:04:51 +0000

Logs and traces generated by applications are valuable sources of information that can help detect issues and improve performance.

However, they are often treated separately from other data, even though they are no different from the data an application works with.

In this tutorial, we will explore a different approach: treating logs and traces as part of a scalable cloud storage repository that can be analysed with the same techniques used for big data.

5 Great Reasons to use jOOQ

Wed, 22 Mar 2023 14:45:13 +0000

Hi, I’m Lukas . I was invited to talk about the business behind jOOQ on Foojay.io and as a short introduction to jOOQ , I’d like to highlight 5 great reasons to use it.

Before discussing those reasons:

What is jOOQ

jOOQ is an internal domain-specific language (DSL) modelling the SQL language as an API directly in Java.

This provides compile-time type safety to your query and enables a lot of other interesting features that I’ll show later.

Efficient Memory Mapping for Terabyte Sparse Files in Java

Wed, 15 Mar 2023 11:50:41 +0000

On Linux, you can create sparse files , where only the pages (of 4 KiB) that are touched utilise either memory or disk space.

This allows you to memory map large virtual regions without worrying about wasted memory or disk

In this program, you can see it reserves 8 TiB (8,192 GiB)

Figure 1. Test 1: Sparse file

Tip: x << y means x × 2y therefore:

1L << 10 = 1 KiB (1024 bytes),
1L << 20 = 1 MiB (10242 bytes),
1L << 30 = 1 GiB (10243 bytes),
1L << 40 = 1 TiB etc

Using multiples of 10 for the shift makes them easier to read.

How Gradle Works: Inside the Daemon

Tue, 14 Mar 2023 11:27:52 +0000

Previously in the How Gradle Worksseries:

How Gradle Works: Startup

This is the second article of the series How Gradle Works.

In this article, we’ll explain what happens inside the Gradle Daemon JVM.

Why Do We Need Gradle Daemon?

In the last article , we mentioned that Gradle starts a Gradle Daemon JVM (“the daemon”) to run the build.

The userguide explains why we need the daemon.

The Daemon is a long-lived background process that reduces the time it takes to run a build. The Daemon reduces build times by caching project information across builds, running in the background so every Gradle build doesn’t have to wait for JVM startup, benefiting from continuous runtime optimization in the JVM, and watching the file system to calculate exactly what needs to be rebuilt before you run a build.

Getting Started with IntelliJ IDEA

Mon, 13 Mar 2023 08:26:00 +0000

First up, I havecreated a tutorial on the IntelliJ IDEA Guide if you want to view the content with videos. I’ll concentrate on text-based for this article.

When someone new joins your team, it can be quite an overwhelming experience.

There are lots of people to meet, new technologies to learn, different processes to learn and of course, an IDE to learn!

It’s helpful to remember what every new starter wants, they want to make a difference, they want to add value, they want to move the needle.

How to Get Started with the Hazelcast Viridian Serverless

Fri, 10 Mar 2023 10:28:45 +0000

In this tutorial, you’ll learn how to build real-time streaming applications with the Hazelcast Viridian Serverless using SQL.

You’ll also learn how to build a materialized view from streaming data and contextual data in Hazelcast.

Streaming data is data that is continuously generated in small sizes.

Streaming data includes a wide variety of sources such as retail purchases, financial trades, or telemetry from connected vehicles.

This data isn’t usually useful by itself because of its size.

How to Best Use Java Records as DTOs in Spring Boot 3

Thu, 09 Mar 2023 17:06:46 +0000

With the Spring 6 and Spring Boot 3 releases, Java 17+ became the baseline framework version.

So now is a great time to start using compact Java Records as Data Transfer Objects (DTOs ) for various database and API calls.

Whether you prefer reading or watching, let’s review a few approaches for using Java records as DTOs that apply to Spring Boot 3 with Hibernate 6 as the persistence provider.

Is it Time to go Back to the Monolith?

Fri, 03 Mar 2023 15:58:20 +0000

History repeats itself. Everything old is new again and I’ve been around long enough to see ideas discarded, rediscovered and return triumphantly to overtake the fad.

In recent years SQL has made a tremendous comeback from the dead. We love relational databases all over again. I think the Monolith will have its space odyssey moment again. Microservices and serverless are trends pushed by the cloud vendors, designed to sell us more cloud computing resources.

42 Practical Java Design Patterns: Builder and More

Mon, 27 Feb 2023 08:27:06 +0000

Figure 1.: Hone your software design skills

The aim of the article is to introduce my newly published book “Practical Design Pattern for Java Developers”.

Together, we’ll explore today’s application development challenges and dive deeper into some of Java’s new language enhancements by exploring the Builder Design pattern in more detail.

The days when applications were developed “ad hoc” seem to have ended only on paper.

How to Get Started with the Hazelcast Viridian Serverless

Wed, 22 Feb 2023 08:13:32 +0000

Hazelcast Serverless means that Hazelcast manages your Cloud infrastructure for you.

Each Viridian Serverless cluster is an independent deployment of Hazelcast Platform in a Kubernetes container.

This design guarantees resource isolation, prevents resource stealing, and provides isolated network access.

Viridian Serverless clusters come in two types:1) Development: Capped storage.

You can store at most 1 GiB of data; and 2) Production: Uncapped storage.

The cluster scales as you add or remove data. In this tutorial, you’ll learn how to connect a client to a cluster and use SQL to query data in the cluster.

Web App Startup in 3ms with RIFE2 and GraalVM

Tue, 21 Feb 2023 09:12:55 +0000

RIFE2 applications already launch quickly with a regular JVM thanks merely calling Java methods, lambdas and doing object instantiations at startup. There are no annotations to scan for, nor any declarations or config files to parse and resolve.

The RIFE2 v1.3.0 release introduced experimental support for GraalVM Ahead-Of-Time compilation with native-image, reducing the startup time of the bootstrap project from 177ms to an incredible 3ms.

Try it out yourself

In order to try this out, you can download the latest GraalVM JDK 19 distribution, and follow the steps to install native-image on your machine.

What are you Missing by Debugging in VS Code?

Fri, 17 Feb 2023 16:20:16 +0000

In the first chapter of my debugging book, I discuss IDE debugging.

In that chapter, I mostly talk about IntelliJ/IDEA.

People often ask me why I didn’t write as much about VS Code…

The reason is that there isn’t much to write about. Its debugger is simpler for better and for worse. It isn’t as powerful as other IDEs. I created the following video that covers the content of this post:

How to Find & Fix Vulnerabilities with IntelliJ IDEA Ultimate

Mon, 13 Feb 2023 09:09:39 +0000

In this article, we’re going to take a look at the Package Checker plugin , that’s bundled with IntelliJ IDEA Ultimate .

We’ll have a look at how to view known vulnerabilities in your Maven or Gradle projects, how to get more information about the known vulnerabilities in a specific dependency and how to remediate these vulnerabilities inside IntelliJ IDEA Ultimate if a new version with a fix is available.

Remote Debugging Dangers and Pitfalls

Fri, 10 Feb 2023 10:14:47 +0000

This is the last part of the debugging series, to learn the rest you’ll need to get the book or the course .

One of the most frequently asked questions I receive is: can we do these things in VS Code?

The answer is unfortunately no. But I elaborate on the debugging capabilities of VS Code in this video . I’ll do a blog post that covers that next week.

Below is the last video in the series:

How Gradle Works: Startup

Thu, 09 Feb 2023 08:45:57 +0000

This is the first article of a series How Gradle Works, which includes the following topics:

How Gradle starts up
How many JVMs are involved in a Gradle build
What happens in each JVM during the build

We’ll explain the first topic How Gradle Starts Up in this blog.

Before reading on, we assume you are familiar with basic JVM/Gradle concepts (jar, classpath, wrapper, daemon, project, task, etc.).

How Gradle Starts Up

There are many ways to start a Gradle build:

Debugging Threads and Asynchronous Code

Fri, 03 Feb 2023 10:07:22 +0000

I’m doing a community interview in the Code Ranch drop by and ask a question to win a free book!

This week we’ll discuss one of the harder problems in programming: threading. For many cases threading issues aren’t as difficult to debug. At least not in higher abstractions.

Asynchronous programming is supposed to simplify the threading model but oftentimes it makes a bad situation worse by detaching us from the core context.

Real-time Stream Processing with Hazelcast and StreamNative

Wed, 01 Feb 2023 09:09:04 +0000

Introduction

One of the most useful features of real-time stream processing is to combine the strengths and advantages of various technologies to provide a unique developer experience and an efficient way of processing data in real time at scale.

Hazelcast is a real-time distributed computation and storage platform for consistently low latency queries, aggregation and stateful computation against real-time event streams and traditional data sources.
Apache Pulsar is a real-time multitenant geo-replicated distributed pub-sub messaging and streaming platform for real-time workloads handling millions of events per hour.

However, real-time stream processing is not an easy task, especially when combining multiple live streams with large volumes of data stored in external data storages to provide context and instant results.

How Java Litters Beyond the Heap: Solid-State Drives

Fri, 27 Jan 2023 10:54:47 +0000

A Java application dutifully executes your logic, leaving behind footprints in the Java heap in the form of dead objects.

A garbage collector will then step in and clean out the memory for the new data. This cycle repeats until the app is stopped. This is well known.

But, the Java heap is one of many places where your app can generate garbage.

The application can also litter other parts of the software stack. It’s not done deliberately, but because some stack components also take advantage of garbage collection.

Release with JReleaser to Maven Central with GitHub Actions

Wed, 18 Jan 2023 08:55:48 +0000

This guide is outdated since 2024. There is a new version here: https://foojay.io/today/how-to-publish-a-java-maven-project-to-maven-central-using-jreleaser-and-github-actions-2025-guide/

{#more-61688}

This article is a tutorial that guides you through the process of releasing a Java module with JReleaser to Maven Central with Github Actions.

JReleaser is a tool that streamlines the release process for Java projects, allowing developers to quickly and efficiently publish their modules to Maven Central.

If you just want to publish your Maven project by hand, then you can follow How to Publish a Java Maven Project to the Maven Central Repository by @Tobias Briones .

JTest: Roll Out Your Own JUnit-Like Testing Framework

Tue, 17 Jan 2023 16:11:50 +0000

In this interactive tutorial and educational project, you’ll be helped in your understanding of the following.

A basic insight into JUnit internals.
The usage of Java annotations and reflection.

You are given minimum starter code (~20 loc), and will have to develop a simple yet self-contained framework that can be used to write real-world unit tests.

Are you ready? Let’s go! 🚀

Task 0: The Big Picture

Before getting your hands dirty, it is a good idea to get a big picture of what you will code up.

Debugging Streams and Collections

Fri, 13 Jan 2023 14:59:59 +0000

I will run a book giveaway promotion on the Code Ranch on January 17th . Be sure to be there and let your friends know. It would be great to answer your questions about debugging. I’m very excited by this and by the feedback I’m getting for the course and new videos.

I also launched a free new Java course for complete beginners . No prior knowledge needed. This is probably not the audience for this course. But if you know someone that might be interested I’ll appreciate a share. I hope people find it useful and learn a bit about Java. I’m working on a cadence of one video per week in this beginner course.

Writing a Profiler from Scratch: The Profiling Loop

Thu, 12 Jan 2023 15:26:34 +0000

This is the second post in the series, building a profiler from scratch using AsyncGetCallTrace. Today, we’re covering wall-clock profiling and how to collect the obtain stack traces. If you’re unfamiliar with AsyncGetCallTrace, please check out my previous article in the series here .

Our goal today is to essentially write the primary loop of a profiler and do the following every n milliseconds (where n is our chosen profiling interval):

Managing Dependencies in IntelliJ IDEA

Tue, 10 Jan 2023 15:13:39 +0000

In this tutorial, following on from viewing dependencies , we’re going to take a look at managing dependencies in IntelliJ IDEA.

We’ll look at different ways to add dependencies to your project, and how to add, upgrade and remove dependencies using Package Search.

There are several ways to add new dependencies to your project.

From the build file using copy-paste

You have probably copied a dependency from Maven Repository (or another website) and pasted into your build file.

New Section Added to Foojay.io: Java Quick Start

Mon, 09 Jan 2023 09:31:47 +0000

Foojay.io aims to be the starting point for “all-things OpenJDK,” but during one of my morning walks the idea struck me that this site really needs complete beginner materials, too.

As we want to spread the love for OpenJDK, i.e., Java, Kotlin, and other OpenJDK languages, the JVM, and all related technologies, we were missing an important audience: someone who is interested in an OpenJDK language, such as Java, but has no experience with it yet, and ends up on Foojay.io.

Spring Boot Annotation Reference-01/b

Fri, 06 Jan 2023 09:54:05 +0000

In the second part of my article series on Spring Boot Annotations, we focus on REST and Spring Stereotype Annotations.

In continuation of part 01/a of this article , let’s continue our Spring Boot Annotations journey.

What percentage (depth and extent) of Spring Boot Annotations do you think you really know? This includes annotations in all their glory and the power that they bring via all of their options. I am sure whatever your answer may be, you will appreciate this quote from Albert Einstein: “The more I learn, the more I realize how much I don’t know.”

Spring Boot Annotation Reference - 01/a

Thu, 22 Dec 2022 09:57:33 +0000

In 2018, I was introduced to the topic of Microservices and Spring Boot via a formal training, during my brief stint as a Senior Architect in Manila, Philippines.

Though I had worked on a ‘similar architecture’ way back in 2007-‘08 while working as a Software Engineer at Symantec - I found the idea of the Uber JAR really exciting. Also, since it will now be enforced via the most popular framework brings in more possibilities.

Writing a Profiler from Scratch: Introduction

Wed, 21 Dec 2022 15:26:44 +0000

Async-profiler is undoubtedly one of the most used open-source Java profilers out there.

Its most commonly used feature is sampling a given Java program’s stack traces and visualizing them as a flame graph. I would recommend reading the excellent async-profiler manual by Krzysztof Ślusarski or taking a look at my profiling playlist on YouTube if you’re new to this tool.

After using the async-profiler for a while, you might wonder: How does this tool work? And, of course, if you’re someone like me: Could I write a stripped-down versionto learn how it really works?

How Java Litters Beyond the Heap: Distributed Databases

Tue, 20 Dec 2022 11:40:43 +0000

Let’s create a simple Java application using a distributed database for the user data and see how the database generates litter in response to application requests.

While the Java Virtual Machine executes our code at runtime, it generates garbage in the heap, which is dutifully collected by the garbage collector. This is a known fact.

However, at the same time, Java apps don’t live in isolation and frequently communicate with services, databases, and other components. Some of those components also generate and collect garbage, while fulfilling the Java app’s requests. This is less known.

Foojay on Mastodon: An Update

Fri, 16 Dec 2022 06:45:03 +0000

Some weeks ago we checked here with the Java community if there was an interest to have a Java-oriented Mastodon service.

Today, Nicolas Frankel, also explained how he moved from Twitter to Mastodon and has set up a cross-posting solution (automated of course, as a true good and lazy developer).

Debug Like a Senior Developer

Fri, 16 Dec 2022 06:34:02 +0000

My book on debugging is already on preorder and I’m super thrilled to announce I’m doing a full online course to go along with it.

The course website isn’t ready yet but I already have the full outline and a lot of recorded material. I will try to drop videos at a rate of two per week in the next few months until the full course will be online.

It’s shaping up to be a very detailed course. I recorded the first module and half of the second module and I’m already close to 3 hours of dense recorded material!

What Java Version Are You Running?

Thu, 15 Dec 2022 08:59:05 +0000

From time to time, you need to check which Java version is installed on your computer or server, for instance when starting on a new project or configuring an application to run on a server.

But did you know there are multiple ways you can do this and even get much more information than you might think, very quickly?

Let’s find out…

Reading the Java Version in the Terminal {#WhatJavaversionareyourunning?TakingalookunderthehoodsoftheJDK.-ReadingtheJavaVersionintheTerminal}

Probably the easiest way to find the installed version is by using the java -version terminal command:

Web resource caching: Server-side

Fri, 09 Dec 2022 15:32:42 +0000

The subject of Web resource caching is as old as the World Wide Web itself.

However, I’d like to offer an as-exhaustive-as-possible catalog of how one can improve performance by caching.

Web resource caching can happen in two different places: client-side - on the browser and server side.

In the previous post , I explained the former; this post focuses on the latter.

While client-side caching works well, it has one central issue: to serve the resource locally, it must first have it in the cache. Thus, each client needs its cached resource. If the requested resource is intensive to compute, it doesn’t scale.

Introducing Gradle Test Suites

Tue, 06 Dec 2022 13:28:26 +0000

This article was initially published at blog.gradle.org

As projects grow in size and complexity and otherwise mature, they tend to accumulate a large collection of automated tests.

Testing your software at multiple levels of granularity is important to surface problems quickly and to increase developer productivity.

In Gradle 7.3 , released November 2021, the Gradle team introduced a new feature called Declarative Test Suites.

Using this feature makes it much easier to manage different types of tests within a single Gradle JVM project without worrying about low level “plumbing” details.

How Java Litters Beyond the Heap: Relational Databases

Tue, 29 Nov 2022 19:08:04 +0000

As Java developers, we’re no strangers to the concept of garbage collection. Our apps generate garbage all the time, and that garbage is meticulously cleaned out by CMS, G1, Azul C4, and other types of collectors.

However, the story doesn’t end with the Java heap. In fact, it is just the beginning.

In this article, we will create a simple Java application that uses a relational database for the user data and solid-state drives (SSDs) as a storage device. From here, we’ll explore how the application generates garbage at the database and SSD levels, while executing the application logic.

Controlling a LED Strip with Pi4J and JBang

Mon, 28 Nov 2022 13:07:06 +0000

In an earlier post here on Foojay.io, JBang and Pi4J were used to control a LED and button connected to a Raspberry Pi .

This week Robert von Burg, one of the main contributors of the Pi4J project, shared on Mastodon another project where a LED strip is controlled via I2C.

This is the result, notice the Foojay.io startup artwork 😉

Wiring

The Raspberry Pi in the video is attached to a custom PCB used by Robert in medical cabinets .

Gossips: An Event-Bus in a Chatty Neighbourhood

Thu, 24 Nov 2022 08:35:32 +0000

In this article, we’ll tackle a common issue: simple communication between system components. With a slightly controversial, themed, domain-driven design.

Though this post has nothing to do with Android, we need a context where an Event-Bus is needed. And boy oh boy is it needed in Android! And we’ll use this as an excuse to write an Event-Bus.

I chose an analogy for the entire thing: Gossips;\

It fits with the nature of the library, and the way it’ll be used. A global pub-sub component to enable cross-component communication.

Java Profiling Overview

Mon, 14 Nov 2022 09:14:25 +0000

When I ask Java developers whether they do profile, the answer is usually “no”.

The few that profiled before usually used VisualVM as a student and maybe JProfiler or YourKit years ago at work.

One of the reasons for this is a lack of available information and thus knowledge for everyday Java developers.

This is a pity as profiling should be a part of the tool belt for every experienced developer (not just for Java). The problem is that most of the open-source profilers are targeted to the OpenJDK developers (or their colleagues), even if they won’t admit it. This can be seen in the lack of entry-level material on this topic and even the little that is out there is distributed across multiple conference websites, blogs, YouTube channels, and Twitter accounts.

Geo-routing with Apache APISIX

Mon, 07 Nov 2022 16:41:47 +0000

Apache APISIX, the Apache-led API Gateway, comes out of the box with many plugins to implement your use case.

Sometimes, however, the plugin you’re looking for is not available.

While creating your own is always possible, it’s sometimes necessary.

Today, I’ll show you how to route users according to their location without writing a single line of Lua code.

Why geo-routing?

Geo-routing is to forward HTTP requests based on a user’s physical location, inferred from their IP. There are many reasons to do that, and here is a couple of them.

When Breakpoints Don't Break

Mon, 24 Oct 2022 07:24:44 +0000

I discussed tracepoints quite a bit in my blog and videos.

They are wonderful, but I feel the nuance of non-breaking is a bit lost.

The true power of this amazing tool is hidden due to our debugging habits and our preconceived notions about debugging. It’s indeed difficult to make the mental shift required for these tools.

The payoff for that mental shift is tremendous when dealing with “weird” bugs. Especially in large systems and with concurrency related issues.

High-Performance Java Serialisation to Different Formats

Wed, 12 Oct 2022 14:15:06 +0000

Java serialisation is a popular mechanism where you are able to serialise and deserialise complex object graphs; for example where object A can contain a reference to object B, which in turn has a reference back to object A.

The problem is that this rich functionality comes at a performance cost.

However, if you do not need to serialise these types of recursive graphs, you can instead use an open source solution called Chronicle Wire.

Am I Testing the Right Way?

Tue, 04 Oct 2022 18:24:12 +0000

Two unit-testing approaches explained!

Pick any topic around testing and there will be at least two very contrary approaches that seem to be at odds.

One of the many points of discussion around unit testing, and in particular TDD, are the question around what good boundaries for tests are.

So the question is: Should you unit test each method on your classes or should you only unit test the public interfaces of a given feature or component?

Resolving Git Merge Conflicts in IntelliJ IDEA

Wed, 21 Sep 2022 11:04:06 +0000

At some point in your career, probably many points, you’ll have to resolve merge conflicts.

A common cause of merge conflicts is when you’re working on a feature branch while other changes have been applied to the main branch.

Merge feature branch into main

In this tutorial, we are currently on the main branch, and we want to merge the feature branch into main.

You can do this by selecting the feature branch in the Git tool window which you can open with ⌘9 (macOS), or Alt+9 (Windows/Linux).

Best Practices for Managing Java Dependencies

Thu, 15 Sep 2022 08:21:10 +0000

Creating Java applications is great, and many resources are available.

To speed up development, many folks use frameworks and libraries that do some of the heavy lifting.

When looking at modern Java applications, almost all of them contain dependencies from libraries developed by someone else.

Dependencies take up about 80 to 90 percent of the binary — so, we should take good care of them when creating a Java project.

Migrating Monoliths to Microservices in Practice

Fri, 02 Sep 2022 14:47:21 +0000

There have been amazing articles on the subjects of migrating from a monolith to a microservice architecture, e.g., this is probably one of the better examples .

The benefits and drawbacks of the architectures should be pretty clear. I want to talk about something else though: the strategy.

We build monoliths since they are easier to get started with. Microservices usually rise out of necessity when our system is already in production.

External Debugging Tools 3: JMXTerm

Fri, 26 Aug 2022 14:52:23 +0000

When tracking a bug we need to take a two pronged approach. Similar to tongs that wrap the buggy module from both sides and squeezes to find the problematic part. Up until now we discussed tools that are very low level. Some can be used to debug system level services. Today we’ll discuss the other side of the stack but still a very advanced management tool. To understand this you need to understand the field we’re in.

Google Remote Procedure Call (gRPC) Example in Payara Server

Thu, 25 Aug 2022 10:09:21 +0000

Google Remote Procedure Call, or gRPC, is an open source Remote Procedure Call (RPC) framework focused on high performance and is portable to any environment.

It is an alternative to REST, deemed by many as more efficient.

After one of our customers requested it, the extension became available in our April 2022 Payara Community and Enterprise releases: 5.2022.2 and 5.38.0.

After providing a brief overview of the gRPC extension in Payara in our April release blog, here we provide more technical details about how to use it in Payara Community, where you will build the module yourself and place it in the modules directory.

External Debugging Tools 1: dtrace and strace

Fri, 05 Aug 2022 13:13:43 +0000

Often when debugging, we need to step outside of the comforting embrace of the IDE to reproduce or track an issue.

In this series, I’d like to go over some tools you might find useful for these cases. I’ll try to limit myself to tools that are 100% debugging tools and not those that are useful for development testing.

E.g., tools like curl or jq are remarkably useful. You can/should use them while debugging. But you probably used them while building and testing the feature. So you would already be familiar with them and should have some sense of what they do. I want to focus on tools that you would mostly reach for when debugging. In that sense, tools like SDKMan etc. also make no sense here.

What is a Java Uber-JAR and Why Is It Useful?

Thu, 04 Aug 2022 12:53:49 +0000

An uber-JAR, also known as a fat JAR or JAR with dependencies, is a JAR file that contains not only a Java program but embeds its dependencies as well, and might also contain the web application that needs to be executed.

In this article, we’ll describe the different variants of the artifact and the advantages and drawbacks it has.

What is an Uber-JAR?

As indicated, the Uber-JAR contains all the program dependencies packaged in the JAR file.

Understand the Root Cause of Regressions with Git Bisect

Fri, 29 Jul 2022 13:18:07 +0000

In this series, I cover a lot of magical tools and git bisect is probably the best example of such magic.

The hardest part in debugging is knowing the general area of the bug… and bisect literally shines a light on the specific commit that caused it!

Before we begin, let’s make one thing clear: bisect is a tool for debugging regressions. It does nothing for regular bugs. When we have a regression, we typically know that the issue used to work in a specific release, we would typically have a specific revision where the code worked. We would typically know that it doesn’t work in the current version, but which commit along the way causes the failure?

Debugging Java Collections Framework Issues in Production

Fri, 15 Jul 2022 08:49:59 +0000

The Java Collections Framework was a huge leap forward when it was introduced as part of Java 2 (JDK 1.2).

Thanks to the included collection classes we finally moved beyond the limits of Vector and Hashtable to more mature and generic solutions. With the introduction of streams and functional concepts in Java 8 the framework took everything to the next level.

One of the core principles underlying the framework is coding to the interface. As such you would use the List interface or a Collection interface instead of the concrete implementation. This is great engineering but it makes debugging the Java Collections far more challenging.

Java on Azure Tooling Update – July 2022

Mon, 11 Jul 2022 07:21:16 +0000

Hi everyone, welcome back to the July update of Java on Azure Tooling.

In this update, we will introduce the brand new getting started experience with the Azure toolkit for IntelliJ.

In addition, we have added support for Managed Identity Authentication.

Let’s see what these new features are.

Azure Toolkit for IntelliJ Improvements

New Guided Getting Started Experience

In April’s blog , we first talked about why we needed better getting started experience. Currently, there are several challenges for a developer who is new to Azure:

Debugging Gson, Moshi and Jackson JSON Frameworks in Production

Fri, 08 Jul 2022 07:14:01 +0000

Parsing bugs are the gift that keeps on giving in the age of APIs.

We use a service, it works perfectly in debugging, QA, etc.

Then some user input that made its way to the web request returns a result we just can’t parse.

Unfortunately, there isn’t much we can do at this stage. We need to understand why the failure occurred and how we can workaround it and fix it.

Available Now - gRPC for Apache Cassandra

Thu, 07 Jul 2022 07:38:47 +0000

Build microservices easily with the NoSQL standard database

If you are like most developers, you are embracing applications built using microservices and a NoSQL database. There are many good reasons: faster time to market, lower total cost of ownership, better performance, less downtime, and easy scalability.

Creating cloud-native applications is hard because microservices are often written in different languages, database drivers have a maintenance burden, or familiar HTTP APIs lack the performance needed.

Understand Source Code – Deep into the Codebase, Locally & Production

Fri, 01 Jul 2022 07:17:53 +0000

Say you have a new code base to study or picked up an open source project. You might be a seasoned developer for whom this is another project in a packed resume. Alternatively, you might be a junior engineer for whom this is the first “real” project.

It doesn’t matter!

With completely new source code repositories, we still know nothing…

The seasoned senior might have a leg up in finding some things and recognizing patterns. But none of us can read and truly follow a project with 1M+ lines of code. We look over the docs, which in my experience usually have only passing resemblance to the actual codebase. We segregate and assume about the various modules, but picking them up is hard.

Debugging jsoup Java Code in Production Using Lightrun

Fri, 17 Jun 2022 09:35:06 +0000

Scraping websites built for modern browsers is far more challenging than it was a decade ago.

jsoup is a convenient API that makes scraping websites trivial via DOM traversal, CSS Selectors, JQuery-Like methods and more. But it isn’t without its caveat. Every scraping API is a ticking time bomb.

Real-world HTML is flaky. It changes without notice since it isn’t a documented API. When our Java program fails in scraping, we’re suddenly stuck with a ticking time bomb.

Wordish with JavaFX - Part 5

Tue, 14 Jun 2022 07:25:37 +0000

Welcome to Part 5 and the final installment of this series.

In Part 1 , we introduced the Wordish game with JavaFX and discussed the main UI layout.
In Part 2 , we discussed look and feel enhancements. We introduced specialized Label and Button controls that use pseudo-classes for advanced CSS styling. In addition, we covered incorporating third-party font libraries and customizing Scene Builder to leverage these features.
Next, in Part 3 , we explored the controller code that maintains game state and responds to user input with appropriate updates to the UI.
Part 4 , What’s in a Word, Anyway?, examines how we get our words and how we determine if a submitted word is valid.

And now in Part 5, we turn to JavaFX charts, showing how to customize charts with orientation and colors and how to add nodes to the chart scene graph.

Java on Azure Tooling Update – June 2022

Mon, 13 Jun 2022 07:40:38 +0000

Hi everyone, welcome back to June update of Java on Azure Tooling.

In this update, we will introduce the new application-centric view on Azure toolkit for IntelliJ that will make the interface more user-friendly.

In addition, we have added support for more Azure services.

For Gradle plugins, we have some new features for Azure Web Apps and Azure Functions.

We hope you like these new features and share your feedback with us. So let us get right into it…

Remote Debugging and Developer Observability

Fri, 10 Jun 2022 10:12:26 +0000

In this post, we’ll go over remote debugging. Debugging production with developer observability tools and debugging asynchronous code which presents its own unique challenges!

This is actually material from four separate videos because I wanted to pool some ideas together into a single blog post and the asynchronous stuff got pulled in. So without further ado, these are the applicable videos… Read on for the analysis and discussion:

🦆 Duckling the 15th:

Building Project Panama's jextract tool by yourself

Thu, 09 Jun 2022 14:22:47 +0000

Absorb what is useful, discard what is useless and add what is specifically your own. – Bruce Lee

Do you want to build Project Panama’s Jextract tool by yourself? I can show you how!

If you’ve seen any of my past articles on Project Panama I’ve mentioned a really convenient tool called jextract that can generate Java binding code that represents native functions or variables (symbols) from C libraries.

This alleviates the developer’s need of creating binding code by hand. By passing in a C header file (.h extension) jextract can generate source code or compiled Java classes.

Wordish with JavaFX - Part 4 : Foojay

Tue, 07 Jun 2022 09:23:47 +0000

Welcome to Part 4 of this five part series.

In Part 1 , we introduced the Wordish game with JavaFX and discussed the main UI layout.

In Part 2 , we discussed look and feel enhancements.

We introduced specialized Label and Button controls that use pseudo-classes for advanced CSS styling.

We covered incorporating third-party font libraries and customizing Scene Builder to leverage these features.

Next, in Part 3 , we explored the controller code that maintains game state and responds to user input with appropriate updates to the UI.

Debugging the Java Message Service (JMS) API using Lightrun

Fri, 03 Jun 2022 09:26:12 +0000

The Java Message Service API (JMS) was developed by Sun Microsystems in the days of Java EE .

The JMS API provides us with simple messaging abstractions including Message Producer, Message Consumer, etc. Messaging APIs let us place a message on a “queue” and consume messages placed into said queue.

This is immensely useful for high throughput systems – instead of wasting user time by performing a slow operation in real-time, an enterprise application can send a message. This non-blocking approach enables extremely high throughput, while maintaining reliability at scale.

Wordish with JavaFX - Part 3

Tue, 31 May 2022 07:23:02 +0000

Welcome to Part 3 of this five part series.

In Part 1 , we introduced the Wordish game with JavaFX and discussed the main UI layout.

In Part 2 , we discussed look and feel enhancements.

We introduced specialized Label and Button controls that use pseudo-classes for advanced CSS styling.

We covered incorporating third-party font libraries and customizing Scene Builder to leverage these features.

Now in Part 3, we’ll examine the controller code. The controller code maintains game state and responds to user input with appropriate updates to the UI.

Memory Debugging and Watch Annotations

Fri, 27 May 2022 08:04:34 +0000

Before diving into debugging memory issues and the other amazing running process, memory debugging capabilities (which are amazing)… I want to discuss a point I left open in the last duckling post . Back there we discussed customizing the watch renderer. This is super cool!

But it’s also tedious. Before we continue, if you prefer, I cover most of these subjects in these videos:

🦆 Duckling the 11th:

Did you know you can see all the objects in memory?

Java Panama Polyglot (Rust) Part 4

Thu, 26 May 2022 08:33:02 +0000

Hello and welcome to the final article of the Java Panama Polyglot series, where we are presenting quick tutorials or recipes on how to access native libraries written in other languages.

In this article you will be using Project Panama to talk to the Rust language.

If you are new to Java’s Foreign Function Access APIs (Project Panama ) check out Panama4Newbies .

In Part 3 you had a chance to learn about how to use Java Project Panama’s abilities to access the locally installed Python interpreter.

Wordish with JavaFX - Part 2

Tue, 24 May 2022 07:50:54 +0000

Building Games and Having Fun with Java and JavaFX

Welcome to Part 2 of this five part series!

In Part 1 , we introduced the Wordish game with JavaFX and discussed the main UI layout.

In this second part, we’ll discuss some important look and feel enhancements.

We’ll show you specialized Label and Button controls and using pseudo-classes for advanced CSS styling.

We’ll also cover incorporating third-party font libraries and customizing Scene Builder to leverage these features.

Debugging Deadlocks and Race Conditions

Fri, 20 May 2022 08:08:00 +0000

Thread debugging has the reputation of being one of the most arduous tasks for developers. I beg to differ.

Asynchronous debugging is so much worse. It’s supposed to solve the problems of threading and to some degree async helps…

But it doesn’t make debugging simpler. I will get into that in the next post.

In the last two ducklings, I talked about threading issues:

🦆 Duckling the 13th:

Debug race conditions and deadlocks easily.

Wordish with JavaFX - Part 1

Tue, 17 May 2022 10:13:21 +0000

Building Games and Having Fun with Java and JavaFX

Wordish is a JavaFX implementation of the game Wordle. It’s like Wordle. It is Wordle-ish. It’s Wordish. Figure 1. Wordish main layout view

Wordle is a daily online word game. You can play the official Wordle game here:https://www.nytimes.com/games/wordle/index.html . If you haven’t played yet, go check it out.

As I played Wordle, I realized how much fun it would be to create a JavaFX implementation. When you submit a word, each tile rotates to reveal how the individual letter matches – or doesn’t match – the target word. (Ooh, animation!)

Publish a Java Project to the Maven Central Repository

Fri, 13 May 2022 06:22:58 +0000

This guide will describe how to publish the JDesk framework to Maven Central.

The project is written in Java using Maven as the build tool. So, the process will be detailed for Java projects with a pom.xml file.

You can follow this article if you need to publish a Java Maven-based library or artifact to Maven.

Get Ready for Publishing Packages

Publishing a Java artifact is not as trivial as Python or JavaScript packages can be deployed.

Setting up and Working with Apache Tomcat in IntelliJ IDEA Ultimate

Tue, 10 May 2022 08:46:17 +0000

In this article, you will learn how to set up IntelliJ IDEA Ultimate to work with Apache Tomcat, herein referred to simply as Tomcat.

We will create a new project that uses Tomcat and then talk about using Tomcat in IntelliJ IDEA so you can benefit from the rich integration capabilities.

Downloading Apache Tomcat

To use Tomcat with IntelliJ IDEA, it needs to be installed on your machine. If you don’t already have Tomcat installed, you can download the latest version, which at the time of writing, is Tomcat 10 .

How To Modernize Legacy Code in Production

Mon, 09 May 2022 15:58:36 +0000

I spent over a decade as a consultant working for dozens of companies in many fields and pursuits. The diversity of each code base is tremendous. This article will try to define general rules for modernizing legacy code that would hopefully apply to all. But it comes from the angle of a Java developer.

When writing this, my primary focus is on updating an old Java 6 era style J2EE code to the more modern Spring Boot/Jakarta EE code. However, I don’t want to go into the code and try to keep this generic. I discuss COBOL and similar legacy systems too. Most of the overarching guidelines should work for migrating any other type of codebase too.

Spring Transaction Debugging in Production with Lightrun

Fri, 06 May 2022 15:00:53 +0000

Spring makes building a reliable application much easier thanks to its declarative transaction management.

It also supports programmatic transaction management, but that’s not as common.

In this article, I want to focus on the declarative transaction management angle, since it seems much harder to debug compared to the programmatic approach. This is partially true. We can’t put a breakpoint on a transactional annotation.

But I’m getting ahead of myself!

What is Spring’s Method Declarative Transaction Management?

When writing a spring method or class, we can use annotations to declare that a method or a bean (class) is transactional. This annotation lets us tune transactional semantics using attributes. This lets us define behavior such as:

Debugging Collections, Streams, and Watch Renderers

Fri, 29 Apr 2022 07:54:01 +0000

In the last two ducklings, I finished the extensive discussion on breakpoints and switched my focus to the watch area. In it, we have several amazing and lesser known tools that let us build insight into our running application. Being able to tell at a glance if something works correctly is crucial for many applications.

This is very important for collections and arrays. We can have thousands or millions of elements within a collection. Debugging this is very difficult without some basic tools.

Exception Breakpoint that Doesn't Suck and Other Use Cases

Fri, 22 Apr 2022 07:37:25 +0000

Two weeks ago, I left this series in a “cliffhanger” of sorts. Well, as much as a programming blog can leave things in the air… The big one amongst them is the premise that exception breakpoints don’t have to suck. If you used them in the past, you would know that grabbing all exceptions is ridiculous. You end up at a breakpoint every second and it doesn’t help.

There’s a solution, and it’s discussed in duckling 6 number 7 also covers a lot of interesting ground for us and another cliffhanger on method breakpoints:

Fullstack IMDB Clone with a Java Backend using SparkJava and Neo4j

Wed, 20 Apr 2022 07:11:02 +0000

Our GraphAcademy is teaching folks starting out in the graph space the fundamentals of the data model, query language, and graph algorithms.

And for developers, there are courses for using our drivers and building the backend of a fullstack app in JavaScript, Go, Python, Java, and soon .Net.

The application is an IMDB clone based on the MovieLens recommendation dataset augmented with movie and cast data from themoviedb.org .

The front-end is written in vue.js and looks pretty slick.

Logging Best Practices: MDC, Ingestion, and Scale

Mon, 11 Apr 2022 12:16:37 +0000

I don’t care about religious wars over “which logger is the best”. They all have their issues. Having said that, the worst logger is probably the one built “in-house”. So yes, they suck, but re-inventing the wheel is probably far worse.

Let’s discuss making these loggers suck less with proper usage guidelines that range from the obvious to subtle. Hopefully, you can use this post as the basis of your company’s standard for logging best practices.

Migrating from Java EE to Jakarta EE with IntelliJ IDEA

Fri, 08 Apr 2022 17:02:37 +0000

In this post, we’re going to migrate some sample code from the javax namespace to jakarta. If you want the history on this change, check out this helpful blog post from Java Magazine. Fundamentally the Java Persistence API was renamed to Jakarta Persistence API meaning that the javax namespace changed to jakarta for frameworks whose APIs have moved to Jakarta EE (which is not all of them).

However, Apache Tomcat recently released version 10 which updated package names from javax to jakarta. SpringBoot also made this change in version 6.

Java Panama Polyglot (C++) Part 1

Wed, 06 Apr 2022 15:41:49 +0000

Hello and welcome to the Java Panama Polyglot series where we will be presenting quick tutorials or recipes on how to access native libraries written in other languages.

For example, you will learn about Java Project Panama’s (foreign function interface) abilities to access native libraries written in C++, Swift, Python, and others.

What is Polyglot?

Have you heard of polyglot as it relates to developing full stack applications? If your answer is yes, then you probably know about the programming languages needed to build an enterprise web application.

Debugging JAXB Production Issues

Mon, 04 Apr 2022 14:13:10 +0000

Java Architecture for XML Binding (AKA JAXB API) is a popular API for marshalling XML data. It’s a framework for mapping between XML documents and Java POJOs (Plain Old Java Objects, AKA regular Java classes) almost seamlessly. The API is very easy to use and many frameworks leverage it to provide their XML support. JAXB2.0 has gained popularity both in desktop applications (Java SE) and in application server code (Spring Boot, Java EE/Jakarta EE, Microprofile etc.).

Increasing Event Streaming with Kafka and Azul

Tue, 29 Mar 2022 13:41:48 +0000

Welcome to getting started with Azul Platform Prime and Apache Kafka !

In this article you will learn how to switch between two different Java runtime environments to run an Apache Kafka instance.

In later articles, this will allow you to compare runtime performance benchmarks.

Before we begin, let’s supply some context on Azul’s Platform offerings and Apache Kafka.

What is Azul Platform Prime and Platform Core?

Azul offers two Java runtime environments Platform Prime and Platform Core . Platform Prime (formerly known as Zing) is a high-performance implementation of the JVM (Java Virtual Machine) while Platform Core refers to Azul’s solution that includes the Zulu build of OpenJDK with dedicated support.

Debugging Java Equals & Hashcode Performance in Production

Tue, 29 Mar 2022 06:50:17 +0000

I wrote a lot about the performance metrics of the equals method and hash code in this article . There are many nuances that can lead to performance problems in those methods. The problem is that some of those things can be well hidden.

To summarize the core problem: the hashcode method is central to the Java Collections API. Specifically, with the performance of hash tables (specifically the Map interface hash table). The same is true with the equals method. If we have anything more complex than a string object or a primitive, the overhead can quickly grow.

Debugging Race Conditions in Production

Wed, 23 Mar 2022 07:45:15 +0000

Race conditions can occur when a multithreaded application accesses a shared resource using over one thread. Unless we have guards in place, the result might depend on which thread “got there first”. This is especially problematic when the state is changed externally.

A race can cause more than just incorrect behavior. It can enable a security vulnerability when the resource in question can be corrupted in the right way. A good example of race condition vulnerabilities is mangling memory. Let’s say we have an admin user name which is restricted and privileged. You can’t change your user name to admin because of validation. But you can change it to anything else…

The Basics of Breakpoints you Might not Know

Thu, 17 Mar 2022 10:41:08 +0000

In episodes 4 and 5 of “140 Second Ducklings”, I got deeper into the more advanced underpinnings of breakpoints. There’s still a lot more to learn to move forward, but even at this stage it’s surprising how many things are relatively unknown in the developer community. And I’m just getting started…

🦆 Duckling the 5th:

Did you know you can disable a breakpoint until you hit another breakpoint?

Do you know what’s a tracepoint?

Java Return Value, IntelliJ Jump to Line

Wed, 02 Mar 2022 15:33:39 +0000

I just published the 3rd episode of the “140 Second Duckling” tutorial series and I’m getting into the rhythm of doing them. I posted the 2nd episode last week and in this post I’ll dig deeper into both.

I tackled a lot of basic stuff about debugging but I picked two big headliners that a surprising amount of developers aren’t familiar with. E.g. How many times did you step over a return statement and cursed?

Project Panama for Newbies (Part 4)

Thu, 24 Feb 2022 08:34:52 +0000

Updated December 31, 2025: This article now features Java 25 and the Foreign Function & Memory (FFM) API, which has been a standard feature since JDK 22.

Welcome to Part 4 of Java’s Project Panama for newbies! If you’ve been following this series of posts on how to use Java’s Project Panama APIs you probably have noticed that all of the examples thus far demonstrate how Java code can execute C code by using the linker ’s downCall() method.

Use git bisect to Pinpoint a Bug

Wed, 23 Feb 2022 14:44:51 +0000

During some recent work on Maven, I found a very specific bug. The error message wasn’t that clear, and I couldn’t make a guess what might’ve caused it.

I had read about git bisect a few times and figured that this time, I would use that tool to find the bug.

So what does git bisect do? It helps you find the exact commit that introduced a bug, using binary search.

Enter the Cloud Native Dojo: Blackbelt-Level Debugging

Tue, 22 Feb 2022 13:28:42 +0000

Debugging is often viewed as an art form or a craft. This is true for most engineering-related troubleshooting processes (e.g., art of motorcycle maintenance). We’re usually indoctrinated into the basic moves by a senior developer and are then thrown into the proverbial pool. As a result, even senior engineers sometimes have gaps in their debugging skills. There are very few university courses or books on the subject, so it’s really hard to blame them.

Playing practically with Stream API

Wed, 16 Feb 2022 00:43:54 +0000

We can find many Stream API examples on Google, but most of them don’t represent real life scenarios. Hence, it often remains a black box to understand the power of the Stream API for many rising programmers.

In this article, I tried to make scenarios based problems where I have tried to make the solution with Stream API. These were initially for my personal practice purposes, and later, I added some more practice problems to demonstrate in my class at Pondit.

What is Debugging in 140 Seconds

Mon, 14 Feb 2022 12:50:58 +0000

I’m launching a new twitter video series that will focus on teaching the concepts of debugging (and other concepts) in small video bites.

This is the first video in the series. I hope to publish a new video every week. It starts with the very basics of debugging and builds up. I think debugging is a powerful tool that even experienced developers don’t leverage enough.

See the video here:

🦆 Duckling the 1st:

Detect and Fix Memory Leaks in Managed Languages

Thu, 10 Feb 2022 08:45:27 +0000

In the previous installment , I talked about the Java garbage collector. In this part, I’ll discuss the most common memory issue: the memory leak. I focus on managed languages, specifically Java, but I will mention some native code tools which are interesting. A memory leak contributes to heap size, which isn’t the most pressing bug in most cases. But when left alone, memory usage can become a problem and, by that point, finding the issue is hard. Unlike a crash dump, where we get a reference to a specific line, a memory leak can remain hidden.

GoF Design Patterns Using Java - Part 02

Fri, 04 Feb 2022 16:46:55 +0000

Link to YouTube Video - Introduction to Design Patterns
Link to Article : GoF Design Patterns Using Java - Part 01
Link to GitHub Code Samples in Core Java for this Article

Adapter Pattern [Sample Code ]

What can one do if he needs to use an Asian Hairdryer in a European Country, each with different socket types? I would seek an Adapter! As in real life, when we want to plug and play with similar but incompatible interfaces we use the Adapter. The Adapter adapts the Adaptee to the desired interface, by composing the Adaptee object and inheriting the desired interface or by multiple inheritance.

Lights, Camera, Action: GitHub Actions with Java (Part 3)

Thu, 03 Feb 2022 15:24:33 +0000

The Java GitHub Action that Rules them all - Disco API{#caption-attachment-51347}

When we ended Part 2 of this blog series Lights, Camera, Action: GitHub Actions with Java Part 2 , I talked about the near future of GitHub Actions. Well, today the future is now, so let’s get into this!

Welcome back to the series of articles on GitHub Actions with Java Part 3. If you didn’t catch Part 1 & 2 head over here: Part 1 & Part 2

Create a CRUD UI in Pure Java

Wed, 02 Feb 2022 17:10:06 +0000

In this guide, we create a web UI that performs full CRUD (create, read, update, and delete) operations on a Spring Data JPA backend. This UI is developed entirely in pure Java using Vaadin Flow (no HTML or JavaScript involved). You can explore the full source code on GitHub .

What You Need

About 15 minutes
JDK 17 or later

Step 1: Import a Starter Project

Click here to download an empty project starter . Unpack the downloaded zip into a folder on your computer, and import the project in the IDE of your choice.

Debugging RAM: Java Garbage Collection - Java Heap Deep Dive (Part 1)

Tue, 11 Jan 2022 15:36:04 +0000

There are many excellent articles on Java Garbage Collection, Java Memory usage and generally Java heap. Unfortunately, they are all over the place. They mix architecture, concepts and problem solving as separate pieces. A lot of the material is out of date or doesn’t include pragmatic information for solving problems with the garbage collector. E.g. e.g. pause times, heap space usage etc.

In this post I won’t go into memory leaks. They’re important but this is a different subject I would like to discuss in a post on its own.

Build Web Apps in Pure Java with Vaadin Flow

Thu, 16 Dec 2021 09:21:24 +0000

Vaadin Flow enables you to quickly build web apps in pure Java, without writing any HTML or JavaScript.

In this guide, you learn how to build a small but fully functional ToDo application using Vaadin Flow.

What You Need

About 5 minutes
JDK 11 or higher (For example, Eclipse Temurin JDK ).

Step 1: Download a Vaadin Project

Click here to download an empty project starter . Unpack the downloaded zip into a folder on your computer, and import the project in the IDE of your choice.

Java Thread Programming (Part 9)

Tue, 14 Dec 2021 11:14:33 +0000

In our last article , we discussed thread-safety in naive terms and shared a couple of ways to ensure thread safety. We also introduced a package containing thread-safe classes, which we can confidently use without worrying much, e.g., AtomicInteger. This is because they are designed in a thread-safe way.

Today in this article, we will continue the discussion and share a few more thread-safe classes that we can use in our day-to-day coding.

Native-image with Quarkus

Mon, 13 Dec 2021 17:50:08 +0000

So far, we have looked at how well Spring Boot and Micronaut integrate GraalVM native image extension. In this post, I’ll focus on Quarkus :

A Kubernetes Native Java stack tailored for OpenJDK HotSpot and GraalVM, crafted from the best of breed Java libraries and standards.

Creating a new project

Just as Spring Boot and Micronaut, Quarkus provides options to create new projects:

A dedicated quarkus CLI
A Web UI

Quarkus offers a definite improvement over its competitors. Every dependency has a detailed contextual menu that allows:

Non-blocking with Spring WebFlux, Kotlin and Coroutines

Thu, 09 Dec 2021 14:03:28 +0000

When a HTTP request comes in, a ’normal’ web application would map the request to a specific thread from the thread pool. This assigned thread stays with the request until a response can be returned to the request socket. Along the way, we might need to fetch data from some web service or database, read or write to a file or do other I/O calls, during which the thread is blocked and has to wait until it gets a response. For applications with high request rates, the thread pool can at some point become exhausted and then no new requests can be handled anymore.

Java Thread Programming (Part 8)

Tue, 07 Dec 2021 18:15:09 +0000

The term thread safety is a frequently and commonly pronounced word among Java developers. However, it is still one of the misunderstood terms as well. In this article, I will try to explain in a very simplified way what it is and how we can achieve it while we write our day-to-day code.

The idea is, when writing a piece of code, it usually contains method and data. If we write a class, it may hold some data in terms of state. For example, if we want to write a Counter class, we will have a variable inside the counter class that holds the current count.

Java Thread Programming (Part 7)

Tue, 23 Nov 2021 10:10:53 +0000

In our previous Java threading articles in this series , we learned a great deal about how we can create threads and how to use them while avoiding the issues that come with them. But what does this leave us with? Can we create as many threads as we want? I wish I could answer this with a straight yes or no. In this article, I will try to come up with an answer via an exercise, so bear with me!

SKP's Agile Cheatsheet : Part 03

Wed, 17 Nov 2021 21:18:19 +0000

SKP’s Agile Cheatsheet is a three part series of articles focused on daily agile terminology, ideal to be printed out and pinned up near your workstation. Part 1 is available here and part 2 here while the PDF cheatsheet is here .

Release Train. The Agile Release Train (ART) is a long-lived team of Agile teams, which, along with other stakeholders, incrementally develops, delivers, and where applicable operates, one or more solutions in a value stream. [Type – Agile Product Management]

Streams Set Distinct Java Code Quiz

Thu, 11 Nov 2021 09:36:45 +0000

Using Streams and Set Collection Factory methods with Java makes code easier to read and maintain.

By using these features, we can also make it more difficult for bugs to remain hidden. If you can use the latest LTS (Long-term support) Java version in your project, it’s the best scenario, so that you can use cool Java features such as Collection Factories from Java 9 onwards.

Now that we know why it’s important to understand Java features well, it’s time for the Java Challenge!

SKP's Agile Cheatsheet: Part 02

Fri, 05 Nov 2021 07:58:00 +0000

SKP’s Agile Cheatsheet is a three part series of articles focused on daily agile terminology, ideal to be printed out and pinned up near your workstation. Part 1 of this article is available here and you can download the PDF of this cheatsheet here .

**Epic.**An epic is a large user story. [Type – Agile Estimation / Agile Product Management]

**Fibonacci Scale.**In Agile software development, the Fibonacci scale consists of a sequence of numbers used for estimating the relative size of user stories in points. Agile Scrum is based on the concept of working iteratively in short sprints, typically two weeks long, where the requirements and development are continuously being improved. The Fibonacci sequence consists of numbers that are the summation of the two preceding numbers, starting with [0, 1]. Agile uses the Fibonacci sequence to achieve better results by reducing complexity, effort, and doubt when determining the development time required for a task, which can range from a few minutes to several weeks. [Type – Agile Estimation / Agile Product Management]

Debugging Tutorial 1 – Introduction: Conditional Breakpoints & Set Value

Wed, 27 Oct 2021 08:03:53 +0000

In this series, I’ll walk you through the process of debugging applications and finding issues within them. As we debug, we’ll cover the techniques important for most developers. I will cover the following debuggers:

IntelliJ/IDEA – with Java/Kotlin
PyCharm – Python
VSCode – for JavaScript
WebStorm – for JavaScript

These should cover most use cases you’ll run into and some things will seem duplicate/redundant so you can just skip to the applicable section if you feel you “got the gist”.

GlassFish & Payara Auto-Clustering for Jakarta EE Applications

Wed, 13 Oct 2021 13:27:30 +0000

Ensuring trouble-proof 24/7 service delivery is among one of the most discussed areas in cloud hosting for the last few years. And the very obvious and commonly used solution here is building a clustered infrastructure for your project.

Intending to help our customers to deal with such a non-trivial task and save time for other project-related activities, we created a special high-availability solution, designed to facilitate the Jakarta EE application hosting – embedded Auto-Clustering for GlassFish and Payara application servers.

Debug Real World Applications using a Systemic Proven Process

Tue, 28 Sep 2021 08:54:00 +0000

In the Debugger Checklist (Part I) , I introduced some of the high level concepts and reviewed some of the common things you can do. In this part, we’ll get down to the process. Again, it’s important to stress that this is boiled down and concentrated!

I don’t want to discuss issue trackers, unit testing and proper TDD. I think there are many resources covering all of these. The focus of these posts is the debug process itself which often gets neglected as “tools”. There’s a lot of technique that separates the seasoned developer from a junior. Furthermore, there are many small advancements and changes we can’t possibly keep up with. I’d like to cover all of those things (some in future posts).

Thorntail Fat, Thin and Skinny Approach for Java Microservices

Wed, 22 Sep 2021 16:25:45 +0000

Thorntail , originally WildFly Swarm , is most suitable for packaging applications as JAR , WAR, or EAR files. The most important value is in the functional agility the Thorntail provides. You can start with the stripped down version of Thorntail, adding the required parts and application code on top.

Below we will describe how to build and deploy Thorntail based applications using Fat, Thin and Skinny approaches. The application will be packaged in the Jar/War format automatically with the help of Builder add-ons prepared by Jelastic. The topology will consist of Maven build node and JVM containers for running microservices.

Debugger Checklist: Bug Solving Process

Tue, 21 Sep 2021 09:37:32 +0000

Win at debugging by following an organized process and leveraging the tools you already have!

I’m a disorganized person by nature. When I follow a process it’s by habit and intuition. But when a debugging problem keeps me up at night and gets me to that state of mind where a career of raising sheep in New Zealand seems like an attractive option… That’s when I need to back off and walk through this process in an orderly fashion. This process never fails. When you walk through it, you can track any problem.

Project Panama for Newbies (Part 3)

Mon, 13 Sep 2021 08:53:47 +0000

Updated December 31, 2025: This article now features Java 25 and the Foreign Function & Memory (FFM) API, which has been a standard feature since JDK 22 (JEP-454 ).

Panama for newbies Part 3

Introduction

Welcome to the third part of the series on Java’s Project Panama for newbies. Before jumping into this article, I want to congratulate you for getting this far, you deserve a virtual pat on the back!

8 Debugging Tips for IntelliJ IDEA Users You Never Knew Existed

Thu, 09 Sep 2021 07:15:54 +0000

As developers, we’re all familiar with debuggers. We use debugging tools on a daily basis – they’re an essential part of programming. But let’s be honest. Usually, we only use the breakpoint option. If we’re feeling frisky, we might use a conditional breakpoint.

But guess what, the IntelliJ IDEA debugger has many powerful and cutting-edge features that are useful for debugging more easily and efficiently. To help, we’ve compiled a list of tips and tricks from our very own developers here at Lightrun . We hope these tips will help you find and resolve bugs faster.

Daemon Thread Java Code Quiz

Wed, 08 Sep 2021 07:29:56 +0000

When we are working with Threads, it’s important to know when to use a daemon or a non-daemon Thread.

Do you know if the main Thread is a daemon or not? And do you know what a daemon Thread is?

That’s what you will find out by trying out the following Java Challenge!

It’s time to improve your Java skills with this Daemon Thread Challenge…

Daemon Thread Challenge

What will happen when running the following main method?

Function Calculation Java Challenge

Wed, 01 Sep 2021 10:10:19 +0000

Functional programming is a very powerful paradigm that makes code more concise and easier to understand.

In Java, the “Function” functional interface can be used as a first-class citizen function, meaning that we can pass a function to a method and declare it as a variable, giving the developer a lot of power.

And now it’s time for you now to test your abilities with lambdas and functional interfaces! Get ready!

Tomcat and TomEE Clustering Automation in the Cloud

Mon, 30 Aug 2021 07:18:36 +0000

Apache Tomcat is an open-source application server maintained by the Apache community. It is one of the most popular solutions for hosting Java applications due to its ease-of-use and lightweight yet versatile functionality. However, if you run the projects based on Jakarta EE 8 (or higher), you may be interested to use TomEE server with built-in required enterprise technology that isn’t found in Tomcat.

Due to the extreme popularity of these stacks globally, and within Jelastic PaaS in particular, we’ve decided to share tips on how to install automatically clustered Tomcat and TomEE servers to get a highly available solution that can efficiently serve a large number of users, process high traffic, and be reliable.

Stream Limit Filter Java Challenge

Tue, 17 Aug 2021 07:00:03 +0000

To manipulate data from a collection by using a Java stream is handy and cleaner than the alternatives.

When you learn how to use streams, your Java code will be much better, and knowing how to limit and filter data with streams is crucial for you to do something useful with streams in Java.

Without further ado, let’s go to the next Java Challenge!

It’s time to improve your Java skills with this Limit Stream Challenge.

Getting Started with Snyk for Secure Java Development

Thu, 29 Jul 2021 06:39:02 +0000

If you’re a Java developer who wants to develop your applications more securely, you’ve come to the right place. Snyk can help you with that mission.

This article will explain how to begin with Snyk for secure Java development so you can be more secure from the get-go.

If you’re new to Snyk, it’s important to know that we offer a variety of developer-focused products and tools. Some of these tools, like our CLI and some IDE integration, support multiple products. However, we can distinguish four different products within Snyk:

Neo Stream Search Java Challenge

Mon, 26 Jul 2021 08:32:40 +0000

Understanding the mechanics of the functional interface Predicate of a Stream is crucial if you want to create something meaningful with streams. On this challenge, we will explore important key methods when we work with a stream so that it becomes clear for you what they do.

Without further ado, let’s go to the Java Challenge!

It’s time to improve your Java skills with this Neo Stream Search Challenge

Neo Stream Search Challenge

What do you think will happen when running the following code?

Join The Jedi Lambda Join Java Challenge!

Wed, 21 Jul 2021 08:08:24 +0000

There are many concepts involved in Java Challenge! In essence, we will explore lambdas and the Function interface the most. However, we also have static methods introduced in Java 8 the private method in interfaces introduced in Java 9. In the invocation of the interface methods, we are using anonymous inner classes too!

Are you ready for this Java Challenge? Less introduction, more action, try out this Java Challenge, and master Java concepts by having fun!

Soprano ofNullable stream Java Challenge

Mon, 05 Jul 2021 08:21:54 +0000

Since Java 9, it’s possible to use Optional with a stream when we need to manipulate values from a List.

In this Java Challenge, we will explore the use of a stream in an Optional!

Are you ready to solve this Java Challenge? It’s time to improve your Java skills with this Soprano ofNullable stream Challenge…

Soprano ofNullable filter Challenge

What will happen after the main method is executed as follows?

Method Reference VS Lambda Java Challenge

Tue, 29 Jun 2021 19:31:00 +0000

Do you know what the differences are between method references and lambdas?

In this Java Challenge, we will explore how lambdas and method references behave so that you can really understand how they work!

Now that you know the main context, it’s time for the Java Challenge!

It’s time to improve your Java skills with this Method Reference VS Lambda Challenge.

Method Reference VS Lambda Challenge

What will happen when we run the following main method?

Introduction to Simplify Protocol Refactoring

Mon, 28 Jun 2021 13:22:24 +0000

The other day, I went grocery shopping. While waiting in line, I thought about some struggles I had in a test I wrote earlier that day. When it was my turn, the cashier scanned my items and said what I owe him. And I just gave him my whole wallet. He stared at me blankly and gave it back. A little confused for a second, I took out my card, paid, and left the store. And at that point, it hit me what was wrong with my test.

Creating a JavaFX World Clock from Scratch (Part 6)

Fri, 25 Jun 2021 16:48:48 +0000

Wherever you go, no matter what the weather, always bring your own sunshine. – Anthony J. D’Angelo

Hello, and welcome to the last part of this series of articles on creating a JavaFX World Clock from scratch!

In this part, I will show you how to make WebService calls (RESTful) to retrieve weather data based on geographic locations.

If you remember, in Part 5 you learned how to use the JavaFX WebView and the popular mapping library Leaflet JS enabling the user to discover geographic locations. In Part 6, I will show you how I used Java 11’s Http Client to retrieve and display weather content. If you are new to this series, you can visit Part 1 -5 .

How to Debug Java on the Command Line

Thu, 24 Jun 2021 16:51:14 +0000

Some bugs are hard to replicate on your personal computer but easily replicated on production or test machines. It is a common situation that professional Java developers deal with frequently. To debug such problems, OpenJDK provides two tools, remote debugging and jdb.

This article focuses on jdb.

For Java applications, typical production and test machines are Linux servers without display managers, so that only command line tools are available. Here we cannot use professional IDEs like IntelliJ IDEA, Eclipse, or Apache NetBeans IDE.

Jakarta EE Application Deployment to Kubernetes Cluster in Jelastic PaaS

Wed, 16 Jun 2021 06:58:31 +0000

Recently, we were asked to sponsor cloud hosting of a Jakarta EE project, called Cargo Tracker . Being a member of Jakarta EE Working Group, Jelastic wanted to support the community and thus we started to run this application at one of our service providers (Scaleforce ).

Cargo Tracker is now deployed to Kubernetes on the cloud using GitHub Actions. Thanks sponsors Jelastic and Scaleforce! https://t.co/zhnmj0TB7Z // @Jelastic, @scaleforce pic.twitter.com/BRGkwxban2

Hidden Dracula Polymorphism Java Challenge

Mon, 14 Jun 2021 11:26:37 +0000

Polymorphism is one of the most important Java concepts. We might not even be aware we’re using it all the time but when we instantiate an ArrayList and assign it to a variable of the List type, we are using polymorphism. It’s a powerful concept because it helps us to decouple responsibilities, therefore, making code more flexible and easier to maintain.

This Java Challenge is one of the hardest ones, are you ready for this one? Now is your time to improve your Java skills by doing this Java Challenge!

Asynchronous CompletableFuture Java Challenge

Tue, 01 Jun 2021 07:42:43 +0000

The Completable Future feature is powerful for better performance when running asynchronous methods.

In Java 5, there is the Future interface, however, the Future interface doesn’t have many methods that would help us to create robust code. To solve the limitations of the Future interface, we have the CompletableFuture API with methods that will help us to build reliable high-performant software.

Now that we had the intro about CompletableFuture, let’s go to the Java Challenge!

Creating a Simple Spring Boot Application in IntelliJ IDEA

Mon, 31 May 2021 17:06:51 +0000

This tutorial uses IntelliJ IDEA Ultimate because we want to create a new project using Spring Initializr. This functionality is only available with IntelliJ IDEA Ultimate. It is based off Building an Application with Spring Boot .

Creating your Spring Boot Project

If you’re in an IntelliJ IDEA project already, select File > Project . Alternatively click the New Project button on the Welcome screen.
Select Spring Initializr on the left-hand side and then enter the following options:

Automatic WildFly Managed Domain Clustering & Scaling in Containers

Mon, 31 May 2021 08:08:12 +0000

Nowadays it’s easy to get up and running WildFly standalone server in a container. But what if you need to enable clustering in Managed Domain mode, which is one of the key features of Jakarta EE in general? That is a not so easy task. Some people claim it’s nearly impossible in the cloud-native world, because Jakarta EE clustering was designed before the containers era. The old question at the official developers portal is still not answered with any adequate instructions, just proving the presence of the issue.

Take the Type Erasure Generics Java Challenge!

Tue, 25 May 2021 06:50:45 +0000

It’s possible to use type erasure generics in a method with Java. To know how to use generics is important because then you are able to create highly reusable code.

In the following Java Challenge, you will see the generic type that will be erased by the compiler and then will be replaced by the type we defined at runtime.

Note also that we are using the extends keyword which means that the generic type will extend the other type.

The Map, Equals, Hashcode Java Challenge

Mon, 17 May 2021 08:38:13 +0000

Understanding deeply how to use a Map, equals, and hashcode in Java will be a massive help for you to create high-quality code. The Map and object reference concepts are not only present in the Java language but in almost all programming languages. Therefore, if you master the concept of object references, equals and hashcode, and Maps, you can apply this in other programming languages and master them far more easily.

7 Functional Programming Techniques in Java: A Primer

Tue, 11 May 2021 07:34:52 +0000

There is a lot of hype around functional programming (FP) and a lot of cool kids are doing it but it is not a silver bullet. Like other programming paradigms/styles, functional programming also has its pros and cons and one may prefer one paradigm over the other. If you are a Java developer and wants to venture into functional programming, do not worry, you don’t have to learn functional programming oriented languages like Haskell or Clojure(or even Scala or JavaScript though they are not pure functional programming languages) since Java has you covered and this post is for you.

Optional takeWhile dropWhile Java Challenge

Mon, 10 May 2021 08:05:57 +0000

The Optional concept is present in many programming languages. The main goal of the Optional class is to avoid NullPointerException. It’s much easier to deal with null values when we use the concepts of an Optional.

In this challenge, we will also explore the takeWhile and dropWhile methods from Java 9. Therefore you will be upgrading your knowledge with Optional, takeWhile, and dropWhile!

Are you prepared to have fun with this Java Challenge and refine your Java skills?

Elastic JVM: Configuring G1 GC for Automatic Vertical Memory Scaling

Wed, 05 May 2021 13:45:22 +0000

Nowadays, JVM-based applications can benefit from elasticity and density of container technology. However, there are still some issues that may prevent from unleashing the full potential of Java and containers “marriage.”

Releasing unused but committed Heap memory by the major JVM implementations based on OpenJDK, in most cases, is not performed automatically, or requires specific knowledge to be configured.

To solve this problem and make Java RAM usage in containers more efficient, the Jelastic team collaborated with different experts involved in JVM development. We have periodically published articles highlighting this issue and motivating the community to help in finding a solution. As a result, attention to this topic has increased, and new improvements were introduced in different Garbage Collection implementations in order to make automatic vertical memory scaling possible.

Java Garbage Collection Types & Settings Customization via Jelastic PaaS

Thu, 29 Apr 2021 07:54:20 +0000

Performance and price are two big considerations in application hosting that always matter. And, often, we question ourselves on how to decrease the spends, without affecting the performance of your apps at the same time. In this article, we’d like to address automatic memory management for Java applications hosted with Jelastic using garbage collection.

Let’s clarify what garbage collection is, what it does for Java applications and how it works within Jelastic PaaS.

SKP's Core Java/Java EE Roots : Gang of Four Design Patterns - Part 01

Wed, 28 Apr 2021 13:43:33 +0000

[About SKP’s Core Java/Java EE Roots]
Series of Articles on Rooted Concepts in Core Java and J2EE. They Revolve Around Memory Architecture, Connection & Memory Leaks, Core Java Syntax & Semantics, Java Object Layout/Anatomy, Multi-Threading, Asynchronous Task Execution, Design Patterns, Java Agents, Class Loading, API Design, OOPs & SOLID.

To understand the philosophical and historical perspective on the Gang of Four’s design patterns, I made a short, 10-minute video. (This was also my PluralSight Author Audition). Please take time to view the [Introduction to Gang of Four Design Patterns] Video.

Modern JavaFX Game Development with FXGL - Pong

Tue, 27 Apr 2021 07:48:29 +0000

In this tutorial we will make a very simple clone of the classic Pong game using the FXGL game engine .

We will be using the latest (currently 11.15) version of FXGL via Maven (or Gradle):

<dependency>
 <groupId>com.github.almasb</groupId>
 <artifactId>fxgl</artifactId>
 <version>11.15</version>
</dependency>

The full source code is available at the end of this page. The game will look like this:

Whilst this tutorial is meant to teach basic concepts, building on them will allow us to produce much more complex examples .

Building Microservices with Spring Boot Fat (Uber) Jar

Wed, 21 Apr 2021 09:28:43 +0000

In most minds,microservices is an approach to make a traditional monolithic system more structured, dividing it into logical components that correspond to different functional areas of application. Thus, acting as a microservice, each component becomes self-contained, easily scaled, maintained and even upgraded without affecting the overall system. Also, with microservice architecture, you can use a software written in different programming languages, including Java. Such freedom attracts but may frighten at the same time.

Jenkins Cluster for Continuous Integration and Delivery in Jelastic PaaS

Mon, 12 Apr 2021 12:44:50 +0000

Jenkins is an open-source continuous integration and delivery system designed to ensure build and deploy automation. It is well-suited to be installed in the cloud to run self-hosted pipelines.

Jenkins supports clustering via master-slave mode. A build process can be delegated to several slave (worker) nodes. This allows serving multiple projects in a single Jenkins cluster setup.

In this article, we’ll describe how to install Jenkins cluster with slave nodes auto-discovering and self-registering inside a master node. Jelastic PaaS implemented this solution in Jenkins DevOps Pack that can be installed from the Marketplace or through environment setup wizard as a New Environment. In this tutorial we’ll cover both. Also, you will find out how to build a simple Java project hosted on GitHub using Jelastic Maven plugin.

OIDC Client with Mutual TLS Client Authentication

Thu, 04 Feb 2021 08:48:06 +0000

It is common to authenticate OAuth and OpenID Connect (OIDC) clients with secrets. When you register a client in the Authorization Server (i.e., the OpenID Connect Provider, OP), you typically get a client ID and a secret. These are then used as credentials whenever your client sends requests to the Authorization Server. Often, this type of credential will provide a sufficient level of security for a deployment; other times, however, this simply is not enough. Authenticating with client ID and secret means that if anyone manages to steal or guess your application’s credentials, they will be able to use them to impersonate it. The attacker does not even have to intercept the credentials themselves. They may be able to capture a request sent to the Authorization Server and replay it. The Authorization Server does not know who is sending the request; it can only check whether the credentials are valid. (This is why it’s also important to use TLS and unguessable client secrets when using this type of credential.)

How to Do Device Monitoring with JavaFX and FXGL

Mon, 11 Jan 2021 10:09:21 +0000

In a previous post “Getting Started with FXGL Game Development” we already have taken a look at the FXGL game development framework developed by Almas Baimagambetov .

But, this game engine can also be used for other use cases. In this post, we will be building a system monitoring dashboard, which can run on a Raspberry Pi. The dashboard can be used to keep an eye on any device that can report its state to a queue. And, for me personally, it finally solves the problem of finding the IP addresses of all my Raspberry Pi’s when my router decided to shuffle them… 😉

How To Bring Your Java Microservices To The Cloud

Fri, 08 Jan 2021 11:20:46 +0000

All companies are software companies, and businesses will always experience the challenge of keeping integrations between users and applications scalable, productive, fast, and of high quality. To combat this, cloud, microservices, and other modern solutions come up more and more in architectural decisions.

Here is the question—is Java prepared to deal with these diverse concepts in a corporate environment?

Yes, and to demonstrate how Jakarta EE and Eclipse MicroProfile work very well and in the cloud, Payara and Platform.sh collaborated together on this webinar. You can watch the video presentation by Otavio Santana and Rudy de Busscher below:

Creating a JavaFX World Clock from Scratch (Part 2)

Thu, 24 Dec 2020 09:46:11 +0000

“The only way to learn mathematics is to do mathematics.” – Paul Halmos[1]

Introduction

Welcome to Creating a JavaFX World Clock from Scratch Part 2!

This is the second installment of a series of blog entries on how I created a “sci-fi” looking world clock using JavaFX.

If you have not read Part 1[2] please see the introduction section of the Creating a JavaFX World Clock from Scratch (Part 1) [2] .

Creating a JavaFX World Clock from Scratch (Part 1)

Mon, 14 Dec 2020 09:27:54 +0000

Good design’s not about what medium you’re working in. It’s about thinking hard about what you want to do and what you have to work with before you start." – Susan Kare [6]

Introduction

Welcome to Creating a JavaFX World Clock from Scratch (Part 1)! In this series of blog entries I would like to show you how I created a “sci-fi” looking world clock that happens to be a cross-platform Java desktop application.

Immutable Collections in Java with Sealed Types

Thu, 10 Dec 2020 03:02:00 +0000

Designing Immutable Collection using Sealed Types in JDK 15{#caption-attachment-36538}

How to define contractual, structural, and verifiable immutable Java collections.

Introducing Sealed Types

JDK 15 was released on September 15, 2020. JEP 360 Sealed Types was included as a preview feature in this release, with its second preview in JDK 16. Sealed Types is part of Project Amber . Sealed classes or interfaces can be used to restrict the interfaces or classes that are allowed to extend them. This is accomplished by using the sealed, non-sealed, and permits modifiers.{#297e}

What are Hidden Classes in Java 15 And How Are They Used?

Thu, 03 Dec 2020 10:15:18 +0000

As we know, sun.misc.Unsafe APIs are not recommended to use outside the JDK, with a slight mistake you may cause the JVM to crash. In some cases, code may not be portable across different platforms and many other related problems may occur.

On the other hand, there are some useful features Unsafe APIs provide and we don’t have an alternative for those as a standard language feature. To remove Unsafe API usages, JDK developers provide standard language features, the JDK 15 “hidden class” is one such feature. After the introduction of hidden classes, sun.misc.Unsafe::defineAnonymousClass is deprecated in Java 15, which will be removed in future releases.

Why I Love IntelliJ IDEA for Java Development

Mon, 30 Nov 2020 09:16:06 +0000

If you’re a Java developer like me, you like to crank out code and get shit done. I like many things about IntelliJ IDEA, but I thought it’d be fun to write about the ones that make me most productive. First, a bit of my development history.

When I first started doing Java development in the late 90s, I used HomeSite as my editor. HomeSite was an HTML editor initially developed by Nick Bradbury. I liked it because it defaulted to a view of your code rather than being WYSIWYG like Dreamweaver and FrontPage. It’s funny to look back now and laugh about how inefficient I was: I used to google for import statements, then copy/pasted them into the editor.

Native Applications from a JavaFX Project for Multiple Devices

Wed, 25 Nov 2020 08:58:00 +0000

The post “Starting a JavaFX Project with Gluon Tools” shows you how to start a Gluon Mobile Multiview project with a few clicks in IntelliJ IDEA thanks to the “Gluon plugin” .

In this post, we will use such a project and build it with GitHub Actions as a native application for Windows, MacOS, iOS, Linux, and Android from one single code base!

Yes, that’s right!

True “Write Once, Run Everywhere”!!!

The Application

This application is built around a Java library I created last year for my book “Getting Started with Java on the Raspberry Pi” which helps you to calculate the value of a resistor from its color rings. This library is further described on “Resistor color codes and calculations as a Java Maven library” .

Starting a JavaFX Project with Gluon Tools

Tue, 17 Nov 2020 08:38:06 +0000

Here on foojay.io you can already find two posts by Carl Dea to get you started with JavaFX:

Beginning JavaFX Applications with IntelliJ IDE : step-by-step how to start a new JavaFX project without any tools, are by using the Maven and Gradle tools.
A JavaFX App on ZuluFX in 60 Seconds : how to use a popular distribution from Azul to build a JavaFX HelloWorld Application in 60 seconds.

In this post, I want to show you yet another approach that uses the tools provided by Gluon , who are the maintainers, and the driving force behind OpenJFX .

For the Record: A Little Less Conversation, A Little More Action

Fri, 13 Nov 2020 08:52:40 +0000

Ever since Java announced their 6-month release cycle, there is excitement around exploring new features and even more so with preview features.

See JEP-12 for the definition of the preview feature.{#2d3e}

A preview feature is a new feature of the Java language, Java Virtual Machine, or Java SE API that is fully specified, fully implemented, and yet impermanent. It is available in a JDK feature release to provoke developer feedback based on real world use; this may lead to it becoming permanent in a future Java SE Platform.{#9a9b}

Getting Started Quickly and Easily with Payara Server

Tue, 10 Nov 2020 09:39:02 +0000

The following four short videos will take you step-by-step through installing, writing, and deploying an application to Payara Server , even if you’ve never used the application server before:

{#more-36262}

Introduction to Payara Server

Learn how to write a simple Hello World application and deploy it to Payara Server.

Install Software

New to IntelliJ IDEA by JetBrains? Me Too!

Fri, 02 Oct 2020 10:07:49 +0000

Until recently, I last wrote Java in anger in 2002. IntelliJ IDEA had just been released; it wasn’t remotely on my radar. I honestly can’t remember what IDE we were using back then, but it certainly was a very long way to the fully featured IDE that JetBrains produce today.

Here’s my experience of using IntelliJ IDEA for the first time!

1. Downloading IntelliJ IDEA

There’s a lot going on when you first load IntelliJ IDEA, but I learned pretty quickly that there are also some good first steps you can take to make your experience a little more comfortable.

Electronics & Quarkus Qute on Raspberry Pi

Wed, 30 Sep 2020 08:07:13 +0000

The “Hello World” version of electronics programming is a blinking LED. But, in this post, we will go a few steps further and control 8 LEDs inside a number display.

We will do this by taking a closer look at one of the projects in the list “Spectacular Java Projects on the Raspberry Pi ”.

Igor De Souza , Dublin based Principal Big Data Consultant at Oracle, set up an interesting experiment in which he combines a LED number display with the Raspberry Pi and Quarkus.

Getting Started with Babel for Java and OpenJDK

Tue, 29 Sep 2020 07:57:36 +0000

In the JavaScript world, developers have to deal with a multitude of JavaScript engines in different browsers and browser versions, while the language itself is evolving quickly. This is only possible because of clever tools like the retrofitting compiler Babel (https://babeljs.io ). Babel backports new features to work on older JavaScript engines, allowing developers to use modern JavaScript language features and still be compatible with the majority of browsers out there.

Getting Started Learning Java as a First Language

Thu, 24 Sep 2020 13:44:00 +0000

I started programming in Java way back in 1999. I had just started a job as the director of web development at a small startup called eDeploy.com. I wrote a lot of HTML, CSS, and JavaScript for a SaaS product that helped companies install network equipment. The backend for our app was written in Java and we deployed to iPlanet Application Server. At our height, we trusted Loudcloud to run our software.

Getting Started with a Simple Service with Spring Boot

Tue, 22 Sep 2020 12:59:42 +0000

In this post, I will demonstrate how to create a simple Web Service using Spring Boot. This framework makes it almost effortless to develop web services, so long as the appropriate dependencies are in place.

In this example, I will create a Web Service that will read the current temperature from a file and make it available to clients via a RESTful endpoint.

1. Use the Spring Intializr

The Spring Initializr helps one to choose the dependencies that are required for production a particular solution.