sweeneyrod

Inherently parallel, sure. How often does that parallelism need to be within a single process? Not that frequently in my experience. If your threads aren't sharing state they can just be processes instead. If they are sharing state that's going to cause trouble if/when you have to scale beyond one process.

What are some situations where you need parallelism? I am not convinced there are many. I have never heard anyone say they are using .NET instead of JavaScript or Python in order to get parallelism.

They are similar to the point of being identical relative to comparisons between either and any other language you can actually get a job using (although I have a soft spot for it, SML does not fall in this category as far as I can tell from a quick search).

Capnrover seems like the best option. I have the same perception of Flynn. Dokku is nice but I don't really see how you could use it in production since it's limited to a single server (there are definitely some cases where that's all you need but I can't imagine you'd need a PaaS for most of them).

OCaml does this and it's moderately annoying.

Why wouldn't you? The size of the community is definitely a significant advantage of Rust of OCaml, but if you want to use either then you need to be comfortable with reasonably niche things. Other than that, what is there? I don't believe multicore is relevant for the vast majority of projects (for instance those where JavaScript or Python could be plausibly used).

On the flip side, OCaml has a GC and Rust does not. For any other language and most usecases, that would be a dealbreaker. It's very cool how Rust has made it less so, but I'm not convinced it is magic enough to make it insignificant.

elm-review still has a confirmation prompt though, right? You don't want to instantly remove an unused value, because you might be in the middle of writing code and about to use it.

I'm not convinced lack of side effects is the thing that lets you build tools that prompt removal of code in this way. In OCaml, if you had an unused variable like in the example you would get a compiler warning about it, and 99% of the time the compiler is right that you should delete the code. It's perfectly possible in principle that computing the value could have side effects. But in good (OCaml) code, you should very rarely have functions that have side effects and return a value other than unit. So the compiler is almost always right in practice (and you can still use side effects when you want to interact with the outside world, which is handy).

What about OCaml?

I don't think this is true. "copulation normally conducted in privacy" is a human universal http://joelvelasco.net/teaching/2890/brownlisthumanuniversal...

The porn that has existed since the dawn of time (I guess cave paintings) is qualitatively different from PornHub content. Arguably even there is even a qualitative difference from the situation even 15 years ago. Then, very few 10-year-olds would have had access to unlimited amounts of high definition hardcore porn; now probably the majority in developed countries can.

I think that 99% of programmers can get approximately all the value of monads by reading an article explaining how promises, options and lists all have this pattern in common, without any mention of monoids or endofunctors. I enjoyed the courses I did in category theory very much, but the benefit to my code has been zero.

Anthony Levandowski got a $120m bonus. What makes you think he is less of an outlier than your friends are in finance? (although FWIW unless your friends are very senior I suspect they're lying about getting million plural bonuses)

I think the artificial shape example does not adequately show how variant types/pattern matching are actually used in languages like SML/F#/Haskell. It combines two different cases.

Suppose you have a type `colour` defined as `RGB(int, int, int) | HSL(int, int, int)` and then you add representation as CIE. Then having to update each match on a colour is absolutely a feature not a bug. If you miss some out then your code will be wrong.

On the other hand, suppose you have various ways of serialization (JSON/XML/s-expressions). In this case, it would probably be nice if you could add a way to serialize to e.g. protobufs without having to jump around your codebase and all its clients fixing type errors. But in most languages of the kind we're discussing, you can do! You just have to represent the different serialization methods in some way other than a variant type. For instance, in OCaml you could just use classes and inheritance (although in practice you probably wouldn't because the language provides nicer tools).

$100/month gets you around 1TB on CloudFront doesn't it? If that's all web pages, surely you should be getting enough traffic that you can monetise somehow for the cost to be negligible.

Docker has on the order of 1 second startup time doesn't it? I don't understand why someone would willingly subject themselves to that for things being manually run multiple times per day without an extremely compelling reason.

Hey, that speed was good enough in ~1995!

Yes, out of Rust, C, C++ and Go, the slow one is going to be the one with a GC.

That's true only if the service Robinhood is providing is giving customers good deals. It seems quite plausible that instead it is actually providing entertainment in the form of "free" trading. If this is the case, the lack of explicit commission is a key feature.

All LSP clients for vim will give you that; it is whatever command calls `hover` on the language server (e.g. ALEHover for ALE or LanguageClient_textDocument_hover for LanguageClient-neovim). Obviously you should bind these to some convenient command like <leader>t.

There are significantly more devs than that (the total is also over 900, that's from 2018).

It depends what you mean by "optimizing their engineering stack". They certainly do put a lot of effort into tooling, by necessity since historically there hasn't been much available for OCaml. For an example of stuff going beyond the open source work to make OCaml usable for large projects, see https://blog.janestreet.com/putting-the-i-back-in-ide-toward...

Obviously there is a lot of infrastructure that you need at a FAANG and not at a company with a few hundred devs. But any trading company that doesn't want to pull a Knight Capital needs to make sure their software is correct and reliable (probably to a greater extent than most of a FAANG).

Right, in other words it is just a function. I don't think the categories have to be discrete just to satisfy the functor laws; even ignoring that, what would the morphisms be in principle? I don't think there is an obvious choice, at least.

I think in OCaml, "functor" basically just means "like a function but for modules". They might technically be categorical functors, but it seems quite different to the meaning in Haskell where they are plainly categorical functors (modulo Hask technically not being a category).

It is much less of a problem with OCaml than most non-OCaml users would expect. OCaml isn't Haskell; if you want for loops and similar generic imperative features you can have them!

How? What are the categories that OCaml's Hashtbl.Make maps between? What are the morphisms in those categories and how are they mapped?

I'm sure that by new you meant obscure, but OCaml has been around for 24 years.

I think a GC is almost always the most important facet. Can you name a set of languages that doesn't include Rust, some with GCs and some without, where the most different pairs are the same in terms of having a GC or not?

Bocconi probably the top one, I think some of the grandes écoles are too.

Outside the US, Oxbridge, ETHZ and NUS would be some examples, where globally prestigious means ~top 20. If you broaden to top 100 there are quite a lot of European/Australian/Canadian/Chinese ones.

As far as I know, apart from a few European business schools there are no globally prestigious private universities outside of the US.

Iran is not Russia.

What does "premier cloud language" mean?