Listen to pod cast
Having spent the last 25 years programming everything from
IBM mainframes, Apple II, OS/2, Macintosh, Unix, and Windows systems, using
assembler, C, C++, Java, JScript and C# I've often thought that what we are
doing as programmers is absolutely crazy. Deep down I say to myself, “there
has to be a better way”! Ryan
Dahl expresses this sentiment perfectly on his blog.
We (programmers) are all drowning in complexity and users
can tell. They get frustrated and yell at the screen every time the software does
something stupid. We programmers hate having to deliver imperfect software.
But perfection just seems unattainable on any sort of reasonable schedule which
is frustrating and demoralizing.
Some blame management for not giving us enough time to
finish the job. Some blame the tools and languages we are using. Some blame
the layer upon layer of stuff we are building on top of. Some say we just
haven’t invested enough in testing our software.
Either way, I claim it is a complexity problem. We
as an industry have hit a complexity ceiling and we can’t seem to break
through. The biggest, best, most well equipped team in the world cannot handle
more than about 50,000,000 lines of code. At this point they hit a complexity
limit that can only be solved by removing stuff.
Everyone I’ve talked to about this acknowledges there is a
problem. But what amazes me is the lack of desire to do something about it. The
usual answer I hear is “let software evolve” and “it’s too expensive to re-engineer
from the ground up”. Well, we’ve let it evolve for 40 years and look at the
mess we are in! Saying it’s too expensive to make a quantum leap into
something better is a ridiculous argument because we don’t know what that thing
is yet, so how can we possibly know it’s too expensive?
Let me make a bold statement. Evolution isn’t working.
We are actually just going around in circles re-inventing the same old crap. There’s
a radical, scary thought. So we chase the next new thing, jump on it, hoping
it will change the world. Some get more popular than others, and in this
highly connected world, the rate of new things appearing, and the rate of
adoption of those new things seems to be increasing. But in the end we all
come away with that sinking feeling that Ryan talks about so eloquently.
They say 50% of the solution is knowing what the problem
is. Well I claim the core problem is that we are using 2 dimensional tools and
languages to solve an N-dimensional problem. Languages and their accompanying
tools are really great at two things, functional decomposition of a problem,
and the linear execution & debugging of the resulting code. Well it’s
better than nothing, but today programmers also have to worry about threading,
security, compatibility, reliability, performance, load balancing, fault
tolerance, testability, installation, updating, patching, and so on. I claim there
are about 30 dimensions like this dissecting our code turning it into a big
stinky pile of dung, and we are the dung beetles scurrying around busily trying
to make the pile of crap less stinky. So next time your manager asks how you
are doing you can say “I’m as busy as a dung beetle” J
It is clearly crazy that we are still programming for-loops in
this day and age. Some say the solution to all this stop writing code, let the
machine do it based on a Model Driven Architecture. The idea being computers
will be better at solving these N-dimensional problems and coming up with bug
free code that implements the desired behavior. Sounds good, but I haven’t
really seen it achieved yet.
Some say the answer is intentional programming; the problem
is we just haven’t been formal enough about all our intentions in code, and
once we add that rigor and provide tools that know how to reduce those
intensions to code then we’ll be good. The zed specification language, program
proving and all that stuff fit in this camp.
Some say the answer is dynamic languages and/or aspect
oriented approaches. This camp essentially says, screw it, systems should be
more dynamic, let me just add my piece of crap wherever I want to add it, and
get out of my way. Interesting approach for cowboys.
Some say we have enough software, we should just stop making
more because we’ll probably only make things worse. We should be happy with
what we’ve got. This is the old fart camp and they’re really full of it.
I say we need a quantum leap in computer science, and
we need the new generation of programmers coming out of college to grab hold of
this idea and run with it. Don’t be happy with the status quo. Continually
push the boundaries on every front. Question deeply everything you’ve been
told. Whoever discovers the quantum leap and smashes the 50m lines of code
ceiling will rule the software world for the next 100 years and lead us into
the Star Treckian realm of billions of lines of code working seamlessly together
to create a better world.
If you are still reading you’re probably wondering what I’m
smokin’ but I claim this will happen sooner than you may think, and I also have
a hunch it may well be triggered by a discovery in the rapidly advancing world
of biochemistry. Life systems are many orders of magnitude more complicated
than any software system we have yet built, yet somehow all that complexity is
boiled down to some seemingly simple DNA encodings (I say seemingly because I
don’t think we really know yet how DNA actually works). But what is the true
DNA of software? What are the proteins, the amino acids, the true patterns
that govern entire complex software systems. The amazingly cool thing for
anyone entering the world of computer science is that we simply don’t know yet.
It is still the wild west.
So I’m a total optimist. While the state of the art is a
big stinky pile of crap, the future will bring new and exciting breakthroughs.
The opportunity for this sort of discovery is reserved to a very small group of
folks who are actually looking for it, so it is truly exciting times ahead for them.
Too Much Stupid Software.mp3 (5.14 mb)
Subscribe