In this article I’m going to introduce some of the key concepts I think should be considered when building a hypothetical ‘Perfect Computer‘. Some of these concepts are based on the techniques of Steve Jobs, who in the last post we discovered wasn’t an inventor, but had a strong Grand Vision coupled with a terrifying ability to squeeze the very best from his company. However, I want to take it in my own direction, meaning that as someone who is a fan of Linux and Free / Open Source Software (FOSS) I’m keen to reap the benefits of that software development model.

So to build my idea of a Perfect Device, we need a few guiding principles:

Be the Chooser

If Apple’s CEO deserves any credit for the incredibly popular devices that his company put out, it comes from his ability to sift through the output of his talented engineers and designers, until only one solution – the best solution in his Grand Vision – remained. He pushed his employees hard, and could be a hellish man to work for or with, but that’s often the price paid for eeking out that extra 1%.

But if Jobs skill was as expert co-ordinator, and tweaker of other people’s designs, then FOSS immediately offers something that Apple could not: unparalleled quantities of raw material from which to draw our final product. If Apple engineers submitted ten proposals before Jobs accepted one, just imagine the possibilities with a global community of contributors!

Ease of Use

There’s no getting away from the fact that ‘Perfect’ needs defining, and that definition in our case is made against intended use, and intended user. The Device must be easy to use, but it must also ‘Do the Stuff’. A desktop with one button marked ‘Shut Down’ – and which does exactly what it says – is certainly easy, but not very useful.

There are a few key words we will probably want to keep in mind: consistency, discoverability, intuitiveness, suitability etc…

So we need to define our user, and define our functions. This is no easy task with a general use computer, and there will always be discussions over who our target user should be, and that’s even before we get into the nitty-gritty of what constitutes our chosen target. I will come to that in more detail in a future post.

Open Specification

To mark this project out from others (especially those which inspired it) I want it to be as Open as the software it uses. I’ve been proposing something which is not so much locked down as devoid of unnecessary options (and it will be our job to render unnecessary as many options as possible). What I want the end result to be therefore is a device that can be replicated by anyone with the necessary technical know-how, without royalties, patent licenses or other gubbins.

So it becomes an easy choice to go for ‘IBM-compatible PC’ (as it was once called) hardware, plus GNU/Linux for the software. And when I say this, I’m restricting myself to everything that comes before the user interface. That’s a whole topic in itself, so here I’m just saying that the hardware components will be easily available, and will work 100% under a GNU/Linux operating system.

In a future post I’ll talk about what hardware is necessary, especially considering the target use and user.

From the ground up

As the previous section suggests, I want to dump all existing interfaces. If, during this project, a familiar idea seems to be appearing then so be it, but it will have to do so via the design principles and processes I’m using. I want to build an interface from the ground up, justifying every button, menu and slider. We add what we need, we don’t subtract from something too complex.

Of course, our new interface will be heavily influenced by existing models, because if we want to run existing software (e.g. Firefox, GIMP) while at the same time adhering to the idea of consistency, then we’ll have little choice unless we want to restrict the available software to that which we have purpose-built ourselves.

Perhaps there will be the possibility of so redefining what the interface looks like that an argument exists for building a new application interface for software which wants to run on our Device. Windows 8 is an example of this, and many existing app vendors will be creating their Metro / Modern / Tile version soon. The iOS interface is another example, which benefited from the fact that it had no existing software to deal with. Let’s keep that possibility in mind.

Pyramid of interfaces

I’m going to start by thinking about the main ‘home screen’ interface (including pondering whether a home screen is necessary at all), and then work my way up via settings, Device / System Information, installing new software and so on. Working up from first principles like this should help dispense with (or at least examine fully) any prejudices we have about what an interface looks like.

I’ll start from the conceited position that the finished interface does not need changing, and then consider such issues as accessibility, and whether this can be incorporated into the existing design, or requires a new one. That very question is one which will shape the project.

Conclusion

Well, that’s it for the preliminaries. In the next post I’ll start looking at the very basics of the interface, and begin building up the framework for the Perfect Device