Comment by babarock | Hacker News Reader

Comment by babarock | Hacker News Reader

Parent Full thread

The core of the argument has nothing to do with popularity. You're right about everything you say (if only you glossed over notable exceptions like Java or C++), but we're discussing "power", not popularity.

Unfortunately, power has a very positive connotation. As a programmer, wouldn't you want to use a more "powerful" tool? However it's different when it comes to programming languages. Too much power can hurt you. Realising that there can be such a thing as "too much power" is new to me or at the very least, it's counter-intuitif enough to deserve being debated. That's the point of, or at least that what I take away from, this page.

Arguably, the success of Java comes from its complete lack of Lisp-y power. Python may be "powerful", it makes a big deal to enforce the "one way to do it" culture and has always had a love/hate relationship with functional features for this exact reason. Speaking from experience, I find it easier to read and understand Java or Python than I do Lisp or Lua (another "powerful" language where every project will inevitably implement its own object model, basically rebuilding Python or Ruby).

So yes, I believe that there's a spectrum of "power" between programming languages, and more "power" isn't necessarily better. It's a characteristic, nothing more.

But more importantly, I wish we could start discussing and comparing programming languages without talking about something as meaningless and volatile as popularity. I don't care if my favorite language becomes the most popular. I don't want to unify all programming languages into one. I am happy when different languages solve the same problems differently, more or less elegantly, and I have so much fun learning all these approaches. I don't care what "succeeded" and what "worked".

I sincerely mean no offense, but I'm tired of having people cut the debate short by turning any meaningful comparison into a popularity contest.

Ok, I'll bite. How would we go about empirically measuring whether too much power" is harmful?

Do we give 100 teams a task to accomplish in Lisp, but tell 50 of them that they can't write their own macros? Or tell 50 of them that they can't use continuations?

If continuations correlated negatively with success, how would we know whether continuations are "too powerful," or merely "poorly designed?" (There is a lot of talk these days about whether continuations are a "Turing Tar Pit" and that a better mechanism needs to be invented)

Or perhaps our 100 programmers are merely unfamiliar with them, and as a result don't use the features well?

My feeling when I consider thought experiments like this is that it is very difficult to define expressions like "too powerful" with precision. This imprecision leads to the effect where we twist our explanations to suit ur biases.

So if we think Lisp is "too powerful" and that it failed in some sense, the lack of precision around "power" and "failure" allow us to draw whatever conclusion we like about the relationship between the terms.

You make very good points. It's obviously very difficult to quantify the differences between programming languages. And yes, I agree, it leads to imprecision which in turn leads to biased results.

I still think it shouldn't stop us from doing the exercise anyway. We might draw "whatever conclusion we like about" it, but it's still a way to move forward. The wiki page in the original link is not trying to convince the reader of anything (or at least the first few posts). It's a user sharing his or her insight on his experience with Lisp. It resonated with mine. Reading this helps me put words on something I've been feeling for a while. We might both be wrong, but at least it helps me in some way.

What I'm trying to say is that languages may be equivalent (Turing!), they're not exactly equal. Our inability to measure the differences with precision should not prevent us from comparing experiences. I am not interested in adopting the manager's point of view of "which language should be best for my project/team?"; I'd rather take the young pupil's point of view of "let's discover how these guys do it". After all, I'm a younger (in programming years) than many people around here.

Your original comment seemed to imply that a language's worth is tied to the popularity of the platform running it. I personally find this aspect the least interesting in programming languages. Maybe because I'm not an entrepreneur and I don't necessarily feel like one.

Too powerful has many facets.

Take languages like Ada. They were designed so that individual code pieces are understandable from reading them without further external context. The DoD had requirements for this.

On the opposite side is something like Lisp. You look at a simple expression inside some piece of code. Basically it can do arbitrary things you don't see from looking at the expression. You need to understand static and dynamic contexts. You can completely alter the meaning of every single expression on many levels (from macros to the Meta Object Protocol). In the Java world you would need a preprocessor for that. Lisp has this built in. Thus one can program in a language in a language in a language. Debugging and program maintenance gets a nightmare without total self discipline.

One can develop on a level without much of the self-modification - but there actually exists quite a lot software which makes use of advanced Lisp features.

On interesting argument in favour of Haskell, is exactly that it takes the right powers away from you. The powers that allow parts of your programme to screw with other parts: side-effects.

How should we measure "power", though? I mean, Turing completeness is Turing completeness. You can do in one what you can do in another. So is power conciseness, then? Is it clarity? Is it maintainability? All/None of the above?

One possibility is to use Felleisen's notion of expressiveness: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.51.4.... The gist is that Turing completeness concerns what you can do with whole programs, but expressiveness concerns what you can do in smaller scopes.

Reply on news.ycombinator.com