It's less the fact that someone owns JS's trademark, and more that it's specifically Oracle (they got it when they bought Sun).

Oracle is an incredibly litigious company. Their awful reputation in this respect means that the JS ecosystem can never be sure they won't swoop in and attempt to demand rent someday. This is made worse by the army of lawyers they employ; even if they're completely in the wrong, whatever project they go after probably won't be able to afford a defense.

The fact that you wrote it wrong is hilariously ironic.

JavaScript is simply the better term, and marketing is everything. Reminds me of Java's POJOs, which was a very simple pattern that no one used, until someone gave them a fancy name.

ECMAScript is a horrible technical name. Might as well call it ACMEScript considering how willie e. coyote it feels to develop with it...

EMCA -> ECMA

> Because in practice, isn't this a bit like "Kleenex"

Maybe. That's what the challenge intends to find out.

> everyone knows

Not everybody knows. People who learn JavaScript don't know. In fact, they must learn this. And from my experience, most learning resources don't mention this, let alone teach this. It took me a really long time to understand what ECMAScript is and how it relates to JavaScript. And the effort I put in this understanding... I would have preferred to not having needed that.

So no, not everybody knows this.

Not to nit-pic, but it's a Trademark cancellation - not a patent. The confusion probably came from the fact it's before the US Patent and Trademark Office.

Wouldn't Oracle's use of the Java trademark be problematic in a trademark cancellation request? We're talking about two very similar names for identical product types (i.e. programming languages). Indeed the similarity was originally intended to imply an association. I wouldn't be surprised if Oracle's sole interest in the trademark is due to its similarity and history.

Side question: can the CEO or sole proprietor of a corporation/small business/ nonprofit litigate pro se on behalf of their company? I know you can do this when acting as an individual, but if a business is too poor to afford representation, can they "wing it" as a last ditch measure? Or is it checkmate at that point?

If possible, I would like to see the good guys in these cases go down fighting, and try to delay proceedings and waste as much money of their well-funded opponents as possible.

> because it's a way better name (much less confusing, given that this lang doesn't have anything to do with Java anyway).

Probably if we were in the early 2000s this could have been a battle worth fighting. But considering we're in 2025 and probably more people are aware of JavaScript than Java at this point, even when you're deep in enterprise-land, I'm not sure it'd be less confusing.

Anyways, you're about two decades too late to this discussion :/

I am going to sound crazy, but, if Microsoft would free up TypeScript and every browser added native TypeScript features to JavaScript… and then we all just started calling it TypeScript. Maybe? Then you would see native ts files. Oracle will never give up JS. The funny thing is the number of people who confuse Java and JS.

EcmaScript is an awful name. It sounds too similar to eczema or ectoplasm. Ugly name.

Filename extension is .js, mime type is text/javascript, millions of people call it javascript. I don't see this changing anytime soon

Unrelated but, the JavaScript capitalization is so odd

The irony is I belive the JavaScript creator wtnted to latch to Java's popularity to called it JavaScript and now both Java and JavaScript are owned by Oracle and they want the name but not want to change is to ECMAScript, it's real official name.

That boat sailed soooo many years ago tho. Oracle has no business claiming javascript as a trademark.

Who are "people"? How would all of this start?

In terms of standard, the specs already use "ECMAScript" and don't even mention JavaScript (https://github.com/tc39/ecma262/), although TC39 website does use it frequently. I guess they could officially recommend people stop using "JavaScript", but I doubt they care.

Otherwise, the petitioner Deno here is only a small part of the ecosystem and barely controls anything (and really nobody other than TC39 controls anything, which is good). They (or anyone else) can't just shout "stop saying JavaScript!" and expect people to follow.

Not to mention JavaScript is a simple, easy to pronounce word compared to ECMAScript despite the baggage, which is probably why they chose it in the first place.

Let's say the "JavaScript" name is officially deprecated somehow. People will continue to use the name for as long as it exists.

So Deno's petition tackles these problems, addresses the root cause and appears to be legally viable. That is the "right thing to do" here. Avoiding the name does not solve the problem. It never does.

But everyone already calls it JS. I think the transition would have been so much easier if the official name started with "J".

What we use nowadays is actually ECMAScript and not JavaScript. We just call it JavaScript.

That’s not retrocompatible with all the .js files out there though.

