Every detail matters, and building great software means taking time to remove the papercuts. Ubuntu has over the past 5 years been refined in many ways to feel amazingly comfortable on the cloud. In the very early days of EC2 growth the Ubuntu team recognised how many developers were enjoying fast access to infrastructure on demand, and we set about polishing up Ubuntu to be amazing on the cloud.
This was a big program of work; the Linux experience had many bad assumptions baked in – everything had been designed to be installed once on a server then left largely untouched for as long as possible, but cloud infrastructure was much more dynamic than that.
We encouraged our team to use the cloud as much as possible, which made the work practical and motivated people to get it right themselves. If you want to catch all the little scratchy bits, make it part of your everyday workflow. Today, we have added OpenStack clouds to the mix, as well as the major public clouds. Cloud vendors have taken diverse approaches to IAAS so we find ourselves encouraging developers to use all of them to get a holistic view, and also to address any cloud-specific issues that arise. But the key point is – if it’s great for us, that’s a good start on making it great for everybody.
Then we set about interviewing cloud users and engaging people who were deep into cloud infrastructure to advise on what they needed. We spent a lot of time immersing ourselves in the IAAS experience through the eyes of cloud users – startups and industrial titans, universities and mid-sized, everyday companies. We engaged the largest and fastest-moving cloud users like Netflix, who have said they enjoy Ubuntu as a platform on the cloud. And that in turn drove our prioritisation of paper-cuts and significant new features for cloud users.
We also looked at the places people actually spend time developing. Lots of them are on Ubuntu desktops, but Windows and MacOS are popular too, and it takes some care to make it very easy for folks there to have a great devops experience.
All of this is an industrial version of the user experience design process that also powers our work on desktop, tablet and phone – system interfaces and applications. Devops, sysadmins, developers and their managers are humans too, so human-centric design principles are just as important on the infrastructure as they are on consumer electronics and consumer software. Feeling great at the command line, being productive as an operator and a developer, are vital to our community and our ecosystem. We keep all the potency of Linux with the polish of a refined, designed environment.
Along the way we invented and designed a whole raft of key new pieces of Ubuntu. I’ll write about one of them, cloud-init, next. The net effect of that work makes Ubuntu really useful on every cloud. That’s why the majority of developers using IAAS do so on Ubuntu.
This work has been a LOT of fun. It started when we were trying to find the zen of each edge of the screen, a long time back. We quickly figured out that the bottom edge is by far the most fun, by far the most accessible. You can always get to it easily, it feels great. I suspect that’s why Apple has used the bottom edge for their quick control access on IOS.
We started in the same place as Apple, thinking that the bottom edge was so nice we wanted it for ourselves, in the system. But as we discussed it, we started to think that the app developer was the one who deserved to do something really distinctive in their app with it instead. It’s always tempting to grab the tastiest bit for oneself, but the mark of civility is restraint in the use of power and this felt like an appropriate time to exercise that restraint.
Importantly you can use it equally well if we split the screen into left and right stages. That made it a really important edge for us because it meant it could be used equally well on the Ubuntu phone, with a single app visible on the screen, and on the Ubuntu tablet, where we have the side stage as a uniquely cool way to put phone apps on tablet screens alongside a bigger, tablet app.
The net result is that you, the developer, and you, the user, have complete creative freedom with that bottom edge. There are of course ways to judge how well you’ve exercised that freedom, and the design guidance tries to leave you all the freedom in the world while still providing a framework for evaluating how good the result will feel to your users. If you want, there are some archetypes and patterns to choose from, but what I’d really like to see is NEW patterns and archetypes coming from diverse designs in the app developer community.
Here’s the key thing – that bottom edge is the one thing you are guaranteed to want to do more innovatively on Ubuntu than on any other mobile platform. So if you are creating a portable app, targeting a few different environments, that’s the thing to take extra time over for your Ubuntu version. That’s the place to brainstorm, try out ideas on your friends, make a few mockups. It’s the place you really express the single most important aspects of your application, because it’s the fastest, grooviest gesture in the book, and it’s all yours on Ubuntu.
In the open source community, we celebrate having pieces that “do one thing well”, with lots of orthogonal tools compounding to give great flexibility. But that same philosophy leads to shortcomings on the GUI / UX front, where we want all the pieces to be aware of each other in a deeper way.
For example, we consciously place the notifications in the top right of the screen, avoiding space that is particularly precious (like new tab titles, and search boxes). But the indicators are also in the top right, and they make menus, which drop down into the same space a notification might occupy.
Since we know that notifications are queued, no notification is guaranteed to be displayed instantly, so a smarter notification experience would stay out of the way while you were using indicator menus, or get out of the way when you invoke them. The design story of focusayatana, where we balance the need for focus with the need for awareness, would suggest that we should suppress awareness-oriented things in favour of focus things. So when you’re interacting with an indicator menu, we shouldn’t pop up the notification. Since the notification system, and the indicator menu system, are separate parts, the UNIX philosophy sells us short in designing a smart, smooth experience because it says they should each do their thing individually.
Going further, it’s silly that the sound menu next/previous track buttons pop up a notification, because the same menu shows the new track immediately anyway. So the notification, which is purely for background awareness, is distracting from your focus, which is conveying exactly the same information!
But it’s not just the system menus. Apps can play in that space too, and we could be better about shaping the relationship between them. For example, if I’m moving the mouse around in the area of a notification, we should be willing to defer it a few seconds to stay out of the focus. When I stop moving the mouse, or typing in a window in that region, then it’s OK to pop up the notification.
It’s only by looking at the whole, that we can design great experiences. And only by building a community of both system and application developers that care about the whole, that we can make those designs real. So, thank you to all of you who approach things this way, we’ve made huge progress, and hopefully there are some ideas here for low-hanging improvements too
Our mission with Ubuntu is to deliver, in the cleanest, most economical and most reliable form, all the goodness that engineers love about free software to the widest possible audience (including engineers :)). We’ve known for a long time that free software is beautiful on the inside – efficient, accurate, flexible, modifiable. For the past three years, we’ve been leading the push to make free software beautiful on the outside too – easy to use, visually pleasing and exciting. That started with the Ubuntu Netbook Remix, and is coming to fruition in 12.04 LTS, now in beta.
For the first time with Ubuntu 12.04 LTS, real desktop user experience innovation is available on a full production-ready enterprise-certified free software platform, free of charge, well before it shows up in Windows or MacOS. It’s not ‘job done’ by any means, but it’s a milestone. Achieving that milestone has tested the courage and commitment of the Ubuntu community – we had to move from being followers and integrators, to being designers and shapers of the platform, together with upstreams who are excited to be part of that shift and passionate about bringing goodness to a wide audience. It’s right for us to design experiences and help upstreams get those experiences to be amazing, because we are closest to the user; we are the last mile, the last to touch the code, and the first to get the bug report or feedback from most users.
Thank you, to those who stood by Ubuntu, Canonical and me as we set out on this adventure. This was a big change, and in the face of change, many wilt, many panic, and some simply find that their interests lie elsewhere. That’s OK, but it brings home to me the wonderful fellowship that we have amongst those who share our values and interests – their affiliation, advocacy and support is based on something much deeper than a fad or an individualistic need, it’s based on a desire to see all of this intellectual wikipedia-for-code value unleashed to support humanity at large, from developers to data centre devops to web designers to golden-years-ganderers, serving equally the poorest and the bankers who refuse to serve them, because that’s what free software and open content and open access and level playing fields are all about.
To those of you who rolled up your sleeves and filed bugs and wrote the documentation and made the posters or the cupcakes, thank you.
I’m very serious about loving the recent changes. I think I’m a fair representative of the elderly community ………. someone who doesn’t particularly care to learn new things, but just wants things to make sense. I think we’re there! Lance
You’ll be as delighted with the coverage of Ubuntu for Android at MWC in Barcelona last week:
“one of the more eye-catching concepts being showcased” – v3 “sleeker, faster, potentially more disruptive” – IT Pro Portal “you can also use all the features of Android” – The Inquirer “I can easily see the time when I will be carrying only my smartphone” – UnwiredView “everything it’s been claimed to be” – Engadget “Efficiency, for the win!” – TechCrunch “phones that become traditional desktops have the potential to benefit from the extra processing power” – GigaOM “This, ladies and gentlemen, is the future of computing” – IntoMobile
Free software distils the smarts of those of us who care about computing, much like Wikipedia does. Today’s free software draws on the knowledge and expertise of hundreds of thousands of individuals, all over the world, all of whom helped to make this possible, just like Wikipedia. It’s only right that the benefits of that shared wisdom should accrue to everyone without charge, which is why contributing to Ubuntu is the best way to add leverage to the contributions made everywhere else, to ensure they have the biggest possible impact. It wouldn’t be right to have to pay to have a copy of Wikipedia on your desk at the office, and the same is true of the free software platform. The bits should be free, and the excellent commercial services optional. That’s what we do at Canonical and in the Ubuntu community, and that’s why we do it.
Engineers are human beings too!
We set out to refine the experience for people who use the desktop professionally, and at the same time, make it easier for the first-time user. That’s a very hard challenge. We’re not making Bob, we’re making a beautiful, easy to use LCARS ;-). We measured the state of the art in 2008 and it stank on both fronts. When we measure Ubuntu today, based on how long it takes heavy users to do things, and a first-timer to get (a different set of) things done, 12.04 LTS blows 10.04 LTS right out of the water and compares favourably with both MacOS and Windows 7. Unity today is better for both hard-core developers and first-time users than 10.04 LTS was. Hugely better.
For software developers:
A richer set of keyboard bindings for rapid launching, switching and window management
Pervasive search results in faster launching for occasional apps
Far less chrome in the shell than any other desktop; it gets out of your way
Much more subtle heuristics to tell whether you want the launcher to reveal, and to hint it’s about to
Integrated search presents a faster path to find any given piece of content
Magic window borders and the resizing scrollbar make for easier window sizing despite razor-thin visual border
Full screen apps can include just the window title and indicators – full screen terminal with all the shell benefits
… and many more. In 12.04 LTS, multi-monitor use cases got a first round of treatment, we will continue to refine and improve that every six months now that the core is stable and effective. But the general commentary from professionals, and software developers in particular, is “wow”. In this last round we have focused testing on more advanced users and use cases, with user journeys that include many terminal windows, and there is a measurable step up in the effectiveness of Unity in those cases. Still rough edges to be sure, even in this 12.04 release (we are not going to be able to land locally-integrated menus in time, given the freeze dates and need for focus on bug fixes) but we will SRU key items and of course continue to polish it in 12.10 onwards. We are all developers, and we all use it all the time, so this is in our interests too.
We care about efficiency, performance, quality, reliability. So do developers and engineers. We care about beauty and ease of use – turns out most engineers and developers care about that too. I’ve had lots of hard-core engineers tell me that they “love the challenges the design team sets”, because it’s hard to make easy software, and harder to make it pixel-perfect. And lots that have switched back to Ubuntu from the MacOS because devops on Ubuntu… rock.
The hard core Linux engineers can use… anything, really. Linus is probably equally comfortable with Linux-from-scratch as with Ubuntu. But his daughter Daniela needs something that works for human beings of all shapes, sizes, colours and interests. She’s in our audience. I hope she’d love Ubuntu if she tries it. She could certainly install it for herself while Dad isn’t watching 😉 Linus and other kernel hackers are our audience too, of course, but they can help himself if things get stuck. We have to shoulder the responsibility for the other 99%. That’s a really, really hard challenge – for engineers and artists alike. But we’ve made huge progress. And doing so brings much deeper meaning to the contributions of all the brilliant people that make free software, everywhere.
Again, thanks to the Ubuntu community, 500 amazing people at Canonical, the contributors to all of the free software that makes it possible, and our users.
The desktop remains central to our everyday work and play, despite all the excitement around tablets, TV’s and phones. So it’s exciting for us to innovate in the desktop too, especially when we find ways to enhance the experience of both heavy “power” users and casual users at the same time. The desktop will be with us for a long time, and for those of us who spend hours every day using a wide diversity of applications, here is some very good news: 12.04 LTS will include the first step in a major new approach to application interfaces.
This work grows out of observations of new and established / sophisticated users making extensive use of the broader set of capabilities in their applications. We noticed that both groups of users spent a lot of time, relatively speaking, navigating the menus of their applications, either to learn about the capabilities of the app, or to take a specific action. We were also conscious of the broader theme in Unity design of leading from user intent. And that set us on a course which led to today’s first public milestone on what we expect will be a long, fruitful and exciting journey.
The menu has been a central part of the GUI since Xerox PARC invented ’em in the 70’s. It’s the M in WIMP and has been there, essentially unchanged, for 30 years.
The original Macintosh desktop, circa 1984, courtesy of Wikipedia
We can do much better!
Say hello to the Head-Up Display, or HUD, which will ultimately replace menus in Unity applications. Here’s what we hope you’ll see in 12.04 when you invoke the HUD from any standard Ubuntu app that supports the global menu:
Snapshot of the HUD in Ubuntu 12.04
The intenterface – it maps your intent to the interface
This is the HUD. It’s a way for you to express your intent and have the application respond appropriately. We think of it as “beyond interface”, it’s the “intenterface”. This concept of “intent-driven interface” has been a primary theme of our work in the Unity shell, with dash search as a first class experience pioneered in Unity. Now we are bringing the same vision to the application, in a way which is completely compatible with existing applications and menus.
The HUD concept has been the driver for all the work we’ve done in unifying menu systems across Gtk, Qt and other toolkit apps in the past two years. So far, that’s shown up as the global menu. In 12.04, it also gives us the first cut of the HUD.
Menus serve two purposes. They act as a standard way to invoke commands which are too infrequently used to warrant a dedicated piece of UI real-estate, like a toolbar button, and they serve as a map of the app’s functionality, almost like a table of contents that one can scan to get a feel for ‘what the app does’. It’s command invocation that we think can be improved upon, and that’s where we are focusing our design exploration.
As a means of invoking commands, menus have some advantages. They are always in the same place (top of the window or screen). They are organised in a way that’s quite easy to describe over the phone, or in a text book (“click the Edit->Preferences menu”), they are pretty fast to read since they are generally arranged in tight vertical columns. They also have some disadvantages: when they get nested, navigating the tree can become fragile. They require you to read a lot when you probably already know what you want. They are more difficult to use from the keyboard than they should be, since they generally require you to remember something special (hotkeys) or use a very limited subset of the keyboard (arrow navigation). They force developers to make often arbitrary choices about the menu tree (“should Preferences be in Edit or in Tools or in Options?”), and then they force users to make equally arbitrary effort to memorise and navigate that tree.
The HUD solves many of these issues, by connecting users directly to what they want. Check out the video, based on a current prototype. It’s a “vocabulary UI”, or VUI, and closer to the way users think. “I told the application to…” is common user paraphrasing for “I clicked the menu to…”. The tree is no longer important, what’s important is the efficiency of the match between what the user says, and the commands we offer up for invocation.
In 12.04 LTS, the HUD is a smart look-ahead search through the app and system (indicator) menus. The image is showing Inkscape, but of course it works everywhere the global menu works. No app modifications are needed to get this level of experience. And you don’t have to adopt the HUD immediately, it’s there if you want it, supplementing the existing menu mechanism.
It’s smart, because it can do things like fuzzy matching, and it can learn what you usually do so it can prioritise the things you use often. It covers the focused app (because that’s where you probably want to act) as well as system functionality; you can change IM state, or go offline in Skype, all through the HUD, without changing focus, because those apps all talk to the indicator system. When you’ve been using it for a little while it seems like it’s reading your mind, in a good way.
We’ll resurrect the (boring) old ways of displaying the menu in 12.04, in the app and in the panel. In the past few releases of Ubuntu, we’ve actively diminished the visual presence of menus in anticipation of this landing. That proved controversial. In our defence, in user testing, every user finds the menu in the panel, every time, and it’s obviously a cleaner presentation of the interface. But hiding the menu before we had the replacement was overly aggressive. If the HUD lands in 12.04 LTS, we hope you’ll find yourself using the menu less and less, and be glad to have it hidden when you are not using it. You’ll definitely have that option, alongside more traditional menu styles.
Voice is the natural next step
Searching is fast and familiar, especially once we integrate voice recognition, gesture and touch. We want to make it easy to talk to any application, and for any application to respond to your voice. The full integration of voice into applications will take some time. We can start by mapping voice onto the existing menu structures of your apps. And it will only get better from there.
But even without voice input, the HUD is faster than mousing through a menu, and easier to use than hotkeys since you just have to know what you want, not remember a specific key combination. We can search through everything we know about the menu, including descriptive help text, so pretty soon you will be able to find a menu entry using only vaguely related text (imagine finding an entry called Preferences when you search for “settings”).
There is lots to discover, refine and implement. I have a feeling this will be a lot of fun in the next two years
Even better for the power user
The results so far are rather interesting: power users say things like “every GUI app now feels as powerful as VIM”. EMACS users just grunt and… nevermind ;-). Another comment was “it works so well that the rare occasions when it can’t read my mind are annoying!”. We’re doing a lot of user testing on heavy multitaskers, developers and all-day-at-the-workstation personas for Unity in 12.04, polishing off loose ends in the experience that frustrated some in this audience in 11.04-10. If that describes you, the results should be delightful. And the HUD should be particularly empowering.
Even casual users find typing faster than mousing. So while there are modes of interaction where it’s nice to sit back and drive around with the mouse, we observe people staying more engaged and more focused on their task when they can keep their hands on the keyboard all the time. Hotkeys are a sort of mental gymnastics, the HUD is a continuation of mental flow.
Ahead of the competition
There are other teams interested in a similar problem space. Perhaps the best-known new alternative to the traditional menu is Microsoft’s Ribbon. Introduced first as part of a series of changes called Fluent UX in Office, the ribbon is now making its way to a wider set of Windows components and applications. It looks like this:
You can read about the ribbon from a supporter (like any UX change, it has its supporters and detractors ;-)) and if you’ve used it yourself, you will have your own opinion about it. The ribbon is highly visual, making options and commands very visible. It is however also a hog of space (I’m told it can be minimised). Our goal in much of the Unity design has been to return screen real estate to the content with which the user is working; the HUD meets that goal by appearing only when invoked.
Instead of cluttering up the interface ALL the time, let’s clear out the chrome, and show users just what they want, when they want it.
Time will tell whether users prefer the ribbon, or the HUD, but we think it’s exciting enough to pursue and invest in, both in R&D and in supporting developers who want to take advantage of it.
Other relevant efforts include Enso and Ubiquity from the original Humanized team (hi Aza &co), then at Mozilla.
Our thinking is inspired by many works of science, art and entertainment; from Minority Report to Modern Warfare and Jef Raskin’s Humane Interface. We hope others will join us and accelerate the shift from pointy-clicky interfaces to natural and efficient ones.
Roadmap for the HUD
There’s still a lot of design and code still to do. For a start, we haven’t addressed the secondary aspect of the menu, as a visible map of the functionality in an app. That discoverability is of course entirely absent from the HUD; the old menu is still there for now, but we’d like to replace it altogether not just supplement it. And all the other patterns of interaction we expect in the HUD remain to be explored. Regardless, there is a great team working on this, including folk who understand Gtk and Qt such as Ted Gould, Ryan Lortie, Gord Allott and Aurelien Gateau, as well as designers Xi Zhu, Otto Greenslade, Oren Horev and John Lea. Thanks to all of them for getting this initial work to the point where we are confident it’s worthwhile for others to invest time in.
We’ll make sure it’s easy for developers working in any toolkit to take advantage of this and give their users a better experience. And we’ll promote the apps which do it best – it makes apps easier to use, it saves time and screen real-estate for users, and it creates a better impression of the free software platform when it’s done well.
From a code quality and testing perspective, even though we consider this first cut a prototype-grown-up, folk will be glad to see this:
Overall coverage rate:
lines......: 87.1% (948 of 1089 lines)
functions..: 97.7% (84 of 86 functions)
branches...: 63.0% (407 of 646 branches)
Landing in 12.04 LTS is gated on more widespread testing. You can of course try this out from a PPA or branch the code in Launchpad (you will need thesetwo branches). Or dig deeper with blogs on the topic from Ted Gould, Olli Ries and Gord Allott. Welcome to 2012 everybody!
The mailing list has seen some decent traffic as well, with people talking mostly about what the future of the Connected TV might be and features they’d like to see.
Thanks guys. The resulting list looks like this:
– 10′ interface- Watching Media (DVR, Live, Network(TV Guide is part of DVR/other services))- Control via remote controlHigh priority– Plugin support- Cloud and/or server storage (for home grown media)
– Playback of physical media (USB cd/dvd/bluray drive)
– Installable image
– Easy configuration of new devices (eg. installing same plugins, mounting same network shares)
– Ubuntu One Accounts
– Push media to/from other Ubuntu devices / Media syncing capabilities (Pause on one device, resume from same spot on another device)
– Control from portable devices (phones/tablets/web interface/PC) (collaboration with Ubuntu Phone/Tablet?)
– Sharing media with friends (social network connectivity)
– Purchasing media through online stores (Ubuntu one/Amazon/Netflix)
Not a bad list at all. Thanks to tgm4883, MrChrisDruif, imnichol, callumsaunders1, dmj726 and others.
Separately, reports from a team that may have a crack at implementing the TV interface:
… tracked down some bugs in QML itself, fixed them, and are submitting patches upstream. Next time you read that Qt Mobility now supports hardware accelerated video playback, or how the “ShaderEffectItem” now respects the “clip” property, or simply that the OpenGL video painter renders where it’s supposed to; you know who to thank. As an added bonus this will benefit Unity-2D. Awesome work.
Our goal with Unity is unprecedented ease of use, visual style and performance on the Linux desktop. With feature freeze behind us, we have a refined target render of the Dash for Oneiric, and here it is:
We’ve moved from the idea of “Places” to a richer set of “Scopes and Lenses”. Scopes are data sources, and can tap into any online or offline data set as long as they can generate categorised results for a search, describe a set of filters and support some standard interfaces. Lenses are various ways to present the data that come from Scopes.
The Scopes have a range of filtering options they can use, such as ratings (“show me all the 5 star apps in the Software Center please”) and categories (“… that are games or media related”). Over time, the sophistication of this search system will grow but the goal is to keep it visual and immediate – something anyone can drive at first attempt.
This delivers on the original goal of creating a device-like experience that was search driven. Collaboration with the always-excellent Zeitgeist crew (quite a few of whom are now full time on the Unity team!) has improved the search experience substantially, kudos to them for the awesome work they’ve put in over the past six months. Since we introduced the Dash as a full screen device-like search experience, the same idea has made its way into several other shells, most notably Mac OS X Lion. While we’re definitely the outsider in this contest, I think we can stay one step ahead in the game given the support of our community.
The existing Places are all in the process of being updated to the Scopes and Lenses model, it’s a bit of a construction site at the moment so hard-hats are advised but dive in if you have good ideas for some more interesting scopes. I’ve heard all sorts of rumours about cool scopes in the pipeline 😉 and I bet this will be fertile ground for innovation. It’s pretty straightforward to make a scope, I’m sure others will blog and document the precise mechanisms but for those who want a head start, just use the source, Luke.
In the panel, you’ll see that the top left corner is now consistently used to close whatever has the focus. Maximising a window keeps the window controls in the same position relative to the window – the top left corner. We have time to refine the behaviour of this based on user testing of the betas; for example, in one view, one should be able to close successive windows from that top left corner even if they are not maximised.
It’s taken several releases of careful iteration to get to this point. Even though we had a good idea where we were headed, each step needed to be taken one release at a time. Perhaps this might make a little clearer the reasons for the move of window controls to the left – it was the only place where we could ultimately keep them consistent all the way up to a maximised window with the title bar integrated into the panel. I’m confident this part will all be settled by 12.04.
As part of this two-step shuffle, the Dash invocation is now integrated in the Launcher. While this is slightly less of a Fitts-fantastic location, we consider it appropriate for a number of reasons. First, it preserves the top left corner for closing windows. Second, the Dash is best invoked with the Super key (sometimes erroneously and anachronistically referred to as the “Windows” key, for some reason ;-)). And finally, observations during user testing showed people as more inclined to try clicking on items in the Launcher than on the top left icon in the panel, unless that icon was something explicit like a close button for the window. Evidence based design rules.
Rather than a flat darkening, we’re introducing a wash based on the desktop colour. The dash thus adjusts to your preferred palette based on your wallpaper. The same principle will drive some of the login experience – choosing a user will shift the login screen towards that users wallpaper and palette.
We’ve also integrated the panel and the dash, so indicators are rendered in a more holographic fashion inside the dash. Together with efforts to mute the contrast of Launcher icons the result is a more striking dash altogether: content is presented more dramatically.
Since we have raw access to the GL pipeline, we’re taking advantage of that with some real-time blur effects to help the readability and presentation of overlay content in the Dash, too. Both Nux in the case of Unity-3D and Qt in the case of Unity-2D have rich GL capabilities, and we’d like to make the most of whatever graphics stack you have on your hardware, while still running smoothly on the low end.
Growing community and ecosystem
A project like this needs diverse perspectives, talents and interests to make it feel rounded and complete. While Canonical is carrying the core load, and we’re happy to do so in order to bring this level of quality to the Ubuntu desktop user experience, what makes me particularly optimistic is the energy of the contributors both to Unity directly and to the integration of many other components and applications with the platform.
On the contribution front, a key goal for the Unity community is to maintain velocity in contributor patch flows. You should expect a rapid review and, all being well, landing, for contributions to Unity that are in line with the design goals. In a few cases we’ve also accepted patches that make it possible to use Unity in ways that are different to the design goals, especially where the evidence doesn’t lean very heavily one way or the other. Such contributions add some complexity but also give us the opportunity to test alternatives in a very rich way; the winning alternative would certainly survive, the other might not.
Contrary to common prognostication, this community is shaping up to be happy and productive. For those who do so for love and personal interest, participating in such a community should be fun and stimulating, an opportunity to exercise skills or pursue interests, give something back that will be appreciated and enjoyed by many, and help raise the bar for Linux experiences. I’d credit Jorge and others for their stewardship of this so far, and my heartfelt thanks to all of those who have helped make Unity better just for the fun of it.
Outside of the core, the growing number of apps that integrate sweetly with the launcher (quicklists), dash (scopes), indicators (both app-specific and category indicators) is helping to ensure that API’s are useful, refined and well implemented, as well as improving the experience of Ubuntu users everywhere. Now that we’re moving to Unity by default for both 2D and 3D, that’s even more valuable.
Under the hood
In this round, Unity-3D and Unity-2D have grown together and become twin faces on the same underlying model. They now share a good deal of common code and common services and – sigh – common bugs :-). But we’re now at the point where we can be confident that the Unity experience is available on the full range of hardware, from lightweight thin client systems made of ARM or Atom CPU’s to CADstations with oodles of GPU horsepower.
There’s something of a competition under way between proponents of the QML based Unity-2D, who believe that the GL support here is good enough to compete both at the high end and on the low end, and the GL-heads in Unity-3D, who think that the enhanced experiences possible with raw GL access justify the additional complexity of working in C++ and GL on the metal. Time will tell! Since a lot of the design inspiration for Unity came from game interfaces, I lean to the “let’s harness all the GL we can for the full 3D experience” side of the spectrum, but I’m intrigued with what the QML team are doing.
A wit said of Google Wave “if your project depends on reinventing scrollbars, you are doing something wrong.” But occasionally, just occasionally, one gets to do exactly that.
Under the Ayatana banner, we’ve been on a mission to make the desktop have less chrome and more content. The goal is to help people immerse themselves in their stuff, without being burdened with large amounts of widgetry which isn’t relevant to the thing they are trying to concentrate on. And when it comes to widgetry, there are few things left which take up more space than scrollbars.
For example, I spend plenty of time in a full screen terminal, and it’s lovely to see how clean that experience is on Natty today:
…but that scrollbar on the right seems heavy and outdated. We took inspiration from mobile devices, and started exploring the idea of making scrollbars be more symbolic, and less physical. Something like this:
Of course, since the desktop isn’t often a touch device, we need to think through pointer interactions. We wanted to preserve the idea of keeping content exposed as much as possible, while still providing for pointer interaction when needed. We also decided to drop the “one line scroll” capability, while preserving the ability to page up and down. Take a look at the result:
The design work behind this has been done by Christian Giordano, who worked through the corner cases (literally) and provided a mockup for testing purposes. And the heavy lifting for Natty is being done by the indefatigable Andrea Cimitan, who is currently polishing up a gtk implementation of the concept for the release. Christian put together a blog post on the subject, and a great video which talks through the design process and a few of the challenges and solutions found:
Marcus and Ivanka in the Canonical Design team sat me down for some words of wisdom a few months ago. “You think you need a logo, but what you really need is a new font. One that sets the standard for both professional design, and embracing the values of Ubuntu in the way it’s produced.”
And how right they were.
Figuring that we wanted to do this once, properly, we said we’d build a complete family: various weights, variable-width and mono, across some of the key language groups of our community. We knew we couldn’t do everything but we figured we could establish a rigorous core upon which everything could be done. We’d fully hint and kern the work too, so it’s good enough to be a default interface font for something we all use all day long. A huge project, one that will take some time to finish. But today we’re publishing the first source for Ubuntu, the font, a milestone worth celebrating.
Marcus introduced Bruno Maag of Dalton Maag, who expressed a willingness to engage around an open font, and we agreed to buy the rights to the work completely, so that it could be licensed freely.
Bruno pulled together a very energetic team of typographers: Lukaz, Amelie, Shiraaz, Malcolm and more, all folks who live and breathe type and typography and keen to explore this rather crazy idea of inviting crowds into the inner sanctum of type design.
We knew at the start we were bringing together two very different worlds. We wanted a process which would ensure participation without drowning out the clear leadership needed for a coherent result. Bruno steered Marcus, Ivanka, me and others through a core initial process where we defined the range and scope of what we wanted to take on, and the values we wanted reflected in the result. I learned that a font is grounded in real values, and fortunately we have a strong expression of the six attributes that we value in Ubuntu and Canonical: collaboration, freedom, precision, reliability, adroitness, accessibility. That small team was best positioned to distill those into the typeface, and shape the broad strokes of the work.
Ubuntu is a global phenomenon, and we knew at the start we didn’t have the breadth of eyeballs close at hand to keep the font on track as it expanded. So we planned a process of expanding consultation. First within Canonical, which has folks from nearly 30 countries, and then within the Ubuntu community. We published the font to Ubuntu Members, because we wanted folks who participate and contribute directly to Ubuntu to have the strongest say in the public process of designing the font. We heard from Greek, Turkish, Hebrew, Arabic, Indian, Chinese and many other cultures. Not everyone has glyphs in this first round, but everyone has had a hand in bringing us to this milestone.
The design team needed help with this outreach program, and it turned out that a longstanding member of the community, Paul Sladen, has a personal interest in typography. We noticed a marked uptick in the pace of bug triage when Paul got involved, and it was going so well we asked him to tackle it semi-professionally. The result has been really fast feedback to people making comments. I’d like to thank Paul for bringing that crucial stewardship to bear on the community engagement process, we would not have made it to the deadline without him.
We also had the benefit of a tool produced by Richard Lee and others in the design team, which lets people identify specific issues in the font, particularly as rendered in various web browsers on various platforms. fonttest.design.canonical.com is very cool: it lets you pick the characters, weight and size, takes a screenshot for you in most browsers, or helps you capture the essential details for the bug report. Fonts are software, but they are not software as we know it, Jim. So the tool helps us keep track of all the tricky details that might help debug a problem someone’s having.
A key open question, of course, was licensing. There are two obvious candidates, among quite a large field: the OFL, from SIL, and the GPLv3 with a font-specific clause added. Digging into this in more detail turned up a tricky situation: both approaches have issues which precluded us from adopting them immediately. We started speaking in some detail with Nicolas Spalinger of SIL, and Dave Crossland, who has done extensive analysis on the libre font process and dynamics. We offered to underwrite an SFLC review of the OFL, and SIL has expressed a willingness to participate in that, with a view to finding common ground that would bring Dave, ourselves, and many others under one common font licence, but we were running out of time. So we came to the compromise of an interim license, which you can find at bzr branch lp:ubuntu-font-licence While licence proliferation sucks, I’m optimistic we’ll converge in due course. James Vasile from the SFLC will help ensure the final result is wiser with the help of all the experience the SFLC gained in stewarding the GPLv3, and SIL and Dave will bring deep typographic industry insight.
Dalton Maag have started talking more widely about their experiences so far in the process. I was worried that they might be put off by the rowdy nature of open commentary, but I would credit them with a sterling constitution and thank them for the way they stepped up once the bug tracker really started to hum. There are few issues that are escalated which don’t get a rapid response and framing. Of course, there are differences of opinion, but in many cases genuine issues have been identified and handled. The team at DM have gotten into a great cadence of weekly iterations, and Paul has been ensuring that work makes it into the hands of Ubuntu users. As of today, *all* Maverick users have it installed by default (I believe this is true for Kubuntu as well, at least I answer questions in support of that goal).
What’s really interesting is that DM have said there is world-wide interest in the project. Many professional typographers are starting to think about open fonts. Now is the time to set a very high standard for what is achievable. There are hard questions to be answered about how the business of typography will evolve in the face of open and free type, but historically, those questions have best been answered by the bold: those who get involved, those who put themselves in the front line.
In due course, we’d like the Ubuntu font to reflect the full, extraordinary diversity of the Ubuntu community. We can’t do it all at once, and so we’re proposing a process for communities and cultures that feel part of the Ubuntu family to participate. If you want the Ubuntu font to speak your language, you need to do a few things to prepare for it. The hard, hard part is that you’ll need to find a qualified, local typographer who is interested in participating and in leading the design of your glyphs. You may need to find several, as we won’t necessarily embrace the first candidate. This is a serious matter: we welcome the crowdsourcing of bugs, glitches, rendering problems, hinting and kerning issues, but we want coherent, professional contributions on the core design. If that sounds exclusive: yes it is. Quality takes time, quality takes precedence. There are other fonts with lots of coverage, we have only one shot to get your glyphs done really beautifully then freeze them, metrically, for all time in the Ubuntu font.
The broader process looks like this.
First, you need to create a wiki page for your language / culture / glyphset (could be Klingon! Phoenician! Elvish ;-)) on wiki.ubuntu.com/UbuntuFont/Coverage. There, you need to document the glyph set you think is required, and any historical quirks that are peculiar to doing it well, such as OpenType features or alternative approaches.
Second, you need to file a bug on launchpad.net/ubuntu-font-family called “Ubuntu Font should support [Klingon]”. If you want, you can invite members of your community to note that they are affected by the bug. We’ll be looking for ways to prioritise communities for attention.
Third, you need to contact local typographers, and tell them about Ubuntu, open content, open typography. If they are still listening, you have just opened the door on the future for them and given them a big head start :-). They will need to be willing to contribute to the font. They will know how much work that will be. They won’t be paid to do it, unless the local community can find a way to raise the funds, but since there is a genuine sense of excitement in the air about open typography and this project in particular, we think you’ll find bold and insightful typographers who are keen to be part of it. Add their details to the wiki page, especially details of their typographic portfolio. Update the bug with that information.
The tools used for open font design are in a state of flux. There are some exceptional technical pieces, and some dark swampy bits too. Dalton Maag will be leading sessions at UDS with folks from the open typography community, with a view to producing what Dave Crossland described as a “lovely long list” (I’m paraphrasing) of bugs and suggestions. Be there if you want to get a professional typographers insight on the toolchain today and what might be possible in the future. All of the Ubuntu font sources are published, though the license does not require source to be published.
Nevertheless, the process for designing your community glyphs will likely involve a mix of free and proprietary tools, at least for the next months. We’ll ask DM to review the portfolios of candidate typographers, and make recommendations for who should be given the go-ahead to lead the work, language by language. Once core glyphs are designed, we’ll facilitate LoCo-based community feedback, much as we did for the main font. We want local Ubuntu members to have the strongest public voice in feedback to their typographer. And Canonical, with DM, will provide feedback aimed at keeping the whole consistent.
Once the glyph design process is wrapped, the typographer will lead hinting and kerning. That’s the tough, detailed part of the job, but essential for an interface font that will be used on screen, everywhere on screen, all the time. And at that point we’ll start automating feedback, using fonttest, as well as starting to integrate those glyphs into the main Ubuntu font. We’ll publish point releases to the main Ubuntu font, with major releases designating points where we update the set of “fixed and metrically frozen” glyphs, point releases denoting occasions where we add or update beta glyphs in the public test font.
In each point release, we’ll include perhaps one or two new glyph sets for beta testing. We’ll prioritize those communities who have followed the process, and have the most substantial community interest in testing.
Phew. If you got this far, you’re interested :-). This is going to be one of those things that lives a very long time. It will take a long time to get everybody represented. But we’re going to do it, together.
Saw this URL fly by today… wow and thank you to the Ubuntu Ads guys
So, who’s up for making Maverick Movies? It would be great to have a “10 best features in 10.10” video collection for release. Unity’s awesome and then there are things to show off in OO.o, Gnome, Firefox…. giving credit where it’s due.
I put together https://wiki.ubuntu.com/MaverickMovies as a starting place to aggregate content. Have subscribed, so if you update that page I’ll see it. If that goes nicely, we can beef the process up in the runup to release.