Use Cases on foojay.io - Friends of OpenJDK

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.

From a JAR to a full-fledged MacOS app

Thu, 05 Feb 2026 10:15:05 +0000

A couple of years ago, I developed a small Kotlin GUI to help me rename my files in batch. I actually created it with different JVM frameworks to compare their relative merits. In any case, I didn’t use it up until last week. And then, I was surprised to see that it didn’t work to rename a network volume, although it had in the past. In this brief post, I aim to describe the issue and its solution.

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!

DocBox v5 - Reborn: Modern API Docs for BoxLang & CFML

Tue, 27 Jan 2026 12:15:45 +0000

Welcome to DocBox v5! We didn’t just update DocBox. We rebuilt it from the ground up.

DocBox v5.0.0 represents a complete architectural rewrite—modern syntax, blazing performance, and a stunning new look that finally brings API documentation into 2025. Gone are the clunky HTML pages of yesteryear. Say hello to a gorgeous, theme-driven single-page application that makes browsing your API docs feel like using a premium developer tool. We have also released a dedicated module for BoxLang: BX-DOCBOX. A fully interactive CLI tool for generating your docs from the command line using pure BoxLang.

BoxLang AI v2: Enterprise AI Development Without the Complexity

Thu, 22 Jan 2026 15:09:25 +0000

One Year. 100+ Features. Unlimited Possibilities.

Just one year ago, in March 2024, we launched BoxLang AI 1.0. Today, we’re thrilled to announce BoxLang AI v2—a massive leap forward that positions BoxLang as one of the most powerful and versatile AI framework on the JVM. This release is 9-months in the making, with over 100 new features! This would have not been possible without all the new features that the BoxLang JVM language exposes to developers like: Server Side Events, HTTP Streaming, HTTP pooling, Caching, and so much more.

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.

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.

JC-AI Newsletter #8

Thu, 30 Oct 2025 06:36: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, agentic system architecture, attack vectors, Model Context Protocol (MCP) implementation, Agent-to-Agent (A2A) protocol, Java code generation within IDEs, LLM benchmarking methodologies, and the security challenges arising from increased AI-LLM adoption.

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

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.

Kotlin adoption inside ING, five years later

Wed, 02 Jul 2025 06:21:47 +0000

TL;DR: Five years after its introduction Kotlin adoption inside ING keeps growing year after year, with a current adoption rate of just over 11%. We were also featured as one of the user stories for the KotlinConf 2025 Keynote.

Five years ago, Hielke and I wrote one of the first blogs of this account about being the first team to put Kotlin on production at ING . The article generated some interest and to this day it is still present as one of the Kotlin website case studies .

Semantic Search with Spring Boot & Redis

Mon, 05 May 2025 15:35:55 +0000

TL;DR: You’re building a semantic search app using Spring Boot and Redis. Instead of matching exact words, semantic search finds meaning using Vector Similarity Search (VSS). It works by turning movie synopses into vectors with embedding models, storing them in Redis (as a vector database), and finding the closest matches to user queries.

A traditional searching system works by matching the words a user types with the words stored in a database or document collection. It usually looks for exact or partial matches without understanding the meaning behind the words.

Review of Junie, a coding agent by JetBrains – Revie

Wed, 26 Feb 2025 01:38:47 +0000

Other languages: Español 한국어 Português 中文

Recently, I talked about Duplicate Finder on the Foojay Podcast hosted by Frank Delporte . We briefly touched upon implementing support for other formats, and Frank asked if I’m planning on adding AsciiDoc, as it could be useful for his technical writing at Azul.

We agreed to think about adding the support soon. At the same time I got access to Junie , a newly announced coding agent by JetBrains, which is currently in early access. After a while, a thought came to me that this is a great opportunity to try it in action.

A solution to the problem of cluster-wide CRDs

Thu, 30 Jan 2025 11:55:14 +0000

I’m an average Reddit user, scrolling much more than reading or interacting. Sometimes, however, a post rings a giant red bell. When I stumbled upon If you could add one feature to K8s, what would it be? , I knew the content would be worth it.

