systemcall dot org

About 15 years ago, when I was working on a dodgy Brazilian firm, I had a conversation with an older programmer that I never forgot. He said something along the lines of:

Medicine is way easier than computer science. Doctors are still using the same books, written decades ago, while we have to buy only the latest ones. Our reality gets rewritten every five years or so, and by the time you leave university, you’re already outdated.

There is a lot of merit in this argument. Even though the common cold’s strain changes every week, its symptoms are exactly the same. Cancer, HIV, malaria, Lupus and other big diseases are treated more or less the same way as they were when first treated, and GPs still give you aspirin/paracetamol/ibuprofen for any kind of pain.

Human anatomy, physiology and psychology doesn’t change at all. Broken legs, runny noses and swollen tonsils are the same on every person and they require the same treatment for everyone.

While doctors kill one patient when they do make a mistake, developers can kill hundreds if they happen to introduce a bug on the Airbus fault-tolerant fail-over system.

But recently, I had to re-think this through, and I have to say I’m not 100% in agreement any more.

When programmers change jobs, they get a few weeks to get used to the new system. They might get months to actually be productive as their peers and will mature within a few years working with the same piece of software. Programmers can run tests, regression tests and usability tests, unit tests, etc, which is something a bit complicated with human beings.

When a doctor gets a new patient, it’s like getting a new programming job. It’s the same language, but the system is completely different. It might take you weeks to start getting the prognosis right, and in a few months you’ll be able to get it right before your patient even tells you the symptoms.

The similarities are remarkable

Consultant programmers get new systems to work on every week. Like ER doctors. They do what they can, with the time they have and the solution is most of the time acceptable. A more stable doctor or programmer might look at the job and cry, but the job was done, the fire was put off and the “patient” is out of the door.

Family doctors, that were there when you were born, know you better than yourself. They know when your symptoms are only psychological and what cause that and when it’s going to go away. They rarely touch the “system”, but normally fix an unrelated bug and you’re good as new.

But not everybody is lucky enough to have such doctors. They are expensive, and there aren’t enough good doctors in the health system of any country to account for every family. Even if the doctor share a hundred families, it’s still very far from enough.

This is the reason that systems fail, and get half-fixed, and why most GPs will send you home with a paracetamol unless you’re dying in front of them.

If doctors and programmers had such a different world, the emergent behaviour wouldn’t be that similar, I believe.

No, not the one everyone is talking about. The one that actually made it all work.

Not the one that was worried about uniforms and style, the one that actually designed and develop the foundations of modern society.

Not the one that enclosed people into a dungeon of usability, but the one that created the tools to enable everyone’s freedom.

The one whose work made possible the computer revolution in the 70s, the micro-computer revolution in the 80s, the open-source revolution in the 90s and the mobile revolution this last decade. Without Unix and C, and their simplistic but elegant design, the stronghold of modern society, none of this would be possible. We’d still be fighting over who invented the bloody pipe.

Rest in peace, Dennis MacAlistair Ritchie and may your wisdom embedded in the world today, linger as much as possible in our minds.

UPDATE: (Wired) Dennis Ritchie: The Shoulders Steve Jobs Stood On

Geeks like to hack stuff, especially if they’re not meant to be hacked. But hacking computers or mobile phones is piece of cake, so some, more adventurous geeks hack cars. The Toyota Prius is a particularly interesting car to hack, since a lot of its functionality is based on control systems and they have interface ports that you can plug in debug systems and change (or add) behaviour to your car.

For instance, you can enable the SatNav screen to play video CDs or MP3s, since the system supports it, but there aren’t enough buttons on the panel and, well, you shouldn’t be watching videos while you drive, anyway.

Another less common hack, but doable is to change the voice commands. They’re normally hard-coded to respond when you press a button on the steering wheel and say something. For instance, on my Prius, if you say “fire photon torpedoes” it puts the air condition temperature down a bit. If you say “Khaaaaaaaan!” it turns off the radio, and so on.

Some controls are a bit less harmless, like activating the breaks or turning off the car, but normally you can’t access them from the control panel, anyway. That is, unless you by-pass the CAN network and connect the central control with the control panel.

Legend tells that a geek bypassed the system and, just for fun, added a voice command to turn off the car when he’d say “off“. That was his pride and joy, and (geek) friends would go jealous of his control over his car. Until the day the car was too old and he decided to buy a new one, with even more technology. Only he forgot to disable the “off” button.

