John A. De Goes

I believe Haskell is worth learning.

But I don't want to spend any more time near purely functional programmers in my professional life, so I will spend some time to unfairly nitpick the article.

> a lot of the new features ... are either inspired by, or at least more robustly implemented in, Haskell.

This is like some programmers, who don't know much about the history of programming languages, saying Java is stealing features from Kotlin (a language I enjoy). In both cases the inspiration usually comes from ML (a language family which includes OCaml - a language I deeply admire).

Type classes (first implemented in Haskell) are neat though. I heard that Java is considering adopting them.

> Let’s imagine we represented these as plain old strings ... `Theatre String String -- venue name and event name respectively` `checkForSeats :: String -> String -> IO [Seat]`

If your language has named arguments, and sum type cases are records where you have to name your fields, using plain strings is just fine, and probably more ergonomic than wrapping the strings in another type.

> `Either AddressParseError ValidAddress`

Real world procedures usually involves many steps which can fail in many ways. The HM type system does not have subtypes. To stuff all possible failures into the `Left` case of `Either` you have to wrap all possible failure types into a sum type, possibly with multiple layers of nesting (huge PITA).

> concurrent Haskell

For all the hassle with the IO monad, you…

If you like this, you're probably also going to like Haskell/OCaml/Ada/F#/Coq (ML family of languages?):

I'll leave links for Haskell since the only one of those I've tried and liked personally:

https://www.haskell.org/

http://learnyouahaskell.com/

IMO Haskell is the type system you wanted Java to have, with even more strictness. While it's possible to write unsafe haskell, just about everything you will read, and the language itself encourages you to push as many worries as you can to be solved by the type system.

If that doesn't get you excited, there's actually a saying that is mostly true in my experience writing Haskell -- "If it compiles, it works"(tm).

Also Haskell on the JVM if you want to dip your toes in:

- https://eta-lang.org/

- https://github.com/Frege/frege

[EDIT] - If you try to learn haskell you'll inevitably run into the M word which rhymes with Gonad. The best guide I've ever read is @ http://adit.io/posts/2013-04-17-functors,_applicatives,_and_monads_in_pictures.html

BTW, be ye warned: when you start understanding/getting cozy with the concepts introduced by Haskell you'll wish they were everywhere, and they're not. Languages without proper union types will look dumb to you, easy function composition/points free style will be a daily desire, and monadic composition of a bunch of functions will be frustratingly absent/ugly in other languages, not doing errors-as-values will look ironically error-prone.

[EDIT 2] - More relevant to the actual post,…

Summary: PrlConf 2016 is being cancelled because Curtis Yarvin[0] is speaking at another conference, LambdaConf, and has written (elsewhere, under a pen name) about political viewpoints that are not mainstream, progressive political viewpoints.

The LambdaConf people are aware of Yarvin's political writings, do not agree with them, but decided to let Yarvin speak anyway if he agreed to their terms, which he did (these are Yarvin's own words to LambdaConf[1] on the subject):

> One: I’m a writer, not an activist. I’m neither a leader nor a member of any kind of organization. I promote only one kind of action: reading old books. I’ve explicitly denounced any other form of “direct action,” violent or otherwise. Instead I promote passive unresistance, or “passivism.” Frankly, any “follower” who needs me to explain this is a dangerous fool and hasn’t read enough old books.

> Two: Politics of any sort is out of scope at a functional programming conference. I pledge to treat other LambdaConf guests as if they were colleagues at a large company or fellow students at a university, and neither utter nor show any content that’s out of scope or otherwise disturbing. My pen name has been “doxed,” but professionally I behave as if it was a secret.

> Three: violence is unacceptable and frankly preposterous at a functional programming conference, even over an issue as charged as strict versus lazy evaluation. The strongest possible pledge is to not respond with verbal or physical violence…

Always cool to see these in action, but multiple "online desktops" have come and gone since the mid-2000s. I personally built one myself in 2010 only to realize it had been tried and failed a few times. My next instinct was that to get attention and attract users I'd need a mobile-style UI. My instincts were wrong, and your gut is right. There wasn't a strong enough use case.

The motivator for these projects is typically something along the lines of, "it would be great if there was just one OS or interface I could use on any device." As engineers it's very easy for us to see the usage pattern of apps, the speed, power and ubiquity of web tooling + JavaScript and say, "aha! The next logical evolution is all of your client logic on the web!"

Alas, if it were only that easy.

"Unfortunately, this ability to see patterns can prove catastrophic as you attempt to build your own company. The more you generalize the solution to a particular pain, the further removed it becomes from that specific pain. While it might end up being able to solve a lot of pains, it won’t be very good at solving any particular one." [1]

A shared, web-based environment is probably where everything is going. I mean we're more than halfway there with most operating systems, cloud backups, tons of SPAs, etc. The problem is there's no consumer-driven need for a fast transition to a JavaScript "OS" environment. Everything is just good enough, and offloading all device logic to the web, for the end user, is…

Another factor the author didn’t mention: Cancel culture.

Some of the biggest Scala companies and institutions have been heavily captured by the Left, and they have wreaked puritanical havoc on their political rival contributors, and anyone deemed to associate with them.

Typelevel, in particular, has taken politicisation to the next level. And the Scala Center made a political sciences grad with no commercial or academic Scala experience their executive director.

Typelevel’s Travis Brown (the activist who notoriously doxxed LibsOfTikTok) made it his mission to identify anyone in the Scala community who had rightwing views, or associated with any rightwinger, and then systematically try to destroy their career. He was so blatent about it, he had GitHub repos with names like “cancel culture” where he would use his insider knowledge of the Twitter social graph to smear people by association. Absolute psychopath.

So Scala’s ecosystem fractured down the middle, with anyone who didn’t share Typelevel’s puritanical worldview being ousted, and many moving to the competitor ecosystem of Zio, run by John De Goes (one of the victims of cancellation). John even created a parallel community of conferences and Scala training, which became very popular. But ultimately the toxicity of the language ecosystem and the Scala Centre’s failures under Darja Jovanovich and lack of commercial savvy of Martin Odersky led John to the point where he all but quit Scala, and embraced Rust…

Watching Hickey's talk, many of the complaints seemed to be valuable, but they didnt seem to be about static types. Rather, it was about some problems with existing data types locking one into a rigid data model when the domain is constantly expanding.

This post by DeGoes makes the same point. http://degoes.net/articles/kill-data

The default model of algebraic data types is too inflexible.

There are different extensions which work with this issue. Good record system, Extensible cases, using free monads etc. We can have concise syntax for automatically declaring an interface for a algebraic data type based on some field values (ie, customizable deriving statements). Namespace qualified keywords, so we have rdf like attribute based semantics.

The post doesnt respond to the issue but suggests that if you want to do the same thing in clojure with error handling etc, you will need to think about this stuff.

Also, Hickey's mention of Monads was again not about static types. Monad laws are not typechecked. Their motivation is purity. The only slight inconvenience in a dynamic context is that you dont have return type polymorphism, so you have to type IOreturn instead of return.