Chronicle Software on foojay.io - Friends of OpenJDK

A Modern Approach to Middleware with Chronicle

Fri, 17 May 2024 09:46:40 +0000

Financial institutions today face significant challenges in updating their legacy middleware systems which are crucial for supporting millions of lines of code serving critical business functions. Prior to multicast support in modern switching hardware that became prevalent in the early 2000s, message middleware was largely done via proprietary protocols that converged onto TCP/IP. IBM’s Websphere MQ was a leader in this space.

Point to point middleware based on TCP/IP requires extra processing power and network bandwidth proportional to the number of consumers, and unreliable or slow consumers can negatively impact performance of the publisher. To combat these challenges, software vendors utilized IP multicast to create messaging platforms that supported topic based publish/subscribe networks.

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.

Achieving High Throughput Without Sacrificing Latency

Fri, 02 Feb 2024 09:39:47 +0000

Latency and Throughput

In discussions on performance, it is common to encounter the terms Latency and Throughput to describe the characteristics of a software component.

We can define these terms as follows:

Latency is a measure of the time taken for one thing to occur. For example, it could be the time taken to respond to a change in the price of a financial instrument that could influence the decision on whether to buy, or sell. It could be the time taken for a component monitoring some external device to respond to an indication of a change in the status of that device (like a change in temperature reported from a thermometer).

Microservices Architecture: Navigating the Buzz

Wed, 24 Jan 2024 20:05:53 +0000

Lately I’ve been exploring what all the talk around ‘microservices architecture ’ is really about. From it popping up in every other social media debate to it increasingly becoming a must-have skill on job listings, what is it that has caused this strong divide between the proponents of the traditional monolithic approach and those who have embraced the microservices paradigm.

In this article I’m here to break it down for you as I outline the benefits, some common challenges, and offer some insights from microservices experts for those considering this approach.

Strategies for Managing State in Chronicle Services

Fri, 01 Dec 2023 08:41:44 +0000

Introduction

In distributed, microservice-based applications, the management of state is one of the most important, yet difficult aspects of design.

Ensuring the accuracy and consistency of state without introducing excessive complexity that affects performance or flexibility to support evolving requirements requires careful thought.

This article discusses issues around state management and shows how the Chronicle Services framework provides support to deal with these in ways that maintain a resilient and high performing microservices architecture.

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.

Chronicle Services: Building Fast Microservices with Java

Wed, 13 Sep 2023 13:47:47 +0000

Low Latency?

In computing, latency is defined as the length of time to perform some task. This could be the time it takes to respond to an interrupt from hardware or the time it takes for a message sent by one component to be available to its recipient.

In many cases, latency is not seen as a primary non-functional concern when designing an application, even when considering performance. Most of the time, after all, computers seem to do their work at speeds that are well beyond human perception, typically using scales of milliseconds, microseconds, or even nanoseconds.

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.

The IKEA Effect

Wed, 26 Jul 2023 13:00:04 +0000

The IKEA effect is a fascinating phenomenon whereby consumers place a (sometimes disproportionately) higher value on things that they have either made themselves, or to which they’ve contributed towards making.

This can have a significant influence on perceived value – to the extent that people might value imperfect things they’ve helped create, more than they would value the equivalent, perfect, but ready-made, product. Those who have pained memories of tussling with Allan keys and occasionally incomprehensible schematics for self-assembly furniture will no doubt have raised eyebrows. Of course, the effect only applies to items that are successfully assembled, of course. If people fail to build an item using the instructions provided, or it takes too long or is too difficult, due either to the complexity of the instructions or the inexperience of the user, then they do not ascribe the same value to the item.

Optimise CPU Performance Through Isolation and System Tuning

Thu, 29 Jun 2023 06:36:39 +0000

What are the challenges of tuning your CPU and system for optimal performance with Linux, and how does Chronicle Tune address them?

CPU isolation and efficient system management are critical for any application which requires low-latency and high-performance computing. These measures are especially important for high-frequency trading systems, where split-second decisions on buying and selling stocks must be made.

To achieve this level of performance, such systems require dedicated CPU cores that are free from interruptions by other processes, together with wider system tuning.

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

Unique Identifiers Based on Timestamps in Distributed Applications

Wed, 14 Jun 2023 11:22:03 +0000

At Chronicle we build applications that must process very high numbers of events with minimum latency. Generating unique IDs for these events using the traditional method of UUIDs introduces an unacceptable time overhead into our applications, so an alternative approach is needed.

I recently wrote an article on how timestamps can be used as unique identifiers, as they are much cheaper to generate than other methods of generating unique identifiers, taking a fraction of a microsecond.

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?

How to Automatically Create Microservices Architecture Diagrams

Thu, 20 Apr 2023 08:01:21 +0000

In application development, microservices is an architectural style where larger applications are structured as a collection of smaller, independent, yet interconnected services.

While this allows for highly maintainable and testable applications (as each service can be maintained independent of the larger application), the problem with this method is the inherent complexity of interactions between microservices.

It can be difficult for developers and team members to visualise how these microservices are connected to each other. We have been looking for ways to produce architectural diagrams that illustrate these interactions.

"The More You Say, the Less People Remember...

Wed, 25 Jan 2023 07:56:39 +0000

…The Fewer the Words, the Greater the Profit."

These wise words were written by François Fénelon, a writer and theologian living during the 17th century.

This is an article summarising different approaches to the development of IT solutions. Learn why the above quote is very relevant for developers in the 21st century.

Business Driven Development

Business-driven development is a meta-methodology for developing IT solutions that directly satisfy business requirements . This leads to increased flexibility and shorter turnaround times when changing the business and adapting the IT systems.

How Does Kafka Perform When You Need Low Latency?

Wed, 18 Jan 2023 10:12:24 +0000

Most Apache Kafka benchmarks appear to test high throughput but not low latency.

Kafka was traditionally used for high throughput rather than latency-sensitive messaging, but it does have a low-latency configuration. (Mostly setting linger.ms=0 and reducing buffer sizes).

In this configuration, you can get below 1-millisecond latency a good percentage of the time for modest throughputs.

Benchmarks tend to focus on clustering Kafka, in a high-throughput configuration.

While this is perhaps the most common use case, how does it perform if you need lower latencies?