A few months later, they say, the new owner was having a fight with his girlfriend on M11 at full speed and, well, as many would do in those circumstances, he was swearing a lot. Loudly. His unfortunate last minute of life began when he accidentally pressed the “talk” button and said something along the lines of “f*** off …”.

The car dutifully acknowledged the command and, since the previous owner forgot to add any security checks, turned itself off at once. Havoc and carnage followed, but that’s another story.

Now you know why Toyota voids your warranty when you open the panel…

This is a little pet project I did a while ago. It’s a FreeCell puzzle‘s solver API.

The idea is to provide a basic validation engine and board management (pretty much like my old chess validation), so people can write FreeCell solvers on top of it. It has basic board setup (of multiple sizes), movement legalisation, and a basic Solver class, which you must derive to create your own solvers.

There’s even a BruteFroceSolver that can solve a few small boards, and that gives you an idea on how to create your own solvers. However, the API is not clear enough yet that children could start playing with it, and that’s the real goal of this project: to get kids interested in solving complex optimisation problems in an easy way.

Freecell is a perfect game for it. Most boards can be solved (only a handful of them were proven – by exhaustion – not solvable), some movements can be rolled back and you can freely re-use cards that have already been placed into the foundations (their final destination) back in the game again.

It’s out of the scope of this project to produce a full-featured graphic interface for kids, but making the API easy enough so they understand the concepts without dragging themselves into idiosyncrasies of C++ is important.

Compiler optimisations

The reason why I did this was to make some of the optimisations compiler engineers have to do more appealing to non-compiler engineers or children with a taste for complex problems. But what does this have to do with compilers? The analogy is a bit far-fetching and somewhat reverse, but it’s interesting nevertheless and it was worth the shot.

Programming languages are transformed into graphs inside the compiler, which should represent the intentions of the original programmer. This graphs are often optimised multiple times until you end up with a stream of instructions representing the source code in the machine language.

Ignore for now the optimisations on those graphs, and focus on the final part: selecting machine instructions that can represent that final graph in the machine language (assembly). This selection can pick any assembly instruction at will, but it has to put them into a very specific order to represent the same semantics (not just syntactic) of the original program. Since many instructions have side effects, pipeline interactions, special flags set or cleaned up, it’s not trivial to produce correct code if you don’t check and re-check all conditions every time. This is a known complex optimisation problem and can be responsible for changes in speed or code size in orders of magnitude.

What does it have to do with the Freecell puzzle? Well, in Freecell, you have a number of cards and you have to put them in a specific order, just like assembly instructions. But in this case, the analogy is reverse: the “sequence” is trivial, but the “instructions” are hard to get.

There are other similarities. For example, you have four free cells, and they can only hold one value at a time. They are similar to registers, and manipulating them, gives you a good taste of how hard it is to do register scheduling when building the assembly result. But in this case, it’s much harder to spill (move the data back to memory, or in this case, card back to cascades), since there are strict rules on how to move cards around.

Reusing cards from the foundations is similar to expanding single instructions into a sequence of them in order to circumvent pipeline stalls. In real compilers you could expand a multiply+add (very useful for digital signal processing) into two instructions: multiply and add, if that gives you some advantage on special cases on special chips. In Freecell, you can use a 9 on top of a 10, to move an 8 from another cascade and free up a card that you need to clean up your freecells (registers).

I’m sure you can find many more similarities, even if you have to skew the rules a bit (or completely reverse them), but that’s not the point. The point is to interest people into complex optimisation techniques without the hassle of learning a whole new section of computer science, especially if that section puts fear in most people in the first place.

Since the end of the dark ages, and the emergence of modern capitalism, science has been connected to business, in one way or another.

During my academic life and later (when I moved to business), I saw the battle of those that would only do pure science (with government funding) and those that would mainly do business science (with private money). There were only few in between the two groups and most of them argued that it was possible to use private money to promote and develop science.

For years I believed that it was possible, and in my book, the title of this post wouldn’t make sense. But as I dove into the business side, every step closer to business research than before, I realised that there is no such thing as business science. It is such a fundamental aspect of capitalism, profit, that make it so.

Copy cats

Good mathematicians copy, best mathematicians steal. The three biggest revolutions in computing during the last three decades were the PC, the Open Source and Apple.