The most voted answer is:

Namespace scoped CRDs

A short intro to CRDs

Kubernetes comes packed with existing objects, such as Pod, Service, DaemonSet, etc., but you can create your own: the latter are called Custom Resource Definitions. Most of the time, s are paired with a custom controller called an operator. An operator subscribes to the lifecycle events of CRD(s). When you act upon a CRD by creating, updating, or deleting it, Kubernetes changes its status, and the operator gets notified. What it does depends on the nature of the CRD.

Java Server and Rust Client Built with Generated Networking Code

Fri, 04 Oct 2024 11:58:05 +0000

FEPCOS-J allows declaratively implementing a Java server and generating its profile, which, for example, can be used to generate the networking code of a Rust client.

Introduction

As I have shown in a previous post [1] and a video [2], the FEPCOS-J development tool [3] prototypically implements a Java language extension that allows implementing a client-server application in Java without the need for manual network programming.

In a nutshell, FEPCOS-J allows a Java developer to program a server’s system specification declaratively using annotations. The FEPCOS-J Processor fjp uses this specification to generate the server’s system export module and system import module.

Implementing the Idempotency-Key specification on Apache APISIX

Mon, 02 Sep 2024 20:58:24 +0000

Recently, I wrote an analysis of the IETF Idempotency-Key specification . The specification aims to avoid duplicated requests.

In short, the idea is for the client to send a unique key along with the request:

If the server doesn’t know the key, it proceeds as usual and then stores the response
If the server knows the key, it short-circuits any further processing and immediately returns the stored response

This post shows how to implement it with Apache APISIX .

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.

JavaFX Nodes versus Canvas

Wed, 07 Aug 2024 08:22:31 +0000

Recently I was working on an article about Azul Zulu with JavaFX support for ARM systems, like the Raspberry Pi. As you can see in this video , I found out my little test application with a lot of “bouncing balls” started losing performance on the Raspberry Pi with more than 1000 of those balls.

Of course, having that high number of visual components in a typical JavaFX user interface would be a badly designed application. Imagine a long registration form with that number of input fields and labels… it would drive your users crazy.

Client-server application in Java: Easy with FEPCOS-J – Video.

Tue, 30 Jul 2024 11:51:04 +0000

This is a result of the FEPCOS-Project , aka @FepcosInfo; #FepcosJ_blog5.

See how FEPCOS-J relieves developers of the network programming required to implement a client-server application in Java.
External link to : G. Fuchs: Video: Easy Implementation of a Client-Server Application in Java with FEPCOS-J; On: YouTube, FEPCOS-Project (@FepcosInfo); 29-July-2024; https://youtu.be/qtPP7kZbriQ .
Impression of the above-linked video: FEPCOS-J provides annotations like @AYSpec, @In, @Out, and @Behavior for programming a client-server application in Java. Watch the video for a complete example application of FEPCOS-J.

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.

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.

Workflow, From Stateless To Stateful

Wed, 05 Jun 2024 06:11:38 +0000

A (long) time ago, my first job consisted of implementing workflows using the Staffware engine. In short, a workflow comprises tasks; an automated task delegates to code, while a manual task requires somebody to do something and mark it as done. Then, it proceeds to the next task - or tasks.

Here’s a sample workflow:

The above diagram uses Business Process Model and Notation . You can now design your workflow using and run it with compatible workflow engines.

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).

Diagnosing user-reported issues using WireQuery

Mon, 13 May 2024 07:11:04 +0000

As a developer, I’ve often struggled with diagnosing user-reported issues, which is often caused by a lack of information to reproduce the problem. While a ticket may contain a screenshot of the problem and a description, it often does not portray the complete picture. For example: what did the user do that led up to the issue? What endpoints were called from the frontend, and how did they respond? What did the underlying systems communicate? Etc.

Debug Without Breakpoints – Guide to IntelliJ IDEA's Pause

