

Why learning Haskell/Python makes you a worse programmer (2006) - misiti3780
http://lukeplant.me.uk/blog/posts/why-learning-haskell-python-makes-you-a-worse-programmer/?

======
ColinWright
Probably none of you care, and some of you will hate me for pointing this out,
but look, here are a few previous submissions:

<https://news.ycombinator.com/item?id=407796> <\- Lots of comments

<https://news.ycombinator.com/item?id=946258>

<https://news.ycombinator.com/item?id=1883663> <\- A few comments

<https://news.ycombinator.com/item?id=2410202>

<https://news.ycombinator.com/item?id=2489298> <\- A few comments

<https://news.ycombinator.com/item?id=3171630>

<https://news.ycombinator.com/item?id=4828284> <\- Lots of comments

It will be interesting to see if this discussion raises any points not in the
earlier one. Or the earlier one. Or the earlier one.

And to the inevitable downvoters, I don't care. No, I'm not baiting you. I
just wanted to help people see that this has been discussed before, and if you
have any respect for the HN community, and if you think the HN community is
smart in any way, then you may want to see what this smart community has said
about this in the past, rather than re-hashing the same old arguments.

Or not. Go to it.

~~~
vacri
It's interesting that HN has no URL matching to prevent simple straight-
forward (multi)reposts like this.

~~~
jat850
It in fact does but I think there may be some manner of "expiry", and it is
also trivially easy to get around from what I have read. This submission
appears to have a /? at the end of it which may be enough to get past a dupe
check.

------
munificent
It's interesting to see how far C# progressed since this was written. Just a
couple of years later, C# 3.0 came out and his example becomes:

    
    
        mylist.Select(foo => foo.Description())
              .Where(x => x != "")
              .Aggregate((a, b) => a + "\n" + b);
    

Which is, I think, pretty nice.

~~~
famousactress
Wow, that's interesting. Is 'x' just a magic var for whatever Select() yields
in each iteration?

~~~
adambard
x is the variable in the anonymous function 'x => x != ""'. I don't know C#
but I presume that everything before '=>' is the argument list and the rest is
the function body (with implicit return).

You can see it again in '(a, b) => a + "\n" + b'.

As a side note, I find it a bit funny how C# chooses method names in Linq for
the benefit of programmers who know SQL, despite `Select`, `Where`, and
`Aggregate` acting exactly like what other functional languages would call
`map`, `filter`, and `reduce`. Not wrong, just sort of quirky.

~~~
cpeterso
JavaScript will use the same "fat arrow" syntax for anonymous functions in
ES6:

<http://css.dzone.com/articles/javascript-fat-city>

~~~
adambard
Coffeescript uses it already.

------
kalterstern
This is quite silly, of course. A solid developer has no problems switching
idioms (not just syntax) when hopping languages.

There's really not much sense in an argument that says you "lose" something by
learning newer things -- provided, that is, you're really making an effort to
wrap your head around the newer things that you're studying, and not just
cramming selected phrases and reflexes into your head in order to finish some
current task at hand.

If anything he's become a _better_ C# programmer, not a worse one, precisely
because of his "bad" experience, because he now sees that overuse of certain
habits can lead to bizarre or otherwise undesirable results (just like with
any language).

So really he should be thinking positively about the whole experience, rather
than negatively.

~~~
zwegner
I personally agree with TFA. Being able to change your environment is really
key--I write Java in my job and it's just awful for me. I definitely lose
motivation from knowing there are better alternatives.

He's not saying you lose anything, more that it's harder to use those things
when you're constantly thinking about how wrong they are. Similarly, the
overuse of certain habits is not always avoidable.

~~~
michaelochurch
You should consider secretly using Scala or Clojure in order to see how long
it takes for someone to say something.

~~~
zwegner
I've thought about it--it's a rather small company, with generally smart
people on the team. It might happen, but the problem is mostly political. I
also need to learn more Clojure... (I've learned enough Scala to convince
myself that I don't really want to learn it)

~~~
michaelochurch
Scala is good _if_ you have good programmers. Otherwise, it's painful, because
they tend to write Java-in-Scala code. Also, it has a compile-speed problem
that is tolerable in general but catastrophic if you have bad engineering
practices (specifically, cyclical dependencies).

I just got back into Clojure after leaving my last job and the language (which
was already very good) has gotten a whole lot better in the past 2 years. I
recommend it highly.

Where do you live? What's the tech scene like in <X>? My wife and I are both
ready to leave New York. We'll stay if I find something great, but I don't
want to work in social media and my "job hopper" story (too many startups and
consulting projects, NYC finance firms tending to perceive the latter as
similar to short-term jobs even though they're not) is making finance
annoying. (I can still get hedge-fund jobs, that's easy as crap, but there are
few good ones and, besides, I like technology a lot better than finance.) Our
short list is SF, Austin, Boston, but not limited to those 3 places by any
means.

~~~
Schwolop
Send an email to Yanis Varoufakis @ Valve. He's the economics guy doing
analysis of in-game economies and applying various machine learning techniques
to determine pricing strategies, etc. I suspect even if that doesn't appeal,
there'd be a bunch of interesting work that could use someone with your
background.

~~~
dpritchett
Wow, that's a great suggestion. Valve + finance + ML. I can't imagine a better
fit off the top of my head.

------
vinceguidry
For anyone thinking "WTF, what about LINQ?", note LINQ was part of .NET
framework 3.5 and wasn't released for another year after he wrote this post.

LINQ makes coding in C# a whole lot more pleasant.

~~~
guiomie
Indeed, it does a lot. If it weren't for LINQ i'd hate c#.

~~~
yen223
I'm using .Net 1.1 for my day job. God how I hate C#.

------
Kapura
I do most of my current work in Python, and I have no problem switching
between paradigms within the language. Whatever makes it easier to read is how
I look at it.

There are times when a functional solution makes the most sense, and if it
makes the most sense, it should be clear and easy to read and understand. But
then there times when a functional solution looks like a symbolic mess, and
it's easier just to throw a couple of for loops into the code so it's easier
to see that i'm, say, iterating through some list.

------
cpdean
I think that having higher standards for solutions doesn't make you a worse
problem solver.

------
Siecje
I program in Python everyday but I still think in C/Java and have to google
things like enumerate for for loops. Though this is happening less often now.

I also try to do Python thinks when I switch back to C.

input = scanf();

------
mwhooker
If learning anything makes us worse at something we should just stop learning

~~~
Houshalter
Or just stop learning the things that make you worse?

------
michaelochurch
This is going to be fun!

I know he's joking, but I agree-- to a point.

First, if you write Haskell-in-Java code, you're going to do a horrible job
unless you have _so_ much autonomy that you end up reinventing Scala... in
which case you should just use Scala. (See: Greenspun's Tenth Rule.)

Second, I think you learn a lot by studying other languages, but most of the
superiority of Lispers or Haskellers comes from the fact that good programmers
_in general_ tend to be a curious set. Learning Lisp will make you a better
Python programmer, and possibly a better C++ system architect. Will it make
you better as a subordinate grunt on a gigantic C++ codeball? No, absolutely
not. It will make you a morale problem and get you fired.

Third, you learn a lot more _in_ expressive languages that makes you a better
programmer but the languages itself don't get all the credit. When you use a
Lisp, you can get a lot done quickly if you know what you're doing and cover a
wide swath of computer science. When you use a true fringe language, you end
up implementing a lot of libraries you'd just assume work in Java. These
experiences are highly valuable but not rooted in the languages _per se_. It's
just that a lot of the work you have to do to make a non-mainstream language
usable in primetime contributes to your long-term awesomeness growth.

Fourth, if you want to be a Corporate Programmer (TM) and not be challenged
too much, then maybe get tapped for management in your mid-30s, then Haskell
and Python will poison you. I've written a lot about the progress of developer
competence (see this, just today:
[http://michaelochurch.wordpress.com/2013/04/22/gervais-
macle...](http://michaelochurch.wordpress.com/2013/04/22/gervais-
macleod-23-the-shodan-programmer/) ). Once you cross the 1.4 rubicon, there
really is no going back, and you'll be in conflict with managerial authority
_forever_. Well, at least until you become _so_ good that it's eminently
obvious and you can escape the CrapFactory (or is it
CrapVisitorSingletonFactory?) Corporate Programming world.

 _However_ , if what you want is to be a _great_ programmer (not an easily
employable one) then Haskell and Python will do you favors, and learning a few
more languages (also C, because the low-level will always be important for
some domains) is probably necessary.

This was written in 2006; I wonder what he'd think of JVM languages,
especially Clojure.

~~~
MostAwesomeDude
I know you're joking, but I agree -- to a point.

First, if you write FORTH-in-Java code, you're gonna do a horrible job unless
you get to reinvent Factor, at which point you should just use Factor. Also,
you get to use Factor, which is awesome.

Second, I think you learn a lot by studying other languages, but most of the
superiority of FORTH hackers come from the fact that good programmers, in
general, tend to be parsimonious. Learning FORTH will make you a better
programmer. It will also make you better at C++. In fact, it will make you
better at everything, including being a morale problem, getting fired, being a
hero to your co-workers, and being promoted.

Third, you type less in concatenative languages. When you use a Forth, you can
get a lot done quickly because you don't type as much.

Forth, if you want to be a Corporate Programmer (R) and not be challenged too
much, then just use FORTH, because, like COBOL before it, FORTH lets you hold
down the Shift key constantly.

However, if what you want is to be a great programmer, then FORTH is still the
answer! Why? Because it says so:

: ANSWER ." FORTH is pretty much the best way to be a great programmer. " ;

~~~
rdouble
_...good programmers, in general, tend to be parsimonious_

Good programmers are frugal to the point of stinginess?

~~~
MostAwesomeDude
Good programmers are terse.

------
platz
I wonder if the same argument applies to using Reactive Extensions (Rx),
ReactiveCocoa, etc..

------
macca321
Resubmitting this article when it's so out of date seems like anti-C# FUD
spreading.