The PC revolution was started by IBM (with open platforms and standard components) but it was really driven by Bill Gates and Microsoft, and that’s what generated most of his fortune. However, it was a great business idea, not a great scientific one, as Bill Gates copied from a company (the size of a government), such as IBM. His business model’s return on investment was instantaneous and gigantic.

Apple, on the other hand, never made much money (not as much as IBM or Microsoft) until recently with the iPhone and iPad. That is, I believe, because Steve Jobs copied from a visionary, Douglas Engelbart, rather than a business model. His return on investment took decades and he took one step at a time.

However, even copying from a true scientist, he had to have a business model. It was impossible for him to open the platform (as MS did), because that was where all the value was located. Apple’s graphical interface (with the first Macs), the mouse etc (all blatantly copied from Engelbart). They couldn’t control the quality of the software for their platform (they still can’t today on AppStore) and they opted for doing everything themselves. That was the business model getting in the way of a true revolution.

Until today, Apple tries to do the coolest system on the planet, only to fall short because of the business model. The draconian methods Microsoft took on competitors, Apple takes on the customers. Honestly, I don’t know what’s worse.

On the other hand, Open Source was born as the real business-free deal. But its success has nothing to do with science, nor with the business-freeness. Most companies that profit with open source, do so by exploiting the benefits and putting little back. There isn’t any other way to turn open source into profit, since profit is basically to gain more than what you spend.

This is not all bad. Most successful Open source systems (such as Apache, MySQL, Hadoop, GCC, LLVM, etc) are so because big companies (like Intel, Apple, Yahoo) put a lot of effort into it. Managing the private changes is a big pain, especially if more than one company is a major contributor, but it’s more profitable than putting everything into the open. Getting the balance right is what boosts, or breaks, those companies.

Physics

The same rules also apply to other sciences, like physics. The United States are governed by big companies (oil, weapons, pharma, media) and not by its own government (which is only a puppet for the big companies). There, science is mostly applied to those fields.

Nuclear physics was only developed at such a fast pace because of the bomb. Laser, nuclear fusion, carbon nanotubes are mostly done with military funding, or via the government, for military purposes. Computer science (both hardware and software) are mainly done on the big companies and with a business background, so again not real science.

Only the EU, a less business oriented government (but still, not that much less), could spend a gigantic amount of money on the LHC at CERN to search for a mere boson. I still don’t understand what’s the commercial applicability of finding the Higgs boson and why the EU has agreed to spend such money on it. I’m not yet ready to accept that it was all in the name of science…

But while physics has clear military and power-related objectives, computing, or rather, social computing, has little to no impact. Radar technologies, heavy-load simulations, and prediction networks receive a strong budget from governments (especially US, Russia), while other topics such as how to make the world a better place with technology, has little or no space is either business or government sponsored research.

That is why, in my humble opinion, technology has yet to flourish. Computers today create more problems than they solve. Operating systems make our life harder than they should, office tools are not intuitive enough for every one to use, compilers always fall short of doing a great job, the human interface is still dominated by the mouse, invented by Engelbart himself in the 60′s.

Not to mention the rampant race to keep Moore’s law (in both cycles and profit) at the cost of everything else, most notably the environment. Chip companies want to sell more and more, obsolete last year’s chip and send it to the land fills, as there is no efficient recycling technology yet for chips and circuits.

Unsolved questions of the last century

Like Fermat’s theorems, computer scientists had loads of ideas last century, at the dawn of computing era, that are still unsolved. Problems that everybody tries to solve the wrong way, as if they were going to make that person famous, or rich. The most important problems, as I see, are:

• Computer-human interaction: How to develop an efficient interface between humans and computers as to remove all barriers on communication and ease the development of effective systems
• Artificial Intelligence: As in real intelligence, not mimicking animal behaviour, not solving subset of problems. Solutions that are based on emergent behaviour, probabilistic networks and automatons.
• Parallel Computation: Natural brains are parallel in nature, yet, computers are serial. Even parallel computers nowadays (multi-core) are only parallel to a point, where they go back on being serial. Serial barriers must be broken, we need to scratch the theory so far and think again. We need to ask ourselves: “what happens when I’m at the speed of light and I look into the mirror?“.
• Environmentally friendly computing: Most components on chips and boards are not recyclable, and yet, they’re replaced every year. Does the hardware really need to be more advanced, or the software is being dumber and dumber, driving the hardware complexity up? Can we use the same hardware with smarter software? Is the hardware smart enough to last a decade? Was it really meant to last that long?

