25 ms·

Yes, you did. And it's a good design. You even did the GC question justice. My concern is more in the spirit of "Your scientists were so preoccupied with wheth

Yes, you did. And it's a good design. You even did the GC question justice. My concern is more in the spirit of "Your scientists were so preoccupied with whether or not they could, they didn't stop to think if they should.". Of course JS being single threaded wasn't a hard constraint. Lift it, and people like you can use the parallelism to do great things. The problem is that most developers are not you. Shared memory concurrency is foot-artillery (especially if truly parallel). Adding threads to the JS ecosystem is selling W48 nuclear artillery shells at the toy store. JS's ostensible limitation to a single thread forced users to do what they should have been doing anyway: message-passing, thread-per-core architecture, and actor-ish stuff. People who don't know better reach for shared memory concurrency because it seems like a good way to solve problems, but it's actually a dangerous attractor in idea space. JS engine limitations were accidentally keeping people away from it. Now that they can hear the siren's song of a mutex, they'll run around on the hard problems of parallel programming. Now, that's not a reason to avoid shipping such a system. It's just not something I would have chosen to implement for the masses.

hexasquid 4mo ago
This is consistent with the endless contempt people have had for JavaScript and those that use it.
- pizlonator 4mo ago
  Yeah I don’t get that either It’s a super successful language
  - Waterluvian 4mo ago
    I think with ES6 and newer things really cleaned up and now we’re left with avoidable ugly parts, of which every language has. Before when you didn’t even have strict equality checking, for example, you were forced to know about implicit type casting. Getting on the same page with modules also helped a lot. Typescript directly in Node is great. Look mom, no build system!! I’m just hoping one day browsers will accept TS the same way.
    - cyberax 4mo ago
      You still need a compiler for TSX, though. There's also a tiny bit of non-erasable Typescript (enums).
      - Waterluvian 4mo ago
        There’s a mode to pretend those features don’t exist and not allow them. Meaning it gets far simpler to just type elide rather than any actual compilation effort. I think this idea is getting more popular and it would be kinda nice if TS committed to not adding any more features like that.
        MrJohz 4mo ago
        TS has committed to not adding any more features like that. Features only get added when they reach a certain threshold on the TC39 standardisation track.
    - ricardobeat 4mo ago
      When did JS not have strict equality?
      - jazzypants 4mo ago
        1995-1999. Strict equality was introduced in ES3 which was first released in December 1999. https://www-archive.mozilla.org/js/language/e262-3.pdf https://www-archive.mozilla.org/js/language/e262-3.pdf
        ricardobeat 4mo ago
        The parent said 'before ES6', I suspect they were not thinking of 1999.
    - thedelanyo 4mo ago
      > I’m just hoping one day browsers will accept TS the same way. Wouldn't that be a direct kill of JS?
  - hyperhello 4mo ago
    It's successful because it's been kept away from the kind of programmers who think the time spent to endlessly specify everything four times is nothing compared to the sadness of losing a byte or a cycle. These are the descendants of people who hundreds of years ago would have insisted that real work is in Latin. C++26 is available for them, or Node/React with hundreds of dependencies if they want JavaScript, or they can even compile and run whole operating systems into WASM now, or anything else. Just let JavaScript be the domain of people who do other things for fun.
pizlonator 4mo ago
I don’t understand the thread phobia Comparing it to nukes is a bit extreme, don’t you think?
- kikimora 4mo ago
  I don’t think it is extreme. Imagine this is added to WebKit. Now I have a new question to answer - can I use library X across multiple threads? How do I know it does not have a little cache inside which breaks if I call it from multiple threads? Another issue is lack of memory model (sorry if ai missed it) which means memory updates will be published to threads differently on different architectures. And then an obvious problem of mixing async with locks - never ends good.
- quotemstr 4mo ago
  > Comparing it to nukes is a bit extreme, don’t you think? Does Herb Sutter strike you as extreme? https://herbsutter.com/2013/02/11/atomic-weapons-the-c-memory-model-and-modern-hardware/ https://herbsutter.com/2013/02/11/atomic-weapons-the-c-memor...
curtisblaine 4mo ago
Worth noting that javascript has had workers, shared memory and atomics for years and that you can use them today. Look at this guy writing a lockless allocator: https://greenvitriol.com/posts/lockless-allocator https://greenvitriol.com/posts/lockless-allocator The only difference in this PR is that it makes threads light (workers are fat because they carry a whole v8 instance with them) and it makes shared memory default with light threads (now you need to pass a shared array buffer first). Javascript is probably not your first language, I get it, but it has had "the siren song of a mutex" for years now. What really surprises me and I can't explain is why you went and took time to express such strong opinions on something that you obviously don't even know or use that well.
- quotemstr 4mo ago
  There's a difference between 1) having a shared-everything heap and 2) having a separate, obscure facility (which practically nobody uses) for building a special data-only portal to shared memory. #1 normalizes the mutex. #2 doesn't. I have strong opinions on the superiority of #2 to #1 because I've dealt with endless bugs caused by people who think they can handle #1 and can't. Reasoning about complex memory order rules and thread interleaving is extremely difficult for both humans and AIs. That's why we abstract over raw threads with actors, STM, fork/join facilities, and (my favorite) structured cooperative concurrency. It's not a knock against anyone's skill to point out that EVERYONE gets concurrency wrong and we need guardrails on top. That said, let's be honest: the JS ecosystem has a culture that'll make #1 worse than it usually is. There's a certain combination of insularity and lack of restraint I've observed in the JavaScript world that prompts its members to re-learn the hard way all the painful lessons in software history.
  - curtisblaine 4mo ago
    #2 is very much used in high performance web apps, whenever you can't afford the overhead of message passing. I agree it's a specialized tool and normally you don't need it, but it's a misrepresentation to say "it's an obscure feature that almost nobody uses". If you do webGL, for example, you almost invariably end up using shared array buffers.
