In production financial systems, security is paramount. FIX messages often contain sensitive trading information that must be protected during transmission. TLS (Transport Layer Security) provides the cryptographic foundation for secure FIX communication. This post explores building a TLS-enabled FIX acceptor using miniFIX, focusing on security best practices for financial applications.

Simple Open Framing Header (SOFH) is a lightweight framing protocol often used to wrap FIX messages for reliable transport over TCP connections. When building high-throughput financial systems, combining SOFH framing with async Rust provides excellent performance characteristics. This post demonstrates how to build a SOFH-enabled TCP server using miniFIX and Tokio.

Modern trading systems require interactive, user-friendly interfaces that can handle real-time market data and order management. This post explores building an interactive trading client using miniFIX with Tokio for async operations, combined with a command-line interface for trader interaction.

Modern financial systems often need to work with multiple message formats. While FIX is the standard for electronic trading, many systems also use JSON for APIs, configuration, testing, and integration with web-based interfaces. miniFIX provides seamless conversion between JSON and FIX tag=value formats, enabling flexible system architectures.

While standard FIX specifications (4.0, 4.1, 4.2, 4.4, etc.) cover most trading scenarios, many organizations need custom fields and message types. Exchanges like Coinbase often extend FIX with proprietary fields for their specific business needs. miniFIX supports custom specifications through QuickFIX XML format and provides code generation capabilities to create type-safe Rust definitions.

While decoding FIX messages is essential for processing incoming data, encoding messages is equally important for sending orders, confirmations, and other trading instructions. miniFIX provides a powerful, type-safe encoder that makes creating FIX messages straightforward while maintaining the performance and reliability needed for financial applications.

In real-world trading applications, FIX messages often arrive as continuous streams over network connections. Unlike processing individual complete messages, streaming scenarios require handling partial messages, buffering incomplete data, and parsing messages as they arrive. miniFIX provides excellent support for streaming FIX message decoding.

The Financial Information eXchange (FIX) protocol is the backbone of electronic trading in financial markets. If you’re building trading systems in Rust, miniFIX provides a modern, type-safe way to work with FIX messages. In this post, we’ll explore how to decode FIX messages using miniFIX’s powerful decoding capabilities.

Intro to a comprehensive blog post tutorial series covering all aspects of the miniFIX Rust crate, from basic usage to advanced production scenarios.

Just something I read and found interesting.

Having spent considerable time looking for information on this format - which is still under development - I decided to compile my own version of the specification.

Just something I read and found interesting.

Just something I read and found interesting.

Having spent considerable time with mathematics, Python, and reading up on Ai, I wanted to spend the next couple of weeks revising my Rust knowledge, from the ground up. I’ll be writing short posts everyday where I cover the language, idiomatic patterns, and interesting crates. This series is inspired by one of my favorite artists, Beeple, who creates a piece of art everyday - hence the title of this series (Rust: Everyday).

This summer I will be reading the book Mathematics for Machine Learning, by marc Peter Deisenroth, A. Aldo Faisal, and Cheng Soon Ong. As one reviewer stated ‘This book provdides great coverage of allthe basic mathematical concepts for machine learning.’. The book has 12 chapters, and my goal is to read one chapter each week.

I recently coded a tiny Rust library, implementing a cryptographic idea in an old paper which had caught my interest. This post is my way of cementing my understanding of the concepts in the paper which I found difficult to grasp.

A quick, non-scientific, look at how we might estimate the number of squarings modulo n that a computer can perform per second.

Exploring how to use Bitcoin block hashes as time-dependent keys for encrypting messages that can only be decrypted after a specific block is mined.

TypeState is a powerful design pattern that we can use to provide compiletime checks based on the state of things. This post is my way of writing about what I’m learning with the hopes that it’ll stick better.

A look at const generics in Rust, explained through a Dungeons & Dragons magic system analogy.

Description: How to get Avalonia setup on MacOS (Big Sur). For VS Code users there’s an extension that can help speed up development process. You can find it on the VS Code Extension marketplace Step: Install .NET $ dotnet new install Avalonia.Templates # Check installation: $ dotnet --version Step: Install Avalonia Using the .NET CLI we install the Avalonia UI templates. We can install Avalonia project templates with the following command: Read more

A quick post looking at two ways to do logging in a Rust code-base.

In this post we’ll create our own third-party cargo subcommand, cargo deploy. When we call our command in a Rust project, the command will send a binary to our server at Netlify, and print out the URL in the command line. Let’s get started. Naming The binary of our command needs to be named cargo-${command}. In our case we’ll name it cargo-deploy. Placement The binary of our command needs to be stored in ~/.cargo/bin. There’s an easy way to do this: we simply create the binary (named cargo-deploy) and then publish it to crates.io. Then, cargo install cargo-deploy will download and place the binary in ~/.cargo/bin. Read more

We start from scratch and try to build our understanding of the most fundamental idea of Fixed Point Theory- the Banach Contraction Principle.

I start by reading the Solana documentation and will see how far I get in building something with Solana.

MVCC stands for MultiVersion Concurrency Control. It’s a way to implement transactional isolation in any application that needs to manage the state of data items. The traditional mechanism for state management in a database is concurrent control using read-write locks. However, this solution is based on blocking and can create contention. MVCC is not blocking. This means that multiple clients can read and write simultaneously - reads do not block other reads and writes do not block other writes or reads. Read more

A beginner-oriented post containing a few fundamental concepts, and usually a step-by-step rudimentary example. I’m hoping this post will serve as a quick refresher on the covered subject. The content of the post is usually heavily inspired by books and Wiki - my aim is to have a post close at hand if I need to refresh my memory. For proper tutorials and primers - please see other sources on the Internet.

I recently started using Axum, a web framework for Rust, and I’m a fan of it so far. I’m writing this post to document my learning process and cover how to build a REST API using Axum as a web framework and SQLx for SQL queries. Let’s go!