All those questions are, in a nutshell, in a scientific nature. If you take the business approach, you’ll end up with a simple answer to all of them: it’s not worth the trouble. It is impossible, at short and medium term, to profit from any of those routes. Some of them won’t generate profit even in the long term.

That’s why there is no advance in that area. Scientists that study such topics are alone and most of the time trying to make money out of it (thus, going the wrong way and not hitting the bull’s eye). One of the gurus in AI at the University of Cambridge is a physicist, and his company does anything new in AI, but exploits the little effort on old school data-mining to generate profit.

They do generate profit, of course, but does it help to develop the field of computer science? Does it help tailor technology to better ourselves? To make the world a better place? I think not.

For all LLVM users in Europe that didn’t catch the announcement on the main list, be warned that we’re organising the European LLVM User Group Meeting in September, 16th, in London. All information necessary to register and submit your work is on the link.

It’s free of charge and we’ll also provide a happy-hour after the meeting for an extended networking. If you’re just curious about LLVM or work with it day to day or is thinking of starting your PhD with LLVM, please register and show up. You won’t regret.

More information will be available on the link above and through the main mailing list. Stay tuned!

Almost a decade ago I joined Yahoo to work on the search team. At that time, Google was giving Yahoo a hard time with their amazing search, while Yahoo was mostly based on directory search and some ad-hoc buyouts (AltaVista et al). Yahoo came with its own search, then bought Inktomy, then re-wrote the search engine, and they’re now using Bing. They were late on the search business. Too late. Not that Inktomy was bad, but it wasn’t better than Google and certainly wasn’t a novelty.

When Google came with Gmail it was a shock to all of us, Yahoo workers. How can they offer 1GB free mail and we only offer 10MB? How can a (then) small company provide such massive storage while the behemoth of the Internet could only afford peanuts? It’s all in the administration. Yahoo, for some reason I still don’t understand, had to have all user’s emails on filers (very expensive storage), and had to reserve the whole storage, even if less than 10% of the users actually used more than 50%. There was a lot of very expensive idle disks at Yahoo Mail…

Another case was social networks. Yahoo was never able to write a single decent social network that wouldn’t close an year later. Several internal attempts were made (during years of development) before the first Yahoo-360 came out, only to die a few months later of starvation.

Yahoo-style

When the internet was young, and Yahoo was at the top, they could do anything, people would just love. Yahoo mail was free and came with a calendar and some bits. It was horrid, but it was free, and we all used one day (especially after Hotmail was acquired by Microsoft). Somehow, the directors of Yahoo decided it was better to have it all, even if the quality was unbelievably low. They were so famous and so ubiquitous that anyone wanted to advertise on their websites. The more they had, the more people wanted.

That cycle made Yahoo create a huge number of useless pages and verticals (content website like weather, mobile, etc), just because people would pay loads of money to advertise there. I’ve seen many pages going live without proper review or a decent market analysis, and some were still with bogus content (non non non) and broken links after years. Yahoo had spread their butter so thin that it was impossible for them to compete with any other company.

Google came, Google destroyed Yahoo, Microsoft came and bought it. It may not be in paper, but Yahoo is the new Microsoft garden, where they put their feet up when they’re tired of working.

Facebook

With Facebook, the story is not completely similar. Google is still not where Yahoo was 8 years ago and the Internet is not as naive as it used to be. It’s true that Facebook killed every other social network website, but it’s not true that they’ll be able to do with GMail, what Google did with Yahoo Mail. Part because GMail is really good, and part because Facebook guys are not that good.

But there’s one trend that is happening to Google that is similar to Yahoo of the past: legacy. Google has a decade of code, normally more bad than good, and the new systems have to integrate with it. But that’s not the worse, by far. As Yahoo, Google started from ground-up, so they always had the start-up mentality. When the company wasn’t a start up any more, they still tried to do things the same way.

Two things happened during the last few years that put Google in a bad situation: first, because in the golden days they had truly done remarkable systems (simple, yet efficient), they thought (and carried on thinking) not only that they were the best of the best, but that they could do anything and anything they did was automatically better than any one else. Second, the lack of process and reality check only made things worse, by kludging infrastructure on top of infrastructure, by solving every problem as if it was map-reduce and by doing everything in-house, it was difficult to use off-the-shelf applications for things that weren’t really that relevant, and move on when it was, indeed, relevant.

