[Edu-sig] quantum instance

Laura Creighton lac at strakt.com
Mon Sep 19 12:21:28 CEST 2005

In a message of Sun, 18 Sep 2005 16:45:21 PDT, "Kirby Urner" writes:

>Perhaps my version of Python is evolving at a faster rate, and in differe
>directions, than you necessarily need in your version, for what you're
>trying to do.  What's the harm in that, as long as your code still runs?

There is enormous potential harm in this.  The problem is that
programming is not an individual activity.  When new features make
code harder to read, or harder to understand, then readers are
penalised at the expense of writers.  When bugs are easier to make,
or harder to detect when reading code, then everybody suffers.

This is terrible for the productivity of a company.  Once your company
is beyond a certain size -- the exact number is subject to debate, and
it varies depending on what language you use -- and once your codebase
is beyond a certain size, you will find that you spend far, far, far
more time _reading_ code than _writing_ it.  The more senior you are,
the worse this is, and managers often end up writing little or no code
at all.

This means that any productivity gains you get when you add {feature}
which makes it easier to write code X has to be weighed against the
productivity losses when you have to read {feature}.  Since readers
outnumber writers, there comes a point where no feature should be
added that produces less-readable code, on the grounds of productivity
gains to the code-writers alone.  Remember, the productivity of a 
company is not driven by the speed at which your coders can write 
new code.  Instead it is the speed at which they can understand the
codebase, and the ease in which they can make modifications to it, and
how bug-free those modifications are that matter.  So if your new
feature makes the code harder to read, it had better make certain
bugs harder to make, or certain modifications easier to make in a
bug free way, or have some other benefit.

Some languages have developed the way they have precisely because
they have persued some other benefit to the exclusion of all else.
C++ sacrifices readability for speed. This was a fine trade for
those people who absolutely must have the speed.  But as CPUs
got faster, people found their companies were more productive 
using something else.

If you have worked commercially, then you will already be familiar
with this situation.  'I don't have time to understand this code, I
will just rewrite it instead'.  This happens all the time.  Writing is
easy.  Understanding is hard.  But every time this happens, there is
an indication that something is seriously wrong in your company.
The fact that it is wrong in everybody else's company too is no
excuse, just a sad commentary on the state of the art.

Was the original code too poorly written?  poorly documented? Is the
new programmer too lazy to read the code?  Too unskilled at reading
code?  Is the old code obscure but really damn excellent at something
important, and the new version inferior? Will it cause subtle bugs?
What about the reabability of the new version?  Next week will
somebody come along, not understand _it_ either, and reinvent the
wheel a third time?

Sometimes the problem is with the language itself.  Take Perl.
I never bother, any more, trying to deeply understand what any
Perl script I find is doing.  I just rewrite it in Python.  I will
never have any confidence in my ability to 'understand' what an
arbitrary Perl script does.  I've been wrong too often.  

One of the sad things about life as a commercial programmer is that
often only the most junior programmers get to write code all day.
This is because somebody else has come and given them the specs and
told them what to write.  Everybody else has to figure out what to
write and where to write it, which requires being familiar with the
code base, which requires reading it regularly, which takes time.
This means that the coolest in new features, those meant to be used
_sparingly_ fall directly into the hands of those who do not have the
maturity and experience to know when not to use them.  With predictable
results. :-)

This means come code review time, you have to waste a whole bunch of
time explaining to your junior people why they need to rewrite their
code to not use this feature.  This makes code review a lot more 
painful and acrimonious than it was.  And it is difficult on the
reviewer.  What do you say when you are only 65% convinced that this
is a poor use of {feature}?  Especially when what you want to say
amounts to 'my XX years of experience in the field say that this is
too cutesy?'  Your junior programmers may only conclude from this that
you are an senile old fart.  You may conclude that they lack the
wisdom that God gave green apples.  Age-based splits in your company 
are among the hardest things to combat and sap morale and team building.
Pair programming will not work unless there is mutual respect.

In general, the greater the difference between 'your best people'
and 'your worst people' the harder productivity suffers.  If the
language is hard to use, you may find out that only your top people
provide positive value to the company.  Your worst people subtract
value.  Not only do the things they write have to be rewritten, but
everybody wastes time on bugs they caused, and talking to them with
their problems and so on and so forth.  I once managed a project
that was late, and the only way we found to fix it was to take the
6 worst people on the team and send them to the other side of the
country to take 3 weeks of training in some damn thing that wasn't
even relevant to what our company did -- I forget what.   Then
everybody else got the job done.  But those 6 people didn't learn
much about how to be productive.  What they really needed was 
training in UI design and how to use C++ without screwing up so much.
But Andrew Koenig hadn't written _C++ Traps and Pitfalls_ yet,
so we couldn't give them a course based on it.  And so it goes.
Some languages have grown so much that only experts can be
productive with it.

What's more, even after you have your own company in shape, with nobody
abusing the new features any more, you still have to interface with
code written by people who do not work for your company.  And they may
not have as strict a set of standards as you do. If the innappropriate
use of a new feature makes for buggy code, then you may be forced to
not use some package that over-uses the feature despite its attractiveness
in other ways.  And you have absolutely no control over these people.

Even deciding whether to use somebody else's code requires reading it.
If the code is hard to read, you may find that you do not have the
time.  Obscure language features can make 'spot the poorly written
code' game a lot harder.  What you need is a way to quickly tell if
the code you are reading is good or not.  For my own peace of mind, I
have decided that 'anybody who over-uses language feature X as much as
those guys do is statistically unlikely to be up to anything good' - but
I know as well as anybody that 'statistically unlikely' is not the
same thing as 'never'.  What opportunities are being missed?

It is the tragedy of the commons all over again.  Code-writers have
the interest and motivation to add every feature they dream up into
the languages they create, in the same way that sheep-owners have
the interest and motivation to overgraze the commons.


More information about the Edu-sig mailing list