5 Things You Might Not Know About JavaScript

JavaScript has been around since 1995, and most of us write it every day without thinking much about where it came from or how it actually runs. Here are five things about the language that tend to catch even experienced developers off guard: who owns the name, why it isn’t the same thing as ECMAScript, how its type system really works, and what happens under the hood when your code executes.

1 - “JavaScript” is a trademark, and it’s contested

The name “JavaScript” is a registered trademark held by Oracle America, Inc. in the United States. It traces back to Netscape, which created the language in 1995. Sun Microsystems applied for the mark that same year, it was registered in 2000, and Oracle inherited it when it acquired Sun in a deal announced in 2009 and closed in January 2010.

A trademark is a legal protection that grants exclusive rights to use a particular word, phrase, symbol, or design to identify and distinguish a product or service.

As the holder, Oracle controls how the term is used commercially in the US: other entities have to follow specific guidelines, or risk legal trouble, if they use it in a way the trademark covers. The language itself is a different story. It’s an open standard governed by the ECMAScript specification, so anyone can implement and use it regardless of who owns the name.

That name has been openly contested for years. In 2022, Node.js and Deno creator Ryan Dahl published an open letter, Dear Oracle, Please Release the JavaScript Trademark, asking Oracle to hand it to the public domain. The effort grew into an open letter co-signed by Brendan Eich and thousands of developers, and in November 2024 Deno escalated by filing a petition with the USPTO to cancel the trademark, arguing the term has become generic and that Oracle abandoned it. As of mid-2026 the case is still working through the Trademark Trial and Appeal Board, with a decision not expected before 2027. For now, Oracle still owns it.

2 - JavaScript and ECMAScript are not the same thing

The two names get used interchangeably, but they aren’t the same. JavaScript is the programming language; ECMAScript is the standardized specification that defines its syntax, semantics, and features. ECMAScript is the contract; JavaScript is one implementation of it.

The spec is maintained by Ecma International through its Technical Committee 39 (TC39), and it ships a new edition every year. Different editions correspond to different capabilities: ES5 brought strict mode and native JSON support, ES6 (2015) added arrow functions, classes, let/const, and modules, and the yearly releases since have layered on things like async/await and optional chaining.

There’s a small piece of trademark history buried here too. The standard was named “ECMAScript” in the first place precisely because Sun would not license the “JavaScript” name for it back in 1997.

3 - JavaScript is dynamically typed, but it does have types

JavaScript is a dynamically typed language: a variable can hold a value of any type, and you don’t annotate types up front. But that doesn’t mean types don’t exist. Every value has a type, and that type determines how it can be used and manipulated.

What JavaScript also has is a loose type system, where coercion happens implicitly. The + operator adds numbers, concatenates strings, and will happily coerce values across types to make an operation work, which is the source of both its flexibility and its most infamous gotchas. When you need to know what you’re actually holding, the typeof operator returns a string describing the type of its operand.

4 - JavaScript has seven primitive types

JavaScript has seven primitive types, the building blocks that every other value is made from:

1. Boolean: a logical true or false.
2. Null: the intentional absence of any object value. Its only value is null.
3. Undefined: a variable that’s been declared but not assigned. Unassigned variables default to undefined.
4. Number: integers and floating-point values, stored in the double-precision 64-bit IEEE 754 format.
5. BigInt: introduced in ECMAScript 2020, for integers beyond the safe range of Number.
6. String: a sequence of characters, in single quotes, double quotes, or backticks.
7. Symbol: introduced in ECMAScript 2015, a unique identifier often used as an object key to avoid name collisions.

Everything else is an object. Primitives have two properties worth remembering. They’re immutable: a primitive value can’t be changed 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 “compiled” (sort of)

Calling JavaScript “compiled” or “interpreted” is where a lot of people get tripped up, because the honest answer is both. Unlike C++ or Rust, there’s no separate build step that turns your source into a machine-code executable ahead of time. Instead, the engine compiles your code while it runs, using a just-in-time (JIT) compiler.

Every modern JavaScript engine (V8, SpiderMonkey, JavaScriptCore) uses a tiered pipeline. Code starts out interpreted so it can run immediately, and as the engine spots “hot” functions that run often, it compiles and optimizes them into machine code based on runtime heuristics. So the old “JavaScript is an interpreted language” line is out of date. It’s more accurate to say it’s JIT-compiled at runtime, which is exactly what makes today’s engines as fast as they are.

If you want to go deeper on this, Kyle Simpson works through it carefully in You Don’t Know JS Yet.

Wrapping up

None of these change how you write a for loop, but they’re the kind of details that explain the language’s quirks: why coercion behaves the way it does, why the spec is called ECMAScript, and why your code runs fast without a build step. If even one of them was new to you, JavaScript still has more corners worth poking into.