How about adding APL and Forth and make it the 6 corners!
An array-oriented language and a stack-based language would make the round trip truly mind-blowing. I have tried all of the languages mentioned, and I find myself always using J (ASCII character, APL-like language) and Lisp without intending to do so.
Definitely Prolog. I have barely played with Prolog except when it is included in the PL as in picoLisp or Shen, but it's in its own category. I agree about Erlang too, but it made me stop to think. Erlang without the BEAM or OTP is pretty much a functional language like Haskell, no? I looked at Pony once. Yeah, ok, Erlang too! I prefer the Lisp version: LFE!
I started playing with it, and J became a very powerful desktop calculator. Then I started to tackle other programs in it, and I was hooked by the way it made me think about a problem. All of the selling points of functional programming, which didn't resonate when I was learning F# or Haskell or Lisp, became crystal to me when tacit programming in J or solely functions. I am a polyglot, but I like the array as the basic unit of computation (now very popular with GPUs, Pandas, and Tensorflow and all other array-laden technologies). I feel like I am distilling a problem down to a very well thought out distillation, and it brings me joy!
Good article. I’ve been fortunate to try them all, even SmallTalk when it was released for the Mac in the 80’s. Lots of code in Lisp and C. Not as much in Haskell.
My favourite so far are the ML family and F# in particular. The only language(s) I regret not learning earlier. Try F# or OCaml if you haven’t already.
My university recently put a package manager for SML up on its GitHub page. So there is still a chance for a comeback https://github.com/diku-dk/smlpkg
Never did find the motivation to dive into Joy. I did write a lot of Haskell though, and it left a slightly sour taste.
I feel the same about statically typed functional programming as about Rust, it's a nice theory but in practice you end up squeezing problems into weird shapes to keep the language happy.
I think not, unfortunately. The official git repo hasn't been touched in 2 years. [0] More recently though, a brave functional programming adventurer has been working on a Joy compiler written in Haskell, for what that's worth. [1]
I skimmed the 'overview' page [2] and it looks unusual enough that I might give it a more serious go at some point.
I'm not especially au fait with functional programming, and have only a basic familiarity with Forth, so it's rather alien. Which is of course the appeal.
At this point I think the most interesting thing in smalltalk is not the OO aspects, but the integrated VM/image. Hacking around in smalltalk is such an incredible difference.
There are some pretty good tutorials on Idris which cover just enough Haskell to get you started but yes, maybe it's too much in one go. Dependent Types though <3
I would also shill one of the APL derivatives. I've gone from a happy Python dev to a die hard k/q guy very quickly. These languages completely change the way you approach a problem.
It's just a shame that q isn't free for commerical use (though it's free for personal use) and there aren't many jobs outside of finance.
I didn't see your reply before I brought up APL and J here. I've tried k several times, but I always fall back on J, then APL, and then k. I think it's personal bias, since I found J first. I like the symbols of APL as I like mathematical formulas, and now that Dyalog has adopted some J-isms, I've been trying reimplement my J stuff in Dyalog APL. Also Roger Hui of J fame is a Dyalog user too. I thought I would gravitate to k because of my Lisp background, but J is sticking with me.
They are certainly very well known still in my experience I find a lot of people who haven't done C or any lisp before specially people who arent coming from CS backgroud
not at all. lisp and haskell are entirely different worlds. don't be fooled by the claim that lisp and haskell are both functional languages. haskell is functional to a fault, but lisp is anything you want it to be. it depends on which lisp you choose. i believe that clojure is more on the functional side, scheme somewhere in the middle, but common lisp (the language i am familiar with), is barely more functional than python. functional programming is not using functions as the main method for code organization.
The usual four corners I give as my examples are Haskell, C, Lisp, SQL. (That is, I usually replace the author's Smalltalk with SQL.)
I then go further and describe languages as linear combinations of these: Python as C minus Haskell plus Lisp; Mathematica as Lisp plus SQL; F# as (Haskell plus C)/2.
I'd add a corner and include 6502 assembly. It's so fun, I think Atari 2600 specifically adds some more intimacy with the hardware compared to other classic systems, but they're all fun to learn.
If a mad scientist removed all the outermost parentheses in the clojure example and made it work the same as the current example in the article, what bad things would happen as a result?