Hacker News Reader

Comment by thedebuglife | Hacker News Reader

I believe ECMAScript is the specification of which JavaScript is an implementation.

I always have had problem with this definition... what do you mean by "implementation"? in my head "implementations" are "programs".

Like... "C" is a specification, "gcc" is an implementation. "Python" is a specification, "CPython", "PyPy", ... are implementations. "ECMAScript" is a specification, "webkit", "spidermonkey", ... are implementations.

"JavaScript" is a (trademarked) specification, and also "ECMAScript" and "JavaScript" are "very very similar" (wink wink)

> "Python" is a specification, "CPython", "PyPy"

Is Python-the-language fully specified now? Of course there are now a lot of PEPs, but I seem to recall (way back then, even before PEP3000 was a thing) that the Python "spec" was largely the "CPython" implementation (incl. bugs and all), and "CPython" was not actually a real name but emerged from a need to distinguish the original Python implementation from "Python-the-language" as well as alternative implementations such as PyPy, JPython/Jython, IronPython...

Flash's ActionScript was also ab implementation of ECMAScript IIRC

That's one thing I never understood. For me they seemed like completely different languages. Now looking at history in Wikipedia, it seems that old version of ActionScript was based on old version of ECMAScript specification. And ActionScript 2 which introduced strict typing and classes (that look nothing like JavaScript) was partially based on ECMAScript 4(which was abandoned as being too different from previous ECMAScript 3). Latest version of ECMAScript is 13. So at this point it seems like latest versions of JavaScript and ActionScript(3) have as much common as D and Rust. They shared early history but afterwards diverged quite a bit.

How do you see them as diverged? I've spent a lot of time thinking about AS, ES4, and working with modern ES, and if anything I see them as having converged. The largest feature of ES4 that ES3 did not have was classes, which were added in ES6. The second largest feature was optional static typing. Optional static typing is nearly a defacto part of the language (from a community/ecosystem point of view) with the popularity of Microsoft's TypeScript superset.

With diverging I meant more about development process not the feature set.

They might have same features from the perspective of checklist. But path they developed and obtained those features is different, the syntax is different and there are probably also some subtle (if not big) differences in semantics. The similarities in feature list isn't result of 2 language "implementations" getting closer to shared specification, but at least partially looking at what features other programming languages have and then sooner or later developing their own version of those language features. I haven't read the ES4 specification or development discussions for ES6 so I can't tell whether differences are caused by ES6 classes being developed from scratch ignoring how they where described in ES4 or whether classes in actionscript were only very loosely based on the way ES4 described them. Either way the development of two languages at some point forked and further developed somewhat independently.

From what I understand graph is something like this: ES2 -> ES3 ES3 -> ES5 ES3 -> ES4 ES3 -> AS1 ES4 -> AS2 AS1 -> AS2 AS2 -> AS3 ES4 -> AS3 ES5 -> ES6

D20 is an open standard for a certain genre of tabletop role playing games, of which Dungeons and Dragons™ is an implementation. But D&D itself is an abstract concept, with two implementations: the open-game-licensed online “D20 SRD”, and the proprietary set of WotC-published core books.

It's not. ECMAScript is just an awkward name they used because people couldn't agree to use "JavaScript". They're really the same thing.

Implementations of ECMAScript/JavaScript are things like V8 and Spidermonkey.

And people couldn't agree to use JavaScript because the term was trademarked.

Reply on news.ycombinator.com