Question. Possibly I'm not searching the right terms, but when async/await was added to ECMAScript, why was threading never pulled into the core language away from Web Workers? (As others I've done the blob thing for years with workers when doing heavily threaded things). I kind of expected that one would be able to just call an async function and have it execute on another thread by now with intuitive shared state, but that was never proposed. Why not?

can someone verify my assessment that https://github.com/mishoo/UglifyJS/issues/5370 represents a deviation of V8 from other major implementations in FunctionDeclarationInstantiation with respect to non-simple parameter lists when VarDeclaredNames includes "arguments"?

$ eshost -se '[].concat(...["function arguments(){}", "var arguments"].map(occluding => ["()", "(..._)", "(_=0)"].map(params => { const r="return typeof arguments; ", f=Function(params.slice(1,-1), r+occluding); return `${f().padEnd(9)} // function${params}{${r+occluding}}`; }))).join("\n")'
#### ChakraCore, engine262, JavaScriptCore, Moddable XS, SpiderMonkey
function  // function(){return typeof arguments; function arguments(){}}
function  // function(..._){return typeof arguments; function arguments(){}}
function  // function(_=0){return typeof arguments; function arguments(){}}
object    // function(){return typeof arguments; var arguments}
object    // function(..._){return typeof arguments; var arguments}
object    // function(_=0){return typeof arguments; var arguments}

#### V8
function  // function(){return typeof arguments; function arguments(){}}
function  // function(..._){return typeof arguments; function arguments(){}}
function  // function(_=0){return typeof arguments; function arguments(){}}
object    // function(){return typeof arguments; var arguments}
undefined // function(..._){return typeof arguments; var arguments}
undefined // function(_=0){return typeof arguments; var arguments}

and shared-memory parallelism isn't just a sharp edge, it's an entire box of rusty razor blades

Jack Works: as with SABs it's something which will be useful to build safe-to-use libraries on top of, but not something I'd expect users to touch in everyday life

I completely get that. I'm migrating over to WebGPU for my current toy projects. Most of my applications were more "spin up 8 threads because I can't use the GPU to compute this" situation. Still for simple projects for demos it would be nice to write a few lines of code to say run a pathfinding algorithm on multiple threads. Though the module block fits those kind of applications cleanly where I'm not sharing state between threads.

"being single-threaded" is a feature, not a bug

you'd still have to postMessage them, and you can do that with a plain object

We could simultaneously introduce manual memory management as a viable alternative to GC in ECMAScript since users will appreciate the freedom. 🚎

my impression is that the expensiveness of the clone is rarely a limiting factor, but it might be for some projects

if something is going to encourage wider usage of multi-threaded programming in JS, that sounds like a huge detriment to the language

doesn't seem to have been ruined

which is the only multithreading in some languages

Well I'm just saying there are situations where a JS programmer runs into an issue and the real solution of just calling a thread and passing work over is much more complicated than it should be.

We can compare this to a early 2000s C++ programmer runs into an issue where they are waiting for a long operation (like disk read) and want to do something in the meantime. The default solution of threads and passing work over is a lot more complicated to wrap around than most other C++ code, especially with the special and hard-to-intuit considerations of thread-safeness.

sure, but structured cloning is its own pile of problems :-)

That reminds me of someone's finance app I saw they made for a company. Kind of lagged. Was doing stuff with hundreds of thousands of records client-side. This was before web workers (and Power BI I think). Fascinating what people try to do in JS single page applications. Granted computers are faster now, so I don't think it's as huge of an issue.

if timing attacks are outside your thread model, though, what do you want that realms don't already give you?