-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

=pod

Here's something that bugs me.  For some reason, long ago, we decided
that a programming language would be a way of life.  You would pick
one, and then use the syntax, language features, tools, and libraries
that came with that language.  If you wanted some other feature or
tool bad enough, you would throw away everything you liked about your
first language and pick another one.  If you didn't want the feature
bad enough to switch, you would just live without it.

That doesn't make any sense.

Language features should be like modules that you can pick and choose
from based on your problem domain.  Want continuations?  Load the
continuations module.  Hate the guy that wrote that one?  Write your
own.  The same should be possible for type systems, optimizations,
object systems, regex engines, AST post-processing (macros), etc.  

You should be able to use any language feature with any syntax.

Of course, this isn't trivial, because not every language concept is
generically compatible with every other.  But that's OK, if you say
you want Haskell-style typing with Perl syntax, the compiler can just
die when you write an impure function.  We shouldn't have to get rid
of Perl's syntax just because some parts aren't functionally pure.
(You should only have to pay for the features you want, not what some
language designer says you should want to pay for.)

Then there's the issue of running this.  I think as long as there
is some intermediate format after the syntax and feature layers,
everyone should be happy.  If you think register-based VMs are the
best way to do things, run your languages on Parrot.  If stacks are
your thing, go for the CLR or JVM.  But what you shouldn't have to do
is reimplement your syntax and features 8000 times; one for your
native VM, one for parrot, one for the JVM, one for the CLR, one for
LLVM, etc.

Anyway, what I'm proposing is that people stop writing programming
languages just because they want some tiny feature.  If you want to
experiment with new syntax, just write a translator from Your Generic
Syntax to The Master Language.  If you want to write a new object
system, don't invent a new virtual machine and syntax, just write a
module for The Master Language!

We all know that reuse is an essential part of our trade.  It should
apply to core language features and syntax, not just the programs we
write with those languages and features!  Just think about how many
man years have been wasted porting the CPAN to Ruby and Python,
porting CLOS to Perl, etc.  If we didn't have to waste our time
reinventing the wheel, society could be that many man years ahead.

Instead of spending time translating syntaxes, we could be advancing
the profession with new ideas.  Wouldn't that be good?
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.6 (GNU/Linux)

iD8DBQFH933P2rw+dVvzZm0RAuLdAJ9i940jRcApnDM6gS7R/ZV0frJ6cACfa2RU
sySAkGElRrFpRr/2PrJjqw4=
=Houa
-----END PGP SIGNATURE-----