Latest Interviews

Matt Might: The Algorithm for Precision Medicine

Matt Might, Matt Mite

Matt Mite, director of the Hugh Call Precision Medicine Institute at UAB, leverages computational optimization and a knowledge graph of 30 million abstracts to derive actionable precision medicine strategies for patients with undiagnosed genetic disorders. His approach, exemplified by the successful treatment of his son Bertrand's NGLY1 deficiency and the identification of Prevacid for ion channel epilepsies, prioritizes logical mechanism proofs to overcome physician skepticism and legal liability. Through an undergraduate-led workflow and the "All of Us" initiative, Mite's institute continues to transform complex genomic data into targeted interventions, from drug repurposing to novel metabolic pathways, asserting that scientific experimentation always yields actionable solutions.

Steve Lee: State of the Shell: PowerShell7

Steve Lee

The PowerShell team announced a strategic shift where Windows PowerShell 5.1 is now maintenance-only, while the primary focus moves to PowerShell 7 as a cross-platform Long-Term Servicing release aligned with the .NET yearly cycle. Significant technical improvements include the introduction of null propagation, parallel processing capabilities, and a new module management system designed to replace the deprecated v2 architecture. While legacy Windows-specific modules now access via implicit remoting, the product strategy excludes future in-box inclusion in Windows due to mismatched support lifecycles.

Michael Sikorski: Dude, Where Are My Files? Reverse Engineering Ransomware

Michael Sikorski

FireEye malware analyst Michael Sikorski details the escalating threat landscape of financially motivated ransomware, highlighting catastrophic real-world impacts on organizations like Maersk and the shift of state actors toward direct extortion. He outlines essential analysis methodologies, ranging from static binary examination to deep reverse engineering, which revealed critical kill switches for devastating strains such as WannaCry and the destructive EternalPetya attack. Ultimately, the presentation emphasizes how these technical insights drive the industry's response to complex encryption schemes and enable data recovery assessments or containment measures against rapidly evolving malicious code.

Unboxed Types for OCaml

Stephen

The presentation "Making a Camel Less Like Lisp and More Like C++" addresses OCaml's performance limitations by introducing explicit "layout kinds" that allow the compiler to statically determine memory representations for unboxed types like 64-bit integers and records. This system distinguishes between tagged pointers managed by the garbage collector and raw bit representations passed directly in registers, enabling efficient libraries to remain opaque while avoiding the overhead of standard boxing. By replacing fragile dynamic heuristics with explicit type annotations, the proposal facilitates predictable high-performance computing without sacrificing the language's safety guarantees or requiring complex template expansion.

Derek Dreyer: RustBelt: Logical Foundations for the Future of Safe Systems Programming

Derek Dreyer, Ralf Jung, Jacques-Henri Jourdan, Robbert Krebbers, Hoang-Hai Dang, Jan-Oliver Kaiser

The MPI for Software Systems' "Rust Belt" project applies decades of academic research to formally verify the safety guarantees of the Rust programming language against the risks posed by "unsafe" code. By leveraging the Iris framework and mechanizing proofs in the Coq assistant, the team establishes a semantic safety model that independently verifies complex libraries like `Arc` and `Mutex`, successfully identifying critical bugs in memory ordering and reference counting. This methodology ensures that future language evolution and standard library modifications can proceed with mathematical certainty that undefined behavior remains impossible.

Playing Atari Games in OCaml

Laurent Mazare

This presentation explores the application of machine learning to Atari games by leveraging OCaml's functional type safety alongside PyTorch and TensorFlow for GPU-accelerated deep learning. It details how supervised convolutional neural networks achieve over 99.5% image classification accuracy and how reinforcement learning agents utilizing Deep Q-Learning can master games like Breakout and Pong, albeit with significantly slower training times than humans. The talk concludes by highlighting the technical interoperability achieved through custom OCaml bindings and outlines future research directions in transfer learning and generalization across varying game environments.

Don Jones: 13 Years in a Shell: Lessons, Practices, and Achievements in PowerShell

Don Jones, Jeffrey Snover, Arnold, Doug Fake

Hosted by Arnold and Doug Fake, the New York PowerShell community meetup featured veteran practitioner Don Jones discussing his evolution from Navy maintenance to modern DevOps strategy. Jones emphasized critical technical anti-patterns such as avoiding Format-* cmdlets and global variables while advocating for Test-Driven Development, Git integration, and the Single Responsibility Principle to ensure script maintainability. The session concluded with guidance on organizational alignment, noting that true DevOps requires cross-functional product teams and continuous skill investment to remain competitive in a fast-moving market.

Safe at Any Speed: Building a Performant, Safe, Maintainable Packet Processor

Sebastian Funk, JOSE ARRIETA

Jane Street engineers optimized their OCaml-based market data distribution system to handle NASDAQ's peak load of 4 million messages per second while maintaining zero-allocation on critical paths to avoid garbage collection delays. By leveraging PPX preprocessors, immediate integer options, and a domain-specific language for protocol generation, the team reduced per-message processing latency from five microseconds to under 750 nanoseconds. This approach demonstrates that strict single-core, low-latency performance targets can be achieved with high-level functional languages through aggressive inlining and careful memory management rather than resorting to lower-level systems code.

A Language-Oriented System Design

Nathan Linger

The Ontology system presents a dual-language architecture that manages organizational permissions through an English-facing interface backed by a dependently typed, deductive database engine. It distinguishes between hard-coded primitives, extensional tables, and intentional logical rules to enforce strict type safety, ensuring that data retrieval returns verifiable proof objects and automatically maintains referential integrity through cascading deletion and trash mechanisms. While the internal Prolog-like inference engine mitigates undecidability risks via execution budgets, the design allows for extensible permission modeling by uploading new type declarations without requiring code-level system upgrades.

Lindsey Kuper: Abstractions for Expressive, Efficient Parallel and Distributed Computing

Lindsey Kuper, Ron, Laura, Kunle Olokutun, Asante Toney, Neil Conway, Peter Alvaro, Carl, Nikki Vazou

The presentation outlines a unified framework for deterministic parallel computing that utilizes Lattice Variables (LVARs) and Conflict-Free Replicated Data Types to ensure correct distributed executions while enabling high-performance acceleration in Julia and Python through non-invasive domain-specific languages. Complementing these runtime systems, the speaker details a formal verification approach for safety-critical neural networks that employs lazy ReLU splitting within SMT solvers to manage the exponential complexity of non-linear activations. Future research aims to democratize solver development by integrating lattice theories directly into SMT architectures and verifying LVAR constraints through advanced type systems.

Jane and the Compiler

Jane, Yaron Minsky

Starting fifteen years ago as a tactical replacement for Python in quantitative research, Jane Street scaled its OCaml infrastructure to a 12-million-line production environment that now powers automated trading for its 800 employees. The firm drives significant ecosystem advancement by transitioning from passive user to active contributor, open-sourcing critical tools like the Dune build system while championing conservative language evolution and rigorous engineering features such as first-class modules and generalized algebraic data types. This strategic stewardship ensures the language remains performant and correct for high-stakes finance while securing long-term viability and attracting top engineering talent.

Marius Eriksen: Distributed, Incremental Dataflow Processing in the Cloud with Reflow

Marius Eriksen

The Braille bioinformatics team has developed Reflow, an open-source workflow engine designed to treat biological data pipelines as functional programs rather than static dependency graphs. By enforcing a strict data model and dynamic cloud resource provisioning, the system automatically parallelizes tasks, caches results through referential transparency, and ensures reproducible computations via versioned "data spaces." Currently adopted by Grail, the Chan Zuckerberg Institute, and several biotech startups, Reflow reduces infrastructure complexity while enabling efficient incremental updates to massive genomic and machine learning pipelines.

Introduction to Incr_dom: Writing Dynamic Web Apps in OCaml

Cristina Rosu

Jane Street engineers presented IncurDOM, an internal OCaml web UI framework designed to handle high-frequency updates and datasets exceeding 10,000 rows while avoiding browser lag. The demonstration highlighted how incremental computations, partial rendering, and strict adherence to the Elm architecture enable efficient state management and automatic code sharing between server and client logic. Attendees examined practical trade-offs against React and BuckleScript, noting specific optimizations like `IncrMap` that reduce reconstruction costs while identifying future needs for explicit component abstractions and dedicated testing tools.

OCaml All The Way Down

Andy Ray

This presentation outlines a hardware design framework utilizing the OCaml-based HardCAML domain-specific language to generate FPGA logic for custom peripherals like LED drivers, SPI sensors, and CORDIC math cores. The implementation targets the MicroBlaze soft CPU architecture, executing OCaml bytecode via a ZINC interpreter while leveraging standard Xilinx place-and-route tools to manage complex FPGA resources such as LUTs and DSP blocks. Future roadmaps prioritize full native CPU development within HardCAML, expanded formal verification using the Z3 solver, and the open-sourcing of testing infrastructure to reduce reliance on vendor-provided software components.

Effective Programming: Adding an Effect System to OCaml

This presentation details a comprehensive framework for algebraic effects that separates effect specification from implementation by treating operations like concurrency and state as explicit, resumable interruptions. It contrasts this approach with traditional monads to eliminate boilerplate and demonstrates a full conversion of the OCaml standard library, introducing syntax for tracking purity, region-based locality, and effect polymorphism directly in the type system. The work culminates in a runtime model where effect handlers manage heap-allocated call stacks while future extensions aim to enforce region safety and support multi-handler compositions for complex scenarios.