This digest covers Oracle’s denial that “JavaScript” is a generic term, recent TC39 proposals, Vercel’s native support for Hono, a Vue‑React hybrid called Veact, V8’s JSON.stringify speed boost, CSS scroll‑spy tricks, masonry layout techniques, and an AI‑generated Space Invaders game.
This article explains how the upcoming JavaScript ‘using’ declaration, inspired by C# and Python, can replace verbose try…finally patterns for both synchronous and asynchronous resources, offering cleaner syntax, automatic disposal, and practical examples across files, databases, and mutexes.
This article explains the role of ECMA TC39, its meeting cadence, member composition, proposal stages from Strawman to Finished, and highlights key updates from the 105th meeting including new Intl.DurationFormat, Error.isError, ESM Phase Imports, immutable ArrayBuffer, and currency display options.
At a recent Emca TC39 meeting, a Google engineer proposed dividing JavaScript into a minimal core language (JS0) and an advanced variant (JSSugar), arguing that new language features often harm security, performance, and stability, and suggesting that higher‑level capabilities be handled by external tools like TypeScript or Babel.
Recent TC39 Stage‑1 proposals introduce iterator deduplication, enhanced template literals, function and object literal decorators, concurrency controls for async iterators, unordered async helpers, immutable ArrayBuffers, a measurement API, Array.zip utilities, reactive Signals, and stricter resource‑management using enforcement, each aiming to extend JavaScript’s core capabilities.
Several Stage‑3 TC39 proposals—including Error.isError for reliable error type checks, RegExp.escape for safe regex construction, Uint8Array methods for base64/hex conversion, and Temporal.TimeZone.prototype.equals for canonical time‑zone comparison—aim to enhance JavaScript’s core capabilities across browsers and Node.js.
This article summarizes TC39’s 2024 JavaScript proposal workflow, detailing each stage from initial concept (Stage 0) through final adoption (Stage 4) and outlining upcoming articles that will track progress across the different stages.
This article reviews the six key ECMAScript 2024 proposals—including well‑formed Unicode strings, asynchronous atomic wait, the new RegExp v flag, ArrayBuffer transfer, array grouping, and Promise.withResolvers—explaining their purpose, API changes, and providing runnable code examples.
This article reviews recent TC39 proposals that have reached Stage 4 or entered Stage 1, covering resizable ArrayBuffers, RegExp.escape, joint iteration, iterator sequencing, locale extensions, negated operators, and stable formatting, and explains their impact on the upcoming ECMAScript releases.
This article reviews the latest TC39 proposals that have advanced to Stage 4—including Change Array By Copy, Intl.NumberFormat V3, and Symbol as WeakMap Keys—explains their new immutable‑array methods, international‑number formatting APIs, weak‑map key support, and also highlights proposals moving between other stages such as Async Context and ArrayBuffer transfer.
The article introduces the TC39 Async Context proposal, explains why asynchronous context is needed, shows a library implementation using run and log functions, describes the AsyncContext API with run, get, and wrap methods, and explores use cases such as trace propagation, task‑priority handling, and comparisons with thread‑local storage and Node.js AsyncLocalStorage.
This article reviews recent TC39 proposals—including Intl.Enumeration, Explicit Resource Management, Set Methods, Well‑Formed Unicode strings, ArrayBuffer transfer, and others—explaining their stage‑gate requirements, core API changes, example code, and how they advance the JavaScript language.
The article reviews the latest TC39 meeting outcomes, explains the criteria for advancing proposals to higher stages, and dives into three key proposals—Array.fromAsync for async iteration, String.prototype.isWellFormed for Unicode scalar validation, and extractors for pattern matching—complete with code examples and usage notes.
The article reviews recent TC39 decisions, detailing how proposals such as Hashbang Grammar, Duplicate Named Capturing Groups, Import Reflection, Function Memoization, Policy Maps and Sets, Symbol Predicates, and Object.pick/omit progressed through the ECMAScript staging process and what criteria each stage requires.
The recent TC39 meeting promoted several proposals—including Hashbang Grammar, Duplicate Named Capturing Groups, Import Reflection, Symbol Predicates, Policy Maps and Sets, Function Memoization, and Object.pick/omit—through various stage thresholds, outlining the requirements for each advancement and providing example code for the new language features.
This article reviews recent TC39 proposals—including findLast, Symbol-as-WeakMap keys, JSON.parse source text access, String.dedent, RegExp modifiers, atomic operators, and faster Promise adoption—explaining their stage progress, technical details, and practical code examples for modern JavaScript development.
This article reviews the latest TC39 proposals—including findLast, Symbol as WeakMap keys, JSON.parse source text access, String.dedent, Import Reflection, RegExp modifiers and atomic operators, and Faster Promise Adoption—detailing their stage progress, implementation requirements, and practical code examples for modern JavaScript development.
The article reviews recent TC39 proposal updates—including decorators reaching Stage 3, type annotations entering Stage 1, the Change‑Array‑by‑Copy immutable methods, RegExp set notation, decorator metadata, and native once‑only functions—explaining their motivations, new syntax, stage‑gate criteria, and example implementations for JavaScript developers.
This article reviews recent TC39 proposal progress—including decorators reaching Stage 3, type annotations advancing to Stage 1, new immutable array methods, RegExp set notation, decorator metadata, and function.once—detailing their syntax, semantics, migration considerations, and example implementations for modern JavaScript development.
This article examines five active TC39 proposals—Pipeline Operator, Function Pipe/Flow, Partial Application, Call This, and Extensions—explaining their design goals, differences, and how they aim to improve function invocation readability, dataflow programming, method extension, and partial application in future ECMAScript versions.
The article explains the recent TC39 progress of the reversible‑string‑split proposal, outlines the criteria for advancing to Stage 1, compares JavaScript’s split behavior with other languages, and describes the new splitN method that restores reversibility while preserving existing split semantics.
The recent TC39 meeting promoted the reversible-string-split proposal to Stage 1, outlining the criteria for advancement and introducing a splitN method that makes JavaScript’s string splitting reversible, while comparing it with split implementations in other major languages.
The December TC39 meeting updated several proposals—including moving Intl.Segmenter to Stage 1 as V2, adding new timeZoneName values, expanding Intl.DisplayNames, introducing Array.prototype.groupBy and Array.fromAsync, and refining RegExp modifiers and buffer boundaries—while outlining the criteria for advancing proposals through the stages.
This article reviews recent TC39 proposals that have reached Stage 4—including Intl.Segmenter, Error Cause, Intl.DurationFormat, Array.groupBy, Destructuring Private Fields, String.cooked, RegExp modifiers, RegExp \R, buffer boundaries, Evaluator Attributes, and Bind‑this—explaining their goals, usage, and providing practical JavaScript code examples.
The article reviews the recent TC39 meeting, outlines the criteria for advancing proposals to Stage 4, and explains several upcoming ECMAScript features—including the relative‑indexing .at() method, Object.hasOwn, class static initialization blocks, the pipeline operator, and other proposals—providing code examples and implementation status.
The article reviews recent TC39 proposals—including Private‑in, Object.hasOwn, Realms, Array.findLast, ArrayBuffer Base64, and Array.groupBy—explaining their stage progress, technical details, usage examples, and potential impact on modern JavaScript development.
This article surveys the most noteworthy ECMAScript proposals—from Record & Tuple and the .at() method to Temporal, private methods, top‑level await, import assertions, error cause, decorators, iterator helpers, throw expressions, upsert, observable, do‑expressions, pipeline operator, partial‑application syntax, and await.opts—explaining their purpose, current stage, and providing practical code examples.
This article surveys the most interesting ECMAScript proposals—ranging from new data structures like Record & Tuple to syntax enhancements such as the pipeline operator—explaining their purpose, current stage, and practical examples, while also covering the TC39 process and related background for front‑end developers.
This article reviews the most recent TC39 proposals—including Realms, RegExp match indices, top‑level await, accessible hasOwnProperty, resizable ArrayBuffers, Intl.DisplayNames V2, extended time‑zone names, and RegExp set notation—explaining their key changes, current stage status, and practical code examples for developers.
The article reviews the recent TC39 meeting where the Class Fields proposal advanced to Stage 4, outlines the criteria for moving between proposal stages, and summarizes several other ECMAScript proposals—including Intl.LocaleInfo, Object.hasOwn, Symbol as WeakMap keys, extended timezone options, copy‑based array methods, and readonly ArrayBuffer—detailing their goals, status, and example code.
Amid the pandemic‑driven shift to fully online TC39 meetings, the committee accelerated meeting frequency while trimming agendas, advancing proposals such as Error Cause to Stage 3, introducing the Temporal API to replace Date, adding Array.findLast methods, and exploring Module Fragments to improve JavaScript module handling.
The article reviews recent TC39 proposal updates—including Error Cause reaching Stage 3, the Temporal API replacing the flawed Date object, the new Array.findLast methods, and Module Fragments—explaining their motivations, design details, code examples, and how they aim to improve JavaScript development across environments.
The January 29 TC39 meeting reviewed progress on dozens of ECMAScript proposals, outlining the criteria for moving from Stage 3 to Stage 4, Stage 2 to Stage 3, and Stage 1 to Stage 2, and highlighting key features such as Intl.DateTimeFormat.formatRange, JSON Modules, Private‑in, class static blocks, resizable array buffers, and new Intl APIs.
The article reviews TC39’s January 29 meeting, detailing the criteria for advancing proposals between stages, summarizing key proposals such as Intl.DateTimeFormat.formatRange, JSON Modules, Private‑in operator, Class static initializer blocks, ResizableArrayBuffer, Intl.LocaleInfo, RegExp enhancements, and the community’s role in shaping ECMAScript.
The TC39 January 29 meeting reviewed progress of multiple proposals advancing to later stages—including Intl.DateTimeFormat.formatRange, JSON Modules, Private‑In, Class Static Initializer Block, ResizableArrayBuffer, new Intl APIs, RegExp enhancements, Array findLast, defer import, and several internationalization extensions—detailing requirements, implementations, and upcoming milestones.
The article reviews TC39’s 2020 final meeting, outlines stage‑gate requirements, and explains key proposals—including Error‑cause, Module Blocks, Extensions, and Grouped Accessors—detailing their motivations, syntax, and potential impact on JavaScript development.
The 2020 TC39 meeting reviewed several proposals—including Error Cause, Module Blocks, Extensions, and Grouped Accessor—detailing their stage requirements, code examples, and community impact, while noting that no proposal progressed from Stage 2 to Stage 3 that year.
The 2020 TC39 meeting reviewed several ECMAScript proposals—including Error Cause, Module Blocks, Extensions, and Grouped Accessor—detailing their motivations, required champion work, and code examples, while noting that no proposal advanced to a higher stage during the session.
The article reviews the latest TC39 meeting, detailing the progression of multiple ECMAScript proposals—including Error Cause, Intl.DisplayNames, .item(), Import Assertions, class static blocks, resizable buffers, enumeration APIs, double‑ended iterators, integer math extensions, standardized debug, string dedent, and locale enhancements—while explaining stage requirements, implementation notes, and example code.
The article reviews the latest TC39 meeting, detailing proposals that moved to higher stages—including Error Cause reaching Stage 4, Intl.DisplayNames enhancements, Import Assertions, .item() for indexables, class static blocks, resizable array buffers, Intl.Enumeration, double‑ended iterators, integer math extensions, standardized debug syntax, String.dedent, Intl.Locale, and DisplayNames v2—while outlining the criteria required for each stage transition.
The TC39 meeting covered a range of ECMAScript proposals—including Error Cause, Intl.DisplayNames, .item() for indexables, Import Assertions, Class static initialization blocks, ResizableArrayBuffer, Intl.Enumeration, Double‑Ended Iterators, integer‑math extensions, Standardized Debug, String Dedent, Intl Locale and DisplayNames v2—detailing their stage‑gate requirements, example implementations, and impact on JavaScript development.
This article reviews the latest TC39 proposals advancing from Stage 3 to Stage 4—including Promise.any, AggregateError, WeakRefs, FinalizationRegistry, logical assignment operators, numeric literal separators, Intl.ListFormat, Intl.DateTimeFormat styles, iterator.item, Intl.Segmenter, Record & Tuple, JSON.parse source‑text access, await extensions, Array.prototype.unique, and resizable array buffers—explaining their goals, required thresholds, and providing concrete code examples.
This article surveys the evolution of JavaScript from ES5 through ES10, explains which features are native in modern browsers, outlines the stage‑process for proposals, showcases code examples for classes, modules, generators, async/await, optional chaining, and discusses whether Babel is still needed.
This article reviews the TC39 function‑implementation‑hiding proposal, explains the new hide‑source and sensitive directives that can conceal Function.prototype.toString and Error.stack details, evaluates their benefits and drawbacks, compares alternative hiding mechanisms, and answers common questions about the specification.
An in‑depth look at the ongoing debate between CommonJS and ECMAScript Modules in Node.js, drawing on the latest TC39 discussions to explain their implementation differences, practical impacts, and why reconciling them has long puzzled the Node.js community.
