From: Martin DeMello <martindemello@...>
Date: 2006-09-15T17:19:14+09:00
Subject: Re: Matrix

On 9/13/06, MonkeeSage <MonkeeSage@gmail.com> wrote:

> I do like Dave's idea about having a named method to do the in place
> modification, though; that would make sure You Really Mean It and
> eliminate the typo where you meant == but actually wrote =.

Paul Graham had an excellent rationale for allowing this sort of thing
in one of his essays on language design :

Hackability
----------------

There is one thing more important than brevity to a hacker: being able
to do what you want. In the history of programming languages a
surprising amount of effort has gone into preventing programmers from
doing things considered to be improper. This is a dangerously
presumptuous plan. How can the language designer know what the
programmer is going to need to do? I think language designers would do
better to consider their target user to be a genius who will need to
do things they never anticipated, rather than a bumbler who needs to
be protected from himself. The bumbler will shoot himself in the foot
anyway. You may save him from referring to variables in another
package, but you can't save him from writing a badly designed program
to solve the wrong problem, and taking forever to do it.

Good programmers often want to do dangerous and unsavory things. By
unsavory I mean things that go behind whatever semantic facade the
language is trying to present: getting hold of the internal
representation of some high-level abstraction, for example. Hackers
like to hack, and hacking means getting inside things and second
guessing the original designer.

Let yourself be second guessed. When you make any tool, people use it
in ways you didn't intend, and this is especially true of a highly
articulated tool like a programming language. Many a hacker will want
to tweak your semantic model in a way that you never imagined. I say,
let them; give the programmer access to as much internal stuff as you
can without endangering runtime systems like the garbage collector.

In Common Lisp I have often wanted to iterate through the fields of a
struct-- to comb out references to a deleted object, for example, or
find fields that are uninitialized. I know the structs are just
vectors underneath. And yet I can't write a general purpose function
that I can call on any struct. I can only access the fields by name,
because that's what a struct is supposed to mean.

A hacker may only want to subvert the intended model of things once or
twice in a big program. But what a difference it makes to be able to.

-- http://www.paulgraham.com/popular.html