The year of the Linux tablet?

Personally, I think Apple has gone too far in attempting to unify their interfaces across devices, at least from the point of view of an advanced user.

As an example, the new auto-hide scrollbars mean you can no longer tell at a glance how much of the document there is or where you are in it. Unless some of the content is actually visibly clipped by the edge of the scrollable area, you have no indication that you're looking at something that scrolls.

The real problem with a unified interface is trying to wedge all the differing capabilities of your device set into a unifying metaphor that doesn't stretch too badly.

I'm coming at the problem from a game development point of view; I do console and mobile phone games, we've developed a cross-platform game engine that (in an OS kind of way) presents a unified programming interface regardless of the underlying hardware.

Or that's the theory, anyways. In practice, there's abstraction breakage, sometimes severely. As an example, consider the situation we faced when the Wii came along; we had a couple of implicit assumptions in the engine design that the Wii violated.

Single Pool of System Memory: The Wii has two banks of system memory, one slow and large, the other fast and smaller.

Many Gamepads, One Mouse/Keyboard: The Wii controllers all have lightgun capabilities, so they can all have screen positions.

Gamepads Don't Change: The Wii controller has dockable subcontrollers.

This kind of thing breaks your abstractions, often badly. You either wind up having to wrap a superset of all possible cases around everything (in which case the game has to understand the platform it's on to access the functional parts), use capability detection (in which case the game has to be modular based on the capabilities reported by the hardware), or find a new abstraction that hides the differences once again.

With our game engine, we have the luxury of retooling our abstractions whenever a new platform arrives; we don't need to have a stable API or ABI because we're effectively our only user.

General purpose operating systems and development ecosystems don't have that luxury. Even if you aggressively deprecate your old mechanisms for new software, you have to keep the old stuff working.

The same is somewhat true for GUIs. You can only change so much out from under your users before they revolt. More to the point, if you change things too much, and your users have to relearn everything, you lose all your "lock in" effect from user experience. If they have to re-learn everything, they may well chose to go learn a different system instead, perhaps one that won't yank the rug out from under them every time the major version number changes...

I do not get the point of releasing free software that you don't want people to change -- maybe "shared source" a la MS would be a more appropriate license.

That said maybe a better option for GNOME would be to produce a "reference platform" as their complete offering, and ask would-be reviewers to test that. If it is really that great in integration, it will stand on its own.

Reminds me a bit of the spats mplayer upstream had with Debian packaging its software non-optimally. For an extreme case of control-freakery and look at Schily's cdrecord.

In particular, the Apple approach is driven by a singular vision per overall product. In iOS, the singular vision is the single app appliance (not that it only has a single app, but you're not really expected to try to use multiple apps simultaneously, and certainly not expected to try to make them interact). In OSX, the singular vision is a MacBook Pro with no peripherals, running a big software package (photoshop, spreadsheet...) full-screen and occasionally switching to full-screen Safari or Mail.

The further you get from the singular vision, the worse it works.

Let's say, for instance, you have a shiny new Mac Pro (one of the $2500+ towers) running Lion, and you've hooked it up to two new 27" screens (which it will do quite nicely). And let's say you want to use that spiffy new "full-screen mode" their programs have. You get full-screen on the "main" display, and the other one goes blank gray. You can't do anything with the second monitor.

The use case that Lion was designed for is the guy sitting in Starbucks with his MacBook Pro. It's designed around a single screen, with other screens being an afterthought. It's designed around the trackpad, with the mouse being an afterthought. It was designed around a relatively small number of installed apps, all of which are expected to run fullscreen (which, I presume, is why their window management is so primitive. No edge resistance in 2011? Really?). The non-vision parts still work, for the most part, but they're not as clean. The further you are from the use-case vision, the more you're on your own.

iOS has similar problems; it's better than it used to be, but real multitasking is still off the table, the launcher shell is a pretty version of progman.exe from windows 3.1 (now with folders! Oops, but don't try to nest them. Oh, and don't try to put more than 16 things in them (or 9, if you aren't on an ipad), because they don't scroll...). Notification is still weak, the filesystem is still inaccessible, you need a dongle to use a memory card...

This is a result of Apple focusing on their use case and building the device they think people want. And really, it does seem to be what a lot of people want, or think they want.

The problem with the Apple model, and by extension the Gnome3 model (since Gnome3 seems to be following Apple quite strongly down this rabbit hole) is that it only serves the specific target audience. What it utterly fails to do, what it's flatly terrible at, is allowing the user to grow and learn.

In recent years the design community has had an absolute hatred of configurability, extensibility and utility. The "ideal" design is one in which there is only one way to do anything, and the novice user can do it preferably with the mouse alone. The plan was that we could give everyone this computer, and anyone could use it.

The trouble with this plan is that it provides no growth path for the user; they can never be anything but a novice because the system doesn't let them take the training wheels off. It also means it's much more difficult to adapt the system to unanticipated needs.

The platonic ideal of this design style is Microsoft Bob, and the things that descended from it (Clippy, "wizards"...). Your whole computing experience is on rails, assistants do everything for you, and you can't do anything your assistants don't know how (or don't want) to do.

The Gnome project has been particularly bad about this over the years; one need look no further than Metacity to see that the current "you will use your computer the way we tell you" attitude is endemic, not some new development. As I recall, the current kerfuffle about lack of options in Gnome3 is a replay of Gnome2; when Gnome2 was new, there was a similar storm of complaints from users about options gone missing, and similar condescending "you simply don't understand my genius" replies from the design team.

The "we must maintain our branding" excuse is new, but it's merely another justification for the "thou shall not question the holy designers" attitude.

I remain unconvinced that the path Free Software should take is the same path Apple and Microsoft took. Ease of use and ease of learning for beginners is definitely important. Some damage control systems are important as well; preventing novices from burning the house down is clearly desirable.

But where all current "mainstream" desktop systems fall down (and I'm including Gnome and KDE here) is decent support for the steps past novice, the road to mastery.

Consider emacs. When you start using emacs, you can treat it as a simple text editor; open and save files with the menu, only open one file at a time, it supports drag and drop, cut and paste from the menu, and so forth. You can give emacs to a novice and expect them to survive in it, though they may occasionally trip over an advanced feature and get confused.

But emacs grows with you. In my experience, about once a month I learn a new trick in emacs that within six months I can't live without. There's a depth, a richness, access to new ways of doing things. Improved ways of doing things. Ways of doing things automatically in an instant that would have taken hours or weeks to do by hand.

We ought to be able to have that in our desktop environments.

There are hints of where to go to make this happen. The example of emacs is particularly instructive; having a completely scriptable system packed with hooks produces a very powerful environment for user mastery.

In window managers, elements of Enlightenment and the SawFish window manager showed some of what could be done.

A particularly important example of the sort of thing we should be doing is (now mostly defunct) Quicksilver for OSX. As much as possible should be made available through dbus, and you should be able to access those services directly through a command interface. I ought, for instance, to be able to bring up a shell and use a simple command to tell firefox to send the image on tab 2 to a new layer in the image I'm editing in gimp.

Perhaps these desktop environments should have a novice mode with training wheels and padded walls, but if we're going to offer a compelling reason to switch to our platforms, the novice mode must have an off switch. The real strength of the free software community is in our experienced users, our willingness to experiment, and our software's ability to grow with experience and need. As per the (attribution and exact wording forgotten...) quote, "Unix doesn't prevent you from doing something stupid because that would also prevent you from doing something clever."

The combination makes for a really slick all-in-one machine. It is a bit tricky to find LCD monitors built with touchscreen included but they do exist.

However, adding a battery backup that could run a thing like that for more than 20 minutes would be quite heavy and painful to haul around.

You want your devices to work consistently, but take advantage of the special hardware you're using. For that reason, I think one interface for tablets and laptops (as an example) is suboptimal, because you end up compromising on both sides. Some of the complaints about gnome-shell and Unity are I think symptomatic for these compromises.

In Plasma Active, we're sharing components and infrastructure across devices, but create specialized interfaces suitable for the type of device (screen, input methods, etc.), and the use-cases that go along with it to get the best user experience out of your hardware. The end result will (hopefully :-)) be a system that works consistently across devices, integrates well with your other form-factors and is easily adaptable to new types of devices.

And yes, the plan is to also support smartphones at some point, but given the "closedness" of this segment of the device spectrum, we are concentrating on tablets first -- a lot of that work also benefits an eventual phone interface at some point in the future, and not to forget the desktop and netbook interfaces.

At home I want the same device to hook up to my 24 inch display either by HDMI or micro USB. No Bluetooth I like speed and efficiency. Bluetooth requires several transceivers and I'd like to save the power when I'm on the road for a more energy efficient micro USB keyboard.

I want my tablet to do everything. I've got a spreed sheet program which works reasonably well. I don't need Microsoft...........

Nobody really needs Microsoft. (Tablets must really have them shaking!)

CPU and GPU Processors for small devices will improve quickly. Batteries will get small and cheaper. What do I need the old workstation for when my tablet frankly can do it all. I love empty pockets one device to rule it all.

5 billion of the worlds people really can afford all the eye candy. Powerful Desktop. Tablet. Mobile Phone. Land Line for data. etc .etc. etc. But they can afford what will be coming in the tablet space and wireless networking.

I wind up repurposing old hardware as unix/linux boxes fairly often. Generally, I reach for gentoo; it takes a little more fiddling to set up, but it works pretty well even on older hardware. Assuming you don't try to install KDE or GNOME, of course... :)