A computer worm is a self-contained computer program that propagates by creating further copies across computing systems, often through a computer network. In the usual security classification it is malware. Unlike a computer virus, it need not attach its code to another program in order to replicate.^[ref]

A worm's impact can include resource exhaustion from replication itself, independently of any additional destructive action. Eugene H. Spafford's analysis of the November1988 Internet worm is an early primary study of a large network incident and its program behavior.^[ref]

An original population model shows why replication matters. Suppose each affected machine remains affected and produces exactly one newly affected machine per time interval, with no overlap or shortage of susceptible machines. If $I_t$ counts affected machines, thenThis stipulated exponential growth model is not a forecast of a real outbreak. Repeated contacts, limited connectivity and containment change the growth pattern. It separates the potential for multiplying copies from the behavior of any particular implementation.

The concept is useful in computer security because one compromised machine can become a source of further disruption. Network structure and the timing of defensive containment matter alongside the behavior observed on an individual host.

Malware is software or code intentionally used for an unauthorized harmful purpose, such as disclosing data, altering it or disrupting access to a computing system. Computer viruses and computer worms are types of malware, but self-replication is not required for every malicious program. The classification concerns purpose and behavior, not merely whether a computer program contains a bug.^[ref]

A useful distinction separates what a program does from how it spreads. Replication, unauthorized disclosure and destructive changes are different properties. A computer worm can disrupt a system through replication-related resource use; another malicious program might disclose data without producing copies of itself.

For an original classification example, suppose three hypothetical programs produce the same unexpected loss of a test file. One has an accidental defect, one implements an authorized deletion request, and one intentionally deletes data without authorization. The visible outcome alone does not establish that all three are malware. Intended function, authorization and behavior supply different evidence.

Likewise, finding a familiar byte sequence in a file is a detection clue rather than a complete behavioral explanation. Digital forensics connects observed artifacts with supported conclusions; a label by itself does not reconstruct an incident.

Sheila Greibach coauthored the 1969 work on the abstract family of languages framework with Seymour Ginsburg and John Hopcroft. Their framework separates common language operations from the particular recognizers used to implement them.^[ref]

One important distinction is between nonerasing word homomorphisms and arbitrary word homomorphisms. Allowing an alphabet symbol to map to the empty word can discard arbitrarily much of a derivation's written evidence. A full abstract family of languages allows that operation, while the ordinary framework only requires the nonerasing version. The distinction prevents an apparently small change in a closure axiom from concealing a substantive change of computational behavior.

John Hopcroft gave a 1971 algorithm for minimizing deterministic finite automata with running time $O(|\Sigma |n\log n)$ for $n$ states and alphabet $\Sigma$. It refines partitions of states until states in the same block accept exactly the same continuation strings.^[ref]

The key accounting idea is to organize refinement around smaller splitters. A transition can then be charged to only logarithmically many successively smaller blocks, instead of rescanning every state in every refinement round. DFA minimization preserves the recognized language while merging observationally equivalent states, making representation size and equivalence checking algorithmic questions.

Judea Pearl developed graphical methods for probabilistic and causal reasoning. His account of D-separation explains how the orientation of arrows in a directed acyclic graph determines conditional independences implied by its factorization assumptions.^[ref]

For a chain $X\to Z\to Y$, conditioning on $Z$ blocks the path. For a collider $X\to Z\leftarrow Y$, the path is blocked before conditioning, but conditioning on $Z$ or an appropriate descendant can activate it. A graphical separation guarantees independence for distributions obeying the graph's assumptions; an unblocked path does not force dependence in every numerical parameterization. These distinctions make the graph a reasoning tool rather than just a picture of observed correlations.

Seymour Ginsburg coauthored the 1969 studies of the abstract family of languages framework with Sheila Greibach and John Hopcroft. This approach compares formal-language classes through closure properties instead of one particular grammar or machine presentation.^[ref]

For example, closure under intersection with regular languages permits restricting an existing language by a finite-state filter. That property is weaker than closure under arbitrary intersections: two context-free languages can have a non-context-free intersection. Stating the allowed operation precisely keeps a shared abstract framework from incorrectly identifying different language classes.

