What I love about Unity
joerlend.schinstad at gmail.com
Thu Dec 29 13:23:05 UTC 2011
In light of a recent thread on this list, I thought I'd provide my
perspective of what Unity is, why I think it's important and why I
actually came to love it. Just to eliminate any doubt, I'll start by
saying that I'm not affiliated with Canonical and I'm not part of the
Unity project. I have no stakes.
I think the most important thing to understand about Unity is that it is
not primarily a program or a desktop. It is primarily a set of
specifications which are implemented in different ways. The two most
prominent implementations are Unity and Unity 2D, but there are already
several others. Since Unity is a set of specifications, it is possible
to implement parts of it without that being considered an incomplete
implementation. For instance, the indicators are supported on LXDE,
Xfce, Windows, KDE and others. This is very important. For instance,
people are complaining about not all Gnome Panel applets being ported to
Gnome Panel 3 yet. This is because the applets become part of the panel
itself, meaning that it has to be completely compatible or it won't
work. This is not the case with indicators, which is why all indicators
are already supported on Gnome Panel 3. The panel just needs to support
the indicator specification and then all indicators automatically work.
It is also an uncomplicated specification, so it's easy and quick to do.
So an indicator actually connects to the indicator service and tells it
what it wants to display. Then it's up to the service to display it
properly according to its environment. This means that indicators will
look native to the environment it is used in without any kind of extra
work. For instance, an indicator that's primarily targeted at Ubuntu
desktop, will look as if it was designed for KDE when that's your
desktop or as if it was designed for Windows when you run it in that
environment. It could also be displayed as text if you don't run a
desktop at all. Further, since indicators are implemented using remote
procedure calls, you could easily run an indicator on a website and have
it integrate with the desktop -- regardless of operating system.
Indicators and notifications are omnipresent across devices and
operating systems. Having a uniform way of adding support for all
operating systems without any kind of extra programming, is highly
valuable. It's valuable to users as well, since it means that an
indicator written in GTK will look and feel identical to an indicator
written in Qt. This increases knowledge re-usability.
Quicklists are also useful. These provides useful actions for an
application. What useful means, is up to the application and how to
access these tools is up to the environment. Unity launchers and Windows
taskbar entries work mostly the same way in this regard. That's not
necessary at all. Again, application developers decides what is
available and the operating system says how to access it.
Unity lenses and scopes are also interesting. Here too, there is a clear
separation between user interface and background services, to an even
higher degree. First, you have the scopes that provides data from a
given source. This can be anything from your personal information, a
corporate server or an online search engine. Then you have the lenses
which chooses which data sources to use when searching, and finally you
have the presentation. Since the scopes provide data in a uniform way,
the lens developers doesn't have to know anything about the source. The
lens developer then simply selects what data sources to search and
retrieve data from, and how this should be laid out. It doesn't do the
presentation itself, but only defines _what_ to do. Finally, you have an
application that displays the lenses according to the definitions. This
means that once an operating system or desktop supports lenses, all
lenses will automatically work and will look native to that desktop.
In summary, Unity is not about how things look. Indeed, we should have
different ways of interacting with your computer and applications. Unity
dash and other components should look and feel different in Lubuntu,
Kubuntu, Windows and OS X. Users should not be expected to understand
the difference between Qt, GTK, XUL or any other toolkit. What
programming language was used to create the software is also not
relevant to the user. Whether the primary focus of the developer is on
Gnome or KDE, should not matter. If it's a browser application, it
should still become part of your desktop like any other application.
This is why the name is so fitting; it unites programming languages,
toolkits, desktops, platforms and operating systems.
In the upgrade from Gnome Panel 2 to Gnome Panel 3, we have "lost" some
applets. Of course, applets can be upgraded as well, but all of them
must be upgraded and there's reason to believe that not all of them will
be. This is a problem, and something that we must actively try to avoid
in all future. This is part of what Unity does, and is probably one of
the things I love most about it. The implementations are not perfect,
but the specifications are really good. I would much rather use a bumpy
implementation of a good specification than to use a perfect
implementation of a bad idea.
Thanks for reading.
More information about the ubuntu-desktop