John A. De Goes

Seems to be similar to the direction taken by John De Goes (using algebras to describe your problem domain, building programs from those algebras via free monads/applicatives/etc., interpreting those programs using natural transformations). I think there is definitely something to this kind of thinking. Both authors argue that modern programming languages do not have the best ergonomics for this style of programming, albeit it is at least possible to do most of it in languages such as Haskell and Scala. 1. Data Structures Are Antithetical to Functional Programming [http://degoes.net/articles/kill-data] 2. A Modern Architecture for FP [http://degoes.net/articles/modern-fp] 3. Modern Functional Programming: Part 2 [http://degoes.net/articles/modern-fp-part-2]

Most guys I follow are either rust or haskell developers. @manishearth - rust - https://manishearth.github.io/ @bitemyapp - writer of haskell: first principles @bartoszmilewski - haskell - https://bartoszmilewski.com/ @jdegoes - writes informative FP blog posts - http://degoes.net/ @aaron_turon - rust - https://aturon.github.io/blog/ @pcwalton - rust @nikomatsakis - rust - http://smallcultfollowing.com/babysteps/ @paf31 - purescript creator @nick_r_cameron - rust @kmett - famous haskeller @steveklabnik - rust - http://words.steveklabnik.com/

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…

John De Goes (https://degoes.net/)

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…

UI design is very complex, because humans are complex. Often you're automating business processes that work based on implicit judgements that are so obvious to the humans performing them that they're not even aware they're making them, making it very difficult for them to explain the rules they follow. What I like about PureScript is the careful typeclass hierarchy - it feels like a rethinking of the Haskell standard library from the ground up. They often end up with a hierarchy of single-method typeclasses, which feels like a first step to something along the lines of http://degoes.net/articles/principled-typeclasses/ . I'd like to combine that with Idris-style full dependent typing but you can't have everything and there's a tension between what's state of the art and what's designed for practical use (I feel like I'd be happier using PureScript in production than Idris). Gradual typing I don't find particularly interesting; YMMV.

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…

> https://degoes.net/articles/insufficiently-polymorphic lol this is not why people do "df1", "df2", etc, nor are those polymorphic names but okay. > it's coming... some places move slower than other but it's coming What is coming, exactly? Again, as said, I work at a company that has rapidly adopted AI, and I have been a long time user. My job was never about rapidly producing code so the ability to rapidly produce code is strictly just a boon.

> We know you don't value aesthetic code lol. Single variable names, `df1`, `df2`, `df3`. https://degoes.net/articles/insufficiently-polymorphic > My job has barely changed semantically, despite rapid adoption of AI. it's coming... some places move slower than other but it's coming

True, but his article (https://degoes.net/articles/splendid-scala-journey) states it is also for Scala new syntax breaking a lot of things (if I remember correctly, been a a while since I read it) and for other reasons. I also thought it was for political reasons before until I read that article back in time.

As an example; John A De Goes, one of the most prolific advocates for Scala and developer and lead of the Zio ecosystem, has announced that he is stopping his advocacy, stepping down from leading the Zio ecosystem, and is going to branch out. A big piece of "drama"/community turmoil that gained exactly one comment on the four posts created for it. https://degoes.net/articles/splendid-scala-journey

How does the Scala.js community reach more developers who want type safety (and probably already use Typescript) yet still want the nimbleness of the Javascript community? I've been a part-time Scala developer for a long time and have trouble choosing Scala.js for any frontend project because of SBT, missing type facades for npm packages and just other general friction of using a non-web-native language for frontend development. I want to see Scala.js succeed but I feel unless some of the major adoption pain points are addressed (which JDG addressed recently[1] about the Scala ecosystem generally) it will continue to be an ultra-niche project. [1] https://degoes.net/articles/scala-resurrection

Feedback was solicited, but it was not a democratic process as is documented here: https://degoes.net/articles/lambdaconf-controversy I have no stake in the process here. As I said, it was clearly well thought-out. But the outcome is regrettable.

Here's a reference you may find useful John A De Goes - A Glossary of Functional Programming http://degoes.net/articles/fp-glossary

> Honestly.. I cannot help but to think that most programs are parsers In some sense that is true. The idea that most programs are just layered interpreters has been explored in: http://degoes.net/articles/modern-fp

All in one place: A Glossary of Functional Programming http://degoes.net/articles/fp-glossary by John A De Goes, keynote speaker at Scala conferences. Discussions on FP using Scala at https://www.reddit.com/r/hascalator

That makes sense if you can then write code using that trait as a more general type. http://degoes.net/articles/insufficiently-polymorphic

Short variable names as "doing it wrong" depends on context. There are good reasons in math and in programming to use short names. See for example: Descriptive Variable Names: A Code Smell. http://degoes.net/articles/insufficiently-polymorphic

No, I'm pretty sure he doesn't, and dogecoinbase should be embarrassed for claiming that he does and that that's his motivation for Urbit. From his personal statement about lambdaconf, at http://degoes.net/articles/lambdaconf-inclusion : > 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.

In functional, statically typed programmings languages, there is a pattern where business logic, including "actions", is encoded in types. This article [1] gives an example of filesystem manipulations that are encoded in a "FreeF" type. When business rules are encoded in datatypes, it's easy to check that the encoding and the transformations are complete, and the logic can easily be mock-tested. [1] http://degoes.net/articles/modern-fp

I think it is important to note that LambdaConf 2016 was successful. In organizers' own words, "It just means there is a space in this world for an indie conference that rigorously ensures professional conduct at the event, but leaves other matters at the door." People who protested against LambdaConf 2016 organized alternative confrence MoonConf at the same place at the same time. Two conferences had cordial relationship. Nothing people worried about actually happened. http://degoes.net/articles/post-lambdaconf-2016

Or "Functional Programming isn't the Question". His later discussion of Free monad is pretty interesting: http://degoes.net/articles/modern-fp

Some interesting thoughts on that by one of the relevant people in this story are here: http://degoes.net/articles/lambdaconf-controversy , in the "Professionalism" section. He explains why, in his opinion, these clashes between the private and the professional are becoming more common.

CONTEXT: Linked post is from Feb 29, 2016. Before the recent tumult about LamdaConf announcing their intention to host a speaker who is also a "fascist", and "slavery apologist." (Post explaining their logic there is: http://degoes.net/articles/lambdaconf-inclusion .) Not sure why it's being posted now.

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…

I am completely serious. Curtis Yarvin is a bellwether - the sort of person that any group that starts excluding people for ideological disagreements, would probably exclude first precisely because his position is so problematic. So any group that accepts his technical contribution can obviously be trusted to tolerate any less-severe ideological disagreement. Conversely, any group that doesn't, especially when they have to make up nonexistent concerns to do it because their rules didn't cover this "obvious" reason to kick someone out and couldn't be hastily adjusted, must be viewed with caution. I personally don't hold any beliefs nearly as objectionable as that. But I do hold objectionable beliefs - as I believe any halfway interesting person does. And those who don't, probably will eventually. Just stand by your convictions and give it time. See also LambdaConf's conclusion on why they should allow him to participate anyway: https://degoes.net/articles/lambdaconf-inclusion I agree with this article fully.

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_… 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,…

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.

I don't think the author groks monads or writing maintainable Haskell. > The essence of monads is to use abstract types to enclose a mutable state That's not really true. Many types that are monads are just data. Some trivial examples: List, Maybe, Either, Free. There are several other misunderstandings in the post. > For one thing, when you use a monad, you get hooked to it: the type constructors of the monad start to appear in the signatures of your function. Only if you write unmaintainable code. I wrote a full RFC 2616 HTTP server and basically every function lives inside a completely parameterized monad type `m`. All of the dependencies each function needs are injected as arguments (See http://www.haskellforall.com/2012/05/scrap-your-type-classes.html). Also these days (though not when the article was written in 2008), free monad DSLs are becoming a very popular way to abstract away this stuff (See http://degoes.net/articles/modern-fp)

An interesting titbit of information from LambdaConf's organiser: "In the past few days, we’ve also seen a huge bump in the number of people applying for our diversity scholarship program (49 applications so far), and we’re doing everything in our power to give out as many scholarships as possible." [0] It's good of Julie and Chris to continue supporting the conference, and (I think) a real shame how quick the other sponsors were to bow out. Hopefully in future people will try to think more about the positive work they can do and less about how they look. (Obviously, for those that really have strong moral reasons to exit, it's a shame but completely understandable.) I guess one of the positives is that we now have two conferences [1], so those that can't stand the idea of being in the same room as Yarvin can be around other people that think exactly the same. [0] http://degoes.net/articles/lambdaconf-controversy [1] http://moonconf.org/