Adi Shamir introduced a polynomial-interpolation construction for threshold secret sharing in 1979. In Shamir's secret sharing, a secret is the constant term of a random polynomial of degree less than $k$ over a finite field; shares are its values at distinct nonzero field elements. Any $k$ shares recover the polynomial and hence the secret.^[ref]

Fewer than $k$ shares leave every possible secret equally compatible when the other coefficients are uniformly random. This is an information-theoretic threshold guarantee, rather than a claim that recovering the secret merely takes a long time. The construction makes distributed authorization and resilience to missing shares compatible. It requires enough field elements for all distinct share positions.

James L. Massey showed that Berlekamp's iterative BCH-decoding algorithm solves a general register-synthesis problem: find a shortest linear-feedback shift register generating a prescribed finite sequence. His 1969 paper derives the algorithm through the lengths and discrepancies of successive candidate recurrences, connecting the Berlekamp-Massey algorithm to error correction.^[ref]

A sequence that satisfies $s_n=c_1{s}_{n-1}+\cdots +c_L{s}_{n-L}$ can be generated from $L$ stored symbols and feedback coefficients over a field. A newly observed symbol may contradict the current recurrence; the algorithm then updates the candidate using a prior discrepancy. Minimal synthesis is therefore more than finding some recurrence that happens to fit the observations.

Boaz Barak works on computational complexity theory, cryptography and the mathematical foundations of machine learning. His research homepage describes these interests and identifies his textbooks and lecture notes.^[ref] His Introduction to Theoretical Computer Science by Boaz Barak develops computation through explicit models and resource bounds.

One example is pseudorandomness: a generated distribution can look random to efficient observers even though an unrestricted observer distinguishes it. Specifying the observer turns “looks random” into a mathematical guarantee, and connects a pseudorandom generator with the randomized algorithms it can safely simulate.^[ref]

Michael L. Fredman co-developed Fibonacci heaps with Robert Tarjan. Their 1987 paper uses deferred restructuring and amortized analysis to obtain constant amortized time for operations including insertion and decrease-key, with logarithmic amortized time for delete-min.^[ref]

This matters in graph algorithms that repeatedly lower tentative priorities: reducing the cost of many decrease-key operations can improve a whole algorithm's bound. A single operation can still be expensive. The guarantee concerns the total cost of a sequence, so confusing amortized time with the worst-case analysis of each individual operation loses the point of the construction.

Dennis M. Ritchie co-developed Unix with Ken Thompson and contributed the C programming language used to express much of the system. Their original paper connects this implementation choice with a practical system offering a hierarchical file system and composable process input and output.^[ref]

The scientific interest is the relation between abstraction and machine control: a language implementation must preserve operations on storage, arithmetic and interfaces while enabling a larger system to be written coherently. Ritchie's preserved Bell Labs homepage records the early Unix collaboration and identifies his historical work.^[ref]

Ken Thompson co-developed Unix with Dennis M. Ritchie and other collaborators. Their 1974 paper describes a compact multi-user operating system with a hierarchical file system, asynchronous operating-system processes and a user-selectable command language.^[ref]

One useful design idea is to combine small programs through a Pipe. The producing program writes an output stream and the consuming program reads an input stream; they need not implement each other's task. The operating system supplies the connection and scheduling. This makes composition a reusable system facility rather than a new integration mechanism for every pair of programs.^[ref]

Brian Harvey developed the Berkeley Logo implementation with student collaborators and used programming as a medium for exploring ideas. His project page identifies the interpreter and its collaborators; his teaching homepage describes work in introductory computing and pre-college education.^[ref][ref]

The command repeat 4 [forward 100 right 90] draws a square by repeating one movement-and-turn rule. Its compact structure connects computer programming, geometry and a visible result, while changing the number of repetitions and angle provides an immediate experiment with the procedure. The language also supports symbolic data and recursion, so its use goes beyond drawing pictures.^[ref]

