I recently came across an excellent series of articles describing the development of the Amiga personal computer. I'm a sucker for these types of articles, I've read Soul of a New Machine countless times (I highly recommend that any budding electronics engineer get a copy) and have gone through the folklore.org site which contains a large collection of insider stories about the development of the original Macintosh more times than is healthy for me as well.
Stories like those described in the sites and book I mentioned above are what enticed me into the career I now have; I wanted to be a part of the process of designing and building something brand new, something that you could see and hold and touch - not just some ephemeral software product.
I do get to do that, to an extent, in my real job and I feel very lucky in that respect. I've brought up Linux on a number of different boards, ported Android to a new device and I'm currently doing another Android port to a different device. Each of these devices has had some sort of custom hardware that I've had to provide interfaces for so that the application layer can communicate with it easily, reliably and quickly. In many respects I am doing the job I dreamt about and have at least a little bit in common with the engineers I read about while I was in my teens.
Somehow though, and I run the risk of being the grumpy old man talking about the good old days here, it doesn't seem as real as what I had expected. Today we have far more tools to help us and existing technology that can be re-purposed - bring up Linux on a new board, as long as it's not a brand new processor, is not actually that difficult. The same goes with Android as it essentially just sits on top of a Linux kernel. Sure, it's fiddly and you might need some inspired hacks to get things working just right but getting Linux to boot and spit something out of a serial console usually doesn't take all that long.
If you read about the history of the original Macintosh, the Amiga and the Atari ST you'll find a very different story - there was no Linux to just port across and fine tune, the whole system had to be built from scratch. Getting the first simple things to work was a giant leap forward:
Sometime in December we started getting chips from the fabs and the real hardware began to come to life. We booted the ST for the first time (it was exhilarating to see the floppy disk spin and seek under OS control - this is something that you take for utterly for granted until you have to make it work yourself). The Atari ST (Part 1) - Landon Dyer
This is one of the reasons I spend a lot of time playing around with microcontroller projects - they are small enough for a single person to fully understand, large enough to do something useful with and have enough resource constraints that it can be a challenge to get them to do what you want them to do. Thankfully they are also cheap enough that when you break one (and you will) it's not going to break the bank as well.
Even the smaller hobbyist friendly microcontrollers (the PIC and AVR family for example) are more powerful than most of the CPUs used in the 70's and 80's not to mention the 32 bit chips that are readily available (ARM and MIPS cores in 28 pin DIP packages from NXP and Microchip respectively). It would probably be possible to get all the functionality that the original 128K Macintosh had in a system based around a PIC32MX150 chip - a pointless exercise really but wouldn't you learn a lot doing it?
I love seeing projects like these (and there are quite a few around the net, like this CPM emulator implemented on an AVR chip) and have a few ideas of my own I'd like to work on. It's one way of reliving the earlier days of the home computer era - the days of the Homebrew Computer Club, machines built by hand and customised by their owners and roll your own BASIC implementations.
Apart from the retro aspect it is a great way to learn more about the underlying structure and implementation of computing devices and pitting yourself against the restrictions and limitations of such small systems is a great way to learn how to write better code for any system. Any existing (or aspiring) programmer or engineer should spend at least a little bit of time playing with systems like this - it's great fun, extremely satisfying and will improve your technical skills as well.