Machine Code
The binary instructions a CPU fetches and executes directly, encoded as opcodes and operands; the layer beneath assembly language that every higher-level program is ultimately turned into.
Concepts
Plain-language explanations of the ideas behind software - compilers, garbage collection, objects, types.
628 entries, all primary-sourced
Macros and Metaprogramming
The practice of writing programs that generate or transform other programs, exemplified by Lisp-family macros that operate on code as data to extend the language itself.
Managed Code
Code whose execution is overseen by a runtime such as the CLR or the JVM, which handles memory, type safety, and security - in contrast to native or unmanaged code compiled directly to machine instructions.
Map, Filter, Reduce
Three higher-order functions over collections: map transforms each element, filter keeps elements passing a test, and reduce combines elements into a single result.
Memoization
An optimization that caches the result of a function call so that later calls with the same arguments return the stored answer instead of recomputing it.
Memory Hierarchy
The layered arrangement of storage in a computer - registers, cache, main memory, disk - trading speed and cost against capacity, so that fast memory holds the data in active use and slow memory holds the rest.
Memory Safety
A property of programs that prevents bugs like use-after-free, buffer overflows, and data races, achieved through approaches such as garbage collection or compile-time ownership checks.
Merge Sort
A stable, divide-and-conquer sorting algorithm that splits a list, sorts the halves, and merges them, with a guaranteed O(n log n) running time.
Message Queue
Middleware that lets systems communicate asynchronously by placing messages on a queue for other systems to consume, decoupling senders from receivers.
Message-Passing Concurrency
Coordinating concurrent processes by sending each other messages instead of sharing memory, eliminating locks and data races by design.
Microcode
An internal layer of micro-instructions inside a CPU that implements its complex machine instructions in terms of simple hardware steps; proposed by Maurice Wilkes in 1951 and now used to patch processor errata in the field.
Minimum Spanning Tree
The cheapest cycle-free set of edges that connects every node of a weighted graph, found by greedy algorithms from Kruskal (1956) and Prim (1957).
Mock Object
A stand-in for a real dependency in a test, programmed with expectations about how it should be called, so a unit can be tested in isolation from slow or unpredictable collaborators like databases and networks.
Monad
A functional design pattern, borrowed from category theory, for sequencing computations that carry a context such as state, failure, or input/output while keeping functions pure.
Monorepo
Keeping many projects or services in a single version-control repository, as Google and others do, trading tooling complexity for unified change and dependency management.
Moore's Law
Gordon Moore's 1965 observation that the number of components on an integrated circuit doubles at a steady, predictable rate, which became the planning roadmap of the semiconductor industry.
Multi-Factor Authentication (MFA)
Requiring two or more independent proofs of identity from different categories - something you know, have, or are - so that a stolen password alone is not enough to log in.
Multi-Tenancy
A single running software instance or pool of infrastructure serving many customers ('tenants') at once, with each tenant's data isolated from the others - the economic engine that makes cloud and SaaS cheap.
MVCC (Multi-Version Concurrency Control)
Keeping multiple versions of rows so readers see a consistent snapshot without blocking writers, and writers do not block readers - how PostgreSQL and Oracle achieve high concurrency.
node_modules
The per-project folder where npm installs a package's full dependency tree, famously huge, and the reason flat installs, hoisting, and pnpm's linking exist.
Normalization
Organizing tables so each fact is stored once, by decomposing them according to their functional dependencies into successive normal forms.
Not Invented Here
The tendency of a team or organization to reject external solutions and rebuild them in-house, out of pride, distrust, or insularity.
NP-Completeness
The class of the hardest problems in NP, such that a fast algorithm for any one of them would yield a fast algorithm for every problem in NP.
Obfuscated Code
Code that is deliberately made hard to read, whether as an art form and competitive sport, as a way to protect intellectual property and hide malware, or as a side effect of compressing source down to nothing.
Object Orientation
A way of organizing programs around objects that bundle data together with the behavior that acts on it, with roots in Simula and Smalltalk.
Object-Relational Mapping (ORM)
A layer that maps database tables to objects in code so developers work with objects instead of writing SQL by hand.
Observer Pattern
A behavioral design pattern in which a subject keeps a list of dependent observers and notifies them automatically when its state changes.
OLAP vs OLTP
The split between transaction processing (many small reads and writes) and analytical processing (large aggregate queries over history), two workloads so different they use different database designs.
One-Time Pad
Encryption with a truly random key as long as the message and used only once; the only cipher proven to offer perfect secrecy, but impractical because of the key-distribution burden.
OOPSLA
The ACM conference on Object-Oriented Programming, Systems, Languages and Applications, held since 1986 and now part of SPLASH, where much foundational object-oriented research and the design patterns movement were first presented.
Open Source
Software released under a license that lets anyone use, study, modify, and redistribute it; defined by the Open Source Initiative's Open Source Definition.
Open-Source Database
A database released under an open-source license, a model that broke the proprietary RDBMS lock and now sits at the center of debates over open core and source-available relicensing.
Operating System
The software that manages a computer's hardware and runs programs, providing processes, memory, files, and access to devices so that applications do not have to control the machine directly.
Orchestration
Automatically deploying, scheduling, scaling, networking, and healing many containers or services across a cluster of machines - the job Kubernetes does.
Out-of-Order Execution
Executing instructions as soon as their operands are available rather than strictly in program order, then retiring results in order; introduced by Tomasulo's algorithm on the IBM System/360 Model 91 in 1967.
OWASP Top Ten
A regularly-updated, community-built list of the most critical security risks to web applications, used as a baseline awareness document for developers and defenders.
Ownership and Borrowing
Rust's compile-time discipline where each value has a single owner and references are 'borrowed' under rules the borrow checker enforces, giving memory safety with no runtime garbage collector.
P vs NP
The central open question of computer science: if a solution can be checked quickly, can it also be found quickly?
Package Manager
A tool that automatically installs, upgrades, configures, and removes software and its dependencies from a repository, replacing manual download-and-build.
Package Registry
A package registry is a central, networked index that stores published packages and serves them to build tools by name and version.
Pair Programming
A practice where two developers share one workstation, one driving at the keyboard and one navigating, to catch defects early and spread knowledge across the team.
Parametric Polymorphism
Writing code that works uniformly over any type by taking the type as a parameter, the idea behind generics in ML, Haskell, Java, and C#.
Paravirtualization
A virtualization technique in which the guest operating system is modified to cooperate with the hypervisor rather than being fully emulated, trading compatibility for performance.
Partial Application
Fixing some of a function's arguments to produce a new function of the remaining arguments, letting you specialize general functions such as add5 = add(5).
Password Hashing
Storing passwords as the output of a slow, salted cryptographic hash so a database breach does not directly reveal the passwords; salting defeats rainbow tables and slowness defeats brute force.
Pattern Matching
Deconstructing a value by testing it against shapes (patterns) and binding variables from the parts that match, used in place of long if/else chains.
Paxos
Leslie Lamport's family of consensus algorithms that let a distributed system agree on values even when some nodes fail.
Penetration Testing
Authorized, simulated attacks on a system to find and demonstrate exploitable weaknesses before real attackers do; a core practice of offensive security distinct from automated scanning.