
Learning Python and Haskell has not improved my programming (2006) - molteanu
https://lukeplant.me.uk/blog/posts/why-learning-haskell-python-makes-you-a-worse-programmer/
======
bhaak
This programmer can't code with taking the constraints of the program's
environment into consideration.

After learning an unrelated programming language he isn't able to write
idiomatic code in a different programming language with a different paradigms.

That's like being depressed when wanting to curse in English as the Russian
curse words are much better but when translating them into English, they lose
a lot of their appeal.

This programmer should learn that you shouldn't fight the basic premises of a
language. That leads sometimes to ugly code but this often is still the best
you can do within this particular language.

Also the next programmer to maintain this code will be much happier.

~~~
beatgammit
The main thing I learned when learning Functional Programming was that there
are multiple ways to solve the same problem, which forced me to look at the
data and output first instead of jumping to the syntax to get intermediate
results. A program isn't a set of conditionals, loops, and objects, it's a
transformation of data from one form to another.

Before FP, I would implement a compiler as a massive state machine. In FP, I
think more in terms of small functions that work together in a stream, and the
state machine is implicit. With declarative programming, I think in terms of
defining the grammar.

I don't use FP techniques for everything, but my whole way of approaching a
problem is different because I know that other options exist. Sometimes I'll
use a for loop, other times I'll make a recursive mapping function, it really
depends on which solution is simpler and less likely to have bugs.

------
tluyben2
This article does not age well. Especially the C# stuff...

Also, using Haskell 'very little' will not give you the experience you need to
write something like this. Haskell has a (very) steep learning curve and you
need to recognize ways to solve problems and to see the elegance (and the
warts as well by the way). That takes time and effort; maybe there are people
who just get it, I am definitely not one of those people, but the work, for
me, was definitely worth it.

~~~
ChrisSD
The article agrees that it made the author a better programmer. The argument
they're making is that it made them a worse C# developer. Their Haskell
experience allowed them to see the specific problems with their C# code but
didn't give them the tools to fix them because functional programming isn't
(or wasn't) idiomatic C#.

~~~
dethswatch
The c# code is ancient at this point and doesn’t use linq, which remedy his
issues.

The language has added significant functional capabilities in the last 13
years...

------
jpochtar
I compare it to Morty experiencing “true level” [0]

[0] [https://youtu.be/w-wbWGwZ7_k](https://youtu.be/w-wbWGwZ7_k)

------
throwaway3627
A dilettante complains about something they "learned," as opposed to
committing to mastering it with real use and then forming an informed opinion.
PEBKAC seems the more likely explanation.

