[throwawaydbfif]

I've used a ton of languages over the years and vastly prefer Java type syntax when working on larger projects. The forced organization tends to lead towards some level of mandatory code clarity. Something greatly lacking in Js land.

OO is a bad word these days and functional is all the rage, even though functional languages were largely superceded by OO languages eons ago for many reasons people are slowly redicovering.

There's a huge push to put more structured language concepts into js now that it's being used for substantial projects and it's out of necessity more than convenience.

When I'm hacking together a quick Python script all that stuff gets in the way but when working on larger systems strong typing and object syntax are practically a neccesary evil for maintaining readability

[klibertp]

> strong typing and object syntax are practically a neccesary evil for maintaining readability

No, it's not like that.

You can write readable code in any language as long as you can write readable code. It sounds tautologic, but what I mean is that ability to write readable code is a skill separate from writing code or knowing a particular language.

Strong static typing - as just about any tool and language feature - can have both good and bad effects on code readability. In the end, the readability (so also maintainability and other related metrics) depends on the skill of a particular developer in the largest part.

Both OO and FP techniques, as well as all the language features, are the same. You can misuse (or ignore) them all.

What we need is to make an "average developer" better at writing code, not more bondage and discipline in our tools. The latter is (a lot) easier, so that's where we focus our efforts, but - in my opinion - it's not going to solve the problem.

[bertrand-caron]

Could you elaborate on how "functional languages were largely superceded by OO languages eons ago for many reasons people are slowly redicovering" ?

[throwawaydbfif]

Erlang and common lisp have been around for a long time, and functional programming is nothing new. The reality is that most business problems map conceptually to communication between objects, and that IDE's which greatly help developer productivity work a lot better with objects.

Functional programming has origins in lambda calculus and academia because mathematical problems map more easily from pure math to functional programming. It's really popular in the circles where it's more useful/easier than OO.

Honestly I don't think the people 20 years ago chose OO for most business languages over functional out of ignorance. They had a choice and decided that OO was better for business problem solving languages like Java even though a large majority of programmers from that era were math majors and familiar with functional syntax.

I feel like we're in one of those cycles where a large number of a previous generation have retired and it's time to learn some of these lessons all over again.

Notice how many wood commercial buildings have been going up in the last 15-20 years? A lot, and just long enough after everyone involved in all the great city fires of WW2 to be too dead to object.

[fmap]

Who "choose" OO 20 years ago and (much more importantly) why?

I'm going to ignore the social component... that said, we work in a wonderful profession where the world is changing completely every decade and many design decisions from the previous generation make no sense anymore. The business case for developing your application in COBOL rather than Common Lisp may have been sound 20 years ago, but today many of the reason why you didn't choose lisp are invalid (e.g., garbage collection takes milliseconds rather than seconds).

Note that this is not the case in more mature fields such as construction.