Facebook is still a young company, but I hardly believe their fate will not be the same. It was also clear from the beginning (8 years ago), that Google would have the same fate. However, I don’t think that Facebook will overrun Google as the latter did with Yahoo, but that’s neither fault. The market is not the same, the Internet is not the same.

Google+

In the same style as Yahoo-360, Google is trying to use their own user-base to compete with Facebook, and for that, it’s very likely that they’ll fail. Not as bad as 360, but they won’t kill Facebook.

Hangouts, Circles, Huddle are just different names for the same functionality in Facebook, Twitter, etc. Even the layout of Google+ is identical to Facebook. 360 was exactly the same thing and that’s where I draw the line. That’s where Google is getting ludicrously similar to Yahoo 8 years ago and that’s why they’ll start failing more and more often from now on.

They stopped being creative. Their creative innovations (wave, buzz) is average at best, their copied products (chrome, android) and similar to the competition with no clear game changer and the old stuff (search, gmail) is still the same. Not bad, but not creative any more.

From now on, is only downhill. In a decade or so, Apple will offer to buy them, and fail to, but enough to dismiss the general trust people have on them and that will be the end. Zombies of the Internet…

Ever since Moore’s idea became a law (by providence), and empires were built upon this law, little has been thought about the need for such advancements. Raw power is considered to many the only real benchmark to what a machine can be compared to others. Cars, computers and toasters are all alike in those matters, and are only as good as their raw throughput (real or not).

With the carbon footprint disaster, some people began to realise (not for the correct reasons) that maybe we don’t actually need all that power to be happy. Electric cars, low-powered computers and smart-appliances are now appealing to the final consumer and, for good or bad, things are changing. The rocketing growth of the mobile market (smartphones, netbooks and tablets) in recent years is a good indicator that the easily seduced consumer mass has now being driven towards leaner, more efficient machines.

But, how lean are we ready to go? How much raw power are we willing to give away. In other words, how far goes the appeal that the media push on us to relinquish those rights bestowed by Moore? It seems not so much, with all chip companies fighting for a piece of the fat market (as well as the lean, but).

What is the question, anyway?

Ever since that became a trend, the question has always been: “how lean can we make our machine without impacting on usability?”. The focus so far has only been on creating smarter hardware, to a lesser extent (and only recently) reducing the unneeded fat of operating systems and applications, but no one ever touches the fundamental question: “Do we really need all that?“.

The questions is clearly cyclic. For example, you wouldn’t need a car if the public transport was decent. You wouldn’t need health insurance if the public health system was perfect, and so on. With computing is the same. If you rely on a text editor or a spreadsheet, it has to be fast and powerful, so you can finish your work on time (and not get fired). If you are a developer and have to re-compile your code every so often, you need a damn good (in CPU and memory) computer to make it as painless as possible. Having a slow computer can harm the creative process that involves all tasks around it, and degrade the quality of your work to an unknown quantity.

Or does it?

If you didn’t have to finish your work quicker, would you still work the same way? If you didn’t have to save your work, or install additional software, just because the system you’re working on only works on a particular type of computer (say, only available on your workplace). If you could perform tasks as tasks and not a whole sequence of meaningless steps and bureaucracy, would you still take that amount of time to finish your task?

Real world

Even though the real world is not that simple, one cannot take into account the whole reality on each investigation. Science just doesn’t work that way. To be effective, you take out all but one variable and test it. One by one, until you have a simplified picture, a model of reality. If on every step you include the whole world, the real world, in your simulations, you won’t get far.

There is one paper that touched some of these topics back in 2000, and little has changed since then. I dare to say that it actually got worse. With all these app stores competing for publicity and forcing incompatibility with invisible boundaries, has only made matters worse. It seems clear enough for me that the computing world, as far I can remember (early 80′s) was always like that and it’s not showing signs of change so far.

The excuse to keep doing the wrong thing (ie. not thinking clearly about what a decent system is) was always because “the real world is not that simple”, but in fact, the only limitation factor has been the greed of investors who cannot begin to understand that a decent system can bring more value (not necessarily money) than any quickly designed and delivered piece of software available today.

Back in the lab…

