You know I don't think I'd ever actually clean my fridge if it was
one of those modern ones that didn't need defrosting every few
months. As it is I usally only get around to defrosting it when the
freezer door breaks off, then accept that I might as well give it a
clean while it's empty anyway.
Anyway I've been meaning to write a post on 'DIY-ability' for most
of the year, but it was going to take way too long to put down all
my thoughts. In the mean time I read various posts from other
phlogs that tied into it neatly, but I've forgotten them now, and
actually I've forgotten most of what I originally wanted to say.
This is great! It means I've distilled everything down into a less
interesting, less precise, but much quicker to write, little
summary. So without further blabber:
Gopher is more 'DIY-able' than the web because it's much simpler.
Programming libraries aim to simplify implementing things, but
thereby encourage the growth of underlying complexity, so that it
becomes impractical to implement things in a way not envisaged by
the library creator. Things can be made easier, but less DIY-able,
they help you to do one thing while steering you away from being
different.
Software also relies today on decidedly unDIY-able hardware. Based
on highly complex integrated circuits that not only can't you
replicate yourself, but quite often can't even be bought in single
quantities.
Of course this is the consequence of technological and perhaps also
social development. But in software it reaches an extreme. In most
trades it's quite possible to understand all the physical processes
involved in producing a product. An average worker in a machine
shop could learn how iron ore is mined, smelted, machined,
installed into a larger machine. They might not want to, but it is
nothing that requires more intellect than needed anyway for their
own job. A farmer knows not only how to grow their produce, but the
mechanics of the machines he uses to work the soil, and what is
done after leaving his farm before his produce goes on sale.
But where is the programmer, whose software works on top of many
layers of operating system code, who really understands all of that
code? In doing so they must understand all of the protocols and
sub-systems that interconnect in the computer hardware, even now
within single chip. Would they also know exactly how those chips
are designed and made, then linked together, and back to how the
minerals they are made of are mined and refined? You'll struggle to
find one, or even to teach one, because it is simply too much, and
it doesn't help them to make a living.
But it is what I dislike about modern programming and electronics.
I like to stick with the technologies that I can truely understand
and manipulate just how I like. In this way I prefer working with
logic chips and discrete analogue electronic components instead of
microcontrollers and computers. If driven to a microcontroller, I
would prefer something like an 8051 programmed in assembly to a
modern PIC32 or a Raspberry Pi which adds complexity and at the
same time puts so many road blocks in your way to really knowing
how every part works; so many things they just don't bother to
explain. You get forced into using certain programming languages,
and in turn programming techniques, and libraries, and protocols
that are aren't designed to be easily understood.
With my preferred level of electronics, the libraries and the
systems designed by others aren't the limit, it's the pure physics.
The physics that you craft into serving your will, the most direct
and simple way that you can. The same as a woodworker could make or
adapt their own tools or techniques, and a mechanical engineer can
determine new ways to build machines. It's the freedom to do what
is truely possible, the way that seems best to you, and you can't
personally get that control, even the understanding of how it could
work, when perched atop the tower of technology where modern
software development sits.
Well I haven't condensed this, I've just worked may way back to an
old gripe about how I can't make money making my old-fashioned
style electronics, and all of these modern microcontrollers and
things annoy me. But the point that I originally wanted to make was
that half the trouble is that people don't consider DIY-ability.
They don't consider how difficult a system is to learn if you don't
just use the process that they provide for interacting with it. The
web of course is an example, where increasingly people expect page
authors to use frameworks, and script everything with Javascript,
adding more layers, forcing web browsers to become so complex that
you can't even understand them alone. Gopher is much more DIY-able,
perhaps not as much the protocol as the decision to still use it
today. It shows a consciousness for DIY-ability, an attempt to
compromise, to offer a modern service yet not dig needlessly deep
into an isolated pit of designed complexity.