Mon, 22 Apr 2024 06:59:28 +0000

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

In a typical debugging scenario, you would set breakpoints to tell the debugger when to suspend your program. A breakpoint usually corresponds to the moment that marks the starting point of the further investigation.

However, in some situations you aren’t certain about where to set a breakpoint. Other times, you might prefer to suspend the program at a particular time rather than aiming at a specific line.

Multithreaded server in Java: That's easy with FEPCOS-J.

Thu, 21 Mar 2024 08:38:28 +0000

FEPCOS-J prototypically implements a Java language extension that allows the realization of a multithreaded TCP/IP server in Java without thread or network programming.

Please help me to make FEPCOS-J a Free/Libre and Open-Source Software (FLOSS).

Introduction

FEPCOS-J [1] is a Java development tool that prototypes a Java language extension for declarative programming of networked systems. See my previous posts for details [2, 3, 4] .

Firstly, this post briefly defines the term “multithreaded TCP/IP server” . It then describes how FEPCOS-J supports programming a multithreaded TCP/IP server in Java . Further, the post explains what implementing the server with FEPCOS-J looks like and provides an example . Finally, the post draws a conclusion .

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.

Building gdocweb with Java 21, Spring Boot 3.x and Beyond

Tue, 30 Jan 2024 12:40:00 +0000

Table of Contents

Introducing gdocweb
- Java 21 and Spring Boot 3.x: Innovation and Maturity
GraalVM Native Image for Efficiency
Deployment: VPS and Docker Compose
Front-End: Thymeleaf Over Modern Alternatives
Final Word

Starting a new project is always a mix of excitement and tough decisions, especially when you’re stitching together familiar tools like Google Docs with powerhouses like GitHub Pages.

FEPCOS-J: Native executables of Java-coded networked systems

Wed, 13 Dec 2023 12:13:07 +0000

FEPCOS-J prototypically enables Java developers to realize networked systems without low-level network programming and to automatically build native executables by means of GraalVM. This post introduces the concept and gives you an example by rebuilding the source code explained in my previous posts.

Please help me to make FEPCOS-J a Free/Libre and Open-Source Software (FLOSS).

Introduction

FEPCOS-J [1] enables a Java developer to declaratively program networked systems and compose them like building blocks [2] . For this purpose, FEPCOS-J provides Java modules and generates code to free a Java developer from network programming [3] .

Chopping the monolith in a smarter way

Thu, 07 Dec 2023 07:40:55 +0000

In my previous post Chopping the Monolith , I explained that some parts of a monolith are pretty stable and only the fast-changing parts are worth being “chopped.”

I turned the post into a talk and presented it at several conferences. I think it’s pretty well received; I believe it’s because most developers understand, or have direct experience, that microservices are not a good fit for traditional organizations, as per Conway’s Law .

Java for desktop applications: Tips and Tricks (Part 1)

Fri, 24 Nov 2023 09:18:15 +0000

As desktop applications have kind of become a niche topic, it’s getting harder to find information about up-to-date best practices for desktop development.

Since I have been doing this for many years now, I hope that I can share some of the lessons learned with other fellow desktop developers. Most items that are discussed here are taken straight from XPipe , the application I am working on right now. So if you’re skeptical or are interested in more details, you can take a look at the actual source code or try them in action yourself in the actual application.

Generative AI and Java - hype or urgent reality?

Mon, 06 Nov 2023 07:59:04 +0000

It’s hard to grasp that it’s been about a year since Chat GPT and other generative AI tools burst onto the scene. We’re all still grappling with, well, everything about them. Whatever equilibrium we eventually find, it’s clear that the world is changing. The whole world mind, not just the IT industry.

Olimpiu Pop and I have debated the situation multiple times, and we realised that there’s lots of rumour around AI and Java but not much in the way of fact.

GlassFish Embedded - a simple way to run Jakarta EE apps

Wed, 01 Nov 2023 15:55:14 +0000

