So What's Up With Those Tiles?

2024-11-01

Readers of this site may notice my little tiles (⠵) I've used for quite some time now as somewhat of a logo. I've never really drawn attention to them but I think it's worth discussing as I feel they sum up what this blog is about.

Personally, I think it neatly sums up the kinds of boxes I fit in. The tiles (Actually the braille character for 'Z') give a passing resemblance to the hacker glider - the symbol for all things hacky, nerdy, and geeky.

Creatively, I think it neatly sums up what the broad goal of this blog is: seeing computing as a series of building blocks. Often times when we hear about computing in the news, it's framed as some magical breakthrough that was simply summoned from the ether. For many, the likes of ChatGPT or the Apple Vision Pro (AVP) was as if we had stolen technology from the future - a refrain I remember hearing often upon their releases was "Computers can do that?". Not that computers 'could' do that but that computers 'can' do that. The potential was always there; emboldened by decades of research that gradually pieced together our understanding - like building blocks.

I wouldn't expect your typical user to know how such a device or piece of software works or what lead up to them; but even amongst those with a technical background, many I knew were unaware of the rich history that built to that moment - in many cases work that was carried out on dramatically less powerful machines. It's that kind of thinking I try to push forward with this blog: how can we take a step back from whatever the 'current thing' is and look at what came before? Anchored to days of computing of yore: what's a technically simpler approach that could achieve similar results? How can we write software that is built to last and makes the most of every last clock cycle?

I fuss excessently on this site about keeping tech simple, that we should try do more with less; not necessarily that the answer is less computing but that we should use what we do have more effectively. There is an immense value in looking at what came before: what research paths have been forgotten? Some just because we didn't quite have the processing power or the storage space needed at the time but in other cases we've rightly moved on having found better techniques. To return to the ChatGPT example, we're no longer building AIs by mapping the relations between millions of entities by hand in Prolog. The same with the AVP, I doubt users would still appreciate you mounting CRTs to their eyes.

I enjoy seeing breathtaking tech demos and products as much as anyone but as technologists we play a dual role - both as the end-user but also the ones responsible for creating the thing the end-user will use. It's this blogs view that we can go further by thinking simpler. Simpler software is often easier to extend, maintain, and reframe for new platforms, contexts, and use-cases.

Nobody wants to build deliberately hard to main, obtuse, and outright kafkaesque software that feels like it's only barely holding it together but the nature of reality is that such desires often have to take a backseat to actually getting something out the door. My concern is when these choices happen subconsciously - we'll use an LLM because everyone else does, even when a basic neural network would do. We'll use this library because everyone else does - even when you could just write it yourself. We'll use React or Gatsby or Angular when a single HTML file chucked onto a server would do.

If this blog can show you how to take a step back, rationally assess what your problem is, what solutions are available, and work forwards from what the most simple approach can't do rather than starting with the most complex and going backwards, it'll have done its job.

But with that in mind, let's build from here. ⠵.