January 23, 2010 at 10:32 am Leave a comment

There are very few rules in programming that are always right. Ever rule ends up losing a fight when it ends up in the wrong corner.

There is however one rule that seems to be always correct, in whatever code base it wanders into, and that rule is : less.

Because you see, less code is less prone to have bugs, because there is less of it.
Concise is also less than verbose, which means that if you go less you have a good chance of making yourself understood.
Less also tends to be faster because there is less to transfer and execute.
You are forced into writing better abstractions by writing less code, because you have less real estate to express semantics.
Redundancy is reduced by orders of magnitude when you try to have less code because redundancy is trivial to remove.
Less is easier to refactor, because you have to refactor less.

You could try to argue that less is just the result of striving for orthogonality, speed, clear code and zero bugs, and that I have it backwards. But you would argue wrong.


Entry filed under: Command Line.

I like, eees nice elife

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

Trackback this post  |  Subscribe to the comments via RSS Feed

Recent Posts


%d bloggers like this: