DIY-ABILITY

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.

 - The Free Thinker.