JavaScript Specification Standards and Proposals
The evolution of JavaScript extends beyond the core language, encompassing a wide array of specifications and proposals designed to standardize how the language interacts with systems, manages modules, and handles data. These standards ensure that different JavaScript implementations can work together seamlessly, regardless of whether they are running in a web browser or a non-web environment.
Current Specifications
Current specifications represent the established standards currently in use. These provide the foundational rules for system behavior and module management.
- Modules/1.1 (and its sub-version 1.1.1), which has superseded the original Modules/1.0.
- Packages/1.0, defining how code packages are structured.
- System/1.0, outlining core system-level interactions.
The Proposal Process
Proposals are forward-looking documents that aim to define a set of Application Programming Interfaces (APIs) useful for non-web JavaScript implementations. By establishing standardized package names, these proposals foster interoperability—the ability of different systems and organizations to work together—within the broader ecosystem.
The goals of these proposals often overlap with those of TC39 (the technical committee that manages the ECMAScript standard). A notable example of this synergy is the development of Promises, which originated as a proposal and was eventually integrated into the ECMAScript language itself.
Version Control and Naming
The naming convention for these specifications uses a slash to denote the version. The progression of a proposal follows a specific logic:
- Letter Versions: When a proposal is still being debated or revised, each individual version or revision is assigned a letter (e.g., A, B, C).
- Numeric Versions: Once the primary direction of the specification is agreed upon, it transitions to numeric versioning.
Detailed Proposal Categories
The current landscape of proposals covers a vast range of functionality, from low-level system access to high-level module loading.
System and Data Handling
Several proposals focus on how JavaScript handles raw data and external communication, including Binary (B, F), Encodings (A, C), and the HTTP Client (B). Additionally, there are specifications for IO (A) and Filesystem (A, A/0) to manage input/output operations.
Module and Package Evolution
The module ecosystem is particularly active, with proposals for Async modules, LoaderPlugins, Resources, and Transport (B, C, D, E). Other efforts include Modules/Wrappings and Explicit-Dependencies to refine how code is encapsulated and linked.
Package management is also evolving through Packages/1.1, AsynchronousDefinition, and Mappings (A, B, C, D).
Utility and Testing
Beyond core architecture, proposals like Console (ported from the Web), Promises (B, D), and Unit Testing (B, 1.0, 1.0.1) aim to standardize the tools developers use for debugging and quality assurance.
Key Facts
- Interoperability: Proposals aim to standardize APIs for non-web JavaScript environments.
- TC39 Influence: Some proposals, such as Promises, have been adopted into the official ECMAScript standard.
- Versioning Logic: Letters are used for contentious revisions; numbers are used once the direction is finalized.
- Supersession: Modules/1.1 has officially replaced Modules/1.0.
Specification Summary
| Category | Current Versions | Notable Proposals |
|---|---|---|
| Modules | 1.1, 1.1.1 | Async, Transport, Wrappings, LoaderPlugin |
| Packages | 1.0 | 1.1, Mappings, AsynchronousDefinition |
| System/IO | System/1.0 | Binary, Encodings, HTTP Client, Filesystem |
| Utilities | N/A | Console, Promises, Unit Testing |
Frequently Asked Questions
What is the difference between a letter version and a numeric version in a proposal?
Letter versions are assigned to individual proposals and sequential revisions while the specification is still being contested. Numeric versions are assigned only after the main direction of the proposal has been established.
How do these proposals relate to TC39?
The goals of these proposals often overlap with TC39. In some cases, features developed in these proposals, such as Promises, are eventually incorporated into the ECMAScript standard.
What is the purpose of standardized package names?
Standardized package names are intended to provide interoperability within the JavaScript ecosystem, particularly for implementations that operate outside of a web browser.
Which version of the Modules specification is currently active?
Modules/1.1 (including 1.1.1) is the current version, having superseded Modules/1.0.
Are these specifications only for web browsers?
No, these proposals specifically intend to define APIs that are useful for non-web JavaScript implementations as well.