In Paul Graham's essay Revenge of the Nerds (Read it, good ideas there):
As an illustration of what I mean about the relative power of programming languages, consider the following problem. We want to write a function that generates accumulators-- a function that takes a number n, and returns a function that takes another number i and returns n incremented by i.
(That's incremented by, not plus. An accumulator has to accumulate.)
In Common Lisp this would be
(defun foo (n) (lambda (i) (incf n i)))
In Smalltalk the code is slightly longer than in Lisp:
foo: n |s| s := n. ^[:i| s := s+i. ]
because although in general lexical variables work, you can't do an assignment to a parameter, so you have to create a new variable s.
Well, the Lisp code has 34 significant characters while the Smalltalk code has only 25 significant characters (we can remove the last dot). So the Smalltalk code is 26% shorter than the Lisp code :)
- Perl example: 32 characters
- Python example: 54 characters
Yeah, Smalltalk is really powerful ;P
Looking at Parser code we can easily remove the temp. variable limitation and write:
foo: n ^[:i| n := n+i]
- One power of Smalltalk is to be able to change the system.
- 17 significant characters: Smalltalk 100% more powerful than Lisp :D (still a joke - but ....)
Why this design decision ? Some explanation from Nicolas and Adrian.