Strange, I was able to sign up from my .family email

Turns out the problem was on my end. Pihole blocked it.

I really wish that Kestrel was available as a standalone library. Kind of like Jetty on the JVM.

Does that mean you are planning a specific editor for it?

I was thinking more of some light weight tools that convert between the two representations and which can be hooked into existing editors.

Except that Google Drive just doesn't seem to work in Firefox.

It works for me seamlessly since the beginning. In fact, I've encountered no major app which weren't working in FF only in Chrome. Since ~2000.

Ada came out of the DOD so assuming it's an all-caps acronym makes a lot of sense. ;)

Jean Ichbiah might have bristled at such an assertion. (He called his language "Green".) But, renamed, Ada was heavily promoted by the DoD.

> I think that makes it the second (production-ready) language to have a primarily-structural type system

I assume we are talking about a static type system here? Many common "scripting" languages are structurally typed - what Python calls duck typing.

It is interesting to me that I read people criticizing Microsoft for their open sourcing code as doing it for marketing reasons---which seems accurate---but not criticizing Google or Apple or whoever else when they open source code.

There are plenty of people on this very forum regularly criticizing Google and Apple's open source efforts...

Apple doesn't release code under Free licenses for marketing purposes: I'd be surprised if anyone in the marketing department of Apple even realized that they were doing so.

Apple releases code under free licenses because they are required to and do exactly that minimum required.

That's not entirely true. launchd was released under a free license, and it was one of the most interesting innovations in software in a long while, for example.

So now copying what Sun, Aix, Tru64 and HP-UX already did is an innovation, I guess it goes with the muster of many Apple "innovations".

You're completely wrong in Sun's case, SMF is nothing like launchd.

It looks quite similar to me in concept.

What's the problem with the module system and functors?

Would you be willing to explain why explicit asynchrony is superior to implicit cooperative threading? Rather than simply engaging in more namecalling.

Mutable state is always a problem, but it's a bigger problem when there are less constraints on when it can mutate. But Mark's dissertation explains this and some related issues a lot better.

Also, I don't think I did any name-calling?

>Mutable state is always a problem, but it's a bigger problem when there are less constraints on when it can mutate.

A very long-time project I’m idly working on with my life-long colleague addresses this issue. It is real, as are all race conditions and threading issues. But it doesn’t have to be solved at the language level.

One of solutions we proposed to ourselves was that an object storage should manage shared access conflicts. You may see it in Redux and other stores that serve a “frontend framework backend layer” duty today. Even with explicit async, you will always have some high-level races that must be dealt with. And these do exactly that.

The basic idea is that local state is strictly local and not a subject of parallel mutation, and shared state is shared via internally locking/serializing controller who knows better how to mutate, merge or throw. It doesn’t push the problem down the code or execution model, since it’s what’s it for.

Sounds like you'd benefit from reading Mark's dissertation. Not that he solved the problem but he did try a lot of candidate approaches, discuss them with others, and comprehensively review the existing literature; and he reports on several years of trying things similar to what you're thinking of.

That isn't a "normative" statement about better, but a "positive" statement about a trade-off of expressive power versus rigor. A bit of mathematical intuition suggests that formally asynchronous approaches tend to be less powerful and hence more rigorous. But if your spec is still in the prototype phase, taking on a lot of expressiveness and permission with respect to your domain model is desirable because it gets you an end-to-end solution sooner.

What is good is not "on time" or "robust", but "on time and robust". Necessary and sufficients.

Yeah, that's why I said “produces more reliable software” rather than “is better”. In this case what you're buying with the flakiness is more a matter of performance than of expressiveness, but everything is intertwingled.

> and not so good at floating point computations

What does this mean? I was under the impression the OCaml compiler did a decent number of floating point specific optimizations, like unboxed arrays and what not.

Surprised me as well janestreet are a well known user of ocaml and I can't imagine they don't use a lot of floats.

I guess it is the typical complain about using separate operators for ints and floats.

It never bothered me in Caml Light, let alone when Objective Caml was introduced.

You can write floating point operators in several different ways. You can write with the normal floating point operators

    x *. y +. z

or, since `Float.(+) = (+.)`, `Float.() = (.)`, etc,

    let open Float in
    x * y + z

or simply

    Float.(x * y + z)

That is pretty neat. Does it mean that one could do something similar for vectors and quaternions?

    let open Quaternion in
    x * y + x

Yep. You could write

    module Quaternion = struct
      let (+) =
        ...
    
      let ( * ) =
        ...
    end

then

    let open Quaternion in

imports the contents of Quaternion into local scope, so you can write

    x * y + z

Yes.

Ah, maybe, perhaps I am in the minority that liked the different operators for ints and floats. :D

Symbols (variants with our without parameters) and integers are unboxed, while floats are not (but in a few specific cases such as arrays of floats, and iiuc that's an inelegant special case on its way out, as it prevents other optimisations).