The morning is a fertile ground for colliding thoughts. You're still groggy from sleep, and your mind isn't focused enough yet to drown out the noise it usually generates. Often, this state drifts me into the absurd. Laughter can usually be heard from the house bathroom as the bizarre thought collision reaches its zenith while I shower.
This morning, however, I found myself thinking about two things that are rarely considered together: Tablet computing, and Haiku OS. While Tablet computing needs little introduction, Haiku certainly does. Haiku is an open source reimplementation of a then-revolutionary operating system called BeOS. Be aimed to be the multimedia OS of tomorrow through a radical new API based on C++, pervasive multithreading, and build-in media abilities. Originally available on PowerPC Macintosh hardware, and then garden-variety x86, Be was a weird, beautiful, and fast creature to behold.
Back in late high school and early college, I was quite fond of BeOS. I presented BeOS to room full of my college peers, showing off its ability to play four video streams concurrently on mediocre hardware. I wrote software for BeOS when not completing college assignments. For almost two years, it was my primary operating system. Eventually, however, reality caught up with the dream. Be Inc., the company behind BeOS made some very poor decisions, eventually needing to sell itself to then-powerhouse Palm, Inc. for a paltry stock price. The same day that was announced, I switched to Linux.
Haiku was one of two reimplementation efforts. One was called Blue Eyeed OS, aiming at source-level compatibility with BeOS. The other was the more ambitious OpenBeOS, now Haiku, which aimed at binary compatibility. At the time, I sided with the former, having already done some coding work toward that end myself. Eventually, however, Haiku proved the winner, and now the only surviving OS from that branch.
So where do Tablets come in?
One of the attributes of BeOS was that it was impossible to theme. This was due to all the UI elements being drawn by hard code. No images or variables were used to control it's presentation. It's object oriented nature meant there was no single memory location in which this UI code lived. It was all over the place. At the time, this was just a hindrance to modders and power-users who wanted to control how their OS looked. Tablets, however, change the equation.
Tablets have a very different interaction style compared to the desktop computer of yore. Instead of pixel-precise pointing devices that scale down clumsy human movements to manageable computer increments, we use one to ten bony meat tubes to interact with the device. The accuracy of fingers leaves something to be desired. On major smartphone and tablet computer operating systems today, the hit-surfaces with which we interact with the device are comparatively large to their mouse-centric brethren. As tablets seem to be the popular computing form-factor going forward, how can an OS like Haiku hope to survive?
"So," you might say, "just make the hit-surfaces in Haiku bigger, that should do it." Not so fast, you're forgetting about a lot of issues. A bigger hit-surface a tablet OS does not make. You need to reconsider every fundamental UI component. Do you even need windows? Does the Tracker (the BeOS equivalent of Window's task bar) even have a purpose? And those are just superficial issues.
Tablets are not desktops in very fundamental ways. The primary power source is battery, not AC. While performance is important, it must be quickly discarded in order to save on power. The preferred CPUs have a different architecture. You cannot even rely on a physical keyboard! If these were the only worries for Haiku in the tablet age, they would already be facing a formidable challenge. Haiku also inherits the OS architecture of the early 2000s. A time when hardware accelerated graphics were uncommon and the phrase "compositing window manager" had not been heard outside of research institutions and the dens of particularly forward thinking hackers.
One might think Haiku can be easily reinvented for the tablet age. After all, we have the source code, why not just take on each of these challenges one by one? That's an admirable attitude, but if you only have a handful of developers and that attitude on one side of the scale, and all these issues on the other, you may find your elevation most displeasing.
Let's take these on one by one:
- UI. Okay, so yeah, you can modify the source code to fix this. The problem is that it's everywhere. You need to fix it in so many places throughout the OS that by the time you're finished, you might as well have scrapped Haiku the app_server and started with a new OS userland completely. (Edit: I let my hyperbole get away from me here. There should be little need to rearchitect the core OS. Strikeouts show the original text.)
- Power. Haiku does not have a heavy hardware requirement. In many ways, it's far lighter than Windows, MacOS, and many distributions of Linux. One of the problems, however, is Pervasive Multithreading. Haiku inherited this philosophy from BeOS, making multi-threading much easier than on other operating systems. This approach may have memory and performance problems on the Tablet's highly variable CPU speed and constrained memory.
- CPU scaling. This one would go the furthest for power-savings, and would involve a relatively small amount of tricky kernel code. Outlying worries would be unexpected behavior in userland when the CPU slows down.
- Lack of physical input devices. Really, this is a minor concern. A virtual keyboard service would need to be added to the OS to bring up the keyboard when the appropriate. Support for a touchscreen can be likewise added. I can imagine this easily being a Google Summer of Code project.
- Hardware Acceleration. Expecting and enforcing it is a serious advantage in the mobile space. iOS proves this over the more traditional graphic stack on which Android relies. While OpenGL was built-in to BeOS and thus, Haiku, it is by no means enforced. There are already efforts to implement this, but hardware support remains a difficult issue.
What are alternative OS devs, like the ones behind Haiku to do? Personally, I think everyone in the non-proprietary space can do well by abandoning the idea they can "win". We probably won't topple Windows, Mac OS, Android, or iOS. However, we can have a lot of fun, and raise crazy, new ideas of computer interaction to fruition.
While our code may not change the world, maybe our ideas will.