Software development
How the field of a Full-Stack Engineer got here: the sourced milestones from every published course of this career, on one axis.
1951 to 2025
259 milestones across 27 courses
The axis stretches toward recent years, where most milestones fall. Bars count milestones per year; dots are single milestones.
14 milestones
1951 Dec 15
The RAND memorandum "Representation of Events in Nerve Nets and Finite Automata" defined regular sets and regular expressions as a model for finite automata. Regular expressions began as mathematics, not a programming tool.
1968 Jun
"Programming Techniques: Regular expression search algorithm" in Communications of the ACM showed how to compile a regular expression into machine instructions and match in linear time. The algorithm is the ancestor of every modern automata engine.
1970
E. F. Codd described organizing data as relations and separating the logical model from storage details. The model became the foundation for table-based database design.
1973
Ken Thompson created grep by extracting the global-regular-expression-print command from the ed editor. Regex search entered everyday use as a command-line primitive.
1974
IBM documented System R as a relational approach to database management. Its work helped establish the practical path from relational theory to DBMS implementation and SQL.
1977
Alfred Aho, Peter Weinberger, and Brian Kernighan built awk, a pattern-scanning language that combined regex matching with fields and actions. The name comes from the three authors' initials.
1979
Relational Software, Inc. released Oracle V2 as a commercial SQL-based relational database. SQL moved from research systems into a product category that competing database vendors adopted.
1986
ANSI published the first SQL standard. A standard core gave database products a common reference point even as their dialects continued to differ.
1986
The Berkeley POSTGRES project began implementation. It became a long-running research and production lineage for object-relational database work.
1987
ISO adopted SQL as ISO/IEC 9075. The paired ANSI and ISO work made SQL an international database-language standard.
1987
POSTGRES demoware became operational in 1987 and was demonstrated at SIGMOD in 1988. The project moved from design papers into a working system.
1987 Dec 18
Perl 1.0 shipped, and the language soon became the main carrier of an extended pattern language whose features influenced every later engine. Perl and Perl-derived flavors popularized lazy quantifiers and lookarounds.
1989 Mar
Tim Berners-Lee wrote the first proposal for a linked hypertext system at CERN. It framed the Web as a way to share information across institutions.
1989 Jun
Version 1 was released to a small group of external users. The release marked an early step from academic prototype toward use outside its original project.
23 milestones
1990 Dec
The first Web server and the WorldWideWeb browser were running at CERN. Developers now had a working client, server, URL, HTTP, and HTML system.
1991
Version 3 added multiple storage managers, an improved query executor, and a rewritten rule system. Those changes emphasized DBMS behavior beyond the table abstraction.
1991 Aug
Berners-Lee announced the WWW software on internet newsgroups after releasing browser, server, and library code. Development spread beyond CERN.
1992
IEEE 1003.2 standardized two POSIX dialects, Basic and Extended Regular Expressions, fixing which characters are metacharacters in each. This remains the reference for grep and awk behavior.
1992
ANSI and ISO published the revision commonly called SQL-92. It became a long-lived baseline for the portable syntax developers still recognize.
1993
NCSA released Mosaic for graphical desktop environments. Its availability on common computers helped the Web spread beyond research systems.
1993 Apr 30
CERN made WorldWideWeb source code available on a royalty-free basis. Implementers could build on the system without a licensing fee.
1994
Postgres95 replaced PostQUEL with SQL and was released to the web as an open-source descendant of Berkeley POSTGRES. SQL became central to this branch of the system.
1994 Oct
Tim Berners-Lee founded W3C to coordinate interoperable Web standards. Standards work became an organized cross-industry activity.
1994 Oct 17
Perl 5.0 shipped with a substantially extended regex engine, cementing the Perl-compatible feature set that PCRE and later engines adopted.
1995 May
Brendan Eich creates the language for scripting in Netscape's browser. Its initial browser role establishes the lasting language-and-host split.
1995 May
Brendan Eich designed and implemented the browser language that became JavaScript. Web pages gained a widely deployed scripting layer.
1996
The project adopted the PostgreSQL name to mark its SQL capability and began version numbering at 6.0. The rename connected the original POSTGRES work to a continuing database project.
1996 Nov
Ecma's TC39 begins work from Netscape's submitted language. Browser implementations gain a shared specification target.
1996 Dec
W3C published CSS1 as a common style-sheet standard. Authors could separate more presentation rules from HTML structure.
1997
Philip Hazel wrote PCRE, the Perl Compatible Regular Expressions library, which became the basis for the regex engines in PHP and R and is bundled in products from Excel to Git.
1997 Jun
The first ECMAScript standard defines a vendor-neutral language core. JavaScript practice can now distinguish standardized semantics from browser APIs.
1997 Dec
W3C published the HTML 4 Recommendation. The specification consolidated document structure, scripting, style-sheet, and accessibility-related work for authors and browsers.
1998 Feb 10
XML 1.0 standardized an extensible text syntax for structured documents and data interchange on the Web. Implementations gained shared rules for well-formed documents and character encoding.
1999
SQL:1999 added features including recursive queries and standardized procedural extensions. It widened SQL beyond basic table queries while retaining the relational core.
1999 Jan
RFC 2246 defined TLS 1.0 as a protocol for protecting client-server communications. HTTPS could then rely on an IETF protocol rather than SSL alone.
1999 Dec
The third edition consolidates the language used through the next decade and becomes the baseline for broad browser implementation work.
1999 Dec
ECMAScript 3 specified a regular expression grammar in the language standard, giving JavaScript a regex engine whose syntax follows the Perl tradition.
28 milestones
2000
Neo4j records the invention of its property-graph model in 2000. This represented a data model in which nodes and relationships are central rather than only tabular joins.
2000
Roy Fielding’s dissertation documented REST as an architectural style, including the uniform interface, resources, representations, and stateless interaction. It gave HTTP API designers a vocabulary for resource-oriented contracts.
2000 May
W3C published SOAP 1.1 as a Note for XML-based message exchange. Contract-first web services commonly paired these messages with explicit service descriptions.
2001 Dec
The OWASP Foundation launched in 2001 to improve software security through community projects and guidance. It became a durable public home for application-security practice.
2003
OWASP published the original Top Ten in 2003. The list made recurring web application risks easier to discuss and prioritize.
2003
OWASP published the first Top 10 list, establishing a shared awareness document for web application security risks.
2003
SQL:2003 added window functions and SQL/XML work. Window functions made ranking and calculations across related result rows part of standard SQL practice.
2004
OWASP updated the original list, beginning a recurring cycle of revisiting the web application risks practitioners use for awareness.
2004
Jason Huggins created JavaScriptTestRunner for an internal application, and the work became the open-source Selenium project. Browser-driven checks gained a reusable project and community.
2004
Browser vendors formed WHATWG to continue evolving interoperable Web application technologies. HTML development shifted toward a continuously maintained standard.
2004 Jan 29
The YAML 1.0 final draft described a human-oriented, cross-language Unicode serialization language. It separated representation, serialization, presentation, parsing, composition, and construction stages.
2005 Nov 16
Django 0.90 became the first packaged public release. It moved the framework from revision-control-only development to an installable distribution.
2005 Dec 13
Rails 1.0 marked the first stable major release of the integrated Ruby web framework. Its conventions made MVC, database persistence, routing, and rendering part of one application structure.
2006
Simon Stewart began a browser-control approach that used native browser capabilities instead of injecting all control through page JavaScript. This created a second automation architecture alongside Selenium Remote Control.
2006 Jul
RFC 4627 documented JSON as a text format for serializing structured data and registered its media type. It gave Internet applications a compact common object and array syntax.
2007
The 2007 update continued the list as a maintained reference rather than a one-time catalog of vulnerabilities.
2007 Jan
Russ Cox's article demonstrated Thompson's NFA simulation in practice and showed how backtracking engines can take exponential time. It became the standard reference for why linear-time engines matter.
2007 Jun
WSDL 2.0 standardized service descriptions with HTTP and SOAP support. It kept operations, messages, and bindings explicit and separate from service implementation.
2007 Dec 7
Rails 2.0 strengthened resource routing, added route inspection, and enabled request-forgery protection in new applications. Resource controllers made HTTP method and path conventions more central to everyday Rails design.
2008
OWASP's project history records the start of ASVS work in 2008. Verification requirements began to complement awareness lists with testable controls.
2008
Google released Protocol Buffers for external use. Developers outside Google could use its schema language, generated bindings, and numbered-field wire format.
2008
The two projects combined their communities and roadmaps. The merger set the direction for WebDriver APIs to replace the original Selenium Remote Control approach.
2008 Sep 2
V8 launches as an open-source JavaScript engine with Chrome. The engine later becomes embeddable in hosts beyond the browser.
2008 Sep 3
Django 1.0 established a compatibility milestone after more than three years of open-source development. Stable upgrade expectations became part of operating Django applications.
2009
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 project began in 2009 with release assets stored in a public object-storage bucket. It established server-side JavaScript around V8 and asynchronous I/O.
2009 Oct
YAML 1.2 made JSON an official subset and revised the recommended schemas. Parser schema selection became a central interoperability decision for human-authored YAML.
2009 Dec
The fifth edition completes the post-ES3 standardization reset. Its strict mode and object facilities provide a firmer base for larger programs.
100 milestones
2010
The 2010 edition refreshed the risk categories for the changing web application landscape.
2010 Mar
Google released RE2, a linear-time engine that deliberately omits backreferences and lookarounds to keep matching time proportional to input length. Safe handling of untrusted patterns became a design goal.
2010 Apr 16
Flask 0.1 was released as the first public preview. It established the project that later grew the WSGI application, routing, context, and extension model covered in this course.
2010 May 12
Flask 0.2 integrated JSON support and allowed add_url_rule to register a view function. Those changes strengthened the route-to-view and JSON-response boundaries.
2010 Jul 6
Flask 0.5 limited automatic template escaping to selected markup extensions and added per-package template and static directories. The release made template and package layout choices more explicit.
2010 Aug 29
Rails 3 introduced a new router, Bundler dependency management, and a composable Active Record query engine based on Arel. These changes shaped the modern route and relation interfaces used in Rails applications.
2010 Oct
AngularJS introduced its client-side templating and data-binding approach. It established the v1.x line later distinguished from modern Angular.
2011
Neo4j launched Cypher as a declarative language for property graphs. The milestone illustrates the growth of specialized query languages alongside SQL.
2011
SQL:2011 added temporal database features. The standard gained a common way to express time-aware data and queries.
2011 Jun
Taylor Otwell released Laravel as a more complete alternative to CodeIgniter, which did not provide built-in user authentication and authorization. It established the framework's focus on developer ergonomics.
2011 Jul 8
Selenium 2.0 delivered stable WebDriver APIs for several languages while retaining compatibility with Selenium 1. The merged architecture became available as a mainstream release.
2011 Aug
The first Swagger Specification formalized a machine-readable description for HTTP APIs. That description could drive documentation and tooling from a contract rather than prose alone.
2012
GraphQL originated in 2012. Its initial use established the client-selected API model before the specification became an open standard.
2012 Feb 22
Laravel 3 introduced the Artisan command-line tool, database migrations, and the Bundles packaging system. Scaffolding and schema management became part of the framework rather than manual work.
2012 Jun
The first stable AngularJS release made the v1.x framework available for production use. Its API generation remains a separate migration concern from modern Angular.
2012 Jul
The CSP 1.0 draft described a policy language that lets a web resource restrict the sources from which a browser loads content. It established a browser-enforced defense-in-depth control for content injection risk.
2013
The 2013 edition revised the list and broadened some category scopes, affecting how teams mapped findings to risk categories.
2013 May
Meta introduced React publicly at JSConf and described composable components, JavaScript-based views, and reconciliation as its core approach.
2013 May 28
Laravel 4, codenamed Illuminate, was rewritten as a set of Composer packages. Eloquent, the query builder, queues, and migrations became a modular core distributed through PHP's standard package manager.
2013 Jun 13
Flask 0.10 changed the default session cookie serialization from pickle to JSON to limit impact if the secret key leaks. This anchors the session-integrity and secret-key guidance used in this course.
2013 Jun 25
Rails 4 made Strong Parameters a headline feature and added Turbolinks and Russian doll caching. Permitted mass-assignment fields became an explicit controller boundary.
2013 Aug 6
Spring introduced Spring Boot as an opinionated path for stand-alone Spring applications. The initial direction centered on reducing setup work while retaining Spring's programming model.
2013 Oct
Ecma published a concise definition of valid JSON text syntax. The standard deliberately left data interpretation and language mappings to other specifications.
2013 Oct
RFC 7049 specified a compact binary representation based on an extended JSON data model. It added binary strings, tags, and streaming-friendly encodings for constrained environments.
2014 Feb 25
The early public release established Vue's declarative view layer and reactive data binding as a standalone project.
2014 Apr 1
The first general-availability release established Spring Boot as a supported project. Teams could adopt its executable-application and starter conventions as a stable baseline.
2014 Jun 5
Development of Cypress began with a first commit. The project pursued an in-browser runner aimed at modern web application testing.
2014 Sep
Swagger 2.0 expanded the formal API description. It made a portable contract a more practical input to code generation, validation, and reference documentation.
2014 Sep 2
Django 1.7 added built-in schema migrations and the migrate command. Database schema history became a first-class deployment artifact.
2014 Dec
The io.js fork created a separate release line and project infrastructure. Its later reconciliation changed project governance and release practice.
2015 Feb
The foundation created a neutral governance home while the Node.js and io.js communities worked toward convergence.
2015 Feb 4
Laravel 5.0 changed the application directory structure and added form requests and a service-provider-based bootstrap. The layout that later versions refined was set here.
2015 Jun
The sixth edition adds major language structures including block-scoped declarations, classes, modules, arrow functions, promises, maps, and sets.
2015 Jun
Ecma published the sixth ECMAScript edition and TC39 adopted yearly specification editions. JavaScript language evolution gained a regular cadence.
2015 Jun 9
Laravel 5.1 was the first release with long-term support, giving teams a version with an extended window of bug fixes to standardize on.
2015 Jun 17
DevTools added automatic restart, development property defaults, and LiveReload support. The release made local feedback during application changes a first-class concern.
2015 Jul
The July 2015 edition made the language and type-system contract available as a public specification.
2015 Sep
Lumen, a stripped-down derivative of Laravel aimed at microservices and APIs, was released. It shared Laravel's components with a lighter bootstrap for latency-sensitive services.
2015 Sep 8
Version 4 reunited the Node.js and io.js code lines and began the release era associated with a regular LTS cadence.
2015 Oct
A second 2015 edition continued the public specification series that implementers could use as a common reference.
2015 Oct 7
The release split host-independent component APIs from the DOM renderer and introduced stateless function components.
2015 Oct 26
Vue reached its first stable major release and formalized the component and directive model used by early production applications.
2015 Dec
Let's Encrypt opened its public beta in December 2015 and made certificate requests available without an invitation. Automated certificate management helped make HTTPS deployment more practical.
2015 Dec
The Swagger 2.0 specification was donated to the OpenAPI Initiative. The description format then moved under vendor-neutral governance as OpenAPI.
2016
SQL:2016 incorporated JSON-related features. Relational databases could standardize some work with semi-structured values without abandoning tables, constraints, and joins.
2016 Apr
The April 2016 edition extended the stable public reference sequence for language and execution behavior.
2016 Apr 7
React 15 moved directly from 0.14 to a stable major version and changed DOM mounting to create elements instead of relying on inner HTML.
2016 Apr 26
Version 6 advanced the regular major-release cadence and brought a newer V8 generation into the production path.
2016 Jun
The seventh edition follows the year-based naming used after ECMAScript 2015. Smaller annual editions replace long gaps between major standards.
2016 Jun 27
ASP.NET Core 1.0 introduced the modular, cross-platform web framework with a unified MVC and Web API stack. It established the host and middleware approach that later releases extended.
2016 Jun 30
Rails 5 integrated WebSocket connections through Action Cable and added a focused API application mode. The framework could support real-time features and JSON services without abandoning its common conventions.
2016 Aug
gRPC 1.0 established a stable protocol and API surface for service contracts, including streaming call forms. API design work could therefore apply contract thinking beyond HTTP resource APIs.
2016 Sep
Angular 2 established the modern framework line with a new component and TypeScript-oriented platform. Documentation and release policy treat AngularJS v1.x separately.
2016 Sep 30
Vue 2 adopted a virtual DOM renderer and server-side rendering support, changing how larger Vue applications were built and delivered.
2016 Oct
The October 2016 edition consolidated the early open-standard work into a later reference point for implementers.
2016 Oct 25
The project begins as a zero-configuration framework for server-rendered React applications.
2016 Nov 26
The first stable release presented components compiled into standalone JavaScript modules. This established compilation as Svelte's defining approach to interface updates.
2016 Dec 21
Flask 0.12 made the CLI command respond to the version option and expanded application operational tooling. The command line became a more visible application boundary.
2017
The 2017 edition documented categories including injection, broken authentication, and sensitive data exposure.
2017 Apr 5
The redesigned Gradle plugin introduced the bootJar and bootWar task model. Packaging became more explicitly connected to the build lifecycle.
2017 May 30
Version 8 introduced the async hooks API, giving diagnostics and instrumentation code a way to track asynchronous resources.
2017 Jul
OpenAPI 3.0 introduced a major revision of the HTTP API description format. Design reviews could use a standard artifact for paths, operations, schemas, responses, and security requirements.
2017 Aug
ASP.NET Core 2.0 added Razor Pages for page-focused server-rendered applications. This gave teams another endpoint model on the same hosting and dependency-injection foundation.
2017 Aug 30
Laravel 5.5, the next LTS release, added package auto-discovery. Installed packages registered their service providers and facades without manual edits to configuration files.
2017 Sep 26
React 16 introduced a rewritten core while preserving the component API, and added error boundaries, fragments, and additional render return types.
2017 Oct 10
Cypress opened its source and public beta after years of private development. Its runner, desktop application, reporter, and supporting adapters became available to the wider community.
2017 Dec
RFC 8259 resolved specification inconsistencies and added interoperability guidance for JSON. It requires UTF-8 for JSON exchanged between systems outside a closed ecosystem.
2017 Dec 2
Django 2.0 added the path function and route syntax with path converters. URL patterns became easier to express without regular expressions for common paths.
2018 Feb 5
Universal Webpack runs the build pipeline for server and client code and expands the plugin model.
2018 Mar 1
Spring Boot 2.0 established Spring Framework 5 as its baseline. The major release marked a new generation of the platform's application model.
2018 Apr 9
Rails 5.2 integrated file attachments through Active Storage and introduced encrypted credentials. File persistence and secret configuration gained standard framework paths.
2018 Apr 18
Version 2 adopted single-curly template expressions, changed lifecycle and component APIs, and emitted modern JavaScript. An upgrade tool supported the breaking transition.
2018 Apr 24
Version 10 introduced an experimental promises interface for file-system operations, extending promise-based application flow into core I/O.
2018 Apr 26
Flask 1.0 dropped Python 2.6 and Python 3.3 support and raised core dependency minimums. Application and extension maintainers had a documented major-version compatibility boundary.
2018 May
Angular 6 continued the modern major-release line. Regular major upgrades became part of the practical maintenance model for Angular applications.
2018 May
ASP.NET Core 2.1 documented integration-test support and expanded the framework's testing story around hosted application behavior. This reinforced testing routes, middleware, and services through the HTTP boundary.
2018 May 16
Static export gains automatic route mapping, while the application extension point and early TypeScript plugin support broaden project structure.
2018 Jun
ECMAScript 2018 shipped dotAll mode, named capture groups, lookbehind assertions, and Unicode property escapes, closing long-standing gaps with the Perl-compatible feature set.
2018 Jun
The June 2018 edition marked a later specification release used by the growing ecosystem of GraphQL tools and services.
2018 Jun 5
W3C standardized platform-neutral and language-neutral interfaces and a wire protocol for remote browser control. Tool and browser implementations gained a common standards target.
2018 Aug
RFC 8446 specified TLS 1.3 and obsoleted earlier TLS specifications. It updated the secure transport baseline used by web applications.
2018 Aug 10
The CLI introduced a plugin-based project system and a graphical management interface for standardized Vue build configuration.
2018 Sep 19
Webpack 4, Babel 7, incremental compilation, and standardized dynamic imports improve build behavior and code splitting.
2018 Sep 20
Cypress declared its test runner generally available and retained the runner as free, open-source software. The accompanying service added hosted recording and parallel execution features.
2018 Oct
GitHub introduced GitHub Actions as a limited public beta. Repository automation became a first-class GitHub capability.
2019
The GraphQL Foundation became a neutral focal point for ecosystem support, and the GraphQL Specification Project was established with the Joint Development Foundation.
2019 Feb 4
The release introduced a unified slot syntax and prepared application code for component patterns that continued into Vue 3.
2019 Feb 6
Hooks made state and other React features available to function components and enabled stateful logic to be reused without changing the component hierarchy.
2019 Apr 1
Django 2.2 added database constraints and began an LTS line. Teams could select a supported baseline while using stronger model-level database constraints.
2019 Apr 22
Version 3 replaced the earlier object-style component API with assignment-based reactivity and a lower-boilerplate component model. The project also moved its main site to svelte.dev.
2019 May 13
The v1 release establishes a stable major-version foundation for utility-based styling. Its release notes document the initial compatibility boundary.
2019 Jul 8
File-based dynamic segments, built-in TypeScript, automatic static optimization, and API Routes reduce the need for a custom server.
2019 Aug
The beta added built-in CI/CD with hosted Linux, macOS, and Windows runners. This established the runner model for build and test jobs.
2019 Aug 15
Rails 6 added Action Mailbox, Action Text, multiple-database support, parallel testing, and the Zeitwerk code loader. Incoming email, rich text, database topology, and constant loading moved further into documented framework conventions.
2019 Sep
Endpoint Routing made endpoint selection and middleware composition explicit in the request pipeline. Authorization, CORS, and Health Checks could use endpoint metadata through this shared mechanism.
2019 Sep
AsyncAPI 2.0 provided a specification for asynchronous APIs. Message channels, publishers, subscribers, and message schemas became first-class contract elements.
2019 Sep 3
Laravel 6 moved to semantic versioning, so a major version number became a reliable signal that an upgrade could contain breaking changes. Upgrade planning became more predictable.
2019 Sep 25
Node.js 12.11 marked worker threads stable, establishing an in-process mechanism for parallel JavaScript computation.
2019 Nov
GitHub Actions became generally available. The platform became available for production repository automation.
2019 Dec 2
Django 3.0 could run as an ASGI application alongside its existing WSGI support. Internal request handling remained synchronous at that point.
94 milestones
2020 Feb
Angular 9 made the Ivy compiler and runtime the default. Application builds and library compatibility thereafter centered on the Ivy-based platform.
2020 Mar 9
getStaticProps and getStaticPaths give Pages Router applications explicit build-time data and route generation APIs.
2020 Apr 21
Node.js 14 stopped emitting the experimental warning for ECMAScript modules, moving standard module use closer to the normal runtime path.
2020 May 6
Playwright reached its first stable major release with bundled Chromium, Firefox, and WebKit builds. One automation API could target the three browser engines.
2020 May 11
Static output can be regenerated after deployment instead of requiring a complete rebuild for every content change.
2020 May 13
Deno 1.0 established the first stable major release. It made the runtime's integrated TypeScript support and opt-in permissions a supported foundation for application work.
2020 May 15
Buildpack image tasks, layered JARs, graceful shutdown, and availability probes arrived together. Container delivery and orchestrator-facing health behavior moved closer to the standard toolchain.
2020 Jul 2
The first Nuxt 3 commit starts a full TypeScript rewrite that becomes the basis of the current framework architecture.
2020 Jul 17
The Svelte organization consolidated compiler, language-server, editor, and checking support for TypeScript in components. The `svelte-check` command provided project diagnostics.
2020 Aug 14
Config data gained ordered documents, imports, changed profile handling, and configuration trees. Configuration precedence became a more explicit deployment concern.
2020 Sep 8
Laravel 8 was the second major release of 2020 and the last before the project moved to a single release per year.
2020 Sep 13
Deno 1.4 added a web-standard WebSocket API, `deno run --watch`, and integrated test coverage. These additions expanded the built-in development loop around the runtime.
2020 Sep 18
Vue 3 introduced Composition API, a rewritten renderer and reactivity system, fragments, Teleport, and stronger TypeScript support.
2020 Oct 7
The official playground brings utility and configuration experiments into a browser-based editing environment.
2020 Oct 20
React 17 focused on making it safer to run multiple React versions on one page so applications could upgrade in stages.
2020 Oct 27
Framework-managed images and locale routing extend the set of production concerns handled through Next.js conventions.
2020 Nov
ASP.NET Core 5.0 Web API templates enabled OpenAPI support by default. The template made an API description and development-time UI part of the starting HTTP API workflow.
2020 Nov 2
Initial work starts on the portable server engine that later owns Nuxt server routes and production output.
2020 Nov 5
The project announced a new application framework with one recommended project path, server rendering, routing, and deployment adapters. Sapper would not proceed to a 1.0 release.
2020 Nov 18
Version 2 adds dark-mode support and ring utilities, expanding the conditional styling vocabulary for application interfaces.
2020 Dec
Environments added protection rules and scoped secrets to deployment targets. Deployment approval became workflow configuration.
2020 Dec
RFC 8949 replaced RFC 7049 with revised encoding rules, deterministic encoding guidance, and operational considerations. It preserved the compact major-type and tag model.
2020 Dec 8
Deno 1.6 introduced `deno compile` for standalone executables and a built-in language server. The release extended Deno from direct script execution into editor and distribution workflows.
2021
OWASP introduced new categories and naming changes that emphasized root causes over symptoms, using a formalized data-collection process.
2021
OWASP released the 2021 Top Ten to mark its twentieth year. The project continued its periodic revision of the web application risk categories.
2021 Jan 22
Initial Vite support establishes the faster development and build path that ships with the Nuxt 3 rewrite.
2021 Feb
OpenAPI 3.1 aligned its Schema Object with JSON Schema draft 2020-12 and added webhooks. HTTP API contracts could express schema constraints with closer alignment to the wider JSON Schema ecosystem.
2021 Mar 15
An experimental compiler generates styles on demand from source usage, including arbitrary values. This changes how developers manage the available utility surface.
2021 Mar 23
The public beta opened the SvelteKit repository and documentation for broader use. It adopted Vite and made adapters the boundary between application builds and deployment platforms.
2021 Apr
GitHub added concurrency controls for workflow runs and jobs. Teams could cancel or queue overlapping work through YAML.
2021 May 11
Flask 2.0 ended support for Python 2 and Python 3.5 and updated Pallets dependency requirements. Deployments and extension stacks needed to align their Python and dependency baselines.
2021 Jun 23
Deno announced the first beta of Deno Deploy, a hosted JavaScript execution service. It connected the runtime's JavaScript and TypeScript workflow to a managed deployment option.
2021 Aug 5
Script setup and style state bindings became stable, making Composition API Single-File Components more concise in production projects.
2021 Sep
Ephemeral runners and workflow_job webhooks enabled single-job self-hosted runners that autoscalers can manage.
2021 Sep 5
Nuxt Bridge brings parts of the new Nuxt 3 architecture to Nuxt 2 projects and creates an incremental migration path.
2021 Oct
Deno 1.15 introduced an early compatibility mode for Node.js applications and libraries. Compatibility became a practical migration concern rather than only a runtime-design distinction.
2021 Oct
The October 2021 edition provided an updated normative reference for the language, type system, validation, and execution rules.
2021 Oct 1
YAML 1.2.2 corrected errors and clarified the YAML 1.2 language without normative changes. The revision also moved the specification source to an open Markdown-based process.
2021 Oct 11
The open beta exposes the Vue 3, Vite, Nitro, native ESM, auto-import, and composable foundation for community testing.
2021 Oct 13
Selenium 4 rebuilt Grid for standalone and distributed operation and added browser-facing capabilities while preserving stable public APIs. End-to-end suites gained a modernized remote execution layer.
2021 Oct 26
The SWC-based compiler becomes the default, while Middleware and early React Server Component support preview new request and rendering boundaries.
2021 Nov
ASP.NET Core 6 added Minimal APIs and the minimal hosting model. Small HTTP services could map handlers directly while retaining the same host, routing, middleware, and dependency-injection services.
2021 Nov
Reusable workflows gained outputs, environment-secret support, and audit-log visibility. Organizations could centralize workflow logic.
2021 Dec 9
Version 3 adopts the just-in-time engine as the normal build path. Developers use arbitrary values without configuring a separate experimental mode.
2021 Dec 15
Rails 7 paired Turbo and Stimulus with an import-map-based JavaScript default. Server-rendered HTML regained a first-party path to interactive interfaces without requiring a Node-based build step by default.
2022 Feb 7
Package tags, documentation, and official ecosystem guidance moved to Vue 3 as the standard starting point for new work.
2022 Feb 8
Laravel 9 started the yearly, first-quarter release schedule that the framework still follows, replacing the earlier six-month cycle.
2022 Mar 29
React 18 added automatic batching, transitions, new client root APIs, and streaming server rendering improvements built on the concurrent renderer.
2022 Jun 7
Version 3.1 introduces arbitrary variants, allowing one-off selector conditions alongside built-in variants.
2022 Jul 1
The final Vue 2 minor line backported Composition API and script setup features to support staged migration toward Vue 3.
2022 Aug 1
Flask 2.2 managed application and request contexts with Python context variables rather than Werkzeug LocalStack. It also introduced the JSON provider customization point used by JSON response behavior.
2022 Aug 3
Django 4.1 added async class-based view handlers and an asynchronous interface for QuerySet data-access operations. The underlying database work remained synchronous.
2022 Oct 19
Version 3.2 introduces an official container-query plugin, enabling component styling based on available container width.
2022 Oct 25
The app directory brings nested layouts, React Server Components, streaming, and component-level data fetching into a new router.
2022 Nov
Angular 15 made standalone APIs stable, allowing applications to compose template dependencies directly without requiring NgModules for new code.
2022 Nov 8
The .NET 7 release added built-in rate limiting policies for handled requests. Rate limits could be attached to endpoints as part of the request-pipeline protection boundary.
2022 Nov 14
Deno 1.28 stabilized npm compatibility and added `npm:` imports. The release made existing package selection part of routine Deno project evaluation.
2022 Nov 16
Nuxt 3.0 establishes a production-ready API around Vue 3, Vite, Nitro, TypeScript, filesystem conventions, and Nuxt Kit modules.
2022 Nov 24
Spring Boot 3.0 raised the Java baseline to 17, moved to Jakarta EE 10, added GraalVM support, and updated observability capabilities. Upgrades now required coordinated review of language, dependency, and API changes.
2022 Dec 14
SvelteKit became the recommended application framework for Svelte projects. Its stable contract covered routing, server and client rendering, data operations, and adapter-based deployment.
2023
ISO/IEC 9075-1:2023 published the sixth framework edition and references SQL property graph queries as part of the standard family. SQL continues to grow through coordinated parts rather than one vendor's dialect alone.
2023 Feb 14
Laravel 10 continued the annual cadence and raised the minimum supported PHP version, keeping the framework aligned with current language releases.
2023 Mar 16
The new documentation began teaching function components and Hooks from the start, while the previous documentation moved to the legacy site.
2023 Mar 28
Version 3.3 adds logical property utilities that support left-to-right and right-to-left layouts with a shared vocabulary.
2023 Apr 25
Flask 2.3 removed the FLASK_ENV environment variable and app.env property, making debug mode a direct setting. It also made setup methods on blueprints after registration an error.
2023 May
Angular 16 introduced signals as a new reactive primitive. The model gave applications a current-value form of reactivity alongside observable streams.
2023 May 2
Deno added support for `package.json` workflows while retaining URL-based imports. Projects could combine Deno-specific configuration with existing Node dependency and script conventions.
2023 May 4
The App Router becomes stable, establishing it as the supported path for layouts, Server Components, and streaming applications.
2023 Jun 22
Version 4 raised dependency and browser baselines, reduced package size, and improved authoring and migration behavior. It prepared the ecosystem for the next reactivity design.
2023 Sep 20
The project introduced runes as explicit compiler syntax for reactive state, derived values, effects, and props. The design extended reactivity beyond component files and reduced differences between component and module logic.
2023 Sep 30
Flask 3.0 restructured the Flask application and Blueprint classes around Sans-IO bases and removed previously deprecated code. The release marked a new major compatibility boundary for applications and extensions.
2023 Oct 26
Server Actions become stable and integrate mutations with forms, caching, revalidation, and redirects.
2023 Nov
Angular 17 introduced modern template control flow and deferrable views. These features changed how templates express conditional, repeated, and deferred content.
2023 Nov 13
The development inspector becomes generally available for examining pages, components, imports, modules, assets, and application behavior.
2023 Nov 14
.NET 8 added Native AOT support for supported ASP.NET Core application types, including Minimal APIs. The deployment choice made trimming, generated JSON metadata, and incompatible dynamic features explicit design constraints.
2023 Nov 23
Spring Boot 3.2 added virtual-thread support, initial CRaC support, RestClient, and observability improvements. Runtime-concurrency and deployment options continued to expand without changing the core application-context model.
2023 Dec
Artifact v4 made uploaded artifacts job-scoped and immutable. Artifact transfer needed to account for its compatibility boundary with earlier versions.
2023 Dec 4
Django 5.0 added database-computed default values and database-side defaults. Model declarations could represent more database-managed behavior.
2023 Dec 19
Version 3.4 adds dynamic viewport units, has variants, and subgrid utilities to the layout vocabulary.
2023 Dec 31
Official Vue 2 feature, fix, and security maintenance ended, making Vue 3 the maintained foundation for new and migrated applications.
2024 Mar 12
Laravel 11 consolidated middleware and application configuration into bootstrap/app.php, reducing the number of default files, and bundled the first-party Reverb WebSocket server.
2024 May
Angular 18 continued the transition by stabilizing built-in control flow and deferrable views, while Angular documented migrations for existing applications.
2024 Jun 30
Official Nuxt 2 maintenance ends, making migration to the Nuxt 3 architecture the supported path for security and browser compatibility updates.
2024 Sep 1
Vue 3.5 revised the reactivity internals and added reactive prop destructuring, watcher cleanup, and hydration improvements without a breaking major release.
2024 Oct 9
Deno 2.0 made Node and npm backward compatibility a central release goal while retaining the integrated toolchain, web APIs, and secure-by-default model. Runtime selection increasingly required testing real packages instead of comparing slogans.
2024 Oct 21
The release changes request and router caching behavior, adds React 19 support, and stabilizes Turbopack for development.
2024 Oct 22
Svelte 5 made runes, snippets, event properties, and the function-based component API stable. Legacy syntax remained supported to permit gradual migration.
2024 Nov 7
Rails 8 arrived with Kamal 2, Thruster, Solid Queue, Solid Cache, Solid Cable, Propshaft, and an authentication generator. A new application could use its relational database for more operational roles and follow a built-in container deployment path.
2024 Nov 13
Flask 3.1 added per-request maximum content length customization, form limits, and trusted-host configuration. These changes made resource and host controls more explicit at the application boundary.
2024 Dec 5
React 19 added Actions for asynchronous transitions, new form integration, the use API, and stable support for React Server Components in compatible frameworks.
2025
The 2025 edition updated the ten-category map, including software supply chain failures and mishandling of exceptional conditions.
2025 Jan 21
Version 4 introduces CSS-first configuration, automatic source detection, and dedicated build integrations. Shared tokens become CSS theme variables.
2025 Feb 24
Laravel 12 continued the annual cadence with a deliberate focus on minimal breaking changes, so most applications could upgrade with little code modification.
2025 Jul 15
Nuxt 4 formalizes the app directory structure, improves data-fetching behavior and type safety, and carries tested compatibility changes into a new major version.