[FoRK] Armor-piercing silver bullets

[Jeff Bone]

Fred Brooks famously claimed in a 1986 paper [1] that there are "no  
[more] silver bullets" in advancing software technology, i.e. no more  
innovations to be had which would increase programmer productivity by  
more than twofold in a matter of two years.  In making this  
pronouncement he was addressing improvements that would in some way  
reduce "essential complexity" --- and noted that by reducing  
"accidental complexity" we might see improvements on the order of a  
tenfold increase over a decade.

There are a number of folks that appear to think that maybe Brooks was  
wrong.  From among these folks we see efforts such as Paul Graham's  
Arc, which appears to be tackling at least the accidental complexity  
part of things, by embedding an implicit processing model (based on  
continuations, never mind that this fundamentally breaks the Web and  
in effect creates just another monolithic "software jail" in which our  
data may be incarcerated) into a web application server.

More interesting, though, is the recent STEPS effort [2] involving  
Alan Kay and friends at the Viewpoints Research Institute. [3]  (Nb.,  
various folks including myself have mentioned the constituent research  
projects of this umbrella project at various points on this list.)   
Their project is quite a bit more ambitious, hoping to "reduce the  
amount of code needed to make systems by a factor of 100, 1000, 10000,  
or more."  (Yes, you read that correctly.)  And despite this ambitious  
and admittedly somewhat scattershot research effort's relatively short  
history to date --- it's just over a year old --- they're  
demonstrating some impressive achievements:

   - a meta-compiler / language toolkit (OMeta) written in about 100  
lines of itself
   - a runtime core including the language toolkit in about 1000 lines
   - usable implementations of TCP and IP totaling less than 200 lines  
of code
   - a significant, useful subset of Cairo (realtime next-gen  
PostScript) in less than 500 lines
   - high-performing Javascript in 170 lines of code
   - Prolog, 90 lines
   - vector graphics toolkit, 450 lines of code
   - Smalltalk, 200 lines
   - Logo, 50 lines

And so on.  Note that these do not comprise a single usable system as  
yet;  this is a research project consisting of numerous discrete and  
independent projects.  One might expect line counts for individual  
subsystems, language implementations, and so on to go up and the  
system evolves and merges into a single artifact --- if it ever does  
--- but one might also expect downward line-count minimizing pressure  
as more common code is refactored and abstracted out.


Interesting stuff...

jb

[1] http://en.wikipedia.org/wiki/No_Silver_Bullet
[2] http://www.vpri.org/pdf/steps_TR-2007-008.pdf
[3] http://www.vpri.org/