Because I don’t give a fig to what they think, I can go back to the lab and think clearly. Remove greed, profit and market from the table. Leave users, systems and what’s really necessary.

Computers were (much before Turing)  meant to solve specific problems. Today, general purpose computers create more problems than they solve, so let’s go back to what the problem is and lets try to solve it without any external context: Tasks.

A general purpose computer can perform a task in pretty much the same way as any other, after all, that’s why they’re called “general purpose”. So the system that runs on it is irrelevant, if it does not perform the task, it’s no good. A good example of that are web browsers. Virtually every browser can render a screen, and show surprisingly similar results. A bad example is a text editor, which most of them won’t even open another’s documents, and if they do, the former will do all in its power to make the result horrid in the latter.

Supposing tasks can be done seamlessly on any computer (lets assume web pages for the moment), than does the computer only computes that task, or is it doing other things as well?

All computers I know of will be running, even if broken, until they’re turned off. Some can increase and decrease their power consumption, but they’ll still be executing instructions to the world’s end. According to out least-work principle (to execute tasks), this is not particularly relevant, so we must take that out of our system.

Thus, such a computer can only execute when a task is requested, it must complete that task (and nothing else more), and stop (really, zero watts consumption) right after that.

But this is madness!

A particular task can take longer to execute, yes. It’ll be more difficult to execute simultaneous tasks, yes. You’ll spend more cycles per particular task than usual, yes! So, if you still thinking like Moore, than this is utter madness and you can stop reading right now.

Task Driven Computing

For those who are still with me, let me try to convince you. Around 80% of my smartphone’s battery is consumed by the screen. The rest is generally spend on background tasks (system daemons) and only about 5% on real tasks. So, if you could remove 95% of your system’s consumption, you could still take 20x more power consumption for your tasks and be even.

Note that I didn’t say “20x the time”, for that’s not necessarily true. The easiest way to run multiple tasks at the same time is to have multiple CPUs in a given system. Today that doesn’t scale too well because the operating systems have to control them all, and they all just keep running (even when idle) and wasting a huge amount of power for nothing.

But if your system is not designed to control anything, but to execute tasks, even though you’ll spend more time per task, you’ll have more CPUs working on tasks and less on background maintenance. Also, once the task is done, the CPU can literally shut down (I mean, zero watts) and wait for the next task. There is no idle cost, there is no operational code being run to multi-task or to protect memory or avoid race-conditions.

Problems

Of course, that’s not as easy as it sounds. Turning on and off CPUs is not that trivial, running tasks with no OS underneath (and expecting them to communicate) is not an easy task, and fitting multiple processors into a small chip is very expensive. But, as I said earlier, I’m not concerned with investors, market or money, I’m concerned with technology and it’s real purpose.

Also, the scaling is a real problem. Connection Machines were built and thrown away, clusters have peak performance way above their average performance levels, and multi-core systems are hard to work with. Part of that is real, the interconnection and communication parts, but the rest was artificially created by operating systems to solve new problems in an old way, just because it was cheaper, or quicker, or easier.

Back in the days…

I envy the time of the savants, when they had all the time and money in the world to solve the problems of nature. Today, the world is corrupted by money and even the most prominent minds in science are corrupt by it, trying to be the first to do such and such, protecting research from other peers just to claim a silly Nobel prize or to be world famous.

The laws of physics had led us into it, we live in the local minima of the least energetic configuration possible, and that’s here, now. To get our of any local minima we need a good kick, something that will take us out in a configuration of a more energetic configuration, but with enough luck, we’ll fall into another local minima that is less energetic than this one. Or, we we’re really the masters of the universe, maybe we can even live harmoniously in a place of local maxima, who knows!?

Today is the annual Day Against DRM, please remember to check your shopping list for possible DRM-ed products, and consider doing some of the ideas on the site… I can give you a few examples why this is bad.

First, I own an iPad and cannot use it. It won’t be recognized by my Linux machine, I can’t copy music or books to it, I can’t browse my music collection on my server to play random songs, I have to sync it with iTunes (and only iTunes) that I have to run on a Windows virtual machine inside my Linux machine. It’s dead slow, it won’t sync up things from my iPad unless I find the magical option pull changes from iPad instead of the ubiquitous sync option, etc.

Secondly, the Play Station is a wonderful machine and many people wanted (and could) run Linux on it. Years ago there were clusters of Play Stations, since its GPU was powerful enough to do scientific computation (better than many computers at the time), but now, you can’t even touch it without going to jail.