One possibility is thus just make some vocalic derivation, which align with well known spontaneous evolution of languages like ablaut[1]. Following that, and keeping the dance connotation, jive[2] is an option. Or closer on phonetic distance to java (/ˈd͡ʒɑː.və/), there is jovial (/ˈd͡ʒəʊ.vɪ.əl/ or /ˈd͡ʒoʊ.vɪ.əl/ or /ˈd͡ʒoʊ.vəl/)[3].

Might our jovial·script enjoy our life.

[1] https://en.wikipedia.org/wiki/Indo-European_ablaut

[2] https://en.wiktionary.org/wiki/jive

[3] https://en.wiktionary.org/wiki/jovial

Our trade has a solid tradition of terrible names for programming languages. They are ALL bad. The whole Ekmuhscrip.js schism fits perfectly. Yes, this is our circus, and these are our monkeys.

No person calls it EcmaScript. They should just call it Jay Es and be done. "JavaScript" is an ugly name too.

> people should rather use EcmaScript name instead of JavaScript

Or go back to calling it “LiveScript”

It’s simply not a better name. If it was, it would’ve caught on by now.

EcmaScript just sounds icky.

I think most of us just call it JS now. And we really write mostly TS anyway.

Switch everything natively to Typescript.

EcmaScript is a terrible name, there is no way people will call JS that. How do you even pronounce it? What does it mean? What is it?

It’s unfortunate that it sounds like some sort of skin disease.

Apart from anything else, ECMAScript is a mouthful! Eeh-cee-emm-ay-script. Five syllables.

Ah yes, "European Computer Manufacturers Association"-script

> I actually think that people should rather use EcmaScript name instead of JavaScript

Take it to Twitter

I'm from the java world and it is basically java. Sure that it can do a lot more, for the most part any java developer will fell at home with the exception of lacking a robust static typing and the IDEs aren't really as good to spot syntax errors. I mean no shade to javascript developers, you just get used to a very robust building environment over there.

WebScript sounds pretty good TBH

WebScript is fine by me!

My personal favourite is "JayScript".

WebScript seems like it would really work. Especially if it was introduced at the same time as a major update to the ECMAscript spec

The context:

> Do not fall into the trap of anthropomorphising Larry Ellison. You need to think of Larry Ellison the way you think of a lawnmower. You don't anthropomorphize your lawnmower, the lawnmower just mows the lawn, you stick your hand in there and it'll chop it off, the end. You don't think 'oh, the lawnmower hates me' -- lawnmower doesn't give a shit about you, lawnmower can't hate you. Don't anthropomorphize the lawnmower. Don't fall into that trap about Oracle. — Brian Cantrill (https://youtu.be/-zRN7XLCRhc?t=33m1s)

Came here for this. Was not disappoint.

TS trademark is owned by Microsoft.

That would be a case of out of the frying pan into the fire. Not really better.

Valid JS is often not valid TS. Any nontrivial amount of JS copied into TS will generally not work without tweaks. When people say TS is a superset of JS, it's just some academic definition of syntax supersets that isn't practically true.

Non-exhaustive examples:

    let foo = 2
    foo = "foo"  // TS disallows type change
    let bar = {}
    bar.baz = 2  // TS disallows adding property

ah yes, the regressive approach

3) remove js and its derivatives from the internet, switch to lua or smth

They have linked to an example from one of the blog posts: https://www.reddit.com/r/programming/comments/14vnipl/rust_f...

I think it's mostly a marketing play by Deno.

The problem is FUD. Some guy at a company gets told he has to wait for legal to approve some open source project or initiative that happens to use JS in the name, because his boss heard there’s a trademark issue, and the enthusiasm fades and the idea gets sidelined. There’s probably been thousands of tiny little instances of FUD like that, which we’d never hear about, and which have led to good things not happening.

One clear instance of FUD we do know about is the spec itself is not titled with the name of the language it specifies, which is then its own source of confusion for newcomers trying to learn the web platform, and makes it harder for old timers to explain things, and is generally annoying. Complexity. Confusion. Doubt. Inaction.

Removing legal FUD from the world is a good cause. I don’t mind if it also works as a good marketing play for Deno.

The petition was partially dismissed and Deno was given leave to amend their petition (but no amended petition has yet been filed, that I can see). There was some initial worthless discovery and now a protective order has been granted allowing Oracle to file information they don't want out in public (e.g. trade secrets). That was at the beginning of November 2025 and the case is ongoing.

