I'm sorry but you just undercut your own anti-intellectualism better than I could right there.
(There exist languages which have guarded against this without loss of expressive power since before Java and, oh, are from academia.)
I'm sorry but you just undercut your own anti-intellectualism better than I could right there.
(There exist languages which have guarded against this without loss of expressive power since before Java and, oh, are from academia.)
Note the very important part of that statement: It solves problems faced by working programmers today.
Academic PL research can have that property. Pizza went on to be the foundation of Java generics, there's a ton of excellent compiler and GC theory that comes from academic research and so on. And of course a few of the ideas in Haskell and others are leaking into the mainstream.
But when it comes to handling null pointer errors, sorry, it's insufficient to say "some languages popular in academia don't have null". So what? Working programmers today hardly use such languages. They very much rely on languages which do have nulls, and APIs which use them, and yet the only language that came out of academia in recent times which has serious production usage is Scala, which has ... nothing to say on the topic. Except, oh, an option type. Which can also be null, and which even C programmers can easily have. It's simply not comparable to language integrated support with backwards compatibility.
It would have been nice if academic research had identified up front the best set of usability tradeoffs for adding optionality into a backwards compatible language, but nobody did, so JetBrains had to do it themselves.
A few? Don't you feel like you're underselling the impact Haskell had had on other languages?
> he only language that came out of academia in recent times which has serious production usage is Scala,
What are your qualifications for serious production usage? Would ocaml count by your standards? Haskell also has increasing production usage, though I'm sure you don't count it. Swift (if you don't count it now, you will)? Rust?
> It would have been nice if academic research had identified up front the best set of usability tradeoffs for adding optionality into a backwards compatible language,
That's not enough. It would have to be more convenient to use optionals than null or programmers in that language would have to be convinced optionals are better.
In an existing language that uses null pervasively, it would be hard to get a critical mass of legacy code which uses optional.
What are the key ideas that make Haskell unique? I'd say they are pure functional by default, lazyness by default, an extremely terse syntax that relies heavily on symbols, effects in the type system, type classes, and a few other smaller things. As a non-Haskell expert at least, these are the ideas I associate with the language.
Writing code in a more functional style is steadily becoming more popular, but functional by default does not seem to be the choice of any modern language targeted at the mainstream. Swift, Rust, Kotlin, Ceylon, Go are all examples of industrial languages developed outside of academia that do not follow this design choice, and their functional programming support primarily consists of map/filter/fold/etc type methods on collections and sometimes (as with Kotlin/Java) a lazy sequences library. Meanwhilst, whilst often convenient and intuitively helpful, the evidence that fully pure functional code is of much higher quality than mixed or mostly imperative code is ... lacking. Certainly it's difficult to get clear evidence without controlling for other factors like experience of the programmers.
Lazyness by default is an equally un-influential choice. It seems Idris is the newest cutting edge academic pure FP language and it's strict by default. Lazyness by default creates an entirely new class of bugs that developers didn't have to think about before, for little obvious benefit (it lets you write in a certain style more easily, but does that style really give better software? again, it's difficult to get robust data on this).
The extremely terse syntax that relies heavily on symbolic operators is widely regarded as a bad choice. Modern industrial languages like the ones I named have all shunned this type of design and Kotlin, for instance, doesn't let you define arbitrary new operators. Haskell code is often rendered much harder to read than necessary due to its abuse of symbolic operators.
Effects in the type system do feel nice, but the impact of this idea has likewise been limited. You could argue that Rust's borrow checker is perhaps somehow inspired by this, although it's sufficiently different that I'd describe it as original work rather than idea that comes from Haskell. Other languages haven't focused on it so much.
I suspect the next idea to cross over from Haskell will be type classes, or a variant of them. But probably as an obscure feature not many people use, rather than a fundamental building block as in Haskell.
All in all, given the level of attention Haskell has received for many years, I feel its ideas have had surprisingly little impact.
With respect to "serious production usage", that was obviously a lax description. As far as I know there's much more usage of Scala in the non-academic world than O'Caml or Haskell, but it's still quite a small amount relative to languages like Python or Java. I don't have any specific thresholds, it was an intuitive description.
> In an existing language that uses null pervasively, it would be hard to get a critical mass of legacy code which uses optional.
Exactly, but that's what Kotlin is trying to do through its auto-convert from Java to Kotlin, the backwards compatible type system, support for nullity annotations and so on. It's got the closest yet.
Please correct me if I'm wrong, but Kotlin doesn't improve on Java in these areas.
Despite its young age it creates really fast, tight code (they have issues benchmarking things because Dotty Linker + LLVM gets rid of too much stuff).
the point would have been better made by pointing out the excellent and extensive tooling built by jetbrains for kotlin. that's something the maker of the intellij platform has more experience with than academics
Also there is a tradeoff between advanced language features and good tooling, which is why you will sometimes miss the former inside kotlin
So? Their academic status might solve this, but create other problems still.
E.g. lack of an actual commercial ecosystem, too much emphasis on research-y features, immature tooling, etc.