A long-time GlassFish user and active member of the GlassFish community, Jan Blavins, shares how he uses GlassFish Embedded to take advantage of some of its unique features compared to traditional application servers.

I’ve been asked by the Eclipse GlassFish project to say a few words about how I use GlassFish Embedded. The GlassFish project is pretty active these days, they have helped me with some complex issues that I have raised. This way I want to thank them, especially to the OmniFish team, who is one of the main contributors to the GlassFish project and helped me with my issues with GlassFish.

FEPCOS-J (2) – Declaratively compose networked systems in Java

Fri, 13 Oct 2023 06:07:00 +0000

FEPCOS-J implements a model-based Java language extension that provides the annotation @Part, which enables a developer to declaratively compose networked systems. This post introduces the concept and gives you an example of how to use it.

Please help me to make FEPCOS-J a Free/Libre and Open-Source Software (FLOSS).

Introduction

FEPCOS-J arises in the frame of the FEPCOS-Project [1] , which aims to simplify the programming of composed networked systems.

FEPCOS-J implements a domain-specific Java language extension whose semantic domain is based on the FEPCOS-Model [2] , which extends the composite design pattern [3] to include networking aspects.

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.

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.

Dissection of Joeffice: Open Source Office Suite in Java

Tue, 11 Jul 2023 09:33:30 +0000

10 years ago, I challenged myself to write an office suite in Java in 30 days . This is how the first version of Joeffice was born. This created quite some buzz, including articles on Slashdot , Ars Technica and PC World .

Last month I released a second update. Let’s explore how I did this. By levering Java libraries, I was able to create such a complex piece of software very quickly.

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.

The Curious Case of Different Runtimes

Fri, 30 Jun 2023 08:12:09 +0000

While running some final tests, we noticed extremely erratic runtime behavior. It was hard to reproduce but very annoying because it means that the application runtime goes up from 5 to almost 14 min. This article tries to show how we diagnosed it and condensed it down to a few test cases. These might hopefully help us to provide some answers. Maybe, but only maybe, we discovered a defect or at least strange edge-case in the JVM.

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).

FEPCOS-J (1) – Description, Impression of Usage, Current State

Wed, 26 Apr 2023 06:09:41 +0000

Abstract: FEPCOS-J has arisen in the context of my work in the field of robot sensor networks. It implements a Java-language extension that frees a Java developer from network programming and supports cross-system concurrency. This article gives you an impression of using FEPCOS-J based on a simple example.

So far, FEPCOS-J is a prototype with 1629 lines of Java-code. I develop and test it on my own within a toy robot-based amd64 / x64 Linux OpenJDK 17 environment, which communicates via a private and secured IPv4-network.

How Not To Skip A Message Even If Your Data Centre Fails

Fri, 07 Apr 2023 15:21:31 +0000

A high level of availability of IT services is crucial to prevent disruptions of service that can lead to financial losses, business opportunity losses, data loss, and reputational damage.

A business’s downtime cost can vary depending on its size, nature and the length of the downtime.

Studies by Network Computing, the Meta Group, and Contingency Planning Research have identified financial services and telecommunications as industries with the highest revenue loss during downtime, demonstrating the importance of FIX engine high availability.

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.

The Right Feature at the Right Place

Tue, 28 Feb 2023 11:08:14 +0000

Before moving to Developer Relations, I transitioned from Software Architect to Solution Architect long ago.

It’s a reasonably common career move.

The problem in this situation is two-fold:

You know perfectly well software libraries
You don’t know well infrastructure components

It seems logical that people in this situation try to solve problems with the solutions they are most familiar with.

However, it doesn’t mean it’s the best approach.

It’s a bad one in most cases.

The evolution of APIs: From RESTful to Event-Driven

Thu, 23 Feb 2023 08:23:25 +0000

History of Services and APIs

Enterprise application landscapes consist of inter-connected and inter-related applications.

The world of application integrations has been constantly evolving over several years.

Over time, we’ve observed a trend towards more modular and data model-focused integration components, and an increased emphasis on real-time processing.

