Quant Developer From Home Jobs in Chicago, IL (NOW HIRING)

We are seeking a senior software engineer who builds fast, robust, concurrent numerical systems and who enjoys turning quantitative models into production reality. You will work side by side with traders and quantitative researchers, take their pricing, volatility, and interest-rate models, and implement high-performance concurrent versions suitable to be consumed by high-speed trading algorithms. This is a hands-on engineering role: you own the architecture, the concurrency design, the performance, the deployment, and the debugging. The theory matters — but we are hiring you first for your ability to build software that runs, runs correctly, and runs fast under load.

This is also a collaborative, social role. You will be in constant contact with the traders and researchers whose models you implement, translating their intent into production systems and making the engineering calls where theory meets the constraints of real hardware.

• Take Options Pricing, volatility, and interest-rate models from quantitative traders and quantitative researchers and implement fast, robust, concurrent, production-grade versions of them.

• Design concurrent/multicore systems with real shared state concurrency with non-trivial data sharing and efficient synchronization. Your experience should tell you that the most difficult problems and their most efficient solutions are very rarely embarrassingly parallel.

• Optimize numerical calculations for high throughput and low latency: among other things you'll be taking advantage of cache-aware approaches to data organization, memory preallocation and reuse, avoiding runtime dynamic memory allocation, and trade-offs between speed and precision when leveraging approximation techniques.

• Make pragmatic engineering decisions. Design systems that actually turn on and run within a finite amount of time, subject to a finite budget of CPU cores and memory — not systems that only “work” given unlimited time and unlimited hardware.

• Own the full lifecycle of your systems: build from source with CMake, manage your own deployments, conduct and verify your own application testing, and be responsible for integration of your systems with other developers.

• Debug and support your systems in production, ensuring that the data being produced by these systems is correct and properly being made available for our high-speed trading algorithms.

• Reason about and explain to our quantitative traders and quantitative researchers the consequences of their requirements and design choices — ranging from performance degradations introduced by a certain calculation, to coming up with alternatives either by identifying and removing redundant calculations or proposing approximation procedures to perform the same calculation faster or with less compute requirements.

• Systems & concurrency (the core of the role)

  • Deep, demonstrable experience in multithreaded/multicore/concurrent programming in C++ and in a Linux environment, with a track record of correct designs involving non-trivial data sharing, that act on and produce high throughput low latency data.

  • Fluency with synchronization primitives and interprocess communication primitives and when to use each: atomics, spinlocks, mutexes, reader-writer locks, POSIX shared memory, and reasoning about data races behind them.

  • Proven experience optimizing calculations for high throughput and low latency — from the perspective of data organization, cache awareness, and memory allocation best practices.

  • Pragmatism about resources: the ability to build systems that run within realistic core and memory budgets, not designs that assume an infinite machine.

  • Strong Modern C++ Programming Skills.  Familiarity with language provided multithreading and synchronization primitives, as well as the merits/drawbacks of different parts of the standard library from a performance perspective.

  • Practical mastery of the build/deploy loop: building software from source with CMake, managing your own application deployments, testing, and integrating with other developers.

• Numerical & quantitative

  • Experience implementing numerical methods, including iterative/optimization methods such as SQP, SLP, SLSQP, Nelder-Mead, Brent's method, and Newton's method, and matrix decompositions such as QR and SVD.

  • A working knowledge of options theory and derivatives pricing sufficient to collaborate closely with traders and researchers and faithfully implement their models.

  • Ability to profile the latency and throughput of various computational subroutines that make up the systems as well their associated data hand-offs, and make suggestions for improvements and changes when a speed up is needed.

• Ways of working

  • Strong collaboration and communication skills — you enjoy working directly with traders and researchers.

  • Ability to work independently and take ownership in a fast-moving environment.

Nice to Have

• SIMD experience (SSE/AVX intrinsics or equivalent).

• POSIX Socket programming experience.

• Interprocess Communication in a Linux environment (unix domain sockets, message queues, shared memory).

• Experience working with market data.