https://www.ietf.org/rfcdiff?url1=draft-ietf-tcpm-rfc793bis-...
sure, maybe IETF uses their homegrown version, but - for example - TC39 uses GitHub https://github.com/tc39/ (here are the proposals for JS https://github.com/tc39/proposals ), whatWG also uses GH https://github.com/whatwg/html
This may speed up a bit if the Built-In Modules proposal [2] passes, which would add a deliberate `import` URL for standard modules which would give a cleaner expansion point for new standard libraries over adding more global variables or further expanding the base prototypes (Object.prototype, Array.prototype, etc) in ways that increasingly likely have backwards compatibility issues.
TC-39 works all of their proposals in the open on Github [3] and it can be a fascinating process to watch if you are interested in the language's future direction.
[0] https://tc39.es/
[1] https://developers.google.com/web/updates/2018/03/smooshgate
> How should exceptions be managed? [...] Has there been a debate about best practice? Where can I find it?
I suggest you handle the errors you can and otherwise let it crash.[1][2] Debates in NodeJS-land have steered towards more monadic/Result-like structures and working synchronous-looking try/catch onto async/await. NodeJS and its various components are open source, you'll have a lot of luck looking around on GH for issues & PRs related to a feature -- same for the language, ECMAScript[3] officially.[4]
Since you mentioned Clojure, have you looked at ClojureScript?[5] That may be a good entry to JS authors & articles you'd enjoy.
> I have the impression that NodeJS is a bit more magical than the JVM [...] Is that correct? Where are good resources on this subject?
As other replies have mentioned, you're really talking about V8[6] for the "JSVM" executing that code. A thing I've seen throw some people for a loop is how minimalist the specification actually is.[7] The magic in NodeJS is certainly from V8 and the rate of optimizations there but also libuv,[8] what actually powers the infamous event loop.
Hope that helps!
[0]: https://github.com/EnterpriseQualityCoding/FizzBuzzEnterpris...
[1]: Borrowing from Erlang, see Making reliable distributed systems in the presence of software errors, Joe Armstrong, page 104 "Error Handling Philosophy" https://erlang.org/download/armstrong_thesis_2003.pdf
[2]: _Most_ kinds of errors will cause the process to crash if you don't handle them, https://nodejs.org/dist/latest-v16.x/docs/api/errors.html . Promise rejections don't (yet) though it will log a warning, and callback-based APIs will always consist of an [error, data] tuple for the arguments
[3]: https://github.com/tc39/proposals
[4]: Because Oracle owns the trademark, of course: http://tarr.uspto.gov/servlet/tarr?regser=serial&entry=75026...
[5]: https://clojurescript.org/
[6]: https://v8.dev/docs
[7]: "ECMAScript as defined here is not intended to be computationally self-sufficient; indeed, there are no provisions in this specification for input of external data or output of computed results. Instead, it is expected that the computational environment of an ECMAScript program will provide not only the objects and other facilities described in this specification but also certain environment-specific objects, whose description and behaviour are beyond the scope of this specification except to indicate that they may provide certain properties that can be accessed and certain functions that can be called from an ECMAScript program." https://tc39.es/ecma262/#sec-overview
Why would WASM mean slowing down JS changes?
For reference on proposal status and details, see https://github.com/tc39/proposals .
Unfortunately, the same can't necessarily be said for the other bodies. WHATWG for instance may put things online and discuss things in the open, but unless you're an editor or one of the blessed few I get the distinct feeling that your contributions are more of a nuisance than anything else, making the whole thing look like process theatre to me. I may well be wrong, but that's my impression. (Note: I haven't been personally affected by this, it's just my impression from reading the discussion on various WHATWG specs.)
[1]: https://github.com/tc39/proposals
Given the history of discussion around this, this seems surprisingly low key and reasonable. (The System.loader stuff was gnarly!)
But what does this mean for nodejs? I don't see how this rhymes with current proposals re `require.import` and the likes. If the above proposal wins out it becomes a language spec, so presumably will also become available in nodejs, and if they go ahead with the ideas mentioned in another comment here, we'd have both `import(specifier)` and `require.import(specifier)` – seems pretty confusing, but maybe I'm getting it all wrong?
It’s not exactly surprising. ES6 came out almost 6 years after ES5, so there was quite a few changes then. The yearly release cycle was always going to mean fewer features being standardised each release.
While I do follow from a distance some of the work TC39 does, I can only assume that most people involved have realised that having an orderly process for feature proposals - and not trying to rush heaps of features into a single release - is a much better way to do things.
> With the language moving this slow compared to faster releasing languages like Python, Elixir, and Go
Python, Elixir and Go have the advantage that they have one main/reference implementation and can break backwards compatibility whenever they want (although that hasn’t gone brilliantly for Python) by just incrementing a version number. ECMAScript runtimes have to be able to run programs that were written almost two decades ago - backwards compatibility can’t be broken - and you have several major implementations (V8, Spidermonkey, etc.) to deal with.
The tail call feature from ES6 is already being revisited because it caused problems [0].
> I wonder if Node.js will start to see a decline in hype since the language hasn't improved much in the last 2 years.
Tools like Babel mean that people who really want to use new or experimental language features can do so. There are dozens of language features in the proposals pipeline [1] and many (if not a majority) can be used via a compiler like Babel or via a polyfill.
Node.js also has the advantages of having it’s own 'standard library’ and an enormous package ecosystem to use. I think it will be fine.
[0] https://github.com/tc39/proposal-ptc-syntax [1] https://github.com/tc39/proposals
[0] http://www.ecma-international.org/ecma-262/7.0/ [1] https://github.com/tc39/proposals [2] http://www.2ality.com/2016/02/ecmascript-2017.html