Adam M. Costello authored the Punycode specification in RFC 3492, which describes a reversible encoding of Unicode strings using the basic ASCII repertoire for internationalized domain-name applications. The encoding preserves basic code points literally and represents additional ones through the Bootstring algorithm.^[ref] He is also listed as an author and former editor of the PNG specification.^[ref]

Christian Brunschen is credited as an author of the PNG specification, the shared technical description of a file format for raster images using lossless source coding.^[ref]

Thomas Boutell is credited both as an author and as a former editor of the PNG specification. The specification defines how raster image data, data compression and ancillary metadata are represented so independently written encoders and decoders can exchange images.^[ref]

Mark Adler coauthored the zlib compression library with Jean-loup Gailly. The project's author credit connects his work to reusable Deflate-based data compression.^[ref] He is also credited as an editor and author of the PNG specification, which defines a portable interchange representation for raster images.^[ref]

L. Peter Deutsch authored RFC 1951, the specification of the Deflate compressed-data format. It combines LZ77 string references with Huffman coding, specifying what a decoder must reconstruct while allowing different encoder strategies. This makes the format distinct from any single compression program.^[ref]

John Kubiatowicz researches computer systems, with projects spanning operating systems, file systems and quantum computing architecture. His institutional homepage links the Tessellation operating system, OceanStore global storage and the Quantum Architecture Research Center. These projects study how a computing service is organized across the underlying hardware and storage mechanisms.^[ref]

Kevin Wayne is a coauthor of Algorithms, 4th edition by Robert Sedgewick and others and Introduction to Programming in Java: An Interdisciplinary Approach by Robert Sedgewick and others. Their accompanying implementations connect abstract data types, algorithm invariants and resource analysis to executable programs. For example, the published Knuth-Morris-Pratt automaton implementation explicitly accounts for alphabet-dependent preprocessing and space.^[ref]

Ulrich Drepper wrote an extended account of computer memory and memory caches, including Memory part 2: CPU caches by Ulrich Drepper. It explains why a computer program's memory-access pattern affects running time, even when the number of arithmetic operations is unchanged. The treatment distinguishes cache organization, lookup and the possibility of overlapping latency with other work.^[ref]

Kevin C. Webb coauthored Dive into Systems by Suzanne J. Matthews and others, which connects computer programs to their machine-level implementation. Its progression through programming languages, instruction set architectures, computer memory and parallel computing explains how the representation and execution of a computer program affect its running time. The authors maintain an open online version with concrete examples.^[ref]

Tia Newhall coauthored Dive into Systems by Suzanne J. Matthews and others, which connects computer programs to their machine-level implementation. Its progression through programming languages, instruction set architectures, computer memory and parallel computing explains how the representation and execution of a computer program affect its running time. The authors maintain an open online version with concrete examples.^[ref]

Suzanne J. Matthews coauthored Dive into Systems by Suzanne J. Matthews and others, which connects computer programs to their machine-level implementation. Its progression through programming languages, instruction set architectures, computer memory and parallel computing explains how the representation and execution of a computer program affect its running time. The authors maintain an open online version with concrete examples.^[ref]

Leslie Lamport developed mathematical ways to specify and reason about concurrent computing. His 1979 paper How to Make a Multiprocessor Computer That Correctly Executes Multiprocess Programs by Leslie Lamport defines sequential consistency: the result must agree with some sequential ordering of all operations that preserves each individual CPU's program order. This gives a precise requirement for shared-memory behaviour without requiring all physical operations to occur one at a time.^[ref] His first-person publication archive explains the development of this and related work.^[ref]

Fred B. Schneider studies dependable concurrent computing and distributed systems, including fault tolerance and computer security.^[ref] He coauthored Defining Liveness by Bowen Alpern and others, which distinguishes a safety property from a liveness property: finite behaviour can establish an irreparable safety violation, whereas every finite behaviour prefix can still be extended to satisfy the liveness requirement.^[ref]

Bowen Alpern coauthored Defining Liveness by Bowen Alpern and others, which formalizes liveness properties of computations in relation to safety. A safety property rules out a bad finite behaviour; a liveness property requires progress that no finite observation alone can finally establish. This distinction supplies a precise vocabulary for specifications of ongoing and concurrent programs.^[ref]

David S. Miller authored Cache and TLB Flushing Under Linux by David S. Miller, which specifies the effects required of Linux kernel cache and translation-invalidation interfaces. When page tables change, an old translation lookaside buffer entry may still describe an obsolete mapping. The documented flush operations make those changes effective for the relevant address spaces and CPUs.^[ref]

Andrea C. Arpaci-Dusseau coauthored Operating Systems: Three Easy Pieces by Remzi H. Arpaci-Dusseau and others. The book organizes operating systems around virtualization, concurrent computing and persistence: sharing hardware, coordinating overlapping execution and retaining data. Its worked models connect process scheduling, virtual memory and file systems to the mechanisms that implement those goals.^[ref]