TITLE: It's All Just Programming
AUTHOR: Eugene Wallingford
DATE: November 02, 2009  6:59 PM
DESC: 
-----
BODY:
One of my colleagues is an old-school C programmer.
He can make the machine dance using C.  When C++
came along, he tried it for a while, but many of
the newly-available features seemed like overkill
to him.  I think templates fell into that category.
Other features disturbed him.  I remember him
reporting some particularly bad experiences with
operator overloading.  They made code unreadable!
Unmaintainable!  You could never be sure what
<FONT SIZE="+1"><TT>+</TT></FONT> was doing, let
alone operators like <FONT SIZE="+1"><TT>()</TT></FONT>
and casts.  His verdict: Operator overloading and
its ilk are too powerful.  They are fine in theory,
but real languages should not provide so much freedom.

Some people don't like languages with features that
allow them to reconfigure how the language looks and
works.  I may have been in that group once, long ago,
but then I met Lisp and Smalltalk.  What wonderful
friends they were.  They opened themselves completely
to me; almost nothing was off limits.  In Lisp, most
everything was open to inspection, code was data that
I could process, and macros let me define my own syntax.
In Smalltalk, everything was an object, including the
integers and the classes and the methods.  Even better,
most of Smalltalk was implemented in Smalltalk, right
there for me to browse and mimic... and
<A HREF="http://www.cs.uni.edu/~wallingf/blog/archives/monthly/2005-11.html#e2005-11-05T14_14_59.htm">
   change</A>.

Once I was shown a world bigger than Fortran, PL/I, and
Pascal, I came to learn something important, something
Giles Bowkett
<A HREF="http://gilesbowkett.blogspot.com/2009/07/do-you-believe-in-magic.html">
   captures in his inimitable, colorful style</A>:

<BLOCKQUOTE><EM>
There is no such thing as metaprogramming.
It's all just programming.
</EM></BLOCKQUOTE>

(Note:  "Colorful" is a euphemism for "not safe to read
aloud at work, nor to be read by those with tender
sensibilities".)

Ruby fits nicely with languages such as Common Lisp,
Scheme, and Smalltalk.  It doesn't erect too many
boundaries around what you can do.  The result can be
disorienting to someone coming from a more mainstream
language such as Java or C, where boundaries between
"my program" and "the language" are so much more common.
But to Lispers, Schemers, and Smalltalkers, the freedom
feels... free.  It empowers them to express their ideas
in code that is direct, succinct, and powerful.

Actually, when you program in C, you learn the same
lesson, only in a different way.  It's all just
programming.  Good C programmers often implement their
own little interpreters and their own higher-order
procedures as a part of larger programs.  To do so,
they simply create their own data structures and code
to manipulate them.  This truth is the raw material out
of which
<A HREF="http://philip.greenspun.com/research/">
   Greenspun's Tenth Rule of Programming</A>
springs.  And that's the point.  In languages like C,
if you want to use more powerful features, and you
will, you <EM>have to roll them for yourself</EM>.  My
friends who are "C weenies" -- including the
aforementioned colleague -- take great pride in their
ability to solve any problem with just a bit more
programming, and they love to tell us the stories

Metaprogramming is not magic.  It is simply another tool
in the prepared programmer's toolbox.  It's awfully nice
when that tool is also part of the programming language
we use.  Otherwise, we are limited in what we can say
conveniently in our programs by the somewhat arbitrary
lines drawn between real and meta.

You know what?  Almost everything in programming looks
like magic to me.  That may seem like an overstatement,
but it's not.  When I see a program of a few thousand
lines or more generate music, play chess, or even do
mundane tasks like display text, images, and video in
a web browser, I am amazed.  When I see one program
convert another into the language of a particular
machine, I am amazed.  When people show me shorter
programs that can do these things, I am even more
amazed.

The beauty of computer science is that we dig deeper
into these programs, learn their ideas, and come to
understand how they work.  We also learn how to write
them ourselves.

It may still feel like magic to me, but in my mind I
know better.

Whenever I bump into a new bit of sorcery, a new
illusion or a new incantation, I know what I need to
do.  I need to learn more about how to write programs.
-----