5 Things You Might Not Know About JavaScript

I write JavaScript every day and have for years. Most of us do. The language is so familiar that it’s easy to stop asking questions about it. But some of the details hiding underneath are genuinely strange: Oracle owns the JavaScript trademark and is fighting to keep it, the spec is called ECMAScript because Sun refused to license the name in 1997, and typeof null returns 'object' – a 30-year-old bug nobody can fix. Here are five things about the language that catch even experienced developers off guard.

1 - “JavaScript” is a trademark Oracle owns (and might lose)

The name “JavaScript” is a registered trademark held by Oracle America, Inc. Sun Microsystems applied for it in 1995, the same year Netscape created the language, and it was registered in 2000. Oracle inherited it when it acquired Sun in a deal announced in 2009 and closed in January 2010. The registration number is 2416017.

That name is being openly contested. In September 2022, Node.js and Deno creator Ryan Dahl published an open letter asking Oracle to release the trademark to the public domain. The effort grew into a petition at javascript.tm that gathered over 19,550 signatures, including JavaScript creator Brendan Eich and many TC39 members.

Then it escalated. On November 22, 2024, Deno Land filed a formal petition with the USPTO’s Trademark Trial and Appeal Board to cancel the trademark (case #92086835). Three claims: genericness, abandonment, and fraud. The fraud claim was the spicy one. During Oracle’s 2019 trademark renewal, it submitted a screenshot of Node.js as evidence of “use in commerce.” Node.js is Ryan Dahl’s project, not Oracle’s. Oracle’s second specimen was a page about Oracle JET, a UI toolkit. On June 18, 2026, the TTAB dismissed the fraud claim. The case continues on genericness and abandonment.

Oracle must respond to the petition by August 7, 2026. Discovery begins September 6, 2026. For now, Oracle still owns the name.

The language itself is a separate matter. It’s an open standard, ECMA-262, implemented by Google (V8), Apple (JavaScriptCore), Mozilla (SpiderMonkey), and others. Anyone can implement it. The trademark only controls commercial use of the name.

2 - Why the spec is called ECMAScript instead of JavaScript

People use the two names interchangeably, but they’re not the same thing. JavaScript is the language. ECMAScript is the standardized specification, ECMA-262, that defines its syntax and semantics. ECMAScript is the contract. JavaScript is one implementation of it.

The spec is maintained by Ecma International through Technical Committee 39, and a new edition ships every year. Different editions correspond to different capabilities. ES5 (2009) brought strict mode and native JSON. ES6, later renamed ES2015, added arrow functions, classes, let/const, and modules. The yearly releases since have layered on async/await, optional chaining, and plenty more.

Here’s the part most people miss. The standard was called “ECMAScript” in the first place because Sun owned the JavaScript trademark and wouldn’t transfer it to the standards body in 1997. The name was a compromise – Brendan Eich called it “an unwanted trade name that sounds like a skin disease.”

3 - Why typeof null returns ‘object’ (a 30-year-old bug)

JavaScript is dynamically typed. You don’t annotate types up front, and a variable can hold a value of any type. It’s also loosely typed, meaning implicit coercion happens whether you want it to or not. The + operator adds numbers, concatenates strings, and will coerce values across types to make an operation work.

But none of that means types don’t exist. Every value has a type, and the typeof operator returns a string describing it: 'number', 'string', 'boolean', 'undefined', 'object', 'function', 'symbol', 'bigint'.

And then there’s the one that lies. typeof null === 'object'. This is a known bug from the first implementation in 1995, and it can’t be fixed without breaking the web. Here’s why: JavaScript’s original engine stored type information in the lower bits of every value. Objects used the type tag 000. null was represented as the null pointer, 0x00 – all zeros. The type-checking code saw the 000 tag and returned 'object'. Every value type has a corresponding typeof string except null, which has been reporting the wrong answer for 30 years and counting.

4 - JavaScript’s seven primitive types

JavaScript has seven primitive types. Everything else is an object. The Records and Tuples proposal, which would have added two more for deeply immutable data structures, was withdrawn by TC39 in April 2025. So the count holds steady.

1. Boolean: true or false.
2. Null: the intentional absence of a value. Its only value is null.
3. Undefined: a declared but unassigned variable. Its only value is undefined.
4. Number: double-precision 64-bit IEEE 754 floating point. This covers integers and decimals alike, and yes, typeof NaN === 'number'.
5. BigInt: introduced in ES2020, for integers beyond Number.MAX_SAFE_INTEGER (2^53 - 1).
6. String: a sequence of characters, immutable.
7. Symbol: introduced in ES2015, a unique identifier often used as an object key to avoid collisions.

Two properties worth remembering. Primitives are immutable: you can’t change a primitive value in place. And they’re passed by value: assign one to a variable or hand it to a function and you get a copy, so changes to the copy never touch the original.

5 - JavaScript is JIT-compiled, not interpreted

The old line that JavaScript is an interpreted language is wrong. Modern JavaScript is JIT-compiled. There’s no separate build step that turns your source into a machine-code executable ahead of time, like C++ or Rust. Instead, the engine compiles your code while it runs.

Every modern engine, V8, SpiderMonkey, JavaScriptCore, uses a tiered compilation pipeline. Code starts out interpreted for fast startup, and as the engine spots “hot” functions that run often, it compiles and optimizes them into machine code based on runtime heuristics. V8’s pipeline specifically goes Ignition (interpreter) to Sparkplug (fast non-optimizing compiler) to Maglev (mid-tier) to Turbofan (optimizing). That tiering is why JS engines are as fast as they are today.

The tooling ecosystem is chasing the same speed. TypeScript’s compiler was rewritten in Go in 2026 for roughly an order-of-magnitude faster builds, and pnpm is rewriting its install engine in Rust. The language runs fast at runtime, and now the tools around it are catching up at build time.

One more corner worth poking

None of these five facts change how you write a for loop. But they explain the language’s shape. Why coercion behaves the way it does, why the spec is called ECMAScript, why typeof null lies, why your code runs fast without a compile step. The language most of us treat as background noise has a 30-year-old bug baked into its type tags and a trademark case scheduled for discovery in federal court this September. And Math.sumPrecise(), newly Baseline in 2026, quietly fixed the floating-point summation errors that reduce silently introduces. That’s worth knowing.