[DeepDive] JavaScript/ECMAScript, V8, Node, WebAssembly, embedded JavaScript, etc

[0xdevalias]

V8

V8 implements ECMAScript and WebAssembly, and runs on Windows 7 or later, macOS 10.12+, and Linux systems that use x64, IA-32, ARM, or MIPS processors. V8 can run standalone, or can be embedded into any C++ application.

V8 compiles and executes JavaScript source code, handles memory allocation for objects, and garbage collects objects it no longer needs. V8’s stop-the-world, generational, accurate garbage collector is one of the keys to V8’s performance.

• https://v8.dev/
  • https://v8.dev/blog
  • https://v8.dev/docs
    • https://v8.dev/docs/embed
    • https://v8.dev/docs/d8

      • d8 is V8’s own developer shell. d8 is useful for running some JavaScript locally or debugging changes you have made to V8.

    • https://v8.dev/docs/inspector

      • V8 provides extensive debugging functionality to both users and embedders. Users will usually interact with the V8 debugger through the Chrome DevTools interface. Embedders (including DevTools) need to rely directly on the Inspector Protocol.

  • https://v8.dev/features

JavaScript / ECMAScript / TC39

• https://tc39.es/

  • Ecma International's TC39 is a group of JavaScript developers, implementers, academics, and more, collaborating with the community to maintain and evolve the definition of JavaScript.

  • https://tc39.es/ecma262/

    • ECMAScript 2020 Language Specification

Profiling JavaScript

• https://mrale.ph/blog/2018/02/03/maybe-you-dont-need-rust-to-speed-up-your-js.html#profiling-the-pure-javascript-version
  • https://mrale.ph/blog/2018/02/03/maybe-you-dont-need-rust-to-speed-up-your-js.html#profiler-is-your-friend
• See also
  • [DeepDive] Website profiling and performance tuning #44

WebAssembly

• https://webassembly.org/
• https://github.com/WebAssembly
  • https://github.com/WebAssembly/binaryen

    • Compiler infrastructure and toolchain library for WebAssembly

• https://developer.mozilla.org/en-US/docs/WebAssembly

AssemblyScript

• https://www.assemblyscript.org/
  • https://www.assemblyscript.org/basics.html
• https://github.com/AssemblyScript/assemblyscript

  • AssemblyScript compiles a strict variant of TypeScript (basically JavaScript with types) to WebAssembly using Binaryen. It generates lean and mean WebAssembly modules while being just an npm install away.

• Articles
  • https://blog.scottlogic.com/2019/06/14/add-webassembly-to-react-app.html
    • https://github.com/DevAndyLee/webassembly-in-react

See Also

• Rust WebAssembly: [DeepDive] Rust (rustup, rustfmt, cargo), Rust embedded/AVR/TockOS/WebAssembly (wasm), etc #80

Babel

• https://babeljs.io/
  • https://babeljs.io/en/repl

Chrome

• https://superuser.com/questions/157484/start-google-chrome-on-mac-with-command-line-switches
  • open -n -a "Google Chrome" --args --user-data-dir=/Users/devalias/Desktop/chrome-foo
• https://stackoverflow.com/questions/12863887/is-there-a-good-reference-for-v8-command-line-arguments-when-using-node-js/26850433#26850433
  • https://github.com/v8/v8/blob/master/src/flags/flag-definitions.h

  • These should also work in chrome via --js-flags

JavaScript on Java (JVM, JDK, GraalVM, etc)

(Originally written as a comment on JetBrains/js-graphql-intellij-plugin#296 (comment)))

I decided to do a little googling to see what the state of JavaScript in JVM is these days.

Rhino is the original JavaScript engine for JVM that I remember hearing about, but it seems it is still maintained, with a stable release in January 2020

Between Java 8 and 11, Nashorn was the JavaScript engine shipped with the JDK, but it is deprecated since Java 11, with GraalVM as the suggested replacement.

GraalVM supports many different programming languages on top of the JVM, of which JavaScript is one of them:

• GraalVM JavaScript: ECMAScript 2019 compliant JavaScript runtime, with support for Node.js

In the JavaScript & Node.js section of the docs on the main GraalVM website it claims even more updated compatibility:

• GraalVM is ECMAScript 2020 compliant and fully compatible with a diverse range of active Node.js (npm) modules. More than 100,000 npm packages are regularly tested and are compatible with GraalVM, including modules like express, react, async, request, browserify, grunt, mocha, and underscore. The latest release of GraalVM is based on Node.js version 12.15.0.

The main docs page talks about the various methods of being able to use GrallVM features, of which the most relevant here is as a library (jar files) rather than as a runtime:

• Libraries (jar files)

  • GraalVM Compiler – a dynamic just-in-time (JIT) compiler that improves efficiency and speed of applications through unique approaches to code analysis and optimization.

  • JavaScript interpreter – an ECMAScript compliant JavaScript engine.

While you can apparently get a GraalVM-based replacement of the standard Java JDK, it's also possible to use it as a jar dependency on the standard JDK:

• https://medium.com/graalvm/graalvms-javascript-engine-on-jdk11-with-high-performance-3e79f968a819

  • GraalVM’s JavaScript engine is a Java application that works on any Java 8+ implementation. The JavaScript execution is built around an abstract syntax tree (AST) interpreter that can be executed like any other Java application. Every Java virtual machine will optimize it to some extent, but the JavaScript execution will remain interpreted, thus slow.

The GraalVM GraalJS repo is on GitHub, and they also have documentation on how to use it with a standard (non-GraalVM) JDK as part of a maven project, or just by referencing the jar files.

• https://github.com/graalvm/graaljs
  • https://github.com/graalvm/graaljs/blob/master/docs/user/RunOnJDK.md

---

There are also various methods for 'calling out' to the hosting system's node, if a non-fully-native-JVM solution is considered acceptable; eg:

• https://github.com/eclipsesource/J2V8

  • J2V8 is a set of Java bindings for V8. J2V8 focuses on performance and tight integration with V8.

Another potential method could be to run node to parse the JS config files, and then export a more Java friendly 'intermediary' config file, that this lib could then read from.

Unsorted

• https://stackoverflow.com/questions/12863887/is-there-a-good-reference-for-v8-command-line-arguments-when-using-node-js/12864353#12864353
  • node --v8-options