Obsessed with speed? Join our client in Austin to build the fastest trading system in the market. We're seeking a highly skilled Low Latency Trading System Developer to architect and implement a cutting-edge platform for equities and futures, focused on market making. Every nanosecond matters.
Responsibilities:
- Design and implement an ultra-low latency trading system optimized for market making.
- Develop high-performance algorithms for order execution, risk management, and market data processing.
- Handle the flow of orders, market data, and other events between different components of the trading system. Efficiently and safely pass data between threads (e.g., order processing, risk management, market data handling) without blocking or data races.
- Maintain order of operations, especially in scenarios involving cancellations or amendments.
- Store and quickly retrieve order book information, position data, and other key-value pairs. Enable efficient lookups and updates in a highly concurrent environment where multiple threads need access to shared data.
- Maintain dynamic lists of orders, instruments, or other entities that need frequent insertions and deletions. Offer flexibility for managing changing data sets while ensuring thread safety.
- Organize and manage order books and efficiently store and query ordered data for fast price discovery and order matching.
- Ensure the system handles massive order volumes with minimal latency.
- Implement robust risk management rules to prevent overselling and manage inventory.
- Collaborate with traders and quants to translate strategies into lightning-fast code.
- Continuously monitor and optimize system performance.
- Stay ahead of the curve in low latency trading technology.
Expertise:
- In low-latency trading, every nanosecond counts. Deep knowledge of concurrent data structures allows you to choose the most efficient structure for each specific task, minimizing contention, and maximizing throughput.
- There's no one-size-fits-all solution. You need to understand the strengths and weaknesses of each data structure to make informed decisions based on the specific performance and consistency requirements of your system.
- You'll need to fine-tune the performance of your chosen data structures, which requires a deep understanding of their implementation details and how they interact with the underlying hardware and operating system.
- Concurrent programming is notoriously difficult to debug. A deep understanding of concurrent data structures is essential for identifying and resolving issues like race conditions and deadlocks.
Skills
- Deep understanding of C++17/20 concurrency features (coroutines, parallel algorithms).
- Deep understanding of memory management techniques (custom allocators, memory pools).
- Deep understanding of synchronization primitives (mutexes, atomics, lock-free structures).
- Concurrent Queues (Lock-free, Blocking, Disruptor).
- Concurrent Stacks (Lock-free).
- Concurrent Hash Tables (Lock-based, Lock-free).
- Concurrent Linked Lists (Lock-free, Skip lists).
- Concurrent Trees.
- Read-Copy-Update (RCU).
Other:
- A knack for identifying and evaluating trade-offs.
- Adherence to the Keep It Simple Stupid (KISS) principle.
- Team work + communication skills.