Graham's Law of Power
Because making programs short is what high level languages are for. It may not be 100% accurate to say the power of a programming language is in inverse proportion to the length of programs written in it, but it's damned close.
Paul Graham, "Take the Arc Challenge"
By definition, there is some optimal path from axioms up to a complete language. The Platonic form of Lisp is somewhere inside the block of marble. All we have to do is chip away till we get at it.
Paul Graham, "First Priority: Core Language"
Paul Graham, Lisp guru, founder of the startup company incubator Y Combinator and essayist, has always been somewhat of a lightening rod for controversy. He is highly opinionated and has a wonderfully concise and direct style of writing that does not back away from confrontation. So it was not too surprising to see the relish with which his detractors have criticized Arc, the language he invented, since an early alpha version was released recently.
Arc is a dialect of Lisp, with a focus on "exploratory programming" or rapid prototyping. A distinguishing feature of Arc is that it was/is built from the ground up with a focus on terse syntax that leads to short programs. As the first quote in this post illustrates, Graham believes that power is inversely proportional to program length. Program length is not equal to character counts necessarily, rather it is based on the size of the tree you'd need to represent the program. So, the first example from Arc is a program that displays a web form with an input field that parrots back what you type in when you submit it:
(defop said req
(aform [w/link (pr "you said: " (arg _ "foo"))
(pr "click here")]
(input "foo")
(submit)))
This example has 23 nodes according to Graham's counting technique and he challenges anybody to produce a shorter program using a different language.
I'm sure there will be no lack of responses to this challenge, but I find the whole premise to be flawed. The idea that a language inherently has a measurable amount of "power" in the first place is suspect. Having power means to possess controlling influence. In the case of a programming language what would it have influence over? The answer could be loosely summed up as the domain of the problem.
To be more specific, if you are writing a telecommunications system, Erlang would be a very powerful language as it grew out of that domain; however, if you were creating a rich client side UI, you might use C++ or C# with WPF. Because programming languages are used to solve such a wide swatch of problems, it is impossible to have one controlling definition of power. Power for a programming language is completely dependent on context.
The contra-argument to this is that I'm describing the libraries of languages, not their core syntax, structures and features. I would argue that you cannot evaluate a language outside of its libraries; even the definition of libraries is difficult, as in the case of Arc where a "core" language feature is a construct for creating web forms. This might be called a library in another language, but if that language decided to incorporate that library into the core, then would that language suddenly become more powerful?
To be fair let's say we ignore the problems with using the term power and accept the premise that certain languages will in general make a programmer more able to solve the problems they encounter. Graham's premise is that brevity is the key to achieving this competitive advantage.
Why would brevity be such an advantage? Less boilerplate/setup code, fewer things for the programmer to keep in their mind; these are what I could think of. I don't find either of those reasons all that compelling. Certainly attractive and nice to have, but not enough of a reason to ditch one language for another. Unfortunately, Graham seems to find the idea pretty much self evident and does not offer much in the way of supporting evidence.
Since Graham is obviously a smart guy, I got to thinking about why he would be so sure that brevity is the key component in designing a powerful language. I looked back at the example of Arc and was struck by the similarities to Shoes, a domain specific language in Ruby for creating GUI's. I spent some time creating an extremely primitive flash card program in Shoes and really enjoyed it. Here's an example of the syntax to create a simple application with a button and an attached click event:
Shoes.app {
button("Press Me") { alert("You pressed me") }
}
So Arc and Shoes possess similar compact syntax and Arc's aform construct looks like a DSL for creating web apps. Pushing the comparison further, Shoes is written in Ruby, a language strongly inclined to produce DSLs, which was strongly inspired by Lisp. And here we come full circle to what I think is the core of Graham's argument.
Graham's affection for Lisp is well known; Arc is a dialect of Lisp and he explicitly states (as shown in the quote above) that he set out to design Arc with the goal of creating the true and pure (or Platonic) Lisp.
So when Graham is saying that succinctness equals power, he is not saying anything he hasn't said before. This is really another front in the long running argument between Lispers and advocates of other languages, where Lisp, for a laundry list of reasons (including the power of macros to make short programs), is held up by its advocates as the one true language and by its detractors as a jumbled mess of parentheses and arcane incantations.
So Graham's Law of Power could perhaps more clearly be stated as the power of a programming language is directly proportional to its "Lispness." Or the more vulgar form that every other successful programming language is really just a poor implementation of Lisp.[1]
[1] I disagree with that argument, but if you are interested in hearing more, allocate a few hours and a couple of Google searches and you will find more than enough material from both sides to keep you busy.