1936
Turing describes a general computation model
Turing’s machine model gave later complexity theory a precise setting for counting computational resources.
← Software Engineer career guide
Software development
Software Engineer timeline
How the field of a Software Engineer got here: the sourced milestones from every published course of this career, on one axis.
1936 to 2026
455 milestones across 48 courses
- Core
- Supporting
- Specialization
The axis stretches toward recent years, where most milestones fall. Bars count milestones per year; dots are single milestones.
Before 1990
80 milestones
1947 Sep 9
The Harvard Mark II logbook records a moth
Operators found a moth in a relay of the Harvard Mark II and taped it into the logbook with the note "First actual case of bug being found." The incident popularized "bug" and "debug" as the vocabulary for this kind of work.
1949
Turing frames checking a large routine
Alan Turing's paper treated checking a large routine as a distinct problem. It established an early foundation for reasoning about whether program behavior matches its intended operation.
1953
Luhn develops an IBM hashing method
Hans Peter Luhn developed a hashing method at IBM. It established a practical route from a key to a storage location, the idea used by later hash tables.
1956
Kruskal publishes a minimum-spanning-tree method
Kruskal's paper treats the shortest spanning subtree as an explicit computational problem. It gave a durable example of selecting a locally eligible edge while maintaining a global structural condition.
1957
Bellman applies dynamic programming to optimization
Bellman's paper solves its optimization problem with the functional equation technique of dynamic programming. It established the pattern of solving related subproblems through a recurrence rather than independently repeating the same work.
1957
Fortran is commercially released
IBM released Fortran for the IBM 704. A compiler could translate mathematical-style statements into machine instructions, separating program expression from direct machine-code entry.
1958
Lisp is created
Lisp, the oldest functional language family, is created in 1958. Its treatment of programs and data as lists and its function abstractions establish functional ideas inside an interactive environment.
1958
Lisp makes list processing central
Lisp emerged from John McCarthy’s work in the late 1950s. Its symbolic processing made linked lists a prominent programming representation.
1959 Dec
Dijkstra publishes a graph-problem algorithm
Dijkstra's paper on graph problems appeared in Numerische Mathematik. It became a canonical example of an algorithm whose correctness and choice of data representation matter as much as the final route.
1960
ALGOL 60 report documents structured language elements
The ALGOL 60 report specified identifiers, expressions, assignments, and conditional statements. It made core programming constructs part of a precise language description.
1960
US Navy formalizes KISS as a design constraint
The Navy notes "keep it simple, stupid" as a design discipline, the earliest dated anchor for the simplicity argument this course frames as KISS.
1962
AVL trees introduce height balancing
Adelson-Velsky and Landis published an algorithm for organizing information in a balanced binary tree. The method constrained tree height to preserve efficient key operations.
1962 Apr
Hoare publishes Quicksort
Hoare's Quicksort paper documented a partition-and-recurse sorting method for random-access storage. It made the practical consequences of pivot choice and worst-case behavior central to a familiar task.
1964
Heapsort connects heaps with ordering
J. W. J. Williams published heapsort. The algorithm uses a heap to repeatedly select an extreme item without maintaining a fully sorted collection during insertion.
1964
PL/I introduces ON conditions
PL/I introduced its own form of exception handling circa 1964, allowing interrupts and error conditions to be handled with ON units that transferred control to a handler.
1964 May
BASIC runs with Dartmouth time-sharing
Dartmouth's BASIC and time-sharing system ran together. The language was designed to make programming accessible to beginners using shared terminals.
1965
Cobham connects feasibility with polynomial bounds
Cobham’s work made polynomially bounded computation a central formal treatment of feasible calculation.
1965
Dijkstra describes cooperating sequential processes
Dijkstra analyzes coordination between loosely connected sequential processes. The work frames explicit communication as central to reasoning about independent activity.
1965
Simula groups data and instructions as objects
Simula was written at the Norwegian Computing Center. Its object blocks combined data and instructions for simulation models, establishing an early language-level form of object-oriented organization.
1968
Dijkstra argues against unrestricted goto
Dijkstra connected unrestricted jumps with difficulty describing program progress. The argument reinforced control flow organized around conditionals, repetition, and procedures.
1968
Fundamental Algorithms begins a systematic reference
Donald Knuth published the first volume of The Art of Computer Programming. It collected foundational algorithms and analysis into a durable study path for data-structure practice.
1968
Knuth begins The Art of Computer Programming
Volume 1, Fundamental Algorithms, appeared in 1968. The series gave algorithm descriptions, analysis, exercises, and implementation detail a common long-form reference for study and practice.
1968
NATO conference names the software crisis
The NATO Software Engineering Conference documented the difficulty of producing reliable software at scale. Testing became part of a broader engineering response to quality and verification problems.
1968
USAS X3.4-1968 defines ASCII
The standard established a common coded character set for information interchange. It made a published mapping from characters to numeric codes a practical interoperability contract.
1968 Oct
NATO Software Engineering Conference
The NATO Science Committee conference in Garmisch convened around the software problem and gave software engineering an early shared forum. It framed software development as an engineering concern beyond writing code.
1970
Savitch relates nondeterministic and deterministic space
Savitch proved a deterministic-space simulation bound, establishing a durable relationship between space classes.
1970 Jan 1
POSIX epoch establishes a common software reference point
The IANA time-zone database uses 1970-01-01 00:00:00 UTC as its main scope boundary for locations whose clocks agree. Software later adopted this instant as the POSIX epoch for many timestamp representations.
1970 Aug
Royce describes staged software development
Winston Royce described a staged development model while warning that a purely sequential approach invites failure. The paper became a reference point for discussing feedback and iteration across life-cycle activities.
1971
Cook introduces polynomial reducibility
Cook used polynomial reductions in a theorem-proving complexity result, establishing a foundation for completeness arguments.
1971 May
Cook formalizes polynomial reductions for proof complexity
Cook's paper defines reducibility and polynomial degrees of difficulty for theorem-proving procedures. It supplied a way to compare problems by the transformations needed to solve one with another.
1972
C takes shape as a Unix implementation language
C's most creative development period occurred in 1972 while Unix was being developed. It paired a procedural language with types and operations close to conventional machine data.
1972
Karp relates combinatorial decision problems
Karp applied polynomial reductions across 21 combinatorial problems, making NP-completeness a reusable analysis method.
1972
Program test methods symposium is held
The Chapel Hill symposium collected work on program test methods and validation. It made testing methods a more visible subject of shared professional practice.
1972
Prolog work begins
Logic programs state relations and an engine searches for consequences.
1972
Smalltalk begins its object-oriented evolution
The Smalltalk line began with Smalltalk-72 and developed through Smalltalk-80. Its evolution explored object-oriented language and system design beyond simulation.
1972 Dec
Information hiding defines a module-decomposition criterion
Parnas described decomposing modules around design decisions likely to change. The idea made change isolation a concrete architectural concern.
1973
ML is created in the LCF project
ML is created in 1973, conceived to develop proof tactics in the LCF theorem prover. It brings static typing, algebraic data types, and pattern matching to the functional tradition.
1974
IBM publishes SEQUEL
SEQUEL separated requested relational data from access strategy.
1974
Stevens, Myers and Constantine publish Structured Design
Their IBM Systems Journal article formalizes coupling and cohesion in print, turning Constantine's internal IBM practice into a citable methodology.
1974 Aug
Dijkstra names separation of concerns
In EWD447, Dijkstra describes studying one aspect of a problem in isolation while remembering that the others exist — the lens this course's later principles all specialize.
1975
Scheme is created
Scheme is created in 1975 by Gerald Jay Sussman and Guy Steele, a minimal Lisp dialect that later becomes a popular teaching language and a testbed for language design ideas.
1975 Apr
Tarjan analyzes disjoint-set union efficiency
Tarjan's paper studies the efficiency of a set-union algorithm rather than only its functional result. It reinforced amortized analysis as a practical way to distinguish operations that have different costs over a sequence of updates.
1976
Fagan publishes formal inspection process at IBM
Michael Fagan's paper describes a structured inspection method with defined roles, exit criteria, and measurement — finding 50–65% of operational defects before testing, later reaching 75–85% in exceptional cases.
1977
A Pattern Language is published
Christopher Alexander and coauthors publish A Pattern Language, the architectural source for describing recurring problems and adaptable solutions.
1977
Backus argues against the von Neumann style
John Backus delivers the 1977 Turing Award lecture Can Programming Be Liberated from the von Neumann Style?, attacks the word-at-a-time programming style, and works on the function-level language FP, sparking research interest in functional programming.
1977
Make introduces dependency-driven builds
Make let build descriptions name targets and prerequisites.
1978
Communicating Sequential Processes is published
C. A. R. Hoare described processes communicating through input and output commands. The model made communication and synchronization a primary design concern rather than an implementation detail.
1978
Red-black tree framework is published
Guibas and Sedgewick presented a dichromatic framework for balanced search trees. The work supplied another way to limit search-tree height while supporting updates.
1978
The C Programming Language describes C
Kernighan and Ritchie's book provided the first published description of C. It gave programmers a common reference before formal language standardization.
1978 Dec
Hoare publishes CSP
Hoare's model treats input, output, and parallel composition of communicating processes as program-structuring primitives.
1979
Myers publishes The Art of Software Testing
Glenford Myers presented testing as a discipline focused on finding errors rather than demonstrating that a program works. The framing influenced test-design teaching and practice.
1979
Valiant defines
Valiant introduced a complexity framework for counting problems, extending attention beyond decision questions.
1979
Work on C with Classes begins
C with Classes began the design path that combined program organization facilities with C efficiency and flexibility.
1982 Jun
gprof introduces the call graph profile
Susan L. Graham, Peter B. Kessler and Marshall K. McKusick present gprof at the SIGPLAN '82 Symposium on Compiler Construction. It extends the existing UNIX profiler by gathering arcs of a program's call graph, so the running time of a called routine is attributed to the routines that called it. The GNU implementation combines an `mcount` call compiled into every function entry with program-counter sampling around 100 times per second, and reports both a flat profile and a call graph — the self-versus-total distinction every profiler has carried since.
1983
C++ becomes the language name
The predecessor evolved from C with Classes into C++, establishing the direction that later standardization would formalize.
1983
C++ gains its name
The name C++ first appeared in a 1983 publication after C with Classes. It marked a widely used extension of C's functions, types, and data model toward class-based program organization.
1984
First printed mention of refactoring
Leo Brodie's Thinking Forth used the word for restructuring Forth code, the earliest printed occurrence. The usage developed independently in the Forth and Smalltalk communities before the term reached the broader programming literature.
1984 Dec
Karmarkar publishes a polynomial-time linear-programming algorithm
Karmarkar presented an interior-point algorithm for linear programming with a polynomial worst-case bound. The result connected asymptotic analysis to a major optimization problem used outside the classroom.
1985
C++ enters the language landscape
C++ was published in 1985. It brought object-oriented constructs into a systems-language lineage that remained important for engineering practice.
1985
First commercial C++ release
The first commercial release made C++ available beyond its initial development setting and began the early tooling ecosystem.
1985
IEEE 754 standardizes floating-point arithmetic
IEEE 754 established binary and decimal floating-point formats and arithmetic behavior. It made rounding, exceptional values, and conversion rules part of a shared numeric contract.
1985
Miranda is released
Miranda is first released in 1985 as a fast interpreter in C for Unix systems. Its lazy, pure design has a strong influence on the later Haskell language.
1985
Splay trees add self-adjustment
Sleator and Tarjan published self-adjusting binary search trees. Access operations restructure the tree so recently used paths can become cheaper over time.
1986
CVS is publicly released
Dick Grune released CVS, a client-server front end to RCS that added repository-level change tracking and concurrent editing. It established the centralized model and the copy-modify-merge workflow this course describes.
1986
Erlang is developed at Ericsson
Erlang is developed by Joe Armstrong, Robert Virding, and Mike Williams in 1986 within Ericsson for fault-tolerant telecommunications systems, proving functional ideas in an industrial setting.
1986
Erlang is first implemented in Prolog
Erlang's first implementation explores language-level concurrency and error recovery for telecommunications work.
1986
Erlang work begins
Work that became Erlang started as an experiment in adding concurrent processes to Prolog for telephony. It established a practical message-passing and fault-handling lineage for concurrent systems.
1986
Fagan publishes advances in software inspections
A follow-up paper in IEEE Software refines the process and reports that IBM inspections found 90% of all defects detected over a product's life cycle with a 9% reduction in average project cost.
1986
The first OOPSLA conference convenes
OOPSLA first met in Portland in 1986. The conference became a forum for object-oriented programming systems, languages, and applications.
1987
FPCA '87 calls for an open standard
By 1987 more than a dozen non-strict, purely functional programming languages exist and Miranda is the most widely used. At FPCA '87 there is strong consensus that a committee be formed to define an open standard for such languages.
1987
Ian Holland formulates the Law of Demeter
At Northeastern University's Demeter Project, Holland proposes that a method should call only objects it directly holds — later summarized as "only talk to your friends."
1987
Unicode project begins
Engineers at Apple and Xerox began work on a universal character encoding architecture. The work addressed the limits of separate national character encodings.
1987 Sep 17
Pattern languages reach object-oriented programming
Ward Cunningham and Kent Beck publish their OOPSLA paper on using pattern languages for object-oriented programs.
1987 Dec 18
Larry Wall releases Perl 1.0
Wall posted Perl 1.0 to the comp.sources.unix newsgroup as a report-processing language that combined shell scripting, C syntax, and the pattern matching of awk and sed. It targeted system administration text tasks that were awkward in any one existing tool.
1988
Bertrand Meyer names the Open-Closed Principle
In Object-Oriented Software Construction, Meyer defines a module as open for extension and closed for modification — the rule Robert Martin later folds into SOLID.
1988
Gelperin and Hetzel describe testing's growth
The article traced changing testing goals from debugging toward defect detection, evaluation, and prevention. It documented how testing had expanded beyond a final coding activity.
1988
ISO 8601 standardizes numeric date and time representations
ISO 8601 established an international date-and-time representation standard. Its year-month-day ordering became the basis for unambiguous machine-readable dates.
1989
ANSI publishes C89
ANSI X3.159-1989 established the first ANSI C standard. It created the baseline later carried into the international C90 standard.
1989
SUnit establishes the xUnit pattern
Kent Beck's Smalltalk framework established the fixture-and-assertion structure later shared by xUnit frameworks. It made automated checks a routine part of writing a small unit of code.
1990s
69 milestones
1990
CVS 1.0 submitted to the Free Software Foundation
CVS 1.0 was submitted to the FSF for distribution, moving the centralized client-server model into broad open-source use and making the repository and working-copy split a default for collaborative projects.
1990
First published article on refactoring
Bill Opdyke and Ralph Johnson presented "Refactoring: An Aid in Designing Application Frameworks and Evolving Object-Oriented Systems" at SIGSOFT '90, the first appearance in published literature. It framed restructuring as a disciplined, behavior-preserving activity.
1990
Haskell 1.0 is published
Haskell is created in 1990 as the committee-defined pure, lazy, statically typed language. Its history is organized around Haskell 1.0 to 1.4, Haskell 98, and Haskell 2010.
1990
ISO/IEC publishes C90
ISO/IEC 9899:1990 made the C standard an international publication. C implementations could now target a shared ISO language specification.
1990 Apr
Haskell 1.0 report released
The first report defined a common non-strict purely functional language. It established the shared language design that later reports refined.
1990 Jun
Introduction to Algorithms first edition is published
The first edition of Cormen, Leiserson, and Rivest's Introduction to Algorithms was published by MIT Press in 1990. It became a durable reference path joining pseudocode, correctness, and complexity analysis for computer science education.
1991
Unicode 1.0 is published
The first Unicode Standard established a unified coded character repertoire. Later versions maintained a documented relationship with ISO/IEC 10646.
1991 Feb
Python is publicly released
Python's first public release appeared in February 1991. It provided a readable general-purpose language used here as the concrete syntax for fundamental programming examples.
1991 Mar
Perl 4.0 and the first Camel book
Perl 4.0 shipped alongside "Programming Perl" by Wall and Randal Schwartz, which became the de facto specification. Perl 4 was still a single-namespace language with no real support for large programs.
1991 Oct
Unicode 1.0 is published
The first published version established the Unicode character repertoire and implementation guidance. It provided a common character-code model before the later alignment with ISO/IEC 10646.
1991 Oct
Unicode and ISO 10646 agree to unify repertoires
Unicode and the ISO draft standard were changed into one numerical character encoding. The agreement led to the synchronized Unicode 1.1 and ISO/IEC 10646-1 work.
1992
Opdyke's dissertation defines the transformations
Bill Opdyke's dissertation "Refactoring Object-Oriented Frameworks" cataloged the framework-refactoring transformations that many of today's catalog entries descend from, including the discussion of a Software Refactory with Ralph Johnson.
1992
Shamir proves IP equals PSPACE
The result connected interactive proof systems with polynomial-space computation and expanded the map of complexity classes.
1992
Software architecture becomes an explicit research field
Work on architectural styles and abstractions separated system-level structure from individual program modules. Architecture became a subject that could be described and analyzed directly.
1992
UTF-8 is introduced
UTF-8 provided a variable-width Unicode encoding compatible with ASCII byte values. It became the byte-oriented representation used by many Internet systems.
1992 Mar
Haskell 1.2 report published
The Haskell 1.2 report documented an early revision of the language. It marks a period when the definition was still changing substantially.
1993
Unicode 1.1 aligns with ISO/IEC 10646-1
Unicode 1.1 documented the merged repertoire and aligned encoded characters and names with ISO/IEC 10646-1:1993. Implementers gained a shared code-point assignment across the two standards.
1993
Yukihiro Matsumoto begins Ruby
Yukihiro Matsumoto started Ruby in 1993. The project combined ideas from object-oriented and scripting languages around programmer-focused syntax and objects.
1994
Design Patterns popularizes composition over inheritance
The Gang of Four's catalog argues for assembling small, delegating objects over deep inheritance hierarchies, reframing "what can this object do" over "what is this object."
1994
First PLoP conference
The Pattern Languages of Programs conference series begins, creating a workshop venue for developing and discussing software patterns.
1994
PHP/FI begins as personal homepage tooling
Rasmus Lerdorf created PHP/FI from CGI scripts used to track visits to his homepage. The project established PHP's original connection to server-side web work.
1994
SEI publishes An Introduction to Software Architecture
The SEI introduction presented architectural representations and styles for reasoning about complex systems. It gave practitioners vocabulary beyond implementation diagrams.
1994
SGI publishes its Standard Template Library documentation
SGI documented generic containers, iterators, and algorithms as one library design. This made shared interfaces and interchangeable container implementations a practical C++ library pattern.
1994 Oct
Design Patterns is published
Gamma, Helm, Johnson, and Vlissides publish the catalog that presents 23 object-oriented patterns in creational, structural, and behavioral groups.
1994 Oct 17
Perl 5.000 released
A near-total rewrite of the interpreter added lexical variables with my, references, nested data structures, packages, modules, and an object model built on bless. These features let the language be extended without patching the core, which is what made an external module ecosystem possible.
1995
Brodie and Stonebraker publish Legacy Information Systems Migration
The study defined a legacy system as one that resists modification to meet new requirements and made incremental migration through gateways and interfaces the centerpiece of the discipline.
1995
C95 amends C90
ISO/IEC 9899:1990 Amendment 1:1995 added a revision to the C90 standard. It showed that the language could evolve through published amendments before a full revision.
1995
Java is released with threads and monitors
Java's first public release brought language-level threads and monitor synchronization to a broad application platform. Shared-memory coordination became a mainstream programming concern.
1995
Java makes its public debut
Sun announced Java publicly in 1995. The language added another mainstream route for expressing variables, control flow, functions, and data structures with a common runtime model.
1995
Microsoft SLM uses a one-branch daily workflow
Paul Hammant's historical account describes a Microsoft workflow that synchronized, built, tested, merged, and checked in against a shared master branch, followed by a daily build.
1995
PLoP archive records a continuing conference series
The official archive lists a second annual PLoP event, showing that the pattern workshop community continued after its first conference.
1995 May
JavaScript is created at Netscape
Brendan Eich creates the language for scripting in Netscape's browser. Its initial browser role establishes the lasting language-and-host split.
1995 Jun
IEEE approves the POSIX threads extension
IEEE approves 1003.1c-1995, the POSIX threads extension for C. Portable thread and synchronization APIs become a standard interface.
1995 Oct 26
CPAN goes online
The Comprehensive Perl Archive Network launched as a mirrored repository for Perl modules and distributions. Shared, installable libraries became the normal way to solve infrastructure problems in Perl rather than copying code.
1995 Dec
Ruby is publicly released
Ruby was publicly released in December 1995. The language became available beyond its original development context and began its community evolution.
1996
Java 1.0 ships checked exceptions
Java introduced checked exceptions: a method declares which checked exceptions it may raise, and the compiler forces callers to handle or propagate them, making the failure contract part of the method signature.
1996
Kent Beck begins leading the C3 project
Beck's work refining Extreme Programming on Chrysler's C3 project is where YAGNI first circulates as a named practice, in exchanges between Beck and Chet Hendrickson.
1996
MIME specifies Base64 transfer encoding
RFC 2045 documented Base64 for representing arbitrary octets in Internet message bodies. The format separated transport-safe representation from the payload bytes it carries.
1996
OCaml is created
OCaml is created in 1996, combining functional programming with an object layer and a strong static type system, and later finds commercial use in financial analysis and static analysis of embedded software.
1996 May
Haskell 1.3 report published
Haskell 1.3 made a substantial step from Haskell 1.2. The later 1.4 revision made only minor changes by comparison.
1996 Jul
Unicode 2.0 is released
Unicode 2.0 synchronized with ISO/IEC 10646 amendments and established the post-merger standard for implementers. Its July release marks the move beyond the early 16-bit-only version.
1996 Aug
Java Language Specification reaches first final release
The first edition of the Java Language Specification reached final release in August 1996. A formal specification made the language's syntax and semantics a portable reference for implementers and programmers.
1996 Nov
TC39 standardization work begins
Ecma's TC39 begins work from Netscape's submitted language. Browser implementations gain a shared specification target.
1996 Dec
CSS Level 1 becomes a Recommendation
CSS standardized matching rules resolved through a cascade.
1996 Dec
Ruby 1.0 establishes the first stable series
Ruby 1.0 marked an early stable release line. Stable language releases made it practical to build reusable libraries and applications around documented behavior.
1997
Debian approves its Free Software Guidelines
The Debian developer community approved the guidelines that later supplied the basis for the Open Source Definition. They made licensing criteria a written part of collaborative software distribution.
1997
JUnit brings the pattern to Java
Kent Beck and Erich Gamma released JUnit for Java. The framework helped make test methods, fixtures, and assertions a familiar part of everyday Java development.
1997
JUnit brings xUnit practice to Java
JUnit made repeatable automated unit tests a standard part of Java development workflows. Its conventions helped integrate automated checks with ordinary programming work.
1997
Python 1.5 converts exceptions to classes
Python moved from string-based exceptions to class-based exceptions, letting exception types carry structure and support inheritance-based matching in except clauses.
1997 Apr
Haskell 1.4 definition completed
Haskell 1.4 became the immediate basis for the later Haskell 98 refinement. The language was moving toward a stable standard.
1997 May
Perl 5.004 and the CGI era
Perl 5.004 bundled CGI.pm and the UNIVERSAL package. Combined with mod_perl, Perl became the dominant language for server-side web programming through the late 1990s and early 2000s.
1997 Jun
First edition of ECMA-262 is approved
The first ECMAScript standard defines a vendor-neutral language core. JavaScript practice can now distinguish standardized semantics from browser APIs.
1998
C++98 standardizes the exception model
The ISO C++ standard formalized throw, try, and catch with stack unwinding, and included optional exception specifications on function declarations. Those specifications were later deprecated and removed from the language in C++17.
1998
Erlang is released as open source
Erlang is released as free and open-source software in 1998, making the fault-tolerant runtime available outside Ericsson and seeding the ecosystem that later includes Elixir.
1998
First ISO C++ standard published
ISO/IEC 14882 established a published international language and library contract for C++ implementations.
1998
The PCP theorem is published
The theorem linked probabilistically checkable proofs to hardness of approximation, changing how approximation limits are proved.
1998 Feb
The Open Source Initiative is founded
Eric Raymond and Bruce Perens founded OSI as an educational, advocacy, and stewardship organization. OSI then focused on explaining and protecting the open source label.
1998 Feb 3
The open source label is coined
A Palo Alto strategy session chose the term open source after Netscape announced it would release browser source code. The label gave collaborative development a distinct public identity.
1998 Jun
PHP 3.0 becomes the successor to PHP/FI 2.0
The PHP Development Team announced PHP 3.0 as the official successor to PHP/FI 2.0. Its expanded language features and database support broadened the work PHP could host.
1998 Aug
ISO/IEC 12207 standardizes life-cycle processes
ISO/IEC 12207 defined a common process framework for software life cycles. It strengthened the practice of treating development, operation, and maintenance as related managed work rather than separate concerns.
1999
Fowler's Refactoring codifies the catalog
Martin Fowler's "Refactoring: Improving the Design of Existing Code" defined refactoring as a noun and a verb, cataloged the transformations with motivation and mechanics, and made the small-step behavior-preserving loop the standard practice.
1999
Hunt and Thomas name DRY in The Pragmatic Programmer
They state the DRY principle as "every piece of knowledge must have a single, unambiguous, authoritative representation" — broader than avoiding copy-pasted code.
1999
ISO/IEC publishes C99
ISO/IEC 9899:1999 replaced the C90-era specification with C99. Selecting a language dialect became increasingly important as implementations supported multiple standard revisions.
1999
Refactoring links design improvement to small transformations
Refactoring presents behavior-preserving changes as a way to improve an existing design incrementally, shifting pattern use toward evidence from code change.
1999 Feb
Haskell 98 report released
Haskell 98 refined and simplified Haskell 1.4 into a stable language and library report. It gave implementations a portable baseline to support.
1999 Feb
Haskell 98 reports are published
Haskell 98 standardized an expression-led functional model.
1999 Sep
Unicode 3.0 data release
Unicode 3.0 was released in September 1999 and aligned with the second edition of ISO/IEC 10646-1. The standard continued its synchronized expansion rather than creating a separate character space.
1999 Oct
OSI publishes its first approved-license list
OSI published its first formal list of approved licenses. The list gave projects a common reference point when selecting licenses that meet the definition.
1999 Dec
ECMAScript 3 is published
The third edition consolidates the language used through the next decade and becomes the baseline for broad browser implementation work.
2000s
92 milestones
2000
BitKeeper adopts a distributed model
BitKeeper introduced a proprietary distributed version control system used for the Linux kernel. It demonstrated that a clone could carry full repository history, the property this course identifies as the defining contrast with centralized systems.
2000
Evolutionary design is presented at XP 2000
Martin Fowler's discussion of patterns and refactoring originates as a keynote for XP 2000, framing patterns within iterative design.
2000
Robert Martin publishes Design Principles and Design Patterns
Martin's paper on software rot introduces the principles that would later be gathered under the SOLID acronym.
2000 Mar
Perl 5.6 ships and Perl 6 is announced
Perl 5.6 added the our declaration, initial Unicode support, and 64-bit integers. At that year's Perl Conference, Wall announced Perl 6 as a community-driven redesign of the language.
2000 May
PHP 4.0 ships with the Zend Engine
PHP 4.0 introduced the Zend Engine after a core rewrite aimed at complex applications and modularity. It also added broader web-server support, sessions, output buffering, and input-handling improvements.
2000 Jun
C# announced
Microsoft announced C# as part of its .NET strategy. The language was positioned with a managed runtime and class library ecosystem from the start.
2000 Jul
C# receives its first widely distributed implementation
Microsoft released the first widely distributed C# implementation in July 2000 as part of its .NET Framework initiative. The language specification defined an object-oriented language and standard-library model.
2000 Sep
Continuous Integration article published
Fowler and Foemmel described automated builds and tests run many times a day. The practice moved integration evidence closer to each change and reduced the time between an interaction defect and its discovery.
2000 Sep
Fowler and Foemmel publish the original Continuous Integration article
The article described a shared source point, automated build and test, and daily integration. It gave teams a concrete CI practice reference beyond scheduled builds.
2000 Sep
IEEE 1471 standardizes architecture description
IEEE 1471 defined architecture description around stakeholders, concerns, viewpoints, and views. It made the audience and purpose of a representation explicit.
2000 Sep 10
Original Continuous Integration article published
Martin Fowler and Matthew Foemmel describe automated, reproducible builds running many times a day so developers can integrate daily and reduce integration problems.
2000 Oct
Subversion project begins
CollabNet started Subversion as an open-source successor to CVS, preserving the centralized topology while fixing CVS limitations such as non-atomic commits and the lack of directory versioning. The course uses Subversion as its representative centralized system.
2001
Fowler observes strangler figs in the Queensland rainforest
The observation became the metaphor for growing a new system around a legacy one and moving behavior across in small pieces.
2001
Google builds Mondrian for internal code review
Google develops Mondrian, a Perforce-based tool that enforces peer-review before submission to the central monorepo, establishing the lightweight, tool-integrated model the company still uses.
2001
IntelliJ IDEA brings refactoring to the IDE
IntelliJ IDEA launched as a mainstream IDE with integrated rename, extract, inline, and move operations with previews. The model of refactoring as a first-class IDE feature became the pattern every later tool followed.
2001
Scala design begins at EPFL
Martin Odersky starts designing Scala at EPFL, building on earlier work on Funnel, Generic Java, and javac.
2001 Feb
Agile Manifesto published
The Manifesto stated values that favor collaboration, working software, and responsiveness to change. Its principles reinforced short delivery and feedback cycles as a way to manage changing requirements.
2001 Mar
Unicode 3.1 adds supplementary-character alignment
Unicode 3.1 synchronized with ISO/IEC 10646-2:2001, which added supplementary characters. UTF-16 implementations now had to handle surrogate pairs for characters outside the Basic Multilingual Plane.
2001 Jul 5
PEP 8 records a shared Python style guide
PEP 8 documented conventions for code in the Python standard library. Application teams gained a common reference for layout, naming, imports, and public interfaces.
2001 Dec
Python 2.2 starts type and class unification
Python 2.2 introduced type and class unification and allowed built-in types to be subclassed. The change moved Python's object model toward a more uniform treatment of built-in and user-defined types.
2001 Dec
Python documents new-style classes
Python's release material distinguished classic and new-style classes while defining a base object type for the new model. Practitioners needed to account for those different inheritance and method-resolution rules.
2002 Feb
C# 1.0 released
C# 1.0 shipped with Visual Studio .NET 2002. It established the language's original object-oriented and managed-programming model.
2002 Jul
RFC 3339 defines an Internet timestamp profile
RFC 3339 specified a constrained Internet profile of ISO 8601 using UTC or numeric offsets. It gave protocols a common syntax for representing an instant.
2002 Jul
Valgrind 1.0 released
Julian Seward released Valgrind 1.0, an instrumentation framework whose Memcheck tool flags an invalid memory read at the instruction that causes it rather than the later crash it produces.
2002 Jul 18
Perl 5.8 stabilizes Unicode and I/O
Perl 5.8 delivered reliable Unicode handling, layered I/O, and restructured threading. It remained the version most systems shipped for more than a decade.
2003
C++03 maintenance revision published
The 2003 revision maintained the ISO standard line while the language continued toward its next major revision.
2003
OSI receives nonprofit recognition
OSI received United States 501(c)(3) recognition. The organization added institutional structure to stewardship of the open source label and definition.
2003
The test pyramid is sketched
Mike Cohn developed the test automation pyramid in conversations with Lisa Crispin during 2003 and 2004. The metaphor connected test granularity to a portfolio rather than a single test type.
2003 Jan
Revised Haskell 98 report published
The revision incorporated corrections and clarifications gathered after the original Haskell 98 report. It preserved the stable specification while resolving ambiguities.
2003 Apr
Unicode 4.0 aligns with unified ISO/IEC 10646
Unicode 4.0 aligned with ISO/IEC 10646:2003, the edition that merged the former two ISO parts into one standard. The synchronization kept code-point assignments consistent across specifications.
2003 Jun
OMG charters the Architecture-Driven Modernization task force
The Object Management Group formed the task force to standardize how existing software assets are represented across modernization tools.
2003 Aug
Ruby 1.8 starts a long-lived production series
Ruby 1.8 became a widely used series through the 2000s. Its long service period formed the baseline that the next major language line had to move beyond.
2003 Nov
OMG issues the Knowledge Discovery Metamodel RFP
The request for proposals began the standard for representing software assets so that discovery and analysis output can move between tools.
2003 Dec 7
PEP 333 specifies WSGI
WSGI defined an interface between Python web applications and web servers or gateways. Framework and server choices could vary across that shared boundary.
2004
AKS primality test is published
The AKS result supplied a deterministic polynomial-time primality test, a notable algorithmic classification result.
2004
Clause 10 is added to the Open Source Definition
OSI added the technology-neutrality clause to address click-wrap licensing issues. The change reinforced that license rights cannot depend on a particular interface or technology.
2004
Guido van Rossum open-sources Rietveld
Van Rossum releases Rietveld on Google App Engine as an open-source counterpart to Mondrian, bringing tool-based review to Subversion projects and proving the model works beyond Google's walls.
2004
Is Design Dead is published
The article argues that refactoring and testing let teams keep a design adaptable and use patterns in an evolutionary style.
2004
JSR 166 adds concurrency utilities to Java
JSR 166 specified executor services, futures, concurrent collections, locks, and atomic variables. These APIs encouraged applications to express work as tasks instead of manually managing every thread.
2004
Scala first appears
Scala first appears on 20 January 2004, designed by Martin Odersky at EPFL, combining object-oriented and functional programming on the JVM and later finding wide use in data science.
2004
Selenium begins as web test automation
Selenium began at ThoughtWorks as a reusable tool for testing a web application. It helped establish open-source browser automation as a common option for dynamic testing.
2004
SWEBOK 2004 published
The IEEE Computer Society issued the first Guide to the Software Engineering Body of Knowledge. It organized the discipline's knowledge areas into a reference map for education and professional practice.
2004 Jan
Scala 1.0 released publicly on the JVM
After an internal release in late 2003, Scala 1.0 reaches the public on the Java platform in early 2004.
2004 Feb
Subversion 1.0 is released
Subversion 1.0 shipped as a production-ready centralized system with atomic commits and directory versioning. Its model is the reference point for the centralized column of the course's topology comparison.
2004 Jun
.NET target shipped, then later dropped
A reference compiler targeting the .NET Common Language Runtime ships in 2004; the target is officially dropped in 2012.
2004 Jun
Fowler publishes Strangler Application
The post gave the gradual replacement technique its name and argued for low-risk incremental replacement over single-cutover rewrites.
2004 Jul
PHP 5 introduces Zend Engine 2.0
PHP 5 released with Zend Engine 2.0 and a new object model. Object-oriented PHP became a stronger basis for larger application codebases.
2004 Sep
JSR 133 revises the Java memory model
JSR 133 revises Java's memory model and threading specification, formalizing important ordering rules for concurrent code.
2005
F# is created at Microsoft Research
F# is created in 2005 at Microsoft Research as an OCaml-influenced language on the .NET platform, bringing the functional style to the Microsoft ecosystem.
2005
Git begins development
Git's history dates its birth to 2005, providing a distributed version-control system that teams could use with either frequent mainline integration or longer-lived branches.
2005
Hudson is released
Hudson introduced a Java-based open-source CI server and became a widely used alternative to CruiseControl. CI automation moved toward extensible build servers that teams could operate themselves.
2005
OSI adds international directors
Directors from Europe, South America, Japan, and India joined OSI. Stewardship of the open source definition became more explicitly international.
2005
Rich Hickey begins work on Clojure
Rich Hickey starts working on Clojure in 2005 and releases it publicly in October 2007, a dynamic, functional Lisp hosted on the JVM.
2005 Mar
GHC 6.4 added full Cabal support
GHC 6.4 included full Cabal support and a revised package framework. Project packaging became part of the mainstream compiler workflow.
2005 Apr
BitKeeper withdraws its free license, prompting new DVCS work
BitKeeper revoked free-of-charge use for the Linux kernel community, removing the tool that had demonstrated distributed version control at scale. The breakdown directly motivated the two systems the course uses as distributed examples.
2005 Apr
Git begins for Linux kernel development
Linus Torvalds began Git days after the BitKeeper license change, designing it around local history and exchange between repositories. The course's repository-and-working-copy model and the inspect-record-exchange loop descend from this design.
2005 Apr
Git development begins
Git's initial public development established the distributed commit and reference model that later workflow policies organize.
2005 Apr
Mercurial is announced
Olivia Mackall announced Mercurial within days of Git, sharing the distributed-clone goal through a different implementation. The course pairs Git and Mercurial to show the distributed topology is not tied to one tool's internals.
2005 Nov
C# 2.0 added generics
C# 2.0 introduced generics, iterators, nullable value types, and partial types. Generic collections could then preserve type information without casts.
2005 Dec
Git 1.0 release
The first stable release made Git available as a general distributed version-control system rather than a Linux-kernel-only development effort.
2006
OSI publishes its license proliferation report
OSI published a report and regrouped its license list in response to growth in the number of licenses. The work made license selection a more deliberate project decision.
2006
RFC 4648 standardizes Base16, Base32, and Base64
RFC 4648 consolidated common Base-N encodings and their alphabets, padding, and canonical behavior. It gave decoders shared rules for accepting and rejecting text representations of bytes.
2006
Rust begins as a personal project
Graydon Hoare began the work that became Rust. Mozilla later sponsored it as a research project.
2006 Jan
Firebug ships for Firefox
Joe Hewitt released Firebug 0.2, the first tool to let developers inspect, edit, and debug HTML, CSS, and JavaScript directly inside the browser rather than through separate editors and alert statements.
2006 Mar
Scala 2.0 rewrites the compiler in Scala
Scala 2.0 ships with the compiler rewritten in Scala itself and adds experimental Java generics support plus the implicit keyword.
2006 Jul
Unicode 5.0 data release
Unicode 5.0.0 was released on July 14, 2006 and synchronized with amendments to ISO/IEC 10646:2003. The release shows the standards' continuing coordinated repertoire growth.
2006 Sep 19
Python 2.5 ships cProfile in the standard library
Python 2.5 adds cProfile, "a C implementation of the existing profile module that has much lower overhead", contributed by Armin Rigo. Deterministic profiling — monitoring every function call, return and exception with precise interval timing — becomes available by default in a mainstream language, along with the documented limits that come with it, including the distortion of Python-versus-C timing comparisons.
2007
Gerrit forks Rietveld for the Android Open Source Project
Shawn Pearce forks Rietveld to create Gerrit, adding access control and server-side enforcement that makes code review mandatory for AOSP contributions — the first large-scale open-source change-based review.
2007
ISO/IEC 42010 adopts the architecture-description standard
ISO/IEC 42010 carried the architecture-description concepts into an international standard. Teams could use a common framework for organizing views around concerns.
2007 Jan
Hackage package repository came online
Hackage became a central archive for Cabal packages. It made package publication and discovery a standard part of Haskell development.
2007 Mar
KDM 1.0 is finalized
The first version of the Knowledge Discovery Metamodel shipped, giving modernization tooling a common representation for software assets.
2007 Apr 26
Branch by Abstraction is named
The Trunk Based Development reference dates the name to Stacy Curl in 2007 and positions the technique as a way to make a large change incrementally without abandoning the trunk.
2007 Sep
Go receives its name
The initial design discussions led Rob Pike to suggest the name Go. The project then developed compilers and a standard library before public release.
2007 Nov
C# 3.0 introduced LINQ
C# 3.0 added query expressions, lambda expressions, extension methods, and implicitly typed local variables. These features made LINQ sequence pipelines part of ordinary C# code.
2007 Dec 18
Perl 5.10 adds modern conveniences
Released on Perl's 20th anniversary, 5.10 introduced say, the defined-or operator, named regex captures, and state variables, and marked the start of a regular release cadence for Perl 5.
2008
GitHub launches with pull requests
GitHub ships with a simple pull request system that wraps `git request-pull` in a web UI, making lightweight code review accessible to every hosted repository.
2008 Feb
GitHub founded
GitHub's founding marked the growth of hosted, social workflows around Git. It helped make shared change history, pull requests, and review conversations common parts of everyday software collaboration.
2008 Feb 1
Git 1.5.4 adds bisect skip
Git 1.5.4 added "git bisect skip" for revisions that cannot be tested, refining the binary-search algorithm Linus Torvalds had built into git bisect.
2008 Apr
Git 1.5.6 introduces rerere
Recorded resolution reuse gave long-running or repeatedly rebased work a way to reuse a prior conflict resolution while still requiring review.
2008 Sep
Chrome ships with a built-in inspector
Google Chrome launched with the Elements and Resources panels of WebKit's Inspector built in, starting the browser-native devtools lineage this course's breakpoint material now documents.
2008 Sep 2
V8 ships with Google Chrome
V8 launches as an open-source JavaScript engine with Chrome. The engine later becomes embeddable in hosts beyond the browser.
2009
Apache Avro publishes its specification
Avro documented binary serialization together with schemas and schema resolution. It made the external data contract explicit for files and RPC payloads.
2009
Node.js embeds V8
The first Node.js release embeds V8 in a server-side host. JavaScript programs gain a major runtime whose files and networking APIs are not part of ECMAScript.
2009
The test automation pyramid reaches a wider audience
Mike Cohn's book described the test automation pyramid, which was then commonly shortened to the test pyramid. Teams used it to discuss the balance between focused and broad tests.
2009 Jan 30
Ruby 1.9.1 launches the stable 1.9 series
Ruby 1.9.1 was the first stable Ruby 1.9 release. The new series emphasized clearer syntax, performance, and multilingual support while Ruby 1.8 remained available during the transition.
2009 Sep
RFC 5545 defines iCalendar time-zone components
RFC 5545 standardized iCalendar objects, including components that carry time-zone definitions for calendar data. Calendar interchange therefore had an explicit mechanism for local-time rules rather than only fixed offsets.
2009 Sep 9
Linux 2.6.31 merges performance counters and the perf tool
The kernel gains a performance counter subsystem abstracting the hardware registers that count instructions executed, cache misses and mispredicted branches, together with the `perf` userspace tool providing `perf top`, `perf record`, `perf report` and `perf annotate`. Sampling profiling stops being a per-application feature and becomes a kernel service any process on the machine can be measured with.
2009 Oct
First Devopsdays conference
The first Devopsdays followed prominent discussion of development and operations collaboration. It made delivery and operational responsibility a visible concern alongside construction and testing.
2009 Nov
Go is released as an open-source project
Go introduced a language design that put lightweight concurrent execution and channels in a new systems-programming ecosystem. Its release made message passing a common default in network-service code.
2009 Nov
Go project launches
Go launches with goroutines and channels, bringing a CSP-influenced concurrency model into a systems-programming toolchain.
2009 Nov 10
Go is released as open source
The Go project launched publicly as an open-source language. This started the ecosystem around packages, tools, and community maintenance.
2009 Dec
ECMAScript 5 is published
The fifth edition completes the post-ES3 standardization reset. Its strict mode and object facilities provide a firmer base for larger programs.
2010s
144 milestones
2010
C4 diagram types receive their initial names
The context, container, component, and class diagram types were named. The set gave software teams a compact hierarchy for explaining structure at different zoom levels.
2010
Continuous Delivery book published
Continuous Delivery connected continuous integration with build, test, and deployment automation, making frequent integration a foundation rather than the end of the delivery path.
2010
Google publishes Google-Wide Profiling
Gang Ren, Eric Tune, Tipp Moseley, Yixin Shi, Silvius Rus and Robert Hundt describe a continuous profiling infrastructure running across Google's data centers in IEEE Micro, reporting stable, accurate profiles at negligible overhead. It establishes that always-on fleet-wide profiling is affordable, and demonstrates analyses that only exist once profiles are collected everywhere, such as measuring application affinity to particular hardware platforms.
2010
Pull Requests 2.0 redefines review as discussion
GitHub overhauls pull requests into permanent, revision-aware discussions with diff views and inline commenting — transforming them from merge notifications into a genuine code review surface.
2010
Rust becomes a Mozilla Research project
The project moved into Mozilla Research and began developing in public. This supplied institutional support before Rust had stable compatibility guarantees.
2010 Feb
Apache Subversion becomes a top-level project
Subversion joined the Apache Software Foundation as a top-level project, consolidating the centralized model the course contrasts with distributed clones. It kept the central-server topology while distributed systems expanded around it.
2010 Apr
C# 4.0 added dynamic binding
C# 4.0 introduced the dynamic type alongside named and optional arguments. Dynamic binding deferred some member-resolution errors from compile time to runtime.
2010 Jun
Test-driven integration is described
Google's testing blog showed an incremental integration approach that tests two components together before expanding the scope. It emphasized keeping the increment small enough to diagnose failures.
2010 Jul
Haskell 2010 report finalized
The Haskell 2010 language report was announced as complete. It remains the report referenced for the language and standard library foundations in this course.
2010 Jul
Scala 2.8.0 unifies the collections library
Scala 2.8.0 ships a redesigned, uniform collections framework and adds named and default arguments, the shape most Scala code still inherits.
2010 Oct
Unicode 6.0 release
Unicode 6.0 was released on October 11, 2010. It synchronized with the second edition of ISO/IEC 10646's third version and included additions such as the Indian rupee sign.
2010 Dec
Google publishes test-size constraints
Google described Small, Medium, and Large tests with explicit limits on network, database, filesystem, and timing behavior. The model made speed and determinism enforceable properties rather than labels alone.
2011
C++11 standard published
The 2011 revision began the modern sequence of regularly named C++ standard editions used by projects to select language modes.
2011
CircleCI launches
CircleCI launched as CI/CD was still a niche practice for a smaller set of teams. Its arrival broadened the set of hosted CI options alongside self-managed servers.
2011
GitLab launches with merge requests
GitLab begins as an open-source alternative to GitHub, adding merge requests a month later and coupling review to an integrated CI/CD pipeline from the start.
2011
ISO/IEC publishes C11
ISO/IEC 9899:2011 published the C11 revision. It became a distinct language mode that compilers could expose alongside earlier C versions.
2011
OSI begins its affiliates program
OSI began an affiliates program and later elected directors nominated by those affiliates. The organization expanded formal connections with open-source communities.
2011
The C4 name is first used
The C4 name made the four-level diagramming approach identifiable and teachable. It emphasized communicating a software system with a small, consistent set of views.
2011 Jan
The Hudson community proposes the Jenkins name
The project proposed moving from the Hudson name to Jenkins after a dispute over trademark control. The renamed project retained the community-driven CI server lineage.
2011 May
Typesafe (later Lightbend) founded
Odersky and collaborators launch Typesafe Inc. to provide commercial support, training, and services around Scala, following a European Research Council grant earlier that year.
2011 Jun 13
PEP 405 specifies standard virtual environments
Python gained a standard mechanism for environments with their own installation context. Project dependency isolation no longer depended only on third-party conventions.
2011 Jun 24
Go publishes its profiling workflow
The Go team documents profiling as part of the language toolchain rather than an external tool, walking through a full optimization session with `go tool pprof`. The runtime samples the executing goroutine's stack about 100 times per second and samples the heap roughly once per half megabyte allocated, and the profile.proto format it emits later becomes the interchange format much of the profiling market stores.
2011 Aug
Swagger 1.0 released
The first Swagger Specification formalized a machine-readable description for HTTP APIs. A stable description format made client libraries something that could be generated from a contract instead of maintained alongside it by hand.
2011 Aug 31
GitHub Flow is described publicly
GitHub's account of its development flow points readers to the GitHub Flow description, a pull-request-oriented workflow that pairs a main branch with short-lived work.
2011 Nov
IANA publishes continuing tz database releases
The IANA release archive records 2011 time-zone-data releases. Distributing updated rule data became an operational concern for systems that schedule future civil times.
2011 Nov
ISO/IEC/IEEE 42010 revises architecture description
The joint revision superseded IEEE 1471 and ISO/IEC 42010:2007. It continued the stakeholder, concern, viewpoint, and view model for systems and software architecture.
2011 Dec
Flame graphs are released
Brendan Gregg releases the flame graph after working a MySQL performance problem, fixing stack depth on the y-axis and an alphabetically sorted stack population on the x-axis so that identical adjacent frames merge into single wide blocks. Profile output stops being a table to read and becomes a picture to scan, and the format spreads to off-CPU, memory, hot/cold and differential variants.
2012
Go 1.0 releases with error values instead of exceptions
Go launched without a try-catch-finally construct, using returned error values for recoverable failures and a panic and recover mechanism, where recover can only be called from a deferred function, for exceptional conditions.
2012
OSI launches individual membership
OSI launched an individual membership program. The organization added another route for participation in the stewardship community.
2012 Jan
Rust 0.1 is released
The first numbered source release established a public pre-stable line. Language and library compatibility could still change between releases.
2012 Feb 14
Julia announced publicly
The creators publish "Why We Created Julia," stating the goal of a language with the speed of C and the dynamism of Ruby, combining strengths they associated with MATLAB, Lisp, Python, R, and C.
2012 Mar
Go 1 establishes a stable release line
Go 1 followed the open-source release with a compatibility commitment. Its concurrency primitives became a stable basis for production libraries and services.
2012 Mar
Go 1.0 establishes a stable production release
Go 1.0 marks a stable release after the project's early iteration. Its runtime-managed concurrency model becomes a dependable platform.
2012 Mar 28
Go 1 establishes compatibility
Go 1 defined a language and core libraries intended as a stable foundation. The compatibility promise made long-lived Go code and documentation a practical expectation.
2012 May
Test pyramid guidance focuses on cost and brittleness
Martin Fowler explained the pyramid as a balance with more low-level tests than broad GUI tests. The discussion connected higher-level tests with slower execution and greater brittleness.
2012 Aug
C# 5.0 added async and await
C# 5.0 made task-based asynchronous methods a language feature. The async and await model changed how C# programs express non-blocking input-output work.
2012 Oct
TypeScript 0.8 introduces the language
TypeScript 0.8 makes an optional static type system for JavaScript publicly available. The language begins with the compile-to-JavaScript model that still separates type checking from runtime behavior.
2013
ISO/IEC/IEEE 29119 begins its software-testing series
The ISO/IEC/IEEE 29119 series organized common concepts, processes, documentation, and test-design techniques into international software-testing standards. It provided a shared structure for testing work across organizations.
2013 Jan
GitLab CI 2.0 adds concurrent per-project builds
GitLab CI 2.0 changed its job processing so separate projects could run builds concurrently. This improved the feedback loop for teams using CI alongside their Git repositories.
2013 Jan
Scala 2.10 adds futures, value classes, and string interpolation
Scala 2.10 introduces futures and promises, value classes, implicit classes, string interpolation, and a new pattern matcher, widening the functional and DSL toolset.
2013 Feb 24
Ruby 2.0 adds keyword arguments and Module prepend
Ruby 2.0 introduced keyword arguments and Module prepend among its language core features. These additions shaped API design and controlled extension of class behavior in later Ruby code.
2013 Mar
Mozilla releases asm.js
A strict, statically-typeable subset of JavaScript that let browsers apply ahead-of-time optimizations to compiled C/C++ output. It proved a browser could run cross-compiled native code fast, and set up the problem WebAssembly's binary format was designed to solve more directly.
2013 Mar 18
PEP 440 standardizes distribution versions
PEP 440 defined accepted version identifiers and comparison rules for Python distributions. Dependency tools could reason about project constraints with shared semantics.
2013 May
Go 1.1 adds the race detector
Go 1.1 adds a race detector for memory synchronization errors. Dynamic detection becomes a standard development tool.
2013 Nov
Buildbox becomes available without an invitation
Buildbox, the original Buildkite product name, left beta and opened signup without an invitation. Hosted CI became more accessible to teams that did not want to run every control-plane component themselves.
2013 Nov 13
Dart 1.0 releases
Dart 1.0 made the SDK a production-ready option for structured web applications. The release established the language, tools, and core libraries as a stable package.
2013 Dec
Go 1.2 adds the race detector
Go 1.2 added the race detector to the standard toolchain. Concurrent programs could then be tested for data races with a supported Go command.
2014 Mar 26
Mozilla announces rr
Robert O'Callahan introduced rr, a Linux record-and-replay debugger built to capture Firefox's intermittent test failures once and replay them with bit-for-bit identical memory and register state on every subsequent run.
2014 Apr
Scala 2.11 focuses on compiler and collection performance
Scala 2.11.0 concentrates on compiler and collection performance improvements and tightens Java interop rather than adding language features.
2014 Apr
TypeScript 1.0 reaches its first major release
TypeScript 1.0 marks the language's first major release and opens the project to community contributions. The release establishes a stable baseline for large-scale JavaScript development.
2014 Jun
Swift announced at WWDC
Apple introduced Swift as a safe, approachable, high-performance general-purpose language for its platforms.
2014 Jun
Unicode 7.0 release
Unicode 7.0 was released on June 16, 2014. Release dates became a practical compatibility boundary for libraries, fonts, and applications that need newly encoded characters.
2014 Jun 26
First JuliaCon held in Chicago
The Julia community holds its first dedicated conference at the University of Chicago's Gleacher Center, over June 26 and 27.
2014 Jul
Terraform 0.1 is announced
Terraform introduced configuration-driven infrastructure plans.
2014 Aug 8
Trunk-correlated practices chart released
Paul Hammant's chart records its first version in 2014, collecting related practices for moving from long release cycles toward continuous delivery.
2014 Sep
Elixir v1.0 is released
Elixir v1.0.0 is released on 18 September 2014 by Jose Valim, a dynamic, functional language that leverages the Erlang VM for low-latency, distributed, fault-tolerant systems.
2014 Sep
Swagger 2.0 released
Swagger 2.0 expanded the formal API description and made a portable contract a more practical input to code generation, validation, and reference documentation for client surfaces.
2014 Sep 29
PEP 484 specifies type hints
PEP 484 standardized annotation conventions for static analysis without adding automatic runtime enforcement. Applications could adopt shared type-checker vocabulary across package boundaries.
2014 Nov
crates.io opens
crates.io became the central registry for discovering and downloading Rust crates. Cargo gained a shared publication and dependency source ahead of Rust 1.0.
2015
C4 renames its fourth diagram type to code
The fourth level changed from classes to code during 2015–2016. The change avoided implying that every codebase should be explained through class diagrams.
2015
Google cautions against end-to-end-heavy suites
Google's testing guidance explained the maintenance and execution costs of a strategy dominated by end-to-end tests. It reinforced choosing test levels according to feedback needs rather than automating every scenario at the same scope.
2015
jscodeshift opens the codemod era
Facebook's jscodeshift toolkit applied AST-based transformations to JavaScript at codebase scale. Scripted, reviewable diffs extended the small-step discipline from an editor keystroke to a transformation applied across many files.
2015
PHP 7.0 introduces Zend Engine 3.0
PHP 7.0 shipped with Zend Engine 3.0, performance and memory-use improvements, stronger exception behavior, and newer language constructs. The release reset expectations for modern PHP performance and type declarations.
2015
Scala.js declared no longer experimental
The Scala.js compiler, in development since 2013, is declared no longer experimental with the 0.6 series, establishing JavaScript as a real target.
2015
Swagger donated to the OpenAPI Initiative
The Swagger specification was donated to the OpenAPI Initiative, moving the description format that SDK generators consume under vendor-neutral governance.
2015
Swift 2.0 introduces throw, do-catch, and try
Swift added error handling with throw, do-catch, and try, plus defer for cleanup actions that run when scope exits whether the function returns normally or throws.
2015 Jan
TypeScript 1.4 adds union types
TypeScript 1.4 adds union types, type guards, and aliases. These features make it practical to model values that may have several valid shapes and then narrow them in code.
2015 Apr
Google argues for focused integration checks
Google advised replacing unnecessary end-to-end checks with smaller integration tests when they detect the same defect. The advice sharpened the distinction between a seam test and a full journey.
2015 Apr 9
PEP 492 introduces native coroutine syntax
Native coroutines and async and await syntax made cooperative asynchronous control flow explicit. Application design gained standard language constructs for concurrent I/O.
2015 Apr 23
Origins of Trunk-Based Development documented
Paul Hammant published a historical investigation that distinguishes a trunk layout from the operating practice of keeping normal work on a shared development line.
2015 May
Rust 1.0 commits to stability
Rust 1.0 establishes a stable systems-programming platform with ownership-based safety guarantees and standard concurrency tools.
2015 May
Rust 1.0 is released
Rust 1.0 committed to a stable language and standard library. Ownership-aware concurrency libraries gave systems programmers a way to express some shared-state constraints in types.
2015 May 15
Rust 1.0 is released
Rust began its stable compatibility commitment while retaining low-level control without a garbage collector. Stable code gained a foundation for long-lived libraries and applications.
2015 Jun
ECMAScript 2015 is published
The sixth edition adds major language structures including block-scoped declarations, classes, modules, arrow functions, promises, maps, and sets.
2015 Jun
WebAssembly formally announced
Mozilla, Google, Microsoft, and Apple simultaneously published coordinated blog posts announcing a joint WebAssembly effort under the W3C WebAssembly Community Group, moving the project from a single-vendor prototype to a shared, multi-browser standard from day one.
2015 Jul
Git 2.5 adds worktree
Linked working trees made concurrent branch work possible without maintaining separate clones of the same repository.
2015 Jul
Go blog codifies errors as values
The Go team's post formalized the idiom of treating errors as ordinary values that can be checked, transformed, and returned inside the normal flow of a function rather than as a repeated branch.
2015 Jul
Kubernetes 1.0 is released
Kubernetes made reconciliation a mainstream operational pattern.
2015 Aug 19
Go 1.5 is self-hosted
The compiler toolchain moved from C to Go, and the garbage collector was redesigned. The release also made the default GOMAXPROCS value match logical CPU count.
2015 Sep 30
PEP 517 separates build frontends and backends
PEP 517 specified hooks between tools that request builds and tools that perform them. Projects could select build backends without requiring installers to run backend-specific commands.
2015 Oct
Git LFS 1.0.0 is released
Git LFS 1.0.0 established an extension that stores large file content outside normal Git objects while committing text pointers. The course names it as the storage extension that addresses the large-binary-asset limit without changing the version-control model.
2015 Oct 23
rr 4.0.0 stabilizes reverse execution
rr 4.0.0 was the first stable release with reverse execution enabled, letting a recorded run be stepped backward from a crash to the state change that caused it.
2015 Dec 3
Swift became open source
The language, compiler, debugger, libraries, Linux port, and package manager opened to community development through Swift.org.
2015 Dec 25
First official Perl 6 release (Rakudo "Christmas")
Fifteen years after the announcement, Perl 6 reached a stable language definition through the Rakudo implementation. It was clearly a separate language from Perl 5, not a successor version.
2016 Feb 8
Andrew Kelley announces Zig
Kelley published the first design of Zig as a systems language intended to replace C, citing problems with C interoperability in Go and with the borrow checker in Rust. Development began as a spare-time project.
2016 Mar
RFC 7808 specifies a time-zone data distribution service
RFC 7808 defined an HTTP service for clients to discover and retrieve time-zone data. The protocol recognized that applications may need current rule data beyond their local installation.
2016 May 10
PEP 518 defines build-system metadata
PEP 518 introduced the pyproject.toml build-system table for build requirements and backend selection. Build tools gained a standard way to prepare an isolated build environment.
2016 Jun
ECMAScript 2016 begins annual editions
The seventh edition follows the year-based naming used after ECMAScript 2015. Smaller annual editions replace long gaps between major standards.
2016 Jul
JUnit 5 reaches its first milestone
The first JUnit 5 milestone release introduced the modern JUnit Platform and Jupiter direction. It separated the platform for running tests from the programming model for writing them.
2016 Aug
gRPC 1.0 released
gRPC 1.0 established a stable protocol and API surface for service contracts, so code generation from a service definition became a standard path for clients beyond HTTP resource APIs.
2016 Sep
TypeScript 2.0 adds strict null checking
TypeScript 2.0 introduces `strictNullChecks` and control-flow-based type analysis. Programs can require explicit handling for null and undefined rather than treating them as compatible with every type.
2016 Sep 13
Swift 3 and Swift Package Manager shipped
Swift 3 delivered broad source changes while the package manager became officially available for cross-platform packages.
2016 Nov
Rust 1.13 stabilizes the question-mark operator
Rust stabilized the ? operator for propagating Result errors from an enclosing function, making the errors-as-values model readable in deep call chains.
2016 Nov
Scala 2.12 requires Java 8 and emits Java 8 bytecode
Scala 2.12.0 requires Java 8, generates Java 8 bytecode, and adds Java 8 SAM (functional interface) language support, aligning Scala with the modern JVM.
2017
All four major browsers support WebAssembly
By the end of 2017, Firefox, Chrome, Edge, and Safari all shipped working WebAssembly support, making it usable in production across the mainstream browser market for the first time.
2017
C++17 standard published
The 2017 revision continued the published ISO C++ language and library line that implementations target through explicit compiler modes.
2017
Trunk Based Development book site released
The Trunk Based Development site was transformed into a book covering feature flags, branch by abstraction, short-lived branches, continuous integration, and continuous delivery.
2017 Mar
C# 7.0 expanded tuples and patterns
C# 7.0 added tuple types, deconstruction, pattern matching, local functions, and other syntax changes. These features made shape-based decisions and small returned values more direct to express.
2017 Mar
Firefox ships the first browser WebAssembly support
Firefox became the first major browser to ship a working WebAssembly implementation, ahead of the other three vendors finishing their own.
2017 May 30
Perl 5.26 removes the current directory from @INC
The default module search path no longer included the current working directory, closing a long-standing local code-execution risk. Some scripts that relied on the old behavior needed a one-line fix.
2017 Jun
Unicode 10.0 release
Unicode 10.0 was released on June 20, 2017. The continuing versioned release process means a system's Unicode data version is part of its text-processing behavior.
2017 Sep 19
Swift 4 preserved Swift 3 source compatibility
Swift 4 combined language and standard-library additions with a compatibility mode for existing Swift 3 source.
2017 Oct 17
Zig 0.1.0 released
The first tagged release. The compiler was written in C++ and used LLVM for code generation. The core ideas, manual memory, comptime, and error unions, were already present.
2017 Nov
Browser implementers reach MVP design consensus
Representatives from the major browser engines agreed that the design of the initial WebAssembly API and binary format was complete, fixing the format's core shape before wider adoption.
2017 Nov 28
Celeste.jl exceeds 1 petaflop on Cori
A Julia astronomy application (Celeste.jl) sustains 1.54 petaflops of double-precision performance across 1.3 million threads on NERSC's Cori supercomputer, the first Julia application to exceed one petaflop per second.
2017 Dec 25
Ruby 2.5 continues language and runtime evolution
Ruby 2.5 continued the annual stable release cadence with language and implementation changes. Applications increasingly needed disciplined upgrade testing rather than treating Ruby versions as interchangeable.
2018
ISO/IEC publishes C17
ISO/IEC 9899:2018 published the C17 revision. Projects that need portability must still state which revision their toolchain accepts.
2018
Refactoring, second edition
Fowler and Kent Beck rewrote the catalog with JavaScript examples, updating the book for a language-neutral, tool-assisted era while keeping the definition and the small-step discipline unchanged.
2018
Sadowski et al. publish modern code review research at Google
A large-scale study of Google's Critique logs finds median time-to-approval under 4 hours, most changes under 24 lines, and developers spending about 3.2 hours per week reviewing — establishing empirical baselines for modern review practices.
2018
Second edition of Refactoring is published
The updated Refactoring book continues the practice of improving design through small behavior-preserving transformations.
2018 Feb
Azure Migrate reaches general availability
Microsoft shipped a managed migration hub offering discovery, assessment, and strategy planning, making modernization planning a supported cloud service.
2018 Feb
Practical Test Pyramid integrates contracts and seams
Martin Fowler's practical guide presented unit, integration, contract, UI, and end-to-end checks as different feedback mechanisms. It showed database and service boundaries as focused integration targets.
2018 Feb 22
Dart 2 preview is announced
Dart 2 was presented as a language update focused on client-side web and mobile development. The preview described a strengthened type system and rebuilt tooling.
2018 Mar
TypeScript 2.8 adds conditional types
TypeScript 2.8 adds conditional types and the built-in utility types `Exclude`, `Extract`, `NonNullable`, `ReturnType`, and `InstanceType`. Library authors can express more relationships between input and output types.
2018 May
OpenAPI Generator forked from swagger-codegen
The OpenAPI Generator project forked swagger-codegen to produce client libraries, server stubs, and documentation from an OpenAPI document across many languages, giving teams a template-driven baseline to layer ergonomics on.
2018 Jun
Kelley begins working on Zig full time
Kelley left his engineering job to develop Zig full time, funded at first by recurring donations. This set the pattern of a small team funded by sponsors rather than a corporation.
2018 Jul
TypeScript 3.0 adds project references
TypeScript 3.0 adds project references and build mode for larger codebases. Teams can express project boundaries and build dependencies instead of treating every source file as one compiler project.
2018 Aug 7
Dart 2 stable ships
The stable Dart 2 release included a rewritten web platform. It aligned the language, libraries, and tools for web and mobile framework work.
2018 Aug 8
Julia 1.0 released
Julia reaches 1.0 after nearly a decade of work, adding a commitment to language API stability: code written for 1.0 continues to work on later 1.x releases.
2018 Aug 24
Go 1.11 introduces modules
Go 1.11 introduced experimental modules as an alternative to GOPATH with versioning and package distribution. Dependency requirements became explicit in the project model.
2018 Sep
Git 2.19 adds range-diff
Range-diff made it practical to compare two versions of a patch series after a rebase or review revision.
2018 Sep 25
JDK 11 open-sources JDK Flight Recorder
JEP 328 moves Flight Recorder, previously a commercial feature of the Oracle JDK, into the open repository and delivers it in JDK 11, which reaches General Availability on 25 September 2018. The stated goal is at most 1% overhead out of the box on SPECjbb2015 and no measurable overhead when disabled. A production-grade recorder of thread samples, lock profiles and allocation ships with the runtime rather than being purchased separately.
2018 Oct
GitHub announces GitHub Actions in beta
GitHub announced Actions as a way to automate and customize development workflows from the repository platform. CI configuration could now sit directly beside pull requests, source, and repository events.
2018 Oct
Kotlin 1.3 ships coroutine libraries
Kotlin 1.3 ships multiplatform libraries for managing coroutines, bringing structured lifetimes into its development ecosystem.
2018 Oct
Kotlin 1.3 stabilizes coroutines
Kotlin 1.3 made coroutines stable and supplied a standard vocabulary for suspension and asynchronous work. This strengthened the distinction between cooperative tasks and operating-system threads.
2018 Dec 6
Rust 2018 reaches stable
Rust 1.31 introduced the first edition after Rust 2015. Crates could opt into new idioms while remaining interoperable with crates from other editions.
2019
Go 1.13 adds error wrapping
Go introduced formatted wrapping with the percent w marker and the errors.Is and errors.As functions, letting a wrapped chain be tested for a specific error and unwrapped to a concrete type without losing the original.
2019
IEEE 754-2019 revises floating-point standard
The 2019 revision continued the standardized treatment of binary and decimal floating-point formats, operations, conversions, and exceptions. It kept numeric representation behavior explicit across implementations.
2019
OpenRewrite automates ecosystem migrations
OpenRewrite introduced an automated refactoring engine running prepackaged recipes for framework migrations, security fixes, and stylistic consistency, turning the refactoring step into a repeatable whole-repository operation.
2019 Mar
Mozilla announces WASI
The WebAssembly System Interface extended WebAssembly's target beyond the browser tab, giving standalone modules a standardized, capability-based way to request access to files, sockets, and other system resources.
2019 Mar
Smithy released as open source
AWS released Smithy, a protocol-agnostic interface definition language built for code generation, under Apache 2.0. One model could drive clients, servers, documentation, and OpenAPI output, coupling contract design to generated client shape.
2019 Mar
Swift 5 established ABI stability on Apple platforms
Apple operating systems could provide the Swift runtime, reducing the need for applications to bundle those runtime libraries.
2019 Jun
Scala 2.13 redesigns the standard collections
Scala 2.13.0 redesigns the standard collections library again and adds literal types, the last major Scala 2 line before Scala 3.
2019 Jul
Azure SDK preview wave
Microsoft previewed a redesigned wave of Azure SDKs built on published client-library guidelines and a shared core library, institutionalizing consistent naming, error handling, pagination, and long-running-operation shapes across languages.
2019 Jul
Threads ship in Chrome only, gated by Spectre mitigations
WebAssembly's threads proposal depended on SharedArrayBuffer, which every browser vendor had disabled after the Spectre and Meltdown side-channel disclosures; Chrome alone had re-enabled it through site isolation, leaving threaded Wasm usable in one browser for the time being.
2019 Jul 23
Composable multi-threading announced (Julia 1.3)
Julia 1.3 introduces `Threads.@spawn` and a dynamic task scheduler, letting nested parallel calls share threads without oversubscribing the machine.
2019 Aug
Git 2.23 adds switch and restore
The new commands separated branch switching and file restoration from the overloaded checkout command.
2019 Aug
Git 2.23 introduces switch and restore
Git 2.23 split branch switching from path restoration into `git switch` and `git restore`, separating two intents previously combined in `git checkout`. It is a workflow-level change that sits on top of the model this course teaches rather than altering it.
2019 Sep
C# 8.0 introduced nullable reference types
C# 8.0 added nullable reference types and nullable static analysis. Projects could express and check whether a reference was intended to be null.
2019 Oct
Perl 6 is renamed Raku
The Perl 6 language was formally renamed Raku, ending the shared name and confirming that Perl and Raku are two independent languages with separate development.
2019 Oct
RFC 8536 documents the TZif binary format
RFC 8536 documented the Time Zone Information Format used to distribute compiled time-zone data. It made the boundary between IANA source rules and runtime-consumable zone files explicit.
2019 Nov
GitHub Actions reaches general availability
GitHub made Actions generally available and announced self-hosted runners, artifact caching, and ARM support. Teams could choose hosted or self-managed execution while keeping workflow definitions in GitHub.
2019 Dec
W3C publishes WebAssembly Core 1.0 as a Recommendation
The Core Specification became an official W3C Recommendation, giving WebAssembly the same standards-track status as HTML, CSS, and JavaScript.
2019 Dec 11
Dart 2.7 adds extension methods
Dart 2.7 added extension methods, letting code add statically resolved members to types it does not control. The feature made static type information central to extension selection.
2020s
70 milestones
2020
C++20 standard published
C++20 added concepts and modules, expanding the language facilities that modern toolchains and build integrations must support.
2020 Feb
Go 1.14 makes modules production-ready
Go 1.14 declared module support ready for production use and encouraged migration. Modules became the default mental model for organizing and resolving dependencies.
2020 Apr 13
Zig 0.6.0 lands zig cc
The release added zig cc, a Clang-based C compiler front end with a GCC-compatible command line, together with bundled libc sources. Zig could now compile and cross-compile C, not only Zig.
2020 May
PEP 615 adds zoneinfo to Python's standard library
PEP 615 introduced the zoneinfo module for IANA time-zone support in Python. It brought named-zone handling and transition behavior into a standard runtime API.
2020 Jun
Crossplane reaches version 1.0
Crossplane applied reconciliation to provider-managed infrastructure.
2020 Jun
Perl 7 is announced
The project announced Perl 7, planned as Perl 5.32 with modern defaults such as strict and warnings enabled automatically. The aim was a cleaner baseline without a Python-2-to-3-style break.
2020 Jun 22
PEP 621 defines standard project metadata
PEP 621 standardized core project metadata in pyproject.toml. Names, versions, dependencies, scripts, and related fields could move from backend-specific files into a shared table.
2020 Jul
Git 2.28 adds initial-branch configuration
The init.defaultBranch setting let organizations choose a default branch name for newly initialized repositories.
2020 Jul
Git 2.28 makes the initial branch name configurable
Git 2.28 made the default name of a newly created repository's initial branch configurable, letting teams name the integration line deliberately rather than inheriting a convention. The course treats branch naming as team policy, which this release made first-class.
2020 Jul 11
The Zig Software Foundation is announced
A 501(c)(3) non-profit was formed to hold the project's assets and fund core contributors through donations and sponsorships, keeping the language independent of any single company.
2020 Aug
TypeScript 4.0 adds variadic tuple types
TypeScript 4.0 adds variadic tuple types and labeled tuple elements. Function APIs can preserve richer relationships among rest parameters and tuple positions.
2020 Aug 18
An independent foundation is planned
The Rust Core Team and Mozilla announced plans for a Rust foundation. The plan moved legal, financial, trademark, and infrastructure responsibilities toward an independent organization.
2020 Sep 22
Official Windows toolchain images became available
Swift published downloadable Windows toolchains, extending practical compiler and library work beyond Apple platforms and Linux.
2020 Oct
Git 2.29 brings Scalar into Git
Scalar entered Git as a contribution for managing large working repositories, extending workflow concerns beyond branch operations alone.
2020 Nov
C# 9.0 added records and top-level statements
C# 9.0 added records and top-level statements. Data-centered types and small console programs could use less declaration boilerplate.
2020 Nov
PHP 8.0 begins the PHP 8 series
PHP 8.0 added named arguments, union types, attributes, constructor property promotion, match expressions, and an optimizing JIT compiler. It also brought breaking changes that made runtime upgrades an explicit engineering task.
2020 Nov 19
Sound null safety reaches beta
The beta began ecosystem migration toward explicit nullability. Packages and applications could opt in through their SDK constraints.
2020 Dec 25
Ruby 3.0 adds Ractor, Fiber Scheduler, and RBS
Ruby 3.0 introduced Ractor for parallel execution, Fiber Scheduler hooks for nonblocking operations, and RBS plus TypeProf for static analysis. Concurrency and type contracts became more visible parts of the language ecosystem.
2021 Feb 8
The Rust Foundation is established
The Rust Foundation began as an independent nonprofit supporting the Rust language and ecosystem. Project governance remained with the Rust Project.
2021 Mar 3
Dart 2.12 makes sound null safety stable
Dart 2.12 introduced sound null safety and stable FFI. New code could use non-nullable types by default while existing projects migrated incrementally.
2021 Mar 24
Julia 1.6 released, and named as the LTS candidate
Julia 1.6 ships with the compiler and release team flagging it as the likely next Long-Term Support release, a status the project confirmed later that year once the release had been used in the field.
2021 May
Scala 3.0.0 released
Scala 3.0.0 ships with a new syntax based on indentation, given and using contextual abstractions, and the Dotty compiler, the largest language change since 2.0.
2021 May
The Perl 7 plan is withdrawn
The newly formed Perl Steering Council set aside the changed-defaults plan in favor of the use VERSION mechanism, where writing use v5.36 or later opts a scope into modern features while old code keeps running unchanged.
2021 Jun
Google restates the need for unit and integration layers
Google recommended a solid base of unit tests, integration testing for groups of components, and end-to-end checks for critical user journeys. The guidance treated the layers as complementary rather than substitutes.
2021 Sep 20
Swift 5.5 introduced structured concurrency
Async and await, tasks, task groups, actors, and isolation became language-level concurrency tools.
2021 Oct 8
Parca applies the Prometheus model to profiles
Polar Signals releases Parca, pairing an eBPF-based profiler that discovers targets through Kubernetes or systemd with storage that identifies profile series by type and key/value labels and queries them with a label selector. Profiles become a queryable time series rather than a file, which is what makes comparing two points in time a query rather than a manual diff.
2021 Oct 21
Rust 2021 reaches stable
Rust 1.56 stabilized the 2021 edition. Edition migration remained opt-in per crate, preserving interoperability across editions.
2021 Nov
AWS announces Mainframe Modernization
The managed service brought replatforming and automated COBOL and PL/I to Java refactoring to mainframe workloads, formalizing mainframe displacement on AWS.
2021 Nov
PHP 8.1 adds enums and fibers
PHP 8.1 added enumerations and fibers, alongside readonly properties and other language changes. It made fixed value sets and cooperative concurrency first-class language features.
2022 Feb
NIST publishes SSDF version 1.1
NIST SP 800-218 presented secure software development practices that can be integrated into life-cycle implementations. It made security requirements, protected development environments, and vulnerability response explicit work.
2022 Mar
Go 1.18 adds type parameters and fuzzing
Go 1.18 added type parameters, built-in fuzzing support, and workspace mode. The release expanded both reusable type design and the standard testing workflow.
2022 May 27
Perl 5.36 makes signatures stable
Subroutine signatures left experimental status, and the use v5.36 bundle turned on strict, warnings, signatures, say, and the isa operator together. This is the practical form of the "better baseline" the Perl 7 discussion was about.
2022 Aug
Smithy IDL 2.0 released
Smithy IDL 2.0 cut the nulls and optionals that leaked into generated code and added enums, mixins, and defaults, making the interface definition a cleaner source for generated client models.
2022 Sep
JDK 19 incubates structured concurrency
JEP 428 introduced structured concurrency as an incubating Java API. It treated related tasks as one unit so cancellation, failure, and observability could follow a visible task scope.
2022 Oct
Git 2.38 makes Scalar a built-in command
Scalar became a built-in command, bringing large-repository configuration and maintenance closer to standard Git distribution.
2022 Oct 31
Zig 0.10.0 makes the self-hosted compiler the default
The compiler rewritten in Zig became the default, replacing the C++ implementation. This unblocked incremental compilation work and Zig's own code-generation backends.
2022 Dec
PHP 8.2 adds readonly classes and DNF types
PHP 8.2 added readonly classes and disjunctive normal form types. These features continued the move toward making object constraints explicit in code.
2022 Dec 25
Ruby 3.2 continues the Ruby 3 series
Ruby 3.2 continued the Ruby 3 line with further language and runtime work. Version upgrades remained a compatibility task that requires release-note review and application tests.
2023
C++23 technical work completed
Technical work for C++23 completed in 2023; its ISO publication became ISO/IEC 14882:2024(E), the current published C++ standard.
2023
Fedora decides to compile with frame pointers by default
Fedora accepts adding `-fno-omit-frame-pointer` and `-mno-omit-leaf-frame-pointer` to default C and C++ compilation flags, targeting Fedora Linux 38. The rationale is that stack unwinding via frame pointers is cheap while the DWARF alternative requires copying the full stack from kernel to user space, against a measured cost of about 2.4% on a kernel compile and 2% on a Blender render. A distribution-wide build flag is changed to make profiling work.
2023 Mar
Kiota generally available
Microsoft's Kiota generator reached general availability, emitting only the strongly typed client surface a caller uses on top of a shared core library — a minimal-generation stance that leaves room for handcrafted ergonomics.
2023 Mar
TypeScript 5.0 standardizes new decorators
TypeScript 5.0 implements the new ECMAScript decorators proposal and adds improvements including const type parameters. The release continues the language's approach of aligning static syntax with JavaScript runtime proposals.
2023 Mar 15
Grafana Labs acquires Pyroscope and merges it with Phlare
Grafana Labs acquires Pyroscope, founded in 2021, and merges it with Grafana Phlare, launched in 2022, under the name Grafana Pyroscope. The open-source continuous profiling field consolidates from two competing databases into one, alongside the framing of profiling as a further observability signal beside metrics, logs and traces.
2023 May
Scala 3.3.0 is the first LTS release
Scala 3.3.0 becomes the first long-term support release of Scala 3, giving libraries and teams a stable maintenance line to target.
2023 May 9
Julia 1.9 adds package extensions and native code caching
Julia 1.9 introduces package extensions (conditional code that loads only when another package is present) and caches native code across sessions, substantially cutting "time to first plot" compilation latency.
2023 May 10
Dart 3 releases records and patterns
Dart 3 required sound null safety and added records, patterns, and class modifiers. It also previewed compilation to WebAssembly for web work.
2023 Aug
Go 1.21 adds profile-guided optimization
Go 1.21 added profile-guided optimization support and improved compiler build speed using PGO. Performance work could use production profile data in the standard toolchain.
2023 Aug 4
Zig 0.11.0 adds a package manager
The build system gained a built-in package manager driven by build.zig.zon, with dependencies named by URL and content hash and built from source. There is no central registry.
2023 Sep
JDK 21 delivers virtual threads
JDK 21 delivers virtual threads managed by the JDK. The feature supports thread-per-task designs with existing diagnostic tools.
2023 Sep 18
Swift 5.9 introduced macros
Macros added compile-time source transformation, alongside ownership work and noncopyable types.
2023 Oct
IBM watsonx Code Assistant for Z reaches general availability
IBM shipped a generative-AI tool that converts COBOL and PL/I to Java and generates unit tests to confirm the translation preserves behavior.
2023 Oct
WasmGC ships by default in Chrome 119
Chrome enabled WebAssembly Garbage Collection by default, adding struct and array heap types that let the host engine's own garbage collector manage memory for languages like Java, Kotlin, and Dart, without those languages bundling their own collector.
2023 Nov
C# 12 added primary constructors
C# 12 added primary constructors for classes and structs, along with collection expressions and other features. Constructor parameters could be placed in a type declaration when that form fits the type's contract.
2023 Nov
PHP 8.3 adds typed class constants
PHP 8.3 added typed class constants and the json_validate function. The release extended type declarations to another part of class design and added a dedicated JSON validation API.
2023 Dec 27
Julia 1.10 ships a new parser
Julia 1.10 replaces the C-based parser with JuliaSyntax.jl, a parser written in Julia itself, improving parse performance and giving more precise syntax-error locations.
2024
AI-augmented review enters the workflow
Tools like CodeRabbit and GitHub Copilot begin posting AI-generated PR summaries and inline suggestions, splitting the review budget between automated first-pass analysis and human design judgment.
2024
ISO/IEC publishes C23
ISO/IEC 9899:2024 published the C23 revision. It is the current published C standard identified by WG14.
2024 Jan
WASI 0.2 launches on the Component Model
WASI Preview 2 shipped built on the WebAssembly Component Model, giving standalone modules a stable, composable system interface and letting independently compiled components share high-level types across a defined boundary.
2024 Apr 20
Zig 0.12.0 removes async and await
The async and await keywords were withdrawn pending a redesign, and the build system was reworked. Concurrency in this period relies on std.Thread.
2024 May
RFC 9557 adds named time zones to Internet timestamps
RFC 9557 extended RFC 3339 timestamps with additional information, including a bracketed IANA time-zone name. It lets a representation carry both an observed offset and the rules intended for local-time interpretation.
2024 May
Rocket Software closes the OpenText AMC acquisition
Rocket Software completed its acquisition of OpenText's Application Modernization and Connectivity business, consolidating mainframe modernization tooling.
2024 May 14
Dart 3.4 advances WebAssembly support
Dart 3.4 documented WebAssembly support for Flutter web and continued work on a Dart-to-Wasm compiler path. The release connected the language's web target to a newer compilation route.
2024 Jun 7
OpenTelemetry accepts a continuous profiling agent
OpenTelemetry accepts Elastic's donation of its eBPF-based continuous profiling agent, which observes code across programming languages and runtimes, third-party libraries, kernel operations and system resources without code instrumentation, recompilation or service restarts, at roughly 1% CPU. Profiling gains a vendor-neutral collection agent and a data model that carries the same attributes as traces and metrics.
2024 Jun 9
Perl 5.40 makes try/catch stable
The try/catch exception syntax and the multi-value for loop left experimental status, giving Perl structured error handling in the core language rather than through eval and $@.
2024 Sep 17
Swift 6 made data-race safety a language-mode contract
Swift 6 added a language mode with stronger concurrency checking and expanded cross-platform libraries and tooling.
2024 Nov
PHP 8.4 adds property hooks and asymmetric visibility
PHP 8.4 added property hooks and asymmetric visibility. These features let classes express behavior and read or write access rules directly around properties.
2025 Feb 20
Rust 2024 reaches stable
Rust 1.85 stabilized the 2024 edition with coordinated language, standard-library, Cargo, rustdoc, and rustfmt changes. Existing crates retained their selected editions until migration.
2025 Mar 5
Zig 0.14.0 released
The release advanced incremental compilation and Zig's own x86_64 backend, and continued large standard-library and build-system changes. The pattern of breaking changes each release continued.
2025 Aug 19
Zig 0.15.1 replaces the reader and writer interfaces
Known in the community as Writergate, the release deprecated the generic std.io readers and writers in favor of non-generic std.Io.Reader and std.Io.Writer types that hold their own buffer. Most I/O code needed rewriting.
2026
GitHub announces native Stacked PRs
GitHub ships stacked pull requests in private preview, acknowledging that the single-branch PR model does not fit how teams ship changes in pieces — a gap Gerrit addressed by design in 2008.