Lambda the Ultimate

...even if the punchline takes too long. :-)

Just to have the list in one place, instead of scattered about:

• Learnability: There is nothing more important that you can do with a language than to learn it.
• Consistency: The most important feature of a language is that it is completely consistent. There should be no inconsistency or nuance or shade of meaning.
• Simplicity: Simple things are easier to learn, so the language will optimize for simplicity, having as few commands as possible.
• Comprehensiveness: A language with support for different platforms and paradigms and tools is better than a language without, so the standard distribution will include support for everything useful.
• Power: Programmers should be able to accomplish anything they envision with ease.
• Enforcing Good Programming Practices: Maintainability requires developer support.
• Invariant Code Formatting: Inconsistency breeds unfamiliarity.
• Naming: Clear thinking promotes clarity.
• DRY: Repetition is hazardous and troublesome. Eliminating repetition eliminates dangers.
• Static Analysis: Finding and fixing errors before running a program is easier than finding and fixing them after deployment.
• No Compiler or Platform-Specific Code: Portability prevents strange bugs.
• A Powerful Type System: Forbidding incorrect operations as early as possible prevents bugs.
• Provability: Correct code has fewer bugs.
• A Single Development Environment: Foolish inconsistency is the hobgoblin of lazy minds.

My personal pet peeve is that Type Systems have much more purpose than simply finding errors, but at least he includes it in the list.

From part 4 of the article:

Using the Eclipse IDE improves the Perl programming language by use of garbage collection, freeing programmers from manual memory management.

This is an odd statement, to say the least. Was "Perl" meant to be some other language or has the author just completely flubbed it?

While I like the idea of talking about program maintainability, I don't think the author's ideas were clear or well thought out.

"Finding and fixing errors before running a program is easier than finding and fixing them after deployment."

While this is obviously true; I would argue that it is also true that it is faster to fix errors for code that you didn't have to write (ie. time=0) than it is to fix static errors in code that you did. What I mean by this is that overly strict static languages often force you to write new code where a more flexible language would let you reuse existing code. Maybe you can debug static code 's' times faster, but if you have to write 'd' times more code, then you only benefit if s > d. The actual values for 'd' and 's' will depend on the project (potential for reuse) and the developer(s) (ability to reuse).

I think a maintainable language should also be: 1. easy to read, 2. easy to modify, 3. easy to refactor.

1. Readability is VERY important. I think it is well known and not necessary to explain anymore.

2. Maintaining a program is somehow modifying it, adding functions, or changing its behavior. Therefore, a maintainable programming language should allow maintainers change the programmes easily.

3. Refactoring is a kind of modification of program, but only the structure of the program is changed and the functions and the behavior are kept unchanged. Refactoring is also important in maintenance, so the ability of refactoring should also be concidered.

For those who were left wondering where exactly the punchline is: based on my previous discussions with chromatic on other forums my understanding is that the entire essay is supposed to be the punchline. From chromatic's point of view, Perl represents an ideal language, and does everything that a language needs to do to be very maintainable - thus all the various restrictions cited in the article (you'll note largely things that Perl doesn't have, or doesn't do well) are, from chromatic's point of view, silly superfluous things that should rightly be laughed at. Those of us who feel that things like powerful type systems, strong static checking, clear learnable syntax, and consistency, are good things... well we're all just left a little puzzled as to what the joke was supposed to be. The thing to keep in mind while reading the article is that it is written from the point of view of people who think Perl is the world's most maintainable language.

My favorite one is "Power: Programmers should be able to accomplish anything they envision with ease." Yes, that is definately on my wish list!