Hacker News Reader

Comment by the-kenny | Hacker News Reader

"Too afraid to learn Lisp"

This is sad. Very very sad.

Yes, if it's true, it is (it's PG's assessment). But since they wrote an interpreter for Lisp in C++, they couldn't have been that afraid, at least not all of them. I guess that's what they "gained", that only a few adventurous of the engineers at Yahoo "had" to learn Lisp and the rest could continue program in C++.

But since they wrote an interpreter for Lisp in C++, they couldn't have been that afraid, at least not all of them

Another interpretation is that this is like the “comb-over” syndrome. How does a middle-aged man end up with a comb-over, given that everybody knows it’s a lame look? The answer is that it creeps up on him day by day, there is no one moment in time when he asks himself, “Should I comb my hair over?”

Likewise, whenever you see a Greenspunned[1] system, there is rarely a moment in time when some bright and ambitious person decided that the right thing to do was to sit down and implement half of Common Lisp. Instead, they make a series of small daily decisions (add this, change that, add such-and-such a feature, whoops, to fix that bug we need to do this...) that end up accreting into an interpreter for Lisp.

I don’t know the whole story, perhaps they did decide to write such an interpreter right from the start. But it could be that they initially decided to write something very small and specific, but wound up with a comb-over.

[1]: https://secure.wikimedia.org/wikipedia/en/wiki/Greenspun%27s...

Nice explanation.

I have to ask though: Is Greenspunning such a bad thing?

It seems like this would be true of any non-trivial software system (successful or not).

What's the variant of the 10th rule - something like:

'Every complex system contains an ad-hoc informally specified implementation of Common Lisp. Including Common Lisp'

> I have to ask though: Is Greenspunning such a bad thing?

Yes, because if you knew you needed Common Lisp, you'd just use CL, rather than an ad-hoc informally specified implementation of CL. In general, the half implementation has half the value of the 'real' implementation.

Only the RTML page templates were left as Lisp. That was very simple code. Plus they pretty much had no choice about leaving at least that much of the program in Lisp: individual users had created their own custom templates (through an easy template editor that generated Lisp on the back end), which means porting the templates would have meant testing not just the default templates but each user's custom templates as well.

http://help.yahoo.com/l/us/yahoo/smallbusiness/store/edit/ad...

Hi Paul. Since you are, maybe you can shed some light on how the rewrite actually happened? Was it the comb-over syndrome that raganwald described in a sibbling comment to yours or was it a more conscious decision?

It was done in one big rewrite.

The two are not mutually exclusive. Most people don't realize they are implementing a lisp interpreter in their massive rewrite, yet after the fact, to anybody who is familiar, it shows up right away.

I don't think it is sad, or even true for that matter. It is just the talk of someone who treats a programming language as a religion.

Why would Yahoo want to keep this one property written in Lisp around while the proficiencies within the company (and the general talent pool outside the company) did not include Lisp?

It has nothing to do with being "afraid" of Lisp, it simply didn't make sense to have one random Lisp property. I am pretty certain if Google made this acquisition, the site would be rewritten too.

edit: typo

On the other hand, Google probably isn't expecting ITA to abandon Lisp anytime soon.

To make it clear - you could replace lisp with erlang/haskell/forth and it still would be sad. I am still student and I see that many people who are still in college (so their programming habits are relatively new and shallow) are reluctant to try new technologies. I am aware that good projects are not about choosing cool, full of buzzwords like 'monad' language, but still, most people want to stick with tool they learned first for everything, which is sad.

At some point a balance has to be struck. If you spend all your time trying out new technologies, you never really get to know any of them very well, and your productivity is constantly hampered as you relearn the ropes on every project. I am all for learning new things, but I think there are definitely cases where it's reasonable to pass on rewriting everything just because someone thinks that "smart people use language Y, not X", and "X developers are too dumb to use Y".

This is how pg interpreted it. I wouldn't be surprised if the real reaction was more about _disgust_ rather than fear: I personally do like the functional programming and everything-is-a-symbol paradigms of Lisp, I just hate THOSE DAMN PARENTHESES and would probably try hard to avoid using Lisp at my workplace. Some people have the same reaction when confronted with whitespace/indentation in Python, doesn't mean they're afraid to learn it.

I'd say that "functional programming" and "everything-is-a-symbol" are not really essential in (and actually quite far from) the actual paradigm of Common Lisp. Modern Common Lisp code is not especially functional, nor do the symbols play a significant role. It's more about the macros and the objects nowadays.

In case you did not mean "Common Lisp" by "Lisp", try to be more specific next time. The "Lisp" term does not include Scheme, and is not really that much used when talking about Clojure.

What do you mean by "everything-is-a-symbol", anyway?

Reply on news.ycombinator.com