https://ttabvue.uspto.gov/ttabvue/v?pno=92086835&pty=CAN&eno...

I think it is posted because of the update on Dec 2nd 2025 where Oracle responded with a request to dismiss.

Edit: I read that date shockingly wrong, their response was February of 2025 so this is pretty old.

Very quaint that they think they can make some legal argument against Oracle

Well, it's not up to Oracle. It is up to the US government (USPTO).

Which you could make a strong case for also not being a democracy and rather a lawnmower... But I digress.

They already did, a year ago:

https://deno.com/blog/deno-v-oracle

This post is more than a year old.

Exactly. When was the last time you heard HTML called "HyperText Markup Language"? When was the last time you heard CSS called "Cascading Style Sheets"? We should stop saying "JavaScript" and fully switch to JS.

YavaScript

Well, look at how Microsoft tried to hijack the JVM back in the 90s. I think the big fear is that somebody creates a "mostly compatible" product, that in fact isn't 100% compatible, and tries to market it as the same thing as the original, which in fact isn't the original.

Based on the link someone put in a different comment about them suing Deno, at least in Oracle's case the answer is presumably "being able to sue people and get money from them".

Even if that weren't the case though, I think part of the problem is that even if the trademarks literally never brings any value, it also potentially costs them nothing to retain them (unless someone tries to get it invalidated, at which point there's some cost to trying to defend it). Arguably the cost to establish in the trademark in the first place is also low enough that companies at that scale don't have much incentive notto establish them in the first piece; they already have lawyers and trademarking things isn't really out of the ordinary for them, so the marginal cost of having them file one more isn't very high.

It's worth considering whether the point you make about there not being much of a realistic concern around someone else attempting to copy the name is something that would be obvious to non-developers. Sometimes what might be obvious to a developer might not be obvious to a lawyer, and at the end of the day, the legal team is probably in charge of deciding things like this at these companies, so in the absence of pressure from someone who understands this point enough influence to make it happen (like maybe a C-level exec), it might not matter that the concern is realistic if it's theoretically plausible.

I guess that's the main issue. A lot of open source projects fell into this pit, when they put a related trademark into their name. Naming something OpenFastFirefox or iPhoneScript would cause a lot of trademark issues.

> Thirty years ago this would have required a desktop app and probably a record label deal.

And that would have been just fine.

What would that be?

Lua

Amen to that (will never happen though).

They thought of that and called the spec ECMAScript instead.

Like Dart and the Dartium browser

:o has anyone thought of this before? /s

Whether the JS community can organize to address those issues may in fact depend on the real and social capital that this seemingly auxiliary campaign has the opportunity to effect.

> Go, which is harder to look up without mangling its name

don't get me started on typescript. Until recently I had to use its full name when googling something

exactly, just a whole lot of haters got nothing better to do.

>Imagine if this effort was spent on solving more pressing problems,

Are you suggesting that Ryan Dahl's contribution has been less than satisfactory so far?

Don't underestimate the benefits of the power of bullying. Just look at the current US administration.

Because every time someone proposes it the immediate follow up is “which language?”, which everyone argues about until they’re exhausted and give up.

Which is why WebAssembly is the right answer.

I'm a huge fan of statically typed languages, but shipping statically typed code as an artifact seems like it loses all of the advantages.

What does it matter to the user whether they get a runtime or a "compile time" error in their invisible devtools console? To them, the page simply doesn't work.

Static languages make sense when compilation happens at dev-time, where the actual devs can respond to the diagnostics. So it's far better to develop in a statically typed language, compile it ahead of time and ship that to the user. Which is exactly what people do now with wasm.

Rust runs quite well today via WebAssembly. Continuing to improve interop between Web API / WASM / language runtimes seems like a good route that allows people to use the language they prefer against shared Web APIs.

Dart is a statically typed high performance language intended for the browser. For a short time you could run Dart in the Chrome browser - as a JavaScript alternative. They then decided it was better to transpile to JS... JavaScript is already strictly typed and safe, but the dynamic nature makes it difficult to optimize. So I think it's a weird decision to transpile to JS.

Because there is no consensus on what that should be, and vendors have so little motivation they just outsource most browser development to Google.

Developers always on their high horse, if after years of trying different options it didnt happen, maybe that means it's not what the world wants or need?

> Why in 2025 can we not ship a statically typed high performance language for browsers?

Which one?

OK we'll change it then. Hello, CliffRichardScript