Why learning Haskell/Python makes you a worse programmer (2006)

http://lukeplant.me.uk/blog/posts/why-learning-haskell-python-makes-you-a-worse-programmer/?

by misiti3780 • 13 years ago

41 48 13 years ago

lukeplant.me.uk

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.

zwegner3• 13 years ago

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.

michaelochurch5• 13 years ago

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

vinceguidry• 13 years ago

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• 13 years ago

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

yen2232• 13 years ago

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

mwhooker• 13 years ago

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

GhotiFish• 13 years ago

Tell that to pandora, cthulhu and heroin.

Houshalter• 13 years ago

Or just stop learning the things that make you worse?

michaelochurch5• 13 years ago

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... ). 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.

MostAwesomeDude3• 13 years ago

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. " ;

rdouble2• 13 years ago

...good programmers, in general, tend to be parsimonious

Good programmers are frugal to the point of stinginess?

michaelochurch5• 13 years ago

I joke don't fully get.

munificent• 13 years ago

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• 13 years ago

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

Fishkins• 13 years ago

x is the input variable to that anonymous function.

Instead of the named syntax e.g. doSomething(x) { return x * x; } the syntax for C# anonymous functions is x => x * x

archivator• 13 years ago

The argument to Where() is a Func<TSource, Boolean>, and that "x => x .. " business is C#'s lambda syntax. x is just a variable name, no magic there.

daeken• 13 years ago

It's a lambda. Saying x => foo(x) is the same as lambda x: foo(x) from Python.

adambard3• 13 years ago

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.

danbruc• 13 years ago

There is String.Join also used in the article but now there is a overload accepting IEnumerable<String>.

  String.Join("\n", mylist.Select(foo => foo.Description()).Where(x => x != ""));

Using a method group yields an even more readable code. Okay, it depends - if you are not used to method groups, it looks a bit strange but I like it.

  String.Join("\n", mylist.Select(x => x.Description()).Where(String.IsNullOrEmpty));

Note that I slightly changed and inverted the predicate because there is no build-in String.IsNotNullOrEmpty but you could of course write it yourself. I have a small extension method in my tool library that wraps String.Join and takes care of filtering out null references and empty and white space-only strings.

  mylist.Select(item => item.Description()).JoinExcludingNullOrWhitespace("\n");

benhoyt• 13 years ago

It gets better, though. C# 3.0 also has query expressions, which are even closer to Python's list comprehensions. Also, I think String.Join(sep, enumerable) would be more efficient than repeated string concatenation with + (given that C# strings are immutable, it'd have to reallocate and copy bytes each time, just like in Python).

So we'd have:

   String.Join("\n", from x in mylist where x.Description() != ""
                     select x.Description());

Hardly looks like a statically typed language anymore, does it?

ColinWright• 13 years ago

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.

merlincorey• 13 years ago

Thank you for your fine service. Whenever someone posts something old to hackernews, I am extremely thankful to those divers who link us to the old posts, which are almost always very useful.

kens• 13 years ago

My crazy theory is that there are three different ways people treat online discussions: the "cocktail party" where people have interesting conversations, the "scientific conference" where the idea is to increase knowledge, and the "debate team" where you argue your position.

Posting links to previous threads is perfectly reasonable in the "scientific conference" model, but rather rude in the "cocktail party" model. So any downvotes on your links are sort of proxy votes on "what HN is".

vacri• 13 years ago

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

jat850• 13 years ago

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.

yen2232• 13 years ago

It does actually. It's set to expire after a certain period because HN explicitly does not disallow reposts.

jpollock• 13 years ago

Perhaps there should be a feature on resubmissions to preload the discussion with high-rated comments from the previous discussions?

Siecje• 13 years ago

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();

Kapura• 13 years ago

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• 13 years ago

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

platz• 13 years ago

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

macca321• 13 years ago

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

Why learning Haskell/Python makes you a worse programmer (2006)

Related Stories