Peter Naur helped define ALGOL 60 and edited its language report. The revised report specifies both the syntax and operational meaning of expressions, statements, blocks and procedures. Its explicit separation of formal syntax from explanatory semantics made the language definition independent of any one compiler.^[ref]

A nested block, for example, can declare a local name without exposing it throughout the entire program. The definition must specify which declaration an occurrence denotes and how procedure parameters behave. Such details make scope and parameter passing part of a language's semantics rather than conventions guessed from examples. ACM's award announcement credits Naur's report editing, language-definition work and compiler contributions.^[ref]

Herbert Edelsbrunner develops algorithms for computational geometry and computational topology. His research account describes a progression from data structures and geometry to topological methods, guided by applications.^[ref] He coauthored Computational Topology: An Introduction by Herbert Edelsbrunner and John L. Harer with John L. Harer.^[ref]

A central computational challenge is to replace a continuous shape by finite combinatorial data while preserving the invariant being studied. For example, a triangulated surface can be described by vertices, edges and faces, allowing homology to be computed from boundary relations. The representation supplies an algorithmic route to a geometric question; the quality of the input model remains part of interpreting the answer.

John L. Harer works at the intersection of topology, geometry and computational data analysis. His Duke research description emphasizes geometric, combinatorial and computational methods for analyzing shape and data.^[ref] With Herbert Edelsbrunner, he coauthored Computational Topology: An Introduction by Herbert Edelsbrunner and John L. Harer, connecting topological invariants to computational methods.^[ref]

An elementary illustration is a triangular outline: it has one connected component and one unfilled loop. Filling its interior keeps the connected component but removes the hole. Homology distinguishes these cases, showing why a description of shape can capture something different from coordinates or pairwise distances. The example illustrates the subject rather than attributing a particular theorem or discovery to the book's authors.

Jonathan Richard Shewchuk developed adaptive exact arithmetic methods for robust computational geometry predicates. Orientation and incircle tests depend on the sign of a determinant; an incorrectly rounded sign near zero can corrupt the geometric decisions of an algorithm. His method spends additional precision only when needed to establish the correct sign.^[ref]

For example, three nearly collinear points may give an orientation determinant extremely close to zero even when their coordinates are individually unexceptional. A fast approximate evaluation can resolve an easy case, while a difficult case triggers more exact work. This connects numerical accuracy to a discrete geometric decision, not merely to the number of printed decimal places.

Homepage: people.eecs.berkeley.edu/~jrs/

Vint Cerf contributed to the architecture and protocols of the Internet, including the design of TCP and IP. His Internet Society biography identifies this internetworking contribution.^[ref] An early primary document is his 1969 RFC 20, which records an ASCII representation for network interchange.^[ref]

Agreeing on transmitted bits is only one part of communication: endpoints must also agree on how those bits encode characters. The RFC's seven-bit table and placement within an eight-bit byte make that convention explicit. This small document illustrates the same broad interoperability problem encountered in network protocols: independent implementations need common meanings as well as a connection.

Francois Yergeau authored RFC 3629, the UTF-8 specification cited here. It describes a variable-length encoding of Unicode scalar values using one to four octets, retaining ordinary ASCII values as single octets. The author-address section supplies the identity spelling used in this article.^[ref]

A key technical detail is that accepting arbitrary byte sequences is unsafe: the specification excludes surrogate code points and requires valid encodings rather than overlong alternatives. Thus decoding is not just collecting low bits from whichever bytes happen to arrive. Checking the permitted forms prevents distinct byte representations from bypassing a text-based security check.^[ref]

Tom L Nguyen is the author credited on the Linux kernel's guide to the PCI Express port bus driver, with an Intel email address in its byline. The guide explains how a single port can provide several services, including hot-plug handling and error reporting, while the ordinary driver model associates one driver with a device.^[ref]

The port bus driver coordinates those services so separate service drivers can coexist instead of competing to claim the same bridge. This is a concrete example of dividing operating-system kernel responsibilities around one physical device. The cited document establishes the technical authorship; it does not justify expanding the name's initials or assigning a biography to a namesake.