Beginning with EJBs in the 90s, progressing to Webservices and Service-Oriented Architecture (SOA) in the early 2000s, and finally evolving to domain-specific microservices, we are seeing a continual progression towards more efficient and effective integration solutions.

Visualizing Brain Computer Interface Data using JavaFX

Fri, 09 Dec 2022 09:42:20 +0000

Recently Sean Phillips shared some fascinating screenshots on Twitter and videos on YouTube of Trinity, a JavaFX application he is working on.

He is a software engineer at the Johns Hopkins University Applied Physics Laboratory (JHUAPL ), specializing in data visualization for multiple projects. JHUAPL works on various projects, ranging from medical work, building drones, cyber defense, and brain-computer interfaces to cislunar defense systems.

The project that caught my eye is a visual exploration tool to test and evaluate machine learning decision-making and decoding systems.

A Poor Man's API

Tue, 29 Nov 2022 09:13:38 +0000

Creating a full-fledged API requires resources, both time and money.

You need to think about the model, the design, the REST principles, etc., without writing a single line of code.

Most of the time, you don’t know whether it’s worth it: you’d like to offer a Minimum Viable Product and iterate from there.

I want to show how you can achieve it without writing a single line of code.

The solution

The main requirement of the solution is to use the PostgreSQL database . It’s a well-established Open Source SQL database.

Structured Error Messages for HTTP APIs

Tue, 01 Nov 2022 11:01:18 +0000

Ever since I started to work on the Apache APISIX project, I’ve been trying to improve my knowledge and understanding of REST RESTful HTTP APIs.

For this, I’m reading and watching the following sources:

Books. At the moment, I’m finishing API Design Patterns . Expect a review soon.
YouTube. I’d recommend ErikWilde’ channel . While some videos are better than others, they all focus on APIs.
s. Most RFCs are not about APIs, but a friendly person compiled a list of the ones who are .

Today, I’d like to introduce the “Problem Details for HTTP APIs” RFC, aka , RFC 7807 .

Embracing Java 17: Here’s What We Learned at Picnic

Mon, 30 May 2022 08:10:20 +0000

