63
What's the most fun programming language to learn? (piefed.ca)
submitted 9 months ago by to c/learn_programming@programming.dev
131 comments fedilink hide all child comments
you are viewing a single comment's thread
view the rest of the comments
[–] 11 points 9 months ago (13 children)

People calling functional programming weird hurts me. It's just unfamiliar not weird.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 13 child comments
    •
  • [+] [S] 2 points 9 months ago (12 children)
    [deleted]
  • permalink
  • fedilink
  • source
  • parent
  • hideshow 12 child comments
    •
  • [–] 5 points 9 months ago (1 child)

    For a newbie probably something like Scheme (which is just a particular flavor of LISP) although I wouldn't call it a good language.

    Here's the thing with purely functional languages that don't allow in place mutation (most of them, or only under special circumstances like Haskell's ST Monad), they force you into learning functions that typically don't exist in other languages like foldl and force you to think about approaching problems in a different way. This will make you a better programmer even when working on other languages, but it's very much something you have to learn and like all learning it will take time and effort.

    I'm actually tempted to say Haskell is the best option because it actually is a really good language but it's not so much a learning curve as it is a learning grand canyon. It has an amazingly powerful type system (very similar to Rusts) and uses it very well, but it's also very unintuitive because it's deeply rooted in academia and uses names for things taken from set theory and mathematics (terms like endofunctor, profunctor, affine space, and of course the famous Monad). If you're finding Rust a struggle Haskell would be 10 times worse for many of the same reasons.

    Another maybe good option that I can't definitively recommend would be OCaml. I've heard really good things about it and what I've seen of it looked good, but I haven't personally used it beyond maybe a little reading and a hello world type thing so I'm unsure what kind of pitfalls a newbie might run into.

    The primary reason I'd recommend Scheme is because it's in many ways a very primitive language. Its type system is very simple and it really doesn't have a lot going on other than being purely functional. That is also its biggest downside with its second biggest problem being a rather annoying syntax (be prepared to spend a lot of time counting parens to make sure you're closing every pair and working in the scope you think you are).

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 1 child comment
    •
    load more comments (1 reply)
  • [–] 2 points 9 months ago* (3 children)

    The language thay you are already using! You need to understand FP, not a new language. Definitely read "Grokking simplicity" by Eric Normand.

    But if you want to learn a new language more suited for FP, I would hardly recommend either guile scheme, racket, or clojure (all are lisps and you can use and build real word things with them forever). Haskell is also great but it's much harder than lisps.

    You can do oop or fp with lisps, there is basically no syntax, you can get started and actually focusing on doing FP in a month. (Som say you can learn the language itself in a week, which you can but if you are really dedicating time to it).

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 3 child comments
    •
  • [–] 2 points 9 months ago (3 children)

    I think Haskell would be a good choice. It's mature, used for real things (amongst a particular crowd, at least) and it's emphatic about being purely functional. Even when it is forced to enable other styles like imperative, it's done in a way that's syntactic sugar for a pure version (do notation being a great example of this, it's really just a chain of lambdas). You can do functional style programming in a lot of languages now, but they'll also let you mix and match other styles, which can make it easy to "cheat." Haskell will teach you functional programming and that's it.

    Also, since it sounds like you're familiar with Rust, it uses a lot of ideas from Haskell. Rust enums are a clone of Haskell's algebraic data types, patterns are almost exactly the same, traits are typeclasses right down to the fact that the compiler can derive some common ones automatically, Rust strongly encourages immutability while Haskell basically requires it, and in both languages you're only allowed to break the rules if you start using things with the word unsafe in them. My experience learning Rust was "oh, C and Haskell had a baby named Rust, cool!" The big difference is that in Rust, you're programming from inside a C-style computer with RAM, while in Haskell you're programming in a mathematical void and the computer is tidily packed away in a box labeled IO.

    A fun guide for learning Haskell is here: https://learnyouahaskell.github.io/

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 3 child comments
    •
  • [+] [S] 1 point 9 months ago (2 children)
    [deleted]
  • permalink
  • fedilink
  • source
  • parent
  • hideshow 2 child comments
    •
  • [–] 2 points 9 months ago (1 child)

    It's very different. You have to come at problems in a very different way because the tools at your disposal are not what you're used to.

    The language itself is quite elegant and simple, if you strip it down to its essence it's basically "when you see A on the left side of the equals sign, replace it with B on the right side of the equals sign" repeated until your program has either errored out or been boiled down to a single value. The type checker ensures that the replacement will be legal no matter what's happening at runtime, and can really help with getting things lined up just right because it's very thorough.

    The simplicity also leads to complexity, though, for a few reasons. The solution to any problem is usually generalizable, since there's such a small surface area to the language itself and the type system allows for very abstract declarations of what a thing does, which leads to very beautiful solutions that are also so general and reusable that it can take work to figure out "okay, so this thing composes one function that is traveling recursively down the list of pairs, applying this function to the first item, and that's composed into this other function that is pulling them apart into separate lists..." whereas if it had been written the "dumb" way it'd be more like "oh, we're breaking these items into two lists and tweaking the first item as we go," unnecessarily tied to the one particular scenario and totally unusable anywhere else in your code, but also more readable and concrete. There's an entire vocabulary of functions that do abstract things that you have to learn to make sense of what's going on sometimes.

    Related to that is monads, which are such a common pattern in Haskell that the language has special notation for them; they're an incredibly powerful tool for putting values in a context and/or creating an environment where background details can be handled out of sight, but they're also so generalizable that they span from the simplest monad that basically just captures "this thing might not actually exist" all the way to the IO monad which, in a way, represents the entire universe, or at least your entire computer. Learning Haskell means wrapping your mind around them, which isn't impossible, they're actually quite simple, basically just 2 functions that need to follow a few rules, but it takes a few examples and explainers to really get it.

    Generally I think any programmer benefits from at least trying out something like Haskell, even if you never become an expert or use it day-to-day, it'll give you a new angle to think from and could spark thoughts you never would have had before.

  • permalink
  • fedilink
  • source
  • parent
  • hideshow 1 child comment
    •
    load more comments (1 reply)