GRAPH NAME SOFTWARE COMPONENTS AND PROGRAM STRUCTURE *** ## NODE 1 NAME EDSAC SUBROUTINE LIBRARY DATE 1949-05-06 PLACE United Kingdom - England - Cambridge WHO Maurice Wilkes, David Wheeler and University of Cambridge BRIEF DESCRIPTION EDSAC begins practical operation and develops one of the earliest organized libraries of reusable subroutines. Programmers no longer need to recreate every low-level operation for every program. Reusable routines establish the library as a fundamental software component and demonstrate that programs can be assembled from previously implemented computational units. LINK *** ## NODE 2 NAME WHEELER JUMP DATE 1951 PLACE United Kingdom - England - Cambridge WHO David Wheeler BRIEF DESCRIPTION David Wheeler develops an early technique for calling reusable subroutines while automatically preserving a return path to the calling code. The method, later known as the Wheeler jump, helps establish the call-and-return mechanism that becomes fundamental to functions, procedures, libraries, stacks, APIs and structured program decomposition. LINK *** ## NODE 3 NAME FORTRAN SOURCE PROGRAM DATE 1957 PLACE USA - New York WHO John Backus and IBM BRIEF DESCRIPTION FORTRAN establishes the high-level source program as a distinct software artifact that can be translated by a compiler into machine instructions. Programmers increasingly work with named variables, expressions, functions and subroutines rather than manually constructing machine code. The source file becomes the primary human-maintained representation of program logic. LINK *** ## NODE 4 NAME FORTRAN SUBROUTINES AND FUNCTIONS DATE 1957 PLACE USA - New York WHO John Backus and IBM BRIEF DESCRIPTION FORTRAN provides structured mechanisms for defining reusable functions and subroutines. Large computations can be decomposed into smaller named units with parameters and return behavior. The function and procedure become fundamental units of program organization and later form the lowest architectural level of most software systems. LINK *** ## NODE 5 NAME ALGOL 60 BLOCK STRUCTURE DATE 1960 PLACE Europe and USA WHO ALGOL COMMITTEE BRIEF DESCRIPTION ALGOL 60 formalizes block structure, lexical scope, nested procedures and local variables. Programs can be organized into nested regions whose internal names and implementation details are hidden from unrelated code. The language strongly influences later concepts of scope, procedure boundaries, modules and structured programming. LINK *** ## NODE 6 NAME LEXICAL SCOPE DATE 1960 PLACE GLOBAL WHO ALGOL 60 COMMUNITY BRIEF DESCRIPTION ALGOL 60 makes lexical scope a central programming-language mechanism. The visibility of names depends on the textual structure of the program rather than only on runtime execution. Lexical scope provides an essential foundation for encapsulation, local state, nested functions, modules and modern programming-language namespace systems. LINK *** ## NODE 7 NAME MULTICS DYNAMIC LINKING DATE 1965 PLACE USA - Massachusetts - Cambridge WHO MIT, BELL LABORATORIES AND GENERAL ELECTRIC BRIEF DESCRIPTION Multics develops a dynamic linking architecture in which procedures can be resolved and connected at runtime rather than being permanently combined into one executable image before execution. Shared procedures can be independently maintained and reused by many programs, anticipating shared libraries, dynamic modules and plugin systems. LINK *** ## NODE 8 NAME SIMULA CLASSES AND OBJECTS DATE 1967 PLACE Norway - Oslo WHO Ole-Johan Dahl and Kristen Nygaard BRIEF DESCRIPTION Simula 67 introduces classes, objects, inheritance and virtual procedures as explicit programming-language mechanisms. Data and the procedures operating on that data can be organized together as reusable abstractions. The class becomes one of the most influential software component types in the history of programming. LINK *** ## NODE 9 NAME UNIX DATE 1969 PLACE USA - New Jersey - Bell Laboratories WHO Ken Thompson, Dennis Ritchie and collaborators BRIEF DESCRIPTION Unix develops around a philosophy of relatively small programs, files and reusable utilities. Instead of placing every capability inside one monolithic application, specialized programs can perform individual tasks and interact through standardized operating-system mechanisms. This philosophy strongly influences later modular software design. LINK *** ## NODE 10 NAME C SOURCE AND HEADER STRUCTURE DATE 1972 PLACE USA - New Jersey - Bell Laboratories WHO Dennis Ritchie BRIEF DESCRIPTION The C programming language develops a compilation model in which program implementations can be divided across multiple source files and connected through declarations and externally visible symbols. Header files provide reusable declarations and contracts shared among compilation units. This source-header organization becomes foundational to systems programming. LINK *** ## NODE 11 NAME INFORMATION HIDING DATE 1972 PLACE USA WHO David Parnas BRIEF DESCRIPTION David Parnas publishes a foundational approach to decomposing software into modules according to design decisions that should be hidden from other parts of the system. A module should expose a stable interface while concealing implementation details likely to change. Information hiding becomes one of the central principles of software architecture and component design. LINK *** ## NODE 12 NAME MODULAR DECOMPOSITION DATE 1972 PLACE USA WHO David Parnas BRIEF DESCRIPTION Software decomposition is reframed from simply grouping sequential processing steps toward organizing code around independent responsibilities and hidden design decisions. This creates a conceptual distinction between a module's public responsibilities and its private implementation and directly influences modern modules, libraries, services and interfaces. LINK *** ## NODE 13 NAME SMALLTALK-72 DATE 1972 PLACE USA - California - Palo Alto WHO Alan Kay, Dan Ingalls, Adele Goldberg and XEROX PARC BRIEF DESCRIPTION Smalltalk-72 develops an environment in which software is organized around communicating objects. Classes, methods and message passing become the dominant structural model rather than procedures operating separately on global data. Smalltalk strongly shapes modern object-oriented component design and interactive development environments. LINK *** ## NODE 14 NAME UNIX PIPES AND UTILITIES DATE 1973 PLACE USA - New Jersey - Bell Laboratories WHO Douglas McIlroy, Ken Thompson and UNIX team BRIEF DESCRIPTION Unix introduces pipelines that connect independent utilities through standard input and output streams. Programs such as filters, sorters and text processors can remain small and focused while being composed into larger workflows. The utility becomes a reusable architectural component defined as much by its interface as by its implementation. LINK *** ## NODE 15 NAME ABSTRACT DATA TYPE DATE 1974 PLACE USA - Massachusetts - Cambridge WHO Barbara Liskov, Stephen Zilles and MIT BRIEF DESCRIPTION Research on data abstraction formalizes the idea that a software type should be defined by the operations available to its users rather than by its internal representation. Clients operate through a specified interface while implementation details remain hidden. Abstract data types provide a theoretical foundation for encapsulated software components. LINK *** ## NODE 16 NAME CLU DATE 1975 PLACE USA - Massachusetts - Cambridge WHO Barbara Liskov and MIT BRIEF DESCRIPTION CLU becomes the first implemented programming language to provide direct linguistic support for data abstraction. Its clusters encapsulate representations behind explicitly exported operations. CLU also introduces influential mechanisms including iterators, exceptions and parameterized abstractions and strongly influences later interfaces, classes, generics and module systems. LINK *** ## NODE 17 NAME MAKE DATE 1976 PLACE USA - New Jersey - Bell Laboratories WHO Stuart Feldman BRIEF DESCRIPTION Make introduces an explicit dependency graph describing how source files and generated artifacts depend on one another. Rather than manually rebuilding an entire program, only components affected by changes need to be rebuilt. Dependencies between software artifacts become machine-readable project structure. LINK *** ## NODE 18 NAME MODULA-2 MODULE SYSTEM DATE 1978 PLACE Switzerland - Zurich WHO Niklaus Wirth BRIEF DESCRIPTION Modula-2 makes modular program organization a fundamental language feature. Definition modules specify what a component exposes while implementation modules contain its internal realization. The separation creates a precise language-level distinction between interface and implementation and strongly influences later module and package systems. LINK *** ## NODE 19 NAME ADA PACKAGES DATE 1983 PLACE USA AND GLOBAL WHO Jean Ichbiah, United States Department of Defense and Ada community BRIEF DESCRIPTION Ada 83 standardizes packages as explicit modular units. A package specification declares public types, constants and operations while a package body contains implementation details. Packages can also be generic, creating reusable parameterized software components. The model becomes especially influential in large and safety-critical systems. LINK *** ## NODE 20 NAME STANDARD ML MODULES DATE 1983 PLACE United Kingdom and USA WHO Robin Milner, David MacQueen and ML community BRIEF DESCRIPTION The emerging Standard ML design develops a sophisticated module system based on structures, signatures and later functors. Signatures describe interfaces, structures provide implementations and functors create modules parameterized by other modules. Modular programming becomes closely integrated with strong static type checking. LINK *** ## NODE 21 NAME C++ DATE 1985 PLACE USA - New Jersey - Bell Laboratories WHO Bjarne Stroustrup BRIEF DESCRIPTION C++ brings classes, inheritance, constructors, destructors, function overloading and other abstraction mechanisms into the C systems-programming ecosystem. Large systems can retain low-level control while organizing implementation around reusable classes and libraries. Object-oriented components spread into performance-critical software. LINK *** ## NODE 22 NAME PERL DATE 1987 PLACE USA WHO Larry Wall BRIEF DESCRIPTION Perl develops as a highly composable scripting language oriented toward text processing, system administration and reusable scripts. Its later module system and community package ecosystem demonstrate how lightweight reusable software components can spread rapidly through network-accessible repositories. LINK *** ## NODE 23 NAME ANSI C STANDARD LIBRARY DATE 1989 PLACE GLOBAL WHO ANSI X3J11 COMMITTEE BRIEF DESCRIPTION The ANSI C standard formalizes a portable standard library containing functions for input and output, strings, memory management, mathematics, conversion and other common operations. Programs can depend on standardized library contracts instead of vendor-specific implementations, strengthening portable component reuse. LINK *** ## NODE 24 NAME PYTHON MODULES DATE 1991 PLACE Netherlands WHO Guido van Rossum BRIEF DESCRIPTION Python is publicly released with a programming model based on modules that group related names, functions, classes and data. The import mechanism allows programs to reuse other modules through explicit dependencies. Modules become the central organizational unit of the Python software ecosystem. LINK *** ## NODE 25 NAME PYTHON PACKAGES DATE 1991 PLACE Netherlands WHO Guido van Rossum and Python community BRIEF DESCRIPTION Python develops hierarchical packaging mechanisms that organize multiple modules under common namespaces. Applications can grow from individual scripts into structured trees of reusable modules and packages while retaining a simple import model. LINK *** ## NODE 26 NAME COMPONENT OBJECT MODEL DATE 1993 PLACE USA - Washington WHO MICROSOFT BRIEF DESCRIPTION Microsoft develops the Component Object Model as a binary standard for independently implemented software components. Components expose interfaces through stable binary contracts rather than requiring consumers to know the source language or internal implementation. COM makes interface identity and binary compatibility central architectural concerns. LINK *** ## NODE 27 NAME DEBIAN PACKAGE SYSTEM DATE 1993 PLACE GLOBAL WHO Ian Murdock and Debian community BRIEF DESCRIPTION The Debian project develops a distribution organized around independently versioned software packages. Packages contain program files together with metadata describing identity, version, dependencies and installation behavior. Software deployment becomes increasingly based on machine-readable package components instead of manually copied files. LINK *** ## NODE 28 NAME STANDARD TEMPLATE LIBRARY DATE 1994 PLACE GLOBAL WHO Alexander Stepanov, Meng Lee and C++ community BRIEF DESCRIPTION The Standard Template Library demonstrates generic programming through reusable containers, algorithms and iterators whose interfaces allow independent components to work together. Reuse becomes based not only on inheritance but also on generic contracts between independently developed software abstractions. LINK *** ## NODE 29 NAME PERL 5 MODULE SYSTEM DATE 1994 PLACE GLOBAL WHO Larry Wall and Perl community BRIEF DESCRIPTION Perl 5 strengthens namespaces, packages, reusable modules and object-oriented capabilities. Libraries can be distributed as separately maintained modules and loaded by applications through standardized naming conventions, preparing the foundation for a global package repository. LINK *** ## NODE 30 NAME CPAN DATE 1995 PLACE GLOBAL WHO Perl community BRIEF DESCRIPTION The Comprehensive Perl Archive Network establishes a globally distributed repository for reusable Perl modules. Software components can be discovered, downloaded and installed from a shared ecosystem rather than exchanged manually. CPAN becomes an influential model for later language-specific package registries. LINK *** ## NODE 31 NAME JAVA PACKAGES DATE 1995 PLACE USA - California WHO SUN MICROSYSTEMS BRIEF DESCRIPTION Java introduces packages as namespaces for organizing related classes and interfaces. Packages reduce naming conflicts, provide access boundaries and make large class libraries manageable. The package becomes a first-class unit connecting source organization, namespaces, APIs and distribution. LINK *** ## NODE 32 NAME JAVA INTERFACES DATE 1995 PLACE USA - California WHO SUN MICROSYSTEMS BRIEF DESCRIPTION Java introduces interfaces as explicit contracts specifying behavior without requiring a particular implementation class. Components can depend on interfaces rather than concrete implementations, strengthening polymorphism, replaceability, testing and architectural decoupling. LINK *** ## NODE 33 NAME JAVA CLASS LIBRARY DATE 1995 PLACE USA - California WHO SUN MICROSYSTEMS BRIEF DESCRIPTION The Java platform ships with a large standardized class library organized into packages. Networking, files, collections, graphical interfaces and numerous other capabilities become reusable platform APIs. The runtime plus standard library model becomes a major software ecosystem architecture. LINK *** ## NODE 34 NAME JAVA ARCHIVE DATE 1997 PLACE USA - California WHO SUN MICROSYSTEMS BRIEF DESCRIPTION The JAR format packages multiple Java classes and resources into a single distributable artifact. Software organization gains a practical mapping between logical packages and physical deployment artifacts. JAR files later become foundational units of Java libraries, applications and dependency repositories. LINK *** ## NODE 35 NAME RPM PACKAGE FORMAT DATE 1997 PLACE USA WHO RED HAT BRIEF DESCRIPTION RPM develops into a widely adopted package format and management system for Linux software. Packages contain versioned files, metadata, dependencies and installation scripts. The model helps standardize the software artifact as an independently installable and manageable system component. LINK *** ## NODE 36 NAME APT DATE 1998-04-03 PLACE GLOBAL WHO DEBIAN PROJECT BRIEF DESCRIPTION APT enters general beta for Debian and adds automated dependency handling, package retrieval and installation ordering above the lower-level package database. Package relationships can be resolved across large repositories, transforming software installation into dependency-graph management. LINK *** ## NODE 37 NAME BOOST C++ LIBRARIES DATE 1998 PLACE GLOBAL WHO BOOST COMMUNITY BRIEF DESCRIPTION Boost develops as a collection of peer-reviewed reusable C++ libraries covering generic programming, smart pointers, containers, algorithms, concurrency, mathematics and numerous other domains. Several Boost designs later influence or enter the C++ standard library, illustrating community-driven library evolution. LINK *** ## NODE 38 NAME OSGI MODULE SYSTEM DATE 2000 PLACE GLOBAL WHO OSGI ALLIANCE BRIEF DESCRIPTION OSGi develops a dynamic component system for Java in which bundles can declare exported and imported packages and can be installed, started, stopped and updated independently. Modular structure extends from compile-time organization into runtime lifecycle and dynamic dependency management. LINK *** ## NODE 39 NAME PYTHON DISTUTILS DATE 2000 PLACE GLOBAL WHO Greg Ward and Python community BRIEF DESCRIPTION Distutils standardizes mechanisms for describing, building and installing Python distributions. Python modules and packages gain common metadata and installation conventions, an important step from source-code reuse toward a structured package ecosystem. LINK *** ## NODE 40 NAME MAVEN DATE 2001-08 PLACE GLOBAL WHO Jason van Zyl and Apache community BRIEF DESCRIPTION The first Maven prototype sources appear within the Apache Jakarta Alexandria project. Maven defines projects through a declarative model describing coordinates, dependencies, build lifecycle and plugins. The project component becomes associated with reproducible metadata rather than only with an ad hoc collection of source files. LINK *** ## NODE 41 NAME .NET ASSEMBLIES DATE 2002-02-13 PLACE USA - Washington WHO MICROSOFT BRIEF DESCRIPTION The .NET Framework introduces assemblies as versioned deployment and execution units containing compiled intermediate language, type metadata, resources and manifests. Namespaces organize source-level APIs while assemblies provide physical component boundaries for deployment and runtime loading. LINK *** ## NODE 42 NAME MAVEN TRANSITIVE DEPENDENCIES DATE 2002 PLACE GLOBAL WHO APACHE MAVEN COMMUNITY BRIEF DESCRIPTION Maven develops a repository-based dependency model in which project artifacts identify required external components through metadata. Dependency graphs can be resolved automatically, including dependencies required by other dependencies. This model becomes fundamental to modern application package ecosystems. LINK *** ## NODE 43 NAME PYTHON PACKAGE INDEX DATE 2003 PLACE GLOBAL WHO PYTHON SOFTWARE FOUNDATION AND PYTHON COMMUNITY BRIEF DESCRIPTION The Python Package Index develops into a centralized public index of Python software distributions. Developers can publish reusable packages under stable names and versions while users can discover and later automatically install them. Python evolves from a module system into a global package ecosystem. LINK *** ## NODE 44 NAME RUBYGEMS DATE 2004 PLACE GLOBAL WHO Chad Fowler, Jim Weirich, David Alan Black, Richard Kilmer and Ruby community BRIEF DESCRIPTION RubyGems establishes a standard package format, repository and installation mechanism for reusable Ruby software. Gems encapsulate libraries and metadata and can declare dependencies on other gems, helping establish dependency-aware language package management as a normal part of application development. LINK *** ## NODE 45 NAME PYTHON SETUPTOOLS ENTRY POINTS DATE 2004 PLACE GLOBAL WHO Phillip J. Eby and Python community BRIEF DESCRIPTION Setuptools extends Python packaging with improved dependency handling and entry-point metadata. Entry points allow installed packages to advertise callable components and plugin implementations through metadata rather than hard-coded registration, helping formalize extensible plugin architectures. LINK *** ## NODE 46 NAME MAVEN 2 DATE 2005-10-20 PLACE GLOBAL WHO APACHE SOFTWARE FOUNDATION BRIEF DESCRIPTION Maven 2 establishes the project object model and repository-based dependency conventions that become standard throughout much of the Java ecosystem. Artifact coordinates, transitive dependencies, dependency scopes, plugins and standardized build lifecycles make software composition increasingly declarative and reproducible. LINK *** ## NODE 47 NAME GO PACKAGES AND INTERFACES DATE 2009-11-10 PLACE USA - California WHO Robert Griesemer, Rob Pike, Ken Thompson and GOOGLE BRIEF DESCRIPTION Go is publicly announced with packages as the basic source organization and reuse mechanism and interfaces based on structural method compatibility rather than explicit declarations. Components can satisfy contracts implicitly, reducing coupling between interface definitions and implementations. LINK *** ## NODE 48 NAME COMMONJS MODULES DATE 2009 PLACE GLOBAL WHO COMMONJS COMMUNITY BRIEF DESCRIPTION CommonJS develops conventions for JavaScript modules outside the Web browser. Explicit module exports and require-based imports give server-side JavaScript a reusable component system and directly influence the module architecture adopted by Node.js. LINK *** ## NODE 49 NAME NPM DATE 2010 PLACE USA WHO Isaac Z. Schlueter and Node.js community BRIEF DESCRIPTION npm develops as the package manager and public package registry associated with Node.js. package.json records package identity, scripts, dependencies and metadata while the registry enables global distribution. The JavaScript ecosystem rapidly becomes one of the world's largest graphs of reusable software dependencies. LINK *** ## NODE 50 NAME NUGET DATE 2010 PLACE USA WHO MICROSOFT AND .NET COMMUNITY BRIEF DESCRIPTION NuGet emerges as the standard package manager for the .NET ecosystem. Libraries can be published as versioned packages with dependency metadata and retrieved from shared repositories, bringing repository-based component management directly into .NET development tools and build processes. LINK *** ## NODE 51 NAME COMPOSER DATE 2012 PLACE GLOBAL WHO Nils Adermann, Jordi Boggiano and PHP community BRIEF DESCRIPTION Composer develops as a dependency manager for PHP. Projects declare required packages and version constraints in composer.json while dependency resolution produces a consistent installation set. PHP application architecture increasingly shifts from copied libraries toward explicit package graphs. LINK *** ## NODE 52 NAME GO 1 DATE 2012-03-28 PLACE GLOBAL WHO GOOGLE AND GO COMMUNITY BRIEF DESCRIPTION Go 1 establishes a long-term compatibility commitment for the language and its core package library. Stable package APIs become a deliberate architectural contract, demonstrating that component compatibility across years can be treated as a language ecosystem requirement rather than an informal convention. LINK *** ## NODE 53 NAME TYPESCRIPT DATE 2012-10-01 PLACE USA WHO Anders Hejlsberg and MICROSOFT BRIEF DESCRIPTION TypeScript introduces static type annotations, interfaces, classes and module-oriented tooling to large JavaScript applications. Interfaces can describe structural contracts independently of implementation, strengthening component boundaries in increasingly complex Web and server software. LINK *** ## NODE 54 NAME PYTHON WHEEL DATE 2013 PLACE GLOBAL WHO PYTHON PACKAGING COMMUNITY BRIEF DESCRIPTION The Wheel binary package format standardizes a built distribution format for Python. Packages can often be installed without rebuilding source locally, separating source distributions from deployment artifacts and improving reliability and performance of package installation. LINK *** ## NODE 55 NAME SWIFT MODULES AND PROTOCOLS DATE 2014-06-02 PLACE USA - California WHO APPLE BRIEF DESCRIPTION Swift is introduced with modules for organizing compiled software and protocols for describing behavioral contracts. Protocol-oriented design allows software to depend on capabilities rather than specific class hierarchies, providing another modern approach to reusable interfaces and components. LINK *** ## NODE 56 NAME CARGO AND CRATES.IO DATE 2014 PLACE GLOBAL WHO RUST PROJECT AND MOZILLA COMMUNITY BRIEF DESCRIPTION Rust develops Cargo as its integrated build and package management system together with the crates.io registry. A crate becomes the primary compilation and distribution unit while Cargo.toml describes metadata and dependencies. Language tooling, dependency management, build execution and package publication are integrated from the beginning. LINK *** ## NODE 57 NAME RUST 1.0 DATE 2015-05-15 PLACE GLOBAL WHO RUST PROJECT BRIEF DESCRIPTION Rust 1.0 establishes a stable language and ecosystem based on modules, crates, traits and Cargo packages. Traits define behavioral interfaces, modules control namespace and visibility, and crates provide compilation and distribution boundaries. These component abstractions are combined with strong compile-time memory and ownership guarantees. LINK *** ## NODE 58 NAME ECMASCRIPT MODULES DATE 2015-06 PLACE GLOBAL WHO ECMA INTERNATIONAL TC39 BRIEF DESCRIPTION ECMAScript 2015 standardizes native JavaScript modules using import and export declarations. JavaScript gains a language-level module system shared across browsers, servers and tooling rather than relying exclusively on incompatible external conventions such as CommonJS or AMD. LINK *** ## NODE 59 NAME PYPROJECT.TOML DATE 2016 PLACE GLOBAL WHO PYTHON PACKAGING AUTHORITY BRIEF DESCRIPTION PEP 518 introduces pyproject.toml as a standard project-level configuration file for Python build requirements. A project's build dependencies can be declared before executing arbitrary setup code, creating a cleaner contract between source projects and build tools. LINK *** ## NODE 60 NAME YARN DATE 2016-10-11 PLACE GLOBAL WHO FACEBOOK, EXPONENT, GOOGLE AND TILDE BRIEF DESCRIPTION Yarn introduces an alternative JavaScript package manager emphasizing deterministic installations, caching and lockfiles. The yarn.lock artifact records resolved dependency versions so that the same declared project can reproduce the same dependency graph across different development and deployment environments. LINK *** ## NODE 61 NAME JAVA PLATFORM MODULE SYSTEM DATE 2017-09 PLACE GLOBAL WHO OPENJDK COMMUNITY BRIEF DESCRIPTION Java 9 introduces the Java Platform Module System. A module is a named, self-describing collection of code and data containing packages while explicitly declaring dependencies and exports. The architecture adds a component level above the Java package and provides stronger encapsulation of previously internal APIs. LINK *** ## NODE 62 NAME PYTHON BUILD BACKEND INTERFACE DATE 2017 PLACE GLOBAL WHO PYTHON PACKAGING AUTHORITY BRIEF DESCRIPTION PEP 517 defines a standard interface between Python build frontends and independent build backends. Package installation tools no longer need to assume that every project is built through one implementation technology. The build system itself becomes replaceable behind an explicit component contract. LINK *** ## NODE 63 NAME GO MODULES DATE 2018-08-24 PLACE GLOBAL WHO GO PROJECT BRIEF DESCRIPTION Go 1.11 introduces versioned module support. A module groups related packages under a versioned dependency boundary described by go.mod. Go applications can manage reproducible dependencies outside the older GOPATH model, bringing explicit package-version graphs into the standard Go toolchain. LINK *** ## NODE 64 NAME GO MODULES PRODUCTION READY DATE 2020-02-25 PLACE GLOBAL WHO GO PROJECT BRIEF DESCRIPTION Go 1.14 declares module support ready for production use and encourages users to migrate to Go modules. The language ecosystem completes its transition toward explicit, version-aware dependency management integrated directly into the compiler and standard development tools. LINK *** ## NODE 65 NAME WEBASSEMBLY COMPONENT MODEL DATE 2024 PLACE GLOBAL WHO BYTECODE ALLIANCE AND WEBASSEMBLY COMMUNITY BRIEF DESCRIPTION The WebAssembly Component Model develops a portable architecture for composing independently compiled components through typed imports and exports. Interfaces can be described independently from implementation languages and components can be linked without sharing one language runtime or memory representation. LINK *** ## NODE 66 NAME WASI 0.2 DATE 2024-01-25 PLACE GLOBAL WHO BYTECODE ALLIANCE AND WASI COMMUNITY BRIEF DESCRIPTION WASI 0.2 provides a stable interface set built around the WebAssembly Component Model. Software components compiled from different languages can communicate through explicit typed interfaces while executing in sandboxed environments. The component boundary becomes portable across languages, operating systems and execution hosts. LINK *** ## NODE 67 NAME MODERN SOFTWARE COMPONENT ECOSYSTEM DATE 2026 PLACE GLOBAL WHO GLOBAL SOFTWARE ENGINEERING COMMUNITY BRIEF DESCRIPTION Modern software is organized through multiple nested component boundaries. Functions and classes form modules; modules form packages; packages become versioned artifacts; artifacts depend on other artifacts through manifests and lockfiles; interfaces separate consumers from implementations; libraries can be loaded statically or dynamically; plugins extend applications; registries distribute components globally; and portable component models increasingly allow implementations written in different languages to interoperate through explicit contracts. LINK