ShadowRealm, a forthcoming ECMAScript standard now at TC39 Stage 3, lets developers create isolated JavaScript global environments without DOM overhead, offering a lightweight alternative to iframes and eval for securely executing third‑party code, with APIs like new ShadowRealm(), evaluate() and importValue().
From Brendan Eich’s ten‑day creation of Mocha in 1995 to the rise of WebAssembly at the edge in 2022, this article chronicles ten pivotal JavaScript milestones—including ECMAScript, Ajax, Node.js, npm, React, TypeScript, and more—that transformed the language into the web’s dominant programming force.
This article explains why the traditional try‑finally pattern for resource handling in JavaScript is verbose and error‑prone, and introduces the upcoming ECMAScript ‘using’ declaration that provides automatic, scope‑based cleanup, supports async resources, and makes code cleaner and safer.
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.
This article reviews several Stage 2 ECMAScript proposals—including discard bindings using the void operator, iterator chunking for sliding windows and non‑overlapping sequences, phase‑based ESM imports for static worker initialization, extractors for custom destructuring, and structs with shared memory, mutexes, and unsafe blocks.
This article reviews the latest Stage 4 ECMAScript proposals—including ArrayBuffer transfer, iterator helpers, RegExp modifiers, import attributes, Promise.try, duplicate named capture groups, and Set methods—explaining their purpose, syntax, and example usage for modern JavaScript development.
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.
Babel is a micro‑kernel JavaScript transpiler that parses source code into an AST, lets plugins and presets transform it, and generates backward‑compatible code with optional source maps, while its runtime helpers, polyfills, and close alignment with the evolving ECMAScript specification ensure modern syntax works across legacy environments.
The article covers Amazon’s $2 trillion market cap milestone, China’s push to standardize brain‑computer interfaces, the approval of ECMAScript 2024 with new JavaScript features, and Google Sheets’ shift from a JavaScript engine to a WasmGC‑based calculation engine, highlighting their broader tech implications.
This article explores five highly anticipated JavaScript proposals—including the Temporal API, Pipe Operator, Record & Tuple, RegExp v flag, and Decorators—detailing their motivations, core syntax, and example code as they move toward inclusion in the upcoming ECMAScript release.
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.
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 explains how JavaScript variable lookup and lexical scope are determined during compilation by the V8 engine, covering the language's compiled‑and‑interpreted nature, JIT optimizations, AST generation, lazy parsing, dynamic lookups, and bytecode creation to demystify runtime performance.
This article explains ECMAScript runtime semantics, detailing how algorithm steps and abstract operations such as ToBoolean and internal methods like [[GetPrototypeOf]] define JavaScript's execution behavior, and introduces related concepts like internal slots, completion records, and shorthand notations used in the specification.
This article explains ECMAScript runtime semantics, the structure of algorithm steps, abstract operations, internal methods and slots, as well as completion records and the shorthand symbols ? and ! used in the specification, providing clear examples and code snippets for JavaScript developers.
The article explains the upcoming ECMAScript 2023 proposals—including non‑destructive array methods (toReversed, toSorted, toSpliced, with), array grouping (group, groupToMap), reverse‑search methods (findLast, findLastIndex), and the asynchronous constructor Array.fromAsync—detailing their stages, usage examples, polyfills, and type signatures for modern JavaScript development.
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.
This article chronicles JavaScript's 27‑year journey from its rapid 1995 creation at Netscape, through browser wars, standardization, the rise of frameworks and Node.js, to its current dominance and promising future with WebAssembly and beyond.
This article traces the history of the JavaScript trademark—from its creation by Netscape and Sun, through Oracle’s acquisition, to Ryan Dahl’s 2022 open letter urging its release, highlighting the confusion with Java and the rise of ECMAScript as a neutral name.
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 explains how Vue 3 replaces Vue 2’s Object.defineProperty reactivity with JavaScript’s Proxy, covering Proxy fundamentals, handler traps, the relationship with Reflect, internal methods and slots, and the distinction between ordinary and exotic objects, providing code examples and visual diagrams.
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.
JavaScript’s upcoming “Change Array by copy” proposal introduces four non‑destructive array methods—.toReversed(), .toSorted(), .toSpliced(), and .with()—which provide immutable alternatives to existing destructive methods, and the article explains their behavior, usage examples, and polyfills while the proposal is in stage 3.
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.
Microsoft’s recent proposal to add optional type‑annotation syntax to JavaScript aims to let external tools like TypeScript perform static checks while keeping runtime behavior unchanged, sparking both excitement and debate among developers.
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.
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.
This article introduces the five major new features of ES2021, including numeric separators, String.prototype.replaceAll(), Promise.any, logical assignment operators, and WeakRefs, with detailed explanations and code examples.
This article explains why Object.keys() may return property keys in an order different from their declaration, by dissecting the ECMAScript 2022 specification and showing how numeric, string, and Symbol keys are classified and sorted during execution.
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.
This article explains the historical concept of activation objects in ECMAScript 1/3, why they disappeared after ES5 in favor of lexical environments, how the idea persists as a generalized abstraction similar to stack frames, and how it relates to closures.
This article explains the historical concept of Activation (or Variable) Objects in ECMAScript 1/3, why they disappeared after ES5, how modern JavaScript uses Lexical Environments as their successor, and how this relates to closures and function execution.
This article explains ECMAScript's cover grammars and finite lookahead mechanisms for resolving ambiguous syntax, focusing on arrow function parameter lists versus parenthesized expressions.
This article explains the historic concept of Activation (or Variable) Objects in ECMAScript 1/3, how they were replaced by Lexical Environments in ES5+, and how the broader notion still helps understand closures and stack frames in modern JavaScript.
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.
This article examines the four ECMAScript grammars—lexical, syntactic, regular‑expression, and numeric‑string—explains how context‑free productions define tokens, shows ambiguous cases such as the '/' and '`' characters, and details why the identifier await is prohibited in async functions through static‑semantic rules.
This article explains how the ECMAScript specification defines four context‑free grammars—lexical, syntactic, RegExp, and numeric string—illustrates ambiguities such as the '/' token and template literals, and shows how static semantics forbid using the await keyword as an identifier inside async functions while allowing it elsewhere.
This article explains how the ECMAScript specification defines property access through the [[Get]] internal method, walks the prototype chain, and uses the Receiver value, illustrating each step with concrete code examples and the relevant abstract operations such as OrdinaryGet and GetValue.
This article walks through how the ECMAScript specification defines prototype chain property lookup, detailing the [[Get]] internal method, OrdinaryGet algorithm, the role of the Receiver parameter, and how these mechanisms are invoked during member expression evaluation and function calls.
This article explains how the ECMAScript specification defines the behavior of Object.prototype.hasOwnProperty, introduces abstract operations, completion records, internal slots and methods, and shows how the spec’s pseudo‑code can be translated into concrete JavaScript examples.
This article walks through a concrete example of Object.prototype.hasOwnProperty in the ECMAScript specification, explaining language and specification types, abstract operations, internal slots and methods, Completion Records, and the shorthand ? and ! used for error handling in spec algorithms.
Frontend developers are urged to spend a relaxed weekend reviewing the nearly completed ECMAScript 2021 specification—set for Ecma’s June approval—which will underpin the next generation of JavaScript implementations, with the full draft available at https://tc39.es/ecma262/2021/.
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 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.
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 explores the history of the abandoned ECMAScript 4 specification, detailing its ambitious features, the industry conflict that halted its release, and how many of its ideas later resurfaced in modern JavaScript versions like ES6.
A roundup of recent tech developments reveals foreign investors courting TikTok, Samsung’s 6G roadmap for 2028, new ECMAScript 2021 features like Promise.any and numeric separators, and the launch of ActiveJ, a lightweight Java framework positioned as an alternative to Spring and Spark.
This article explains why developers should dive into the massive ECMAScript specification, outlines the kinds of language features it defines, shows how to locate the official text, and walks through concrete examples that reveal the spec’s role in everyday JavaScript behavior.
This article explains the Stage‑1 JavaScript Record & Tuple proposal, showing how the new immutable value types are created with a leading #, how they differ from objects by using value‑based comparison, and why they improve deep equality, sharing, non‑destructive updates, and usage in Maps and Sets.
This article explores how JavaScript’s ECMAScript specification defines property access on primitive values, detailing the runtime semantics of member expressions, abstract operations like GetValue and ToObject, internal slots, records, and the behavior of methods such as String.prototype.substring when invoked with various receivers.
The article explains why developers should study the massive ECMAScript specification to understand JavaScript's exact behavior, resolve confusing runtime issues, differentiate operators like == and ===, and reliably write code across browsers and Node.js environments.
This article explains how the spread operator combined with logical && can conditionally add properties to an object, detailing the underlying ECMAScript specification, the CopyDataProperties abstract operation, and edge cases with null, undefined, and primitive values.
This article introduces the Kangax ES compatibility table, showing how to view new ECMAScript features, their support across browsers and Node.js, and explains the table’s layout, version selectors, and color‑coded compatibility indicators for developers seeking up‑to‑date feature information.
This article explains the distinction between ECMAScript and JavaScript decorators, walks through the TC39 proposal stages, demonstrates how to work with property descriptors, Object.defineProperty, Object.defineProperties, Object.create, and shows practical examples of method, class‑field, and class decorators using Babel.
This article explains the special NaN value in ECMAScript, its two unusual properties, how division by zero yields NaN, and demonstrates the behavior of the isNaN() function with various inputs, including numbers, strings, booleans, and objects, illustrating conversion rules and pitfalls.
This article explains JavaScript identifiers and systematically breaks down every type of operator—from unary and boolean to relational, equality, conditional, assignment, comma, and bitwise—illustrating each with clear definitions, code examples, and visual diagrams for front‑end developers.
Node.js v7 upgrades its V8 engine from version 5.1 to 5.4, introducing ECMAScript features like the exponentiation operator, Object.values/Object.entries, Object.getOwnPropertyDescriptors, and performance improvements such as reduced memory usage, faster garbage collection, and enhanced Promise handling.
