I Probably Hate Writing Code in Your Favorite Language

Functional programming just has something magical about it that really draws certain kinds of people in.

I wonder if it has to do with the fact that, when you play inside the boundaries of what a functional programming language can do, everything feels so neat. So tidy. Like a game. Or using lego bricks. It almost feels insane to do things any other way.

But then again, most problems live in the real world, where things are not neat, or tidy, or like a game. I wonder if this is why you tend not to see functional programming languages more broadly used...?

The language I would like to write in.

The language in which I would like to debug and maintain code written by someone else.

> make the language and syntax as simple as possible, and then even simpler at the expense of expressivity

I understand why people say this because you can write these small highly condensed statements which would take a lot of code otherwise to do. I think it's probably the wrong word though. These languages generally prevent you from manually managing memory, which ironically makes expressing some designs or patterns impractical. If you want to express say writing a performant garbage collected language or something, a language like c or c++ is ironically more expressive than these other higher level functional languages with a runtime gc.

I agree with the author about Rust in that it has a beautiful and expressive type system. The fact that it can be used for systems programming, has a modern package system, and can be deployed as a single static binary are bonuses.

Rust is a perfect little Go/Java replacement for microservices and web servers.

    def winning_team(game_log: GameLog) -> Team:
        team_a, team_b = get_teams(game_log)
        points_a = get_points(game_log, team_a)
        points_b = get_points(game_log, team_b)
        
        return team_a if points_a > points_b else team_b

FWIW, I do not like any OO languages at all.

    if {"Bjarne Stroustrup: 

        There are only two kinds of languages:
        the ones people complain about and
        the ones nobody uses."} == True &
        {"Your favorite programming language is probably used a lot"} == True then:

        return {"Must hate and complain about your programming language"}

...

> The thing I hate about all of the languages I listed is their emphasis on mutation. When I call a function and pass it a list or object or whatever, I have no guarantees about that thing’s value when the function returns.

This is not true for C++, where the 'const' keyword allows you to disallow mutation. Perhaps the author would complain that this behavior isn't the default, but the functionality exists.