Rob Austin on foojay.io - Friends of OpenJDK

Top 7 Java Microservices Frameworks

Wed, 29 May 2024 08:58:16 +0000

History of Microservices

The concept of microservices has its roots in Service Oriented Architecture (SOA), which was prominent in the early 2000s. However, the term “microservices” itself didn’t appear until around 2012, when it started being discussed at software architecture events and on software architecture blogs.

Early pioneers of microservices include companies like Netflix, Amazon, and eBay. For instance, in 2009, Netflix started to transition from a monolithic architecture to a microservices architecture to better handle their rapidly scaling customer base. Other major companies followed, realizing that the monolithic architecture model had limitations when dealing with large-scale, complex systems.

The High Availability Features of Microservices using Chronicle Services

Thu, 25 Apr 2024 13:36:34 +0000

In low-latency microservices, ensuring system resilience without compromising performance is vital.

This article explores how Chronicle Services , a Java-based framework optimised for low-latency microservices, meets these critical requirements by integrating HA, performance, and data persistence.

Stateful and Stateless Services

A Chronicle Service application consists of a number of processing units known as Services, which interact with each other using events posted on Chronicle Queues . The Chronicle Queue is an extremely fast shared memory inter-process communication; it also has an enterprise version that facilitates replication of queues over the network.

Preserving Software Continuity: Empowering Failover Strategies for Uninterrupted Operations

Thu, 16 Nov 2023 07:53:49 +0000

In today’s ever-changing and fast-paced digital landscape, maintaining uninterrupted business continuity is of utmost importance.

Enter Chronicle Services , a robust mechanism dedicated to upholding application integrity even in the face of service disruptions.

Let’s examine the world of failover strategies and explore how they safeguard software continuity.

Stateless vs. Stateful Services

It’s important to appreciate the difference between stateless and stateful services. Your choice of failover approach is highly influenced by this understanding, especially if the aim is to resume services seamlessly from where they were interrupted.

Building High-Performance Java Microservices with EDA

Wed, 16 Aug 2023 21:34:18 +0000

Event-Driven Architecture (EDA) is a design principle focused on the creation, detection, and reaction to events.

Renowned for its resilience and low latency, EDA is a reliable choice for developing robust, high-performing microservices.

Moreover, this method can be helpful in improving productivity and making the process of cloud migration smoother.

In this article we will outline 6 key considerations and tactics for developing such services.

1) Crafting Event-Based Microservices

Within EDA, microservices interact with each other through events. An event is simply an immutable indication that something has happened. Microservices register their interest in a subset of events and perform their processing by reacting to these events when they occur. On completion of handling of an event, microservices will usually post one or more events reflecting the result of this processing, which will trigger further downstream microservices.

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?”

Is There a Best OS to Develop a Java Application on?

Wed, 22 Feb 2023 11:43:40 +0000

One subject that often evokes a lot of debate is which is the best OS to develop a Java application on. This article gives my view on the issue.

Java runs very well on Windows, macOS and Linux Distributions.

I work for Chronicle Software , and much of our software is open-source Java libraries, so we don’t, or rather we can’t, require our customers to run on a particular operating system. You may be surprised to hear that we don’t mandate which operating system our staff should use either. We let them use the one that causes the least friction, the one that they are most productive with.

Why Core-to-Core Latency Matters

Thu, 02 Feb 2023 11:16:43 +0000

A few years ago we had a global shortage of microchips; now, I feel there is a worldwide shortage of software developers.

Like many other software companies, Chronicle Software is rapidly expanding and interviewing candidates. We usually ask candidates to demonstrate a good knowledge of core Java, then we cover slightly more advanced concepts, such as the use of volatile memory, memory barriers and fences.

While it is important to have a high-level understanding of these concepts when writing concurrent code, it’s surprising how few Java developers with 10+ years of experience have a deep knowledge of the underlying hardware. An initial goal of Java was to “write once, run anywhere”, but does that mean we should not be sympathetic to the hardware?

How to Leverage Method Chaining to Add Smart Message Routing

Wed, 04 Jan 2023 08:33:43 +0000

This article explores how to use method chaining to add routing information to serialised data structures in a lightweight fashion, where the routing information can be read separately by an intelligent message router.

We are going to use the open-source serialisation library Chronicle Wire . Let’s assume we have some data that we want to send to a particular destination; we don’t want to pollute our business data structures with the routing information. In the future, the routing information could be removed or changed based on external factors such as system failover or horizontal scaling.

Challenges when Developing a GUI for FIX

Wed, 21 Dec 2022 08:06:18 +0000

In this article, we explore the challenges in developing a Graphical User Interface (GUI) for Financial Information Exchange (FIX) data.

FIX is both a protocol and a message format, but to create a FIX GUI we will focus just on the message format.

A FIX message is a standard message format for transmitting financial and investment banking data.

Below is an example of a FIX message, where the “|” character is sent as ‘\1’:

Why the Cool Kids Use Event Loops

Wed, 14 Dec 2022 10:17:48 +0000

A Discussion On the Benefits of Event Loops in Java.

When I was working in software development back in the 1990s, nearly all the software libraries that I worked on made use of event loops. This was because at the time most hardware had just one single CPU.

Back in the day, I remember the excitement when threads were introduced into our development framework. It was revolutionary that we could now run two things at once, or rather appear to run two things at once, since a lot of the hardware at that time still only had a single core, hence our threaded code was never really truly concurrent.

Learn How to Develop Event-Driven Architectures

Wed, 07 Dec 2022 15:25:16 +0000

Previously, I wrote an article on Open source Chronicle Wire , that discusses how we could serialise an application’s state into different message formats.

Now in this article, I’m going to look at how we can use Open source Chronicle Queue and Chronicle Wire to structure applications to use Event-Driven Architecture (EDA).

EDA is a design pattern in which decoupled components (often microservices) can asynchronously publish and subscribe to events.

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.