Along with nostrademons, I disagree strongly with that article. In my opinion, the thing that affects maintainability the most is the length of the resulting programs. What's easier to maintain, 20 lines of paren-filled code or 200 lines of BASIC garbage?
I especially disagree with the last criterion: enforcement of good programming practices. The definition of good programming practice varies greatly with the intended use, and is something that is best defined on a problem-by-problem basis. Every language I've encountered that attempted to enforce "good programming practice" has required me to write workarounds anytime I wanted to do something interesting.
One good example is writing a few Java classes that inherit from a parent in different ways, and then making a few method calls to note which method was called. I wanted to print something akin to:
"Entering class Child constructor.
Entering class Parent constructor.
Exiting class Parent constructor.
Exiting class Child constructor."
The easiest way to do this is to have something like
public Child () {
System.out.println("Entering class Child constructor.");
super();
System.out.println("Exiting class Child constructor.");
}
Unfortunately, the creators of Java decided that good practice maintains that the call to the parent constructor must occur before any other code. Because of this, I had to create silly workarounds with parameter overloading to call the parent method, something that was not at all extensible or scalable.
If you want maintainable programs, use a powerful language, hire good programmers, and agree on some common conventions. If something doesn't fit within the conventions, discuss it and clearly comment it in the code. How hard can that be?
Only so much can be automated. At some point, programmers have to take responsibility for what their programs look like, and no "maintainable language" will ever be able to solve this problem.
Can you read a legal contract and instantly understand all the implications without having to consult a lawyer? How about a mathematical paper? A medical test result?
'Worlds most X' programming language, for programming what? The ideal language in which to express something kind of depends on what you are trying to express, doesn't it? ( maybe unless you are some kind of meta lisper ( or perl6'er :) ) dreaming of a language that's a strict superset of all possible others )
There's a place in the comments of the last article in this series where a guy called Tony says, "I have one word: Scheme." And chromatic replies, "I wonder if a language that sticks so closely to the lambda calculus is comprehensible to non-math geeks."
This kind of perspective (chromatic's) is a problem. The thing is, programming languages with the property that you can build powerful abstractions and still keep the program comprehensible and maintainable almost certainly will be closely coupled with some areas of mathematics. Things with such powerful and peculiar properties usually are.
It doesn't mean that the thing in question can only appeal to math geeks. One thing you can do with Scheme's abstraction power is build abstractions that do not seem especially mathematical.
I especially disagree with the last criterion: enforcement of good programming practices. The definition of good programming practice varies greatly with the intended use, and is something that is best defined on a problem-by-problem basis. Every language I've encountered that attempted to enforce "good programming practice" has required me to write workarounds anytime I wanted to do something interesting.
One good example is writing a few Java classes that inherit from a parent in different ways, and then making a few method calls to note which method was called. I wanted to print something akin to:
"Entering class Child constructor.
Entering class Parent constructor.
Exiting class Parent constructor.
Exiting class Child constructor."
The easiest way to do this is to have something like
public Child () {
System.out.println("Entering class Child constructor.");
super();
System.out.println("Exiting class Child constructor.");
}
Unfortunately, the creators of Java decided that good practice maintains that the call to the parent constructor must occur before any other code. Because of this, I had to create silly workarounds with parameter overloading to call the parent method, something that was not at all extensible or scalable.
If you want maintainable programs, use a powerful language, hire good programmers, and agree on some common conventions. If something doesn't fit within the conventions, discuss it and clearly comment it in the code. How hard can that be?
Only so much can be automated. At some point, programmers have to take responsibility for what their programs look like, and no "maintainable language" will ever be able to solve this problem.