Java 17? Count us in! At Picnic , we’re more than a grocery delivery company.{#eb88}

There’s a lot of tech behind the scenes that enables us to provide the affordable, sustainable service our customers have come to expect — and the back end of most of that tech is written in Java.{#eb88}

So when the new Java 17 release was announced, we were excited to get started.{#eb88}

Having moved to Java 11 within the quarter after its release, we stepped it up a gear this time and are proudly running Java 17 in production in the same quarter it was released — we like to move fast!{#eb88}

Hardware Acceleration For Java? TornadoVM Can Do It!

Fri, 01 Apr 2022 07:37:03 +0000

Java programs can primarily run on x86 and Arm platforms and recent efforts focus on ports to PowerPC and RISC-V.

Despite the diverse range of ISAs, contemporary computers are equipped with heterogeneous devices, such as Graphics Processing Units (GPUs), Field Programmable Gate Arrays (FPGAs), and Tensor Processing Units (TPUs), which operate as co-processors that offload data processing from the main processor.

A question that rises is whether such compute power can be utilized by Java programs. The answer is that several frameworks have been created to address this challenge. For instance, IBM J9 , Aparapi , and TornadoVM , are frameworks that aid Java programmers to accelerate their programs on heterogeneous hardware devices.

Observability for JVM Frameworks with Grafana in Java and Kotlin

Wed, 30 Mar 2022 06:30:58 +0000

Grafana dashboard for all running frameworks

Introduction

In times of Cloud and distributed applications, it is becoming more and more important to be able to evaluate a functionality at runtime, an aspect which is referred to as observability .

A Cloud-based application is usually set up as a collection of different subsystems that may be located in one or more network zones or machines. These subsystems communicate with each other by passing messages (signals) and executing desired actions to each other. The whole collection then appears to the end user as a single coherent system.

Beautify Third-Party APIs with Kotlin

Tue, 21 Dec 2021 08:15:42 +0000

Scala has popularized the “Pimp my library” pattern:

This is just a fancy expression to refer to the ability to supplement a library using implicit conversions.

– Pimp My Library Pattern in Scala

Kotlin does provide the same capability. However, it achieves it via extension functions. While the generated bytecode is similar to Java’s static methods, the developer experience is the same as adding functions to existing types.

This approach has limitations, though. One cannot update the type hierarchy.

Multiple Spring Boot Applications in the Same Project

Wed, 08 Dec 2021 16:42:44 +0000

I frequently use the Spring Boot framework in my demos. The latest one is no different. It shows how to achieve using two different code paths:

the command part is implemented via Spring Data JPA
the query part via jOOQ

My use case is a banking application that offers a REST layer allowing clients to call any parts. Demoing the query part is easy enough with curl as the URL is not complex:

Visual Recognition for Chess with Deep Learning in Java on Android

Thu, 11 Nov 2021 20:07:51 +0000

Find out how can you use AI in Java to build applications that can see and understand the world. This article describes an Android chessboard position scanner built with pure Java deep learning engine Deep Netts .

Over the last few decades, the technological advancement in the Artificial Intelligence (AI) field has greatly assisted many chess grand masters’ preparation as well as understanding chess theory. There are programs called chess engines, like Bagatur, Stockfish, and Komodo, which play extremely strong chess. These engines make deep and beautiful moves, but sometimes these moves are difficult to understand even by chess experts. Clearly, AI/ML has allowed chess engines to become quite advanced, but they are only one aspect of the story. There are more applications of AI/ML in playing the game of chess.

Hazelcast + Kibana: Best Buddies for Exploring & Visualizing Data

Thu, 04 Nov 2021 14:22:15 +0000

A lot, if not all, data science projects require some data visualization front-end to display the results for humans to analyze. Python seems to boast the most potent libraries, but do not lose hope if you’re a Java developer (or if you’re proficient in another language as well).

In this article I will describe how you can benefit from such a data visualization front-end without writing a single line of code.

Timely Computation of Derived Values

Fri, 10 Sep 2021 09:22:36 +0000

In a recent article here on Foojay , on a real world stream collector, I described the use-case of an e-commerce shop.

In general, interactions in such a shop are the following:

You can browse a catalog of items
Each item has a price tag
You can put x items in your cart

This is where the exciting part starts.

On most pages, you want to give users a condensed view of their cart’s state.

Deep Learning in Java for Drug Discovery

Fri, 20 Aug 2021 09:28:10 +0000

In the age of big-data, rising pharmaceutical costs, and an ever-increasing market demand, it is becoming apparent that drug design strategies need to adapt in order to meet patients’ therapeutic needs for a host of medical conditions.

Costly and time-intensive experimental work is one of the main bottlenecks in the drug discovery pipeline, which can take up to a decade, while experiencing a failure profile of up to 95% before a molecular candidate can be approved for patient use.

GitLab: Your Continuous Deployment One-Stop Shop

Wed, 04 Aug 2021 07:44:20 +0000

This week, I want to take a break from my Rust series and focus on a different subject. I’ve already written about my blogging stack in detail.

However, I didn’t touch on one facet and that facet is how I generate the static pages from Jekyll. As I describe in the blog post, I’ve included quite a couple of customizations. Some of them require external dependencies, such as:

A for PlantUML diagrams generation
The graphviz package for the same reason
etc.

All in all, it means that I require a fully configured system. I solved this problem by using containerization, namely Docker. Within the Dockerfile, I’m able to install all required dependencies. Then, in my GitLab build file, I can reference this image and benefit from all its capabilities.

SKP's Primer: Failures, Pitfalls, and Disadvantages of Microservices

Mon, 02 Aug 2021 09:35:44 +0000

[About SKP’s Definitive Microservices Primer]
Series of Articles on Microservices Architecture. They Revolve Around Microservices Strategy, Decision Making, Monolithic vs Microservices, Microservices Infrastructure, Failures & Pitfalls of Microservices, Microservices Design Patterns, Database Design, Security, Logging, Messaging, Containerization, Cloud Providers and Everything that is Microservices and More!

Intro to Microservices Adoption in Real World

Microservices Adoption is almost becoming the normal in almost all software product and it services organizations. Hereby, i am taking this opportunity to make you aware of the Real-World Issues (Case Studies) that are faced by organizations (small, mid, large) of all sizes in migrating or adopting microservices. Since learning from other’s mistakes and knowing the pitfalls upfront help us prepare and plan better - this article will be helpful for those planning a shift to the Microservices Strategy organization-wide or simply making a move from Monolithic to Microservices Architecture.

Primitive Set Operations in Eclipse Collections — Part 2

Tue, 22 Jun 2021 22:58:38 +0000

Primitive Set Operations in Eclipse Collections - Part 2{#caption-attachment-45284}

Continuing from Part 1 , in the Eclipse Collections 11.0 release, we will have the following Set operations union, intersect, difference, symmetricDifference, isSubsetOf, isProperSubsetOf, cartesianProduct on primitive collections.

Set Operations that will be available on primitive sets in Eclipse Collections 11.0.{#caption-attachment-45283}

Querying Your In-Memory-Data-Grid: Why and How?

Fri, 21 May 2021 07:11:28 +0000

An in-memory data grid (IMDG) is a set of networked/clustered computers that pool together their random access memory (RAM) to let applications share data with other applications running in the cluster. Though IMDGs are sometimes generically described as a distributed in-memory data store, IMDGs offer more than just storage. IMDGs are built for data processing at extremely high speeds. They are designed for building and running large-scale applications that need more RAM than is typically available in a single computer server. This enables the highest application performance by using RAM along with the processing power of multiple computers that run tasks in parallel. IMDGs are especially valuable for applications that do extensive parallel processing on large data sets.

A Real-World Example of a Stream Collector

Fri, 07 May 2021 07:34:45 +0000

Java Stream’s Collectors methods fit most use-cases. They allow returning either a Collection or a scalar. For the former, you use one of the toXXX() method, for the latter, one of the reducing() one.

Let’s imagine an e-commerce platform that implements a shopping cart. The cart is modeled as the following:

This diagram might translate into the following (abridged) code:

public class Product {

 private final Long id; // 1
 private final String label; // 1
 private final BigDecimal price; // 1

 public Product(Long id, String label, BigDecimal price) {
 this.id = id;
 this.label = label;
 this.price = price;
 }

 @Override
 public boolean equals(Object object ) { ... } // 2

 @Override
 public int hashCode() { ... } // 2
}

Getters
Only depend on id

public class Cart {

 private final Map<Product, Integer> products = new HashMap<>(); // 1

 public void add(Product product) {
 add(product, 1);
 }

 public void add(Product product, int quantity) {
 products.merge(product, quantity, Integer::sum);
 }

 public void remove(Product product) {
 products.remove(product);
 }

 public void setQuantity(Product product, int quantity) {
 products.put(product, quantity);
 }

 public Map<Product, Integer> getProducts() {
 return Collections.unmodifiableMap(products); // 2
 }
}

Organize products into a map. The key is the Product; the value is the quantity.
Remember to return a read-only copy of the collection to maintain encapsulation.

Once we have defined how we store data in memory, we need to design how to display the cart on-screen. We know that the checkout screen needs to show two different bits of information:

Creating CAD Applications with Java and JavaFX

Wed, 09 Dec 2020 11:26:19 +0000

I’m a Java (JavaFX) freelance consultant, Software Engineer and Software Designer and a few months ago I finished a CAD application for a client.

This is a CAD application whose purpose is to calculate the energy efficiency of Dwellings (or multiple Dwellings). It can be seen as an application similar to Autocad (which is used in Civil Engineering, Architecture, etc) but with the specific purpose to do energy efficiency assessment.