- 4mo ago

hexasquid 4mo ago

This is consistent with the endless contempt people have had for JavaScript and those that use it.

pizlonator 4mo ago
Yeah I don’t get that either It’s a super successful language
- Waterluvian 4mo ago
  I think with ES6 and newer things really cleaned up and now we’re left with avoidable ugly parts, of which every language has. Before when you didn’t even have strict equality checking, for example, you were forced to know about implicit type casting. Getting on the same page with modules also helped a lot. Typescript directly in Node is great. Look mom, no build system!! I’m just hoping one day browsers will accept TS the same way.
  - cyberax 4mo ago
    You still need a compiler for TSX, though. There's also a tiny bit of non-erasable Typescript (enums).
    - Waterluvian 4mo ago
      There’s a mode to pretend those features don’t exist and not allow them. Meaning it gets far simpler to just type elide rather than any actual compilation effort. I think this idea is getting more popular and it would be kinda nice if TS committed to not adding any more features like that.
      - MrJohz 4mo ago
        TS has committed to not adding any more features like that. Features only get added when they reach a certain threshold on the TC39 standardisation track.
  - ricardobeat 4mo ago
    When did JS not have strict equality?
    - jazzypants 4mo ago
      1995-1999. Strict equality was introduced in ES3 which was first released in December 1999. https://www-archive.mozilla.org/js/language/e262-3.pdf https://www-archive.mozilla.org/js/language/e262-3.pdf
      - ricardobeat 4mo ago
        The parent said 'before ES6', I suspect they were not thinking of 1999.
  - thedelanyo 4mo ago
    > I’m just hoping one day browsers will accept TS the same way. Wouldn't that be a direct kill of JS?
- hyperhello 4mo ago
  It's successful because it's been kept away from the kind of programmers who think the time spent to endlessly specify everything four times is nothing compared to the sadness of losing a byte or a cycle. These are the descendants of people who hundreds of years ago would have insisted that real work is in Latin. C++26 is available for them, or Node/React with hundreds of dependencies if they want JavaScript, or they can even compile and run whole operating systems into WASM now, or anything else. Just let JavaScript be the domain of people who do other things for fun.

pizlonator 4mo ago

I don’t understand the thread phobia Comparing it to nukes is a bit extreme, don’t you think?

kikimora 4mo ago
I don’t think it is extreme. Imagine this is added to WebKit. Now I have a new question to answer - can I use library X across multiple threads? How do I know it does not have a little cache inside which breaks if I call it from multiple threads? Another issue is lack of memory model (sorry if ai missed it) which means memory updates will be published to threads differently on different architectures. And then an obvious problem of mixing async with locks - never ends good.
quotemstr 4mo ago
> Comparing it to nukes is a bit extreme, don’t you think? Does Herb Sutter strike you as extreme? https://herbsutter.com/2013/02/11/atomic-weapons-the-c-memory-model-and-modern-hardware/ https://herbsutter.com/2013/02/11/atomic-weapons-the-c-memor...

curtisblaine 4mo ago

Worth noting that javascript has had workers, shared memory and atomics for years and that you can use them today. Look at this guy writing a lockless allocator: https://greenvitriol.com/posts/lockless-allocator https://greenvitriol.com/posts/lockless-allocator The only difference in this PR is that it makes threads light (workers are fat because they carry a whole v8 instance with them) and it makes shared memory default with light threads (now you need to pass a shared array buffer first). Javascript is probably not your first language, I get it, but it has had "the siren song of a mutex" for years now. What really surprises me and I can't explain is why you went and took time to express such strong opinions on something that you obviously don't even know or use that well.

quotemstr 4mo ago
There's a difference between 1) having a shared-everything heap and 2) having a separate, obscure facility (which practically nobody uses) for building a special data-only portal to shared memory. #1 normalizes the mutex. #2 doesn't. I have strong opinions on the superiority of #2 to #1 because I've dealt with endless bugs caused by people who think they can handle #1 and can't. Reasoning about complex memory order rules and thread interleaving is extremely difficult for both humans and AIs. That's why we abstract over raw threads with actors, STM, fork/join facilities, and (my favorite) structured cooperative concurrency. It's not a knock against anyone's skill to point out that EVERYONE gets concurrency wrong and we need guardrails on top. That said, let's be honest: the JS ecosystem has a culture that'll make #1 worse than it usually is. There's a certain combination of insularity and lack of restraint I've observed in the JavaScript world that prompts its members to re-learn the hard way all the painful lessons in software history.
- curtisblaine 4mo ago
  #2 is very much used in high performance web apps, whenever you can't afford the overhead of message passing. I agree it's a specialized tool and normally you don't need it, but it's a misrepresentation to say "it's an obscure feature that almost nobody uses". If you do webGL, for example, you almost invariably end up using shared array buffers.
4mo ago