[Baypiggies] Chompapps Position - from Issue 31

[K. Richard Pixley]

Dennis Reinhardt wrote:
> The half-life of technical knowledge was thought to be 5 years some 40 
> years ago.  I don't think it is even that long now.  Consider the 
> topics of the last year's Baypiggies.  Are half the foundations of 
> those talks over 5 years old ... or more like 18 months?  How old are 
> the tools, files, and technologies you deal with.  Are half over 5 
> years old? ... or less?
Please note that python, our primary focus here, is 18 years old.

While it is true that technology moves on, that statement about half 
life from 40 years ago applied to a tiny body of existing computer 
technology.  While our technology improves and explodes, we also now 
reuse a significantly higher portion than we did 40 years ago.

Gone are the days when every computer manufacturer designed their own 
CPU, memory architecture, hardware, buses, interfaces, peripherals, and 
operating systems.  Gone are the days when every vendor had their own 
pet programming language in which their proprietary operating system was 
written.  Instead, the computer world has been reduced to essentially 
two operating system architectures, (each with a handful of major 
variations), a small number of CPU architectures, (x86, amd64, arm, 
powerpc, ...), and essentially one general purpose computer architecture 
(with some major variations).

Partly /because/ we move so fast, and partly because we have a much 
larger existing body of technology now, it is no longer possible to 
design everything from scratch while remaining competitive.  Instead, we 
reuse large portions of technology from previous projects.

I spoke with a mobile device company yesterday who is about to release 
their first product, 
(http://en.wikipedia.org/wiki/Barnes_%26_Noble_nook).  It has been 6 
months in the making.  That's all.  Just 6 months from design to release 
of an entirely new product line.  The device includes arm cpu, android 
OS, 3G (data only) uplink, custom hardware and industrial design, (from 
available parts), and custom software apps, (leveraging existing 
technologies).  This was unprecedented 40 years ago but becoming common 
today.

I'm currently working on a well known mobile device.  Our primary 
technologies are:

    * C, (~40 years old)
    * Make (~40 yo)
    * gcc (30 yo)
    * GNU (~30yo)/Linux (18 yo)
          o which is directly descended from Unix(tm) (~40 yo)
    * debugging using gdb (30 yo)
    * cross/embedded techniques (>40 yo)
    * continuous build and parallelism techniques (>30 yo)
    * arm architecture (26 yo)
    * subversion (10 yo)
    * openembedded (>5 yo)
          o the openembedded build tool is bitbake, which is written in
            python.
          o bitbake "recipie"s are written in bitbake, which uses python
            escapes much as C code sometimes uses assembler escapes.
    * custom device drivers (<2 yo)

Although largely outside my domain and restricted to perhaps half of the 
engineers on the project, we also work with:

    * javascript (14 yo)
    * eclipse (>8 yo?)
    * prototype (5 yo)
    * proprietary frameworks (<2 yo)

Of course most of these technologies are under active development or at 
least active maintenance.  So it's not entirely accurate to say that 
we're using 40yo technology.

My point here is that I'm working on a very modern project and yes, a 
significant portion of the technology involved extends back 40 years or 
more.

--rich
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/baypiggies/attachments/20091030/62cff692/attachment.htm>