The point is that most of the popular statically-typed languages (C, C++, Java, C#) didn’t have any type inference when python got really popular.

(Edited from “was invented” to “got really popular”… python was invented before Java or C#… Type inference in these major language didn’t happen until circa 2010 or later.)

Come on. I know what early 2000s Haskell was like. It's a slim minority view even on the Haskell reddit that it was/is production-ready for anything, and it certainly wasn't useful for networking and had a lot of other significant issues... and it would be the premiere Hindley-Milner language available at the time. It is missing a ton of things that Haskell programmers would consider basic necessities now, even in the language itself, to say nothing of libraries. Haskell slipped from research language to production-ready for at least many tasks very gradually, so it's hard to put a date on it, but that date is definitely late 200x at the earliest, and mid-2010s is probably a lot more realistic.

ML (later StandardML) is a very nice language which has been around since the 70s.

https://en.wikipedia.org/wiki/ML_(programming_language)

Significantly before Haskell, and certainly worth looking at.

I'm not sure why it lost in the popularity wars. Maybe it lost to C/Pascal/C++ because it had garbage collection and then never regained its footing.

I have never seen a serious case that ML is production-ready, not in the early 2000s and not now.

I do not mean this as some sort of major criticism or anything, just as a brute engineering fact. It's not like Haskell has a huge suite of programs I can point at that people use because they are legitimately useful and not because they are Haskell programmers (Pandoc, XMonad, and honestly I'm already coming up a bit dry here), but I can still point to more than I can ML, which is a flat zero.

Heh, that's probably true about being "production-ready", but I think you're conflating quality with popularity, and there are plenty of counterexamples to that. The point was that there have been good staticly typed languages for a pretty long time now.

I guess we could debate what "good" means...

No, I'm not conflating quality with popularity; I am telling you the definition of the term I am using. You are welcome to your own definitions but you need to label them as such.

There was no option in the early 2000s of deploying any significant production software in ML. You can see this very easily, let me make a list: C++, C, Java, ML. Which one doesn't belong to the set "production-quality language in 2001"? Anyone who can't answer that is just being deliberately obtuse. Even though Java was jammed into that list more by executive fiat than anything else, it was still in that list. You may like ML a lot, you may have preferred to work in it, but it is very clearly not able to run in the same spaces as C++/C/Java.

I used Haskell circa 2012 to build a highly concurrent network server for a game contest. I'm glad it was just a game contest and the biggest stakes were which college student got the grand prize. It crashed under load. Really quite a bit; I was restarting it about every hour, under what would have been a trivial amount of load by any production standard. And it was just Haskell bugs; as Haskell advanced, the exact same code crashed less and less. Probably it would be fine today. But this is the sort of thing I mean; even if you like the language, production shines a really, really harsh light on a language. Having a theoretically superior concurrency solution didn't make my code not crash the runtime. Having a theoretically superior typing solution still leaves a language needing tested libraries, tested framework, exposure to real world situations. The odds of hitting a critical snag is just too high otherwise.

Even today, telling me that you're building a critical system in ML would basically be a firing offense (if you obstinately stuck by it). I'm as open minded about languages as anybody, but I know enough to know with close-enough-for-business-certainty that it's a bad business decision. Should the ML community suddenly revive and fix up the language over the next 5-10 years, I'd happily reconsider, but today? No question. Even Haskell would be a very uphill battle, for many good and sufficient business reasons, but maybe you could just about convince me there's some task you just need it for.

I can't tell if you're spun up or not, but from the tone and choice of words, this doesn't seem like a friendly conversation any more. Take care, and I won't reply any further.

(off-topic/a bit of personal history) I was in college around those years, and working on the side as a consultant [dotcom boom=companies were crazy for anyone with some experience]. I had a infatuation with programming languages and got proficient enough in 14 of them to write non-trivial code: a toy language (logic language, prolog/datalog) and problems from my consulting gigs, IIRC network flow analysis from logs, and relational database sync with data compression (a client had sales agents[1] on dial-up; I wrote their app in Delphi, but was struggling to sync without errors and fast enough).

(start here to not get bored) Haskell wasn't definitely ready for enterprise. It felt very researchy.

I do remember other functional languages with HM-style types that felt more polished and ready: e.g. I did learn Ocaml, or Concurrent Clean.

https://en.wikipedia.org/wiki/Clean_(programming_language)

Jane Street adopted Ocaml in the mid 2000s.

https://blog.janestreet.com/what-the-interns-have-wrought-20...

"Yaron Minsky joined Jane Street back in 2002, and claims the dubious honor of having convinced the firm to start using OCaml."

https://www.janestreet.com/tech-talks/jane-and-compiler/

"that’s when we made a real kind of fateful step into integrating OCaml into our permanent infrastructure. And that was like in 2005, we started doing this 2006, we had about 10 people who were programming in OCaml"

(more off-topic) [1] I really liked Ocaml... but, sadly, I discovered it only after I finished that sales agents system and the final version was in Delphi for the main app and Dolphin Smalltalk for the sync part (I needed metaprogramming to pull it off).