Finally, in the age of the internet, companies are still attached to material values such as possession and ownership, whereas the internet transforms everything into a service. Amazon, although they still use DRM on Kindle, they understood it quite well and have created the most important cloud service on the planet.

Why those companies are not using the same model for everything? Well, generally reality doesn’t get transformed that quickly, so it was a great shock. But now society is demanding new rules for a new reality and the fact that many people are going to jail for preserving their own rights is alarming and a crucial sign that the old rules don’t apply any more.

This day is to remind you that you are not alone in thinking that this is all wrong, that you should be able to listen to any music, on any device, anywhere, since the technology allows you to. If the business model does not account for it, change the business model!

May the 4th be with you…

I’ve been using virtual keyboards for a while (iPad, Android phone) and, while it’s good enough, it made me wonder…

QWERTY

The QWERTY keyboard was invented in the 19th century and before computers had keyboards, it was mainly used for typing letters. The advanced feature of a typewriter was the SHIFT key.

When computers had their input changed from switches and punched cards to keyboards and printers (before monitors were invented), the natural choice was to use the ubiquitous QWERTY layout. But because of the nature of computing, many additional keys were needed. Since the single most important function of a keyboard was to input code (and not Word documents), the SHIFT concept was extended with CONTROL keys, the FUNCTION keys were added and some other impossible concepts in typewriter, such as the Home/End, Insert/Replace, etc.

All that was added around the traditional keyboard, and today it’s now ubiquitous as well. All editors (code and otherwise), use extensively those keys and it’d be impossible to imagine a keyboard without it. But, to be honest, the layout of the computer keyboard did not technically have to mimic the old fashioned typewriter. It just did to ease the transition between writing letters on paper and code on silicon.

Nowadays, the virtual keyboard is, again, mimicking the 120 years-old layout, just because everyone got use to, but now the excuses to keep it are fading. I do not know anyone that still uses a typewriter, do you? Also, most of the extra keys are still only used by coders of some sort, including Vim, Emacs, Photoshop and Excel.

Swipe movements

Clicking on links, editing text and drag&dropping is very awkward on the iPad (not to mention on phones), so that’s not going to stick more than a decade. However, gestures are so intuitive on touch-screen interfaces that it can easily become mainstream, if done right.

One browser I use on Android (Dolphin) has hand gestures, and I have to say it’s horrible and too complicated. It’s based on the old mouse-gestures that, by definition, is out-dated and not technologically compatible.

Touch gestures have to be more natural, like moving objects on your desk. One way to do this is to use the (now famous) two-finger swiping. Another is to add hot-areas to your touch screen, where people know are for specific purposes. For example, imagine a touch-screen keyboard the size of an iPad (10″, no screen on it, just the keyboard). Remove every other key than the QWERTY keyboard itself. Just as you would use the lower area as a pointing device, the lower area (either swiping or tapping) brings a full-screen pointing device, with all gestures and controls one needs. Another tap would bring the main keyboard back.

The same way, right and left screens would bring editing capabilities to your programs, and each program could have its own screen. Some could revert back to the main keyboard as you press on key (as to save the return tap), others would require you to press multiple keys are the same time. The top part could bring the multi-media area, with animated buttons, etc.

Feed-back

All that is not complete without some feed-back, the worse thing on using virtual keyboards. The click noise is easy enough, but tactile is coming a long way without really going anywhere. Microsoft, Apple, Nokia, Sony, all tried (and patented) solutions to tactile touch-screen and yet, not mainstream device today uses one. I’m sure that’s mostly due to technical difficulties (maybe battery life, or bulkiness), none of them critical to a keyboard.

When playing games on the phone that emulate joysticks (SNES emulator, or other Android-specific ones), I often die because of the lack of tactile feed-back, that is, I take my finger off the D-pad without noticing. This is most annoying and virtual keyboards aren’t going anywhere without a decent feed-back system.

Some laptop/tablet cross-breeds, have dual touch-screens for that purpose, and I think (or rather, hope), that this is the future. But they need to change the layout of how keyboards are supposed to work. Luckily, that can be done all in software, and Linux is an open system, which anyone could implement it.

If you do, please open source it and make it free. Any penny you get from it is a second away from it being universally accepted.

« Previous entries Next entries »