The Network as a Program with Nate Foster

Nate Foster joined Ron Minsky to trace a career that began in physics, pivoted into programming languages and type systems, and later took aright turn into networking — a journey that shapes his current research philosophy: treat the network itself as a program. Foster summarized early PL work—an undergraduate summer project building a Java compiler/type-system, PhD work with Benjamin Pierce that produced and matured lenses (bidirectional transformations), and a multi‑year engagement with the Haskell community where lens ideas flourished. He described lenses as an example of a PL idea that found many unexpected uses because of a clean mathematical definition and compositionality.

Foster explained why he moved from classical PL topics to networking: a postdoc at Princeton with Jen Rexford and Dave Walker introduced him to the practical needs driving software‑defined networking (SDN). He outlined SDN's two technical drivers — hyperscalers needing faster innovation and enormous scale — and argued that programming‑language abstractions (DSLs, composition, verification) are a natural fit for expressing forwarding behavior, composing isolation policies, and proving properties of large networks. He emphasized domain constraints that differ from general software (extreme packet rates, tiny per‑packet resources, and infrastructure-level isolation needs) and described NECAT, a DSL family for forwarding behavior whose semantics line up with Kleene Algebra with Tests (often called KAT/CAT). That algebraic connection gave his group re‑usable constructions, enabled a probabilistic NECAT extension to model randomness/failures and allowed building compilers and verification tooling.

The conversation moved to industry engagement. Foster recounted a sabbatical at Barefoot (the P4 switch company) to learn chip pipelines and design space; that experience produced work on in‑network computing (small computations on switches), and convinced him to focus on what functions make sense on constrained data‑plane processors. He reviewed the history of OpenFlow and P4: OpenFlow exposed a simple match/action table model that proved hard to map to real pipelines; P4 came later and exposed pipeline structure, enabling more realistic programmability. Foster emphasized the symbiosis of the networking research community with hyperscalers, vendors, and academia — a mix that accelerates idea transfer and practical impact.

Finally, Foster described concrete results at Jane Street: Butane, a higher‑level policy language checked into version control and compiled to per‑router BGP configs, plus an associated UI and verification pipeline. Butane brings software engineering practices (code review, testing, visualization) to wide‑area routing and lets engineers do large policy edits with automated checks for connectivity, isolation, and latency impact. Foster stressed that some verification is straightforward (snapshot forwarding checks with model‑checkers or SAT tools) while other goals remain active research (synthesizing safe configuration changes, reasoning about vendor quirks, and bridging centralized policy to distributed BGP implementations). He and Ron agreed that SDN’s original centralized visions did not fully materialize — the field found hybrid truths — and that formal PL foundations (algebraic routing models, routing algebras) offer promising ways to design composable policy languages and compilers while keeping the speed and robustness of distributed protocols. Throughout, Foster argued for experimentation: many plausible designs will fail to become dominant, but exploring them drives better understanding and useful tools that industry can adopt.