The History of E-commerce
A comprehensive reference on the history of electronic commerce, from its origins in 1960s Electronic Data Interchange (EDI) and videotex systems to the modern era of AI-driven, omnichannel retail.
99 posts about history
A comprehensive reference on the history of electronic commerce, from its origins in 1960s Electronic Data Interchange (EDI) and videotex systems to the modern era of AI-driven, omnichannel retail.
The probabilistic primality test from the work of Miller and Rabin in the 1970s, its role in generating cryptographic keys, and its error bounds.
A comprehensive history of the web browser, from the early hypertext concepts at CERN to the intense competition of the Browser Wars and the modern platform era dominated by a few major engines.
The randomized tree that is both a binary search tree and a heap, formalized by Seidel and Aragon in 1989, and its simple expected balance.
A comprehensive, chronological history of robotics, tracing its evolution from ancient mechanical automata to modern AI-driven autonomous systems.
A comprehensive reference on the history of the network firewall, tracing its evolution from early packet filters in the 1980s to modern, cloud-native Next-Generation Firewalls and the principles of Zero Trust architecture.
From hierarchical and network models to Codd's relational revolution, the NoSQL wave, NewSQL, and the serverless present.
A comprehensive, chronological reference on the history of social media, from early computer networks and bulletin board systems to the rise of modern centralized platforms and the emerging decentralized web.
From the room-sized machine to colocation and the hyperscale campus, and the power and water problem it created.
From subroutine libraries to CORBA and SOAP, then REST, GraphQL, and gRPC, with each generation fighting the last one's ceremony.
A comprehensive reference history of conversational AI, tracing its evolution from the simple pattern-matching programs of the 1960s to the large language models of the present day.
The method for drawing a fair random sample from a stream of unknown length, the elegant algorithm R, and its use in large-scale data systems.
A comprehensive, chronological history of information theory, from its thermodynamic and telegraphic precursors through Claude Shannon's 1948 revolution, the development of error-correcting codes, and its modern applications in networking, quantum computing, and machine learning.
A comprehensive history of Ethernet, from its origins at Xerox PARC as a 2.94 Mbps shared network to its modern role as the terabit-speed foundation of global data centers and carrier networks.
Rust began as one engineer's personal project, grew up inside a browser maker, and became the first language in decades to seriously challenge C and C++. Here is where it came from, how it actually works, and why it matters for the web.
The shortest-path algorithm that handles negative weights, developed around 1958, and its role in distance-vector internet routing.
From the 1947 point-contact transistor to the integrated circuit and decades of scaling, and what is replacing the law as it slows.
For much of the web's history, we built page layouts with tools that were never designed for the job. The story of CSS layout is the slow arrival of tools that actually fit the problem, and why the old hacks were not anyone's fault.
From the MIT tinkerers and phone phreaks to the criminal and nation-state era, and how the word hacker changed meaning.
From the Altair and the hobbyist era to the Apple II, the IBM PC, and the clone market that set the shape of the industry.
A comprehensive, chronological history of the computer mouse, from Douglas Engelbart's first wooden prototype in 1964 to the modern optical, laser, and wireless devices that are ubiquitous in personal computing.
The character-indexed tree behind autocomplete and routing tables, named by Fredkin in 1960 from the word retrieval, and its space tradeoffs.
From imperative and structured code to object-oriented and functional styles, and why each won and then drew the next backlash.
From Fairchild and Silicon Valley to the fabless model, the rise of TSMC, and why one company in the Netherlands became a chokepoint.
The ordered tree that makes search, insertion, and deletion logarithmic, its independent discoveries around 1960, and why balance matters.
The 1987 rolling-hash approach to string matching, how it finds multiple patterns efficiently, and its use in plagiarism and duplicate detection.
A comprehensive history of automatic identification technology, tracing the development from early linear barcodes like UPC to the ubiquitous two-dimensional QR code and its modern applications.
A comprehensive, chronological history of Optical Character Recognition (OCR), from early electromechanical concepts and the first commercial systems to the modern era of AI-driven document intelligence.
The dynamic-programming method for all-pairs shortest paths, its 1962 formulation, and its connection to Kleene's work on regular expressions.
The spatial index behind geographic databases, introduced by Antonin Guttman in 1984, and how bounding rectangles accelerate location queries.
From the perceptron to the backpropagation revival and the GPU-and-data moment that finally made deep learning work.
A comprehensive, chronological reference on the evolution of computer display technology, from the early cathode ray tubes and vector graphics to the standardization of VGA, the rise of LCD flat panels, and the modern era of self-emissive OLED and MicroLED screens.
From classical ciphers to the public-key breakthrough and TLS securing commerce, and the coming post-quantum transition.
A comprehensive history of markup languages, tracing their evolution from the mainframe era's GML and SGML to the web's HTML, XML, and HTML5, and finally to the rise of human-centric formats like Markdown.
A comprehensive reference history of digital photography, from its theoretical origins and the first prototype in 1975 to the era of computational imaging and smartphone dominance.
The array-backed heap that powers heapsort and scheduling, introduced by J. W. J. Williams in 1964, and how it keeps the extremum at the root.
The adaptive hybrid sort Tim Peters wrote for Python in 2002, how it exploits existing runs, and the bug formal verification later found in it.
A comprehensive history of floating-point arithmetic, from Konrad Zuse's first implementation to the proprietary mainframe formats, the landmark IEEE 754 standard, and the new specialized formats driven by artificial intelligence.
How hashing turned lookup into near-constant time, from Hans Peter Luhn's 1953 IBM memo and open addressing to modern collision strategies.
The dynamic-programming measure of string similarity defined by Vladimir Levenshtein in 1965, and its uses in spell check, DNA, and diff tools.
The 1975 multi-pattern matcher built on a trie with failure links, created at Bell Labs, and its role in intrusion detection and virus scanning.
From Bell Labs to the BSD split and the lawsuits, and the family tree that leads to Linux, macOS, and Android.
From flat tables to hierarchical directories, journaling, and copy-on-write, and what each design was built to protect against.
Where a web page gets built, on the server or in the browser, has swung back and forth for twenty years. Each swing solved the previous era's pain and created new pain of its own. Here is the full arc, and why it is not going in circles.
SQL is more than fifty years old, has been declared obsolete more than once, and still runs the data layer of nearly every web application. Here is where it came from, the rival language it beat, and why nothing has managed to replace it.
Go was a reaction. Three veteran engineers at Google, frustrated by slow builds and growing complexity, built a language that left features out on purpose. That restraint made it the language of modern cloud infrastructure.
C# was born out of a lawsuit. Blocked from extending Java, Microsoft built its own modern language, had it standardized so no one could call it a cage, and spent two decades turning it into a fast, open, cross-platform tool.
PHP was never meant to be a programming language. It started as a few tools one developer wrote to track visits to his resume, survived an existential threat from Facebook, and still runs a large share of the web. Here is how.
The 1977 string-matching algorithm that never backtracks in the text, how its failure function works, and the story of its three independent inventors.
The entropy coder that encodes a whole message as a single fraction, its development at IBM, the patent thicket it created, and its role in modern codecs.
From batch processing and time-sharing to the three families that survived, and the ideas each generation left behind.
From fixed-function 3D accelerators to programmable shaders and CUDA, and how a chip built for games became the engine of the AI boom.
Computing the smallest enclosing polygon of a point set, from Graham's 1972 scan to Jarvis's march, and its uses in graphics and collision detection.
Robert Floyd's constant-space method for finding loops in sequences and linked lists, how the two-pointer trick works, and where it is applied.
Peter Fenwick's 1994 structure for cumulative frequency tables, and how a clever use of binary representation yields compact range sums.
Most languages optimize for the machine or the problem. Ruby set out to optimize for the person writing the code. That unusual goal, plus one framework, turned it into the language behind a generation of startups.
The algorithm that counts billions of distinct items in kilobytes, from Flajolet and Martin's 1984 work to the Flajolet 2007 refinement used in databases.
From mainframe virtual machines to VMware's x86 breakthrough and the hypervisor that made the public cloud possible.
From the Intel 4004 to x86 dominance, the RISC challenge, and the ARM and Apple Silicon era, and why the instruction set became a business weapon.
A comprehensive reference history of the Universal Serial Bus, from the pre-USB chaos of legacy ports to the rise of USB-C and the current challenges of protocol fragmentation.
The log-structured merge-tree behind modern write-heavy databases, introduced by O'Neil and colleagues in 1996, and its compaction tradeoffs.
Java was built to run on television set-top boxes. That market never arrived, but the idea underneath it, code that runs anywhere without changes, made Java the language of enterprise software and Android. Here is the story.
From the first academic worms and the Morris Worm to ransomware as organized crime and nation-state tooling.
The structure that finds all intervals overlapping a point or range, its basis in computational geometry, and its use in scheduling and genomics.
A compact structure for frequency estimation on data streams, introduced by Cormode and Muthukrishnan in 2005, and its accuracy guarantees.
A comprehensive history of the Bluetooth wireless standard, from its origins at Ericsson in the 1990s through the formation of the SIG, the evolution of its core specifications, and its modern applications in audio, IoT, and beyond.
The space-efficient probabilistic set that allows false positives but never false negatives, created by Burton Bloom in 1970, and where it is used.
From magnetic core memory to DRAM and the modern cache hierarchy, and the widening gap between processor speed and memory speed.
From SCCS and RCS to centralized CVS and Subversion, then Git's distributed model and the GitHub era.
From Akamai and the flash-crowd problem to the programmable edge, and how caching reshaped the economics of the web.
The dictionary-based compression of Lempel and Ziv in 1977 and 1978, the foundation of gzip, PNG, and ZIP, and the patent saga around LZW.
The ancient method for finding prime numbers attributed to Eratosthenes, its efficiency, and the modern segmented and wheel variants.
From VisiCalc selling the Apple II to Lotus 1-2-3 and Excel's lock-in, the most-used programming tool nobody calls programming.
Compressed tries that cut wasted nodes, from Morrison's 1968 PATRICIA to the radix trees in IP routing and modern key-value stores.
A comprehensive, chronological history of the theory of computation, from the foundational mathematical questions of the early 20th century to the development of Alan Turing's formal model of computation and the subsequent rise of complexity theory and its impact on modern computing.
From the utility-computing dream to AWS renting spare capacity and the serverless present, told as the slow death of owning servers.
From ARPANET and packet switching to the commercial opening of the 1990s and the cloud backbone, and the choices that kept it open.
A comprehensive, chronological history of the Domain Name System (DNS), from its origins as a solution to the scaling problems of ARPANET's HOSTS.TXT to its modern role as a cornerstone of internet infrastructure, security, and privacy.
From proprietary agreements to the GPL's copyleft and permissive MIT and Apache licenses, and the recent source-available revolts.
A comprehensive, chronological history of cryptocurrency and blockchain, from the cryptographic foundations of the 1970s through the creation of Bitcoin, the rise of Ethereum, and the modern era of institutional adoption and technical scaling.
A comprehensive reference on the history of supercomputing, tracing its evolution from early vacuum-tube machines and the vector processing era of Cray to today's massively parallel, accelerator-driven exascale systems.
The 2014 consensus algorithm Ongaro and Ousterhout designed for understandability, its leader-election and log-replication mechanics, and its wide adoption.
From the IBM System/360 to the present, and why the machine the industry declared dead still runs the world's banks.
The elementary quadratic sorts taught first everywhere, their tangled early naming, and why simple algorithms still matter for small inputs.
From Grace Hopper's A-0 and FORTRAN to optimizing compilers and LLVM, and the shift from craft to infrastructure.
How distributed systems order events without synchronized clocks, from Lamport's 1978 paper to vector clocks, and their role in databases like Dynamo.
Finding cycles and clusters in directed graphs, from Tarjan's 1972 single-pass algorithm to Kosaraju's two-pass method, and their applications.
JavaScript's flexibility is a gift on a small page and a liability in a large codebase. TypeScript was Microsoft's answer: keep the language, add a type system on top. Here is where it came from and why it won when every earlier attempt failed.
Space-partitioning trees for images and 3D scenes, from Finkel and Bentley's 1974 quadtree to octrees in graphics and collision detection.
From rule-based parsing to statistical methods, word embeddings, and transformers, and the leap from grammar to scale.
Two greedy methods for minimum spanning trees, their rediscovery history back to Boruvka in 1926, and their uses in network design.
The hash tree that lets systems verify large data with small proofs, patented by Ralph Merkle in 1979, and its role in Git, backups, and blockchains.
From Xerox PARC's desktop metaphor to the Macintosh and Windows and on to touch and voice, and the ideas reinvented along the way.
The policies that decide what a cache discards, their implementation with hash maps and linked lists, and the modern adaptive policies that refined them.
From waterfall and big design up front to the Agile Manifesto, then DevOps and the collapse of the wall between dev and ops.
The history of the keyboard is a story of mechanical ingenuity, accidental standards, and powerful economic inertia, centered on the enduring QWERTY layout. Originally designed in the 1870s to prevent typewriter jams, QWERTY has outlived its technical purpose to dominate digital input for over a century, resisting more efficient alternatives through the power of network effects.
A comprehensive history of reinforcement learning, tracing its origins from three distinct threads in psychology, control theory, and computer science, and detailing their convergence into the modern field of deep reinforcement learning.
The link-analysis algorithm Page and Brin devised at Stanford in the late 1990s, how the random-surfer model ranks the web, and its lasting influence.
From vector displays and the first rendered frames through the rasterization and ray-tracing arc to real-time photorealism.