Settings UX testing for GNOME 3.36

A little while ago, I wrote about using data-driven design approaches in GNOME. For the 3.36 development cycle we successfully used one these techniques to improve the Settings app, and I wanted to share the story of what we did, and how the testing we’ve conducted is feeding into the GNOME user experience.

Starting out

The inspiration for the testing initiative came from several sources of feedback. A number of our own contributors had complained that, in the Settings app, they struggled to remember which settings were in each of the two sub-sections (called Devices and Details). Then, last GUADEC, Deb Nicholson ran a SpinachCon (a kind of usability testing event) and a number people were observed having trouble finding some of the settings, particularly the Date & Time settings.

Suspecting that there might be an issue around settings navigation, we experimented with some ideas for how the structure of the Settings app could be improved.

Hypothesis testing

After a little experimentation, we came up with an updated design for settings navigation, which we hoped would solve the issue with the sub-categories. But would it work? I wanted to put the new design to the test, rather than assuming that the new design would be successful. Happily, the nature of the design – shuffling settings categories around – made it relatively easy to test. A simple paper prototype would do.

Paper prototyping is great if you can do it: it’s quick and easy to do and, most importantly, it allows different changes to be tested before developers spend time implementing them. The initial prototype consisted of a set of cards, each one representing one of the settings panels. These were laid out in front of the test participant, who was asked to pick a card where they thought a particular setting might be found.

After running a pilot test, I realised that the cards weren’t necessary and that a simple rendering of the list of settings panels would be more accurate, as well as being easier to produce (no more cutting up pieces of paper). The lesson: always run a pilot test!

Our prototype

With zero setup for the testing arrangements, the paper prototypes raised the possibility of drafting in volunteers from the GNOME community to help run the tests. To help standardise the tests, I wrote a testing script for the test facilitators to read out. The script included the list of test scenarios, for example:

You are in a cafe with your laptop, and you have connected to the wi-fi. A friend joins you and asks for the wi-fi password. Where would you go to look it up?

Each of these scenarios was designed to test a different aspect of the design, and we managed to test 16 separate scenarios over the entire exercise.

Test, redesign, test

In the first round of testing, we conducted the test with four people. Generally you would test with more people than this, but some issues with the design were already becoming clear. Improving the design and running tests on the new version seemed like a better use of our time, rather than re-confirming obvious problems.

We updated the design to try and resolve the issues that we saw in the first round of testing, and then we conducted tests on the new version. This design, test, redesign, retest is a powerful way to iteratively improve UX designs.

Prototype, v2

The results from the second round showed that the updated design had resolved a number of the issues we’d seen in the first round of testing. The main UI changes we were planning – grouping the networking settings, removing the sub-categories, moving default apps and removable media under apps – had all performed well. These results gave us the confidence to move ahead with the design changes.

The upcoming GNOME 3.36 includes some of these UI changes. Most noticably, the Devices and Details subsections have been removed (the settings they contained are now all visible on the top level). We’re confident that these changes will make it easier for users to find their way around the Settings app.

Further changes are planned for future releases: we want to consolidate the list of settings panels into fewer items, by merging the Wi-Fi and Network panels, and moving Default Applications and Removable Media inside the Applications section. These changes have been tested and, we think, validated from a navigation perspective.

New discoveries

The tests that we ran did their job, and allowed us to validate the updated Settings design prior to it being implemented. At the same time, we also discovered a number of other separate issues with Settings navigation. These varied in terms of their scale, and included issues in both the existing version and future changes that we have planned.

In some cases we’ve already been able to make improvements based on these new discoveries. For example, we’ve improved the icons for a number of the settings categories, to make it more obvious what they are. In other cases, we are still working on design solutions to the issues we observed. This includes things like:

These are all small papercut issues which it will be great to try and make progress on over the upcoming 3.38 release cycle.

The additional issues that we discovered are a good example of how exploratory testing can have a role alongside validation of existing proposals. I think it also shows how research needs to be regular and ongoing: once we’ve figured out designs to fix these new issues, we should really do more tests to see if they really have been resolved.


Hopefully this initiative is a good example of how lightweight testing can improve quality and reduce design and development overhead by identifying design issues early in the development process.

The exercise enabled us to test a design, reject some aspects of it, and then test a revised version, without having to write a single line of code. Without this out-of-band testing, the same process would have required implementing the design, releasing it, (maybe) getting feedback, then redesigning it and implementing the new design.

The other really nice thing about this process is that it enabled a whole array of contributors to participate in the design process. By the end, we’d had 11 tests conducted by five contributors, located in four different countries. That’s pretty cool!

Speaking of contributors: many thanks to António Fernandez, Vojtech Stanek, Philip Withnall and Clarissa Borges, all of whom conducted tests and made this initiative possible.

Towards a UX Strategy for GNOME (Part 4)

This post is part of my blog series on GNOME UX strategy. The other parts in the series covered background research and analysis for the strategy, then outlined some high-level goals and principles, followed by an outline of recent design work which fits within the strategy. This can all be thought of as answering “what” and “why” questions: what should GNOME be doing, and why?

In this, the final post in the series, I’m turning to the question of “how”: how can the GNOME project can deliver all this? For me, this how question is just as important as the what and the why. Having an effective strategy means nothing if we can’t successfully deliver it.

This post is primarily about design and development process. I’m going to draw on my experiences working on the GNOME project, as well as methodologies from the wider software industry, and recent experiments that have taken place in the GNOME project. Agile is clearly present, but it’s just one element, and has necessarily been adapted to an upstream, open source context.

While these reflections on development process are an important part of the strategy I’m laying out, they hopefully have more general relevance to our work in the GNOME project and beyond.

The process matters

The naive view is that software quality is primarily determined by the character and skills of the individuals who have worked on that software. While these individual capabilities are undoubtedly important, they are only one part of the story. Indeed, I would argue that the design and development process is just as important as the skillset of those doing the work.

One reason for this is that UX work is never a solitary endeavour – it involves multiple people with different specialisms. How we work together is critical to success, because each of those specialisms don’t just need to be aligned, but also need to feed into one another.

In my time working on GNOME, I’ve been involved in some really successful UX initiatives, where we’ve delivered new features or updated versions of our software, in a way that has pleased and even delighted our users. I’ve also worked on initiatives that haven’t been successful. I’ve reflected on these, and have identified a number of recurrent issues. These include:

  • New features that have been delivered in an incomplete state
  • Implementations that have significantly deviated from the intended design and UX vision
  • Usability or design issues which have been identified post-implementation, and have been subsequently unaddressed
  • Designs whose ambitions have surpassed our engineers’ abilities to deliver them
  • Rough and ready designs that have gone on to be implemented before they have sufficiently matured
  • Designs which have been incompatible or out of alignment with the technical plumbing that they’re built on top of

I’ve previously argued that driving up UX quality is critical to the future success of the GNOME project. If we are to do this, issues like these have to be eliminated from our development practices. We can’t succeed if they occur in core development initiatives.

The good news is that all of these issues stem from the design and development process, and can therefore be avoided. This is also a real opportunity to learn from the wealth of experience that we have in the GNOME project, and develop best practice approaches.

What we need to do

There are three main things that I think we can do to improve our design and development processes.

1. Embrace iteration

A great man once taught me that design is all about iteration. He wasn’t wrong: designs that have passed through a lot of revisions are usually superior to those that haven’t. The same is true for software development.

Many of the issues that I identified above are a result of a failure to incorporate iteration into the development process. Iteration is key to eliminating bugs, but it is often also critical to ironing out larger design issues. Despite all our expertise and experience, it is impossible to anticipate every potential UX issue, or fully understand how a design will perform in practice. We therefore have to assume that many implemented features will contain issues that have to be addressed.

The first and most important step in embracing iteration is to change the way we think about the design and development process. Iteration has to be treated as being essential and non-negotiable. The time and resources that are required for iteration must be accounted for at the outset, with the first implementation being seen as just one step in the process.

If you, as a designer or a developer, don’t have the time to iterate on a piece of work, you probably shouldn’t be doing it in the first place. I’ve been guilty of this is the past, and it can be a hard habit to break. It’s so tempting to make drive-by design recommendations, or quickly implement a new feature that you’ve been wanting for ages. We must all resist that urge. High-quality software takes time and care.

The other way to embrace iteration is to build user testing and feedback into the design and development process. This isn’t hard to do, and has been successfully done in the GNOME project. For example, earlier this year, Clarissa Borges successfully ran user tests on a development snapshot of Files, which allowed us to refine design changes prior to release. Another example: right now, we are using paper prototypes to get real-world feedback on potential Settings changes. These tests can take mere hours to design and conduct, and can save weeks of developer time.

2. A closer relationship between design & development

Design and development aren’t separate domains. Designs need to reflect technical realities. Developers need to be familiar with the UX vision that they’re implementing. Designers need to be involved in the development of the underlying technologies and platforms. This requires shared understanding between designers and developers, at all stages of the process.

A good number of the issues I identified earlier in this post are what happens when that shared understanding is missing. This leads to all kinds of problems, like designers over-estimating what developers can achieve, or not fully understanding the technological constraints, or developers implementing something different from the UX vision.

It has become my firm belief that the more interconnected that design and development are, the better our software will be. A close relationship between these two specialisms prevents problems, helps shared understanding, and increases efficiency.

I’m going to describe four things that we can do to bring design and development more closely together.

First, we need to ensure high-bandwidth communication between design and development, throughout the process. This communication doesn’t have to be talking or messaging – it can be sharing of mockups, screenshots and screencasts, and testing of development code – but it does need to happen frequently.

Second, designers need to treat developer resources as a design constraint. Design work has to be speculative sometimes. However, when it comes to sitting down and implementing features or changes, it is vital to fit the design to the amount of developer time that’s available.

Third, we need to champion transparent design. Transparent designs reflect how the underlying technologies work, and don’t try to present a different picture. They are good for all the reasons that reducing technical complexity is good, plus the fact that they avoid leaky abstractions. Transparent designs sometimes expose issues with the underlying technical architecture, which can be painful, but also exerts pressure in the right place.

Fourth, designers need to get their hands dirty, and touch the code. This can take many forms, including using GTK for prototyping, editing CSS or GtkBuilder files, or making simple code changes. This is hugely beneficial! It’s vastly more efficient for designers to make simple changes themselves, rather than having to go back and forth with developers to make them on their behalf. In turn, these efficiency savings enable a higher level of precision and quality, since they allow designers to be far more specific and wide-ranging in their polish work. Having designers directly involved in development is also a fantastic way to improve the platform, since it makes us aware of how it works, and makes us even more invested in improving it.

To make this last point happen, designers need to push themselves to get involved in development (I have a rule for myself: don’t ask someone to make changes you couldn’t have a go at making yourself). However, we also need developers to make their projects designer-friendly. This means using things like CSS, GtkBuilder, and high-level languages.

3. Time-Based Coordination

The third and final thing that we can do to improve our design and development processes is to coordinate around blocks of time. Coordination for upstream projects is tricky. However, for many of the things that I’ve described above, we need to have shared expectations for how and when work will be done. It is only then that we can do things like testing of in-progress software, or have conversations about how much developer time is available for a particular initiative.

One possibility here is to organise ourselves around sprints, and Georges has spearheaded some really successful experiments in this area. It’s a simple idea: he divides his time into blocks, and gives the design team advance notice of what he will be working on and for how long. We can then ensure that he has the designs he needs. We can also ensure that those designs can be implemented in the time he has available, and even arrange testing to happen in the periods between time blocks.

It would be great if more developers embraced this approach!


It’s taken a while, but we’ve got to the end! If you’ve stuck with me for the entire blog series, well done, and thank you. I hope you’ve found it interesting, and maybe even useful.

For me the best outcome of this series would be if some of these ideas could be taken up more widely by the GNOME project (or other Free Software projects), and I’d love to discuss strategy or development process with other contributors.

This last post has been especially important to me, because it reflects my own developing practice and concern with successful UX delivery. I genuinely think that these techniques could revolutionise how we work, and am already seeing some major improvements through their adoption.

Towards a UX Strategy for GNOME (Part 3)

This post is part of a series on UX strategy. In my previous two posts, I described what I hope are the beginnings of a UX strategy for GNOME. In the first post, I described some background research and analysis. In the second post, I introduced what I think ought to be the high-level goals and principles for the UX strategy.

Now it’s time for the fun bit! For this instalment, I’m going to go over recent work that the GNOME design team has been doing. I’m doing this for two reasons. First: I want to show off some of the great work that the design team has been doing! Second, I want to show this design work fits into the strategic approach that I’ve previously described. A key element of that plan was to prioritise on areas which will have the biggest impact, and I’m going to be using the prioritisation word a lot in what follows.

This post is intended as an overview and, as such, I’m not going to go into the designs in great detail. However, there are detailed designs behind everything I’m presenting, and there’s a list of links at the end of the post, for those who want to learn more.

Core System

In my previous post, I argued that prioritisation ought to be a key part of our UX strategy. This is intended to help us drive up quality, as well as deliver impactful improvements. One way that we can prioritise is by focusing on those parts of GNOME that people use all the time.

The obvious place to start with this is the core elements of the GNOME system: those parts of the software that make up the most basic and common interactions, like login, app launching, window switching, notifications, and so on. I believe that improving the level of polish of these basic features would go a long way to elevating the standing of the entire platform.

Unlock and Login

Login screen mockup

The design team has longstanding ambitions to update GNOME’s unlock and login experience. The designs have continued to evolve since I last blogged about them, and we continue to return to and improve them.

System unlock is a classic example of a touchstone experience. People unlock their computers all the time and, as the entry point to the system, it comes to define the overall experience. It’s the face of the system. It is therefore critical that unlock and login leave a good impression.

The new designs are intended to reduce the amount of friction that people experience when they unlock. They require users to take fewer steps and involve going through fewer transitions, so that people can get to their session faster and more seamlessly. This will in turn make the experience feel more comfortable.

The designs are also intended to be beautiful! As an emblematic part of the GNOME UX, we want unlock and login to look and feel fantastic.


Notifications popover mockup

The design team has been systematically reviewing almost all parts of the core GNOME system, with a view to polish and refine them. Some of this work has already landed in GNOME 3.34, where you will see a collection of visual style improvements.

One area where we want to develop this work is the calendar and notifictions list. The improvements here are mostly visual – nicer layout, better typography, and so on – but there are functional improvements too. Our latest designs include a switch for do not disturb mode, for example.

There are other functional improvements that we’d like to see in subsequent iterations to the notification list, such as grouping notifications by application, and allowing notification actions to be accessed from the list.

Notifications are another great example where we can deliver clear value for our users: they’re something that users encounter all the time, and which are almost always relevant, irrespective of the apps that someone uses.

System Polish

System menu and dialog mockup

Our core system polish and refinement drive knows no bounds! We have designs for an updated system menu, which are primarily intended to resolve some long-standing discoverability issues. We’ve also systematically gone through all of the system dialogs, in order to ensure that each one is consistent and beautiful (something that is sadly lacking at the moment).

These aren’t the only parts of the core system that the design team is interested in improving. One key area that we are planning on working on in the near future is application launching. We’ve already done some experimental work in this area, and are planning on building on the drag and drop work that Georges Stavracas landed for GNOME 3.34.


The principle of prioritisation can also be applied to GNOME’s applications. The design team already spends a lot of time on the most essential applications, like Settings, Software and Files. Following the principle of prioritisation, we’ve also been taking a fresh look at some of the really basic apps that people use every day.

Two key examples of this are the document and image viewers. These are essential utilities that everyone uses. Such basic features ought to look and feel great and be firmly part of the GNOME experience. If we can’t get them right, then people won’t get a great impression.

Today our document and image viewers do their jobs reasonably well, but they lack refinement in some areas and they don’t always feel like they belong to the rest of the system. They also lack a few critical features.

Document viewer mockup
Document viewer mockup
Image viewer mockup
Image viewer mockup

This is why the design team has created updated designs for both the document and image viewers. These use the same design patterns, so they will feel like they belong together (as well as to the rest of the system). They also include some additional important features, like basic image editing (from talking to GNOME users, we know that this is a sorely missed feature).

It would be great to extend this work to look at some of the other basic, frequently-used apps, like the Text Editor and Videos.

There’s a lot of other great application design work that I could share here, but am not going to, because I do think that focusing on these core apps first makes the most strategic sense.

Development Platform

Another way that we can prioritise is by working on the app development platform. Improvements in this area make it easier for developers to create apps. They also have the potential to make every GNOME app look and behave better, and can therefore be an extremely effective way to improve the GNOME UX.

Again, this is an area where the design team has already been doing a lot of work, particularly around our icon system. This is part of the application platform, and a lot of work has recently gone into making it easier than ever to create new icons as well as consume the ones that GNOME provides out of the box. If you’re interested in this topic, I’d recommend Jakub’s GUADEC talk on the subject.

GTK widget mockup
Mockups for menus, dropdown lists, reorderable lists, and in-app notifications

Aside from the icon system, we have also been working to ensure that all the key design patterns are fully supported by the application development platform. The story here is patchy: not all of the design patterns have corresponding widgets in GTK and, in some cases it can be a lot of work to implement standard GNOME application designs. The result can also lack the quality that we’d like to see.

This is why the design team has been reviewing each of our design patterns, with a view to ensuring that each one is both great quality, and is fully supported. We want each pattern to look great, function really well, and be easy for application developers to use. So far, we have new designs for menus, dropdown lists, listboxes and in-app notifications, and there’s more to come. This initiative is ongoing, and we need help from platform and toolkit developers to drive it to completion.

What Next?

UX is more than UI: it is everything that makes up the user’s experience. As such, what I’ve presented here only represents a fraction of what would need to be included in a comprehensive UX strategy. That said, I do think that the work I’ve described above is of critical importance. It represents a programme to drive up the quality of the experience we provide, in a way that I believe would really resonate with users, because it focuses on features that people use every day, and aims to deliver tangible improvements.

As an open, upstream project, GNOME doesn’t have direct control over who works on what. However, it is able to informally influence where resources go, whether it’s by advertising priorities, encouraging contributions in particular areas, or tracking progress towards goals. If we are serious about wanting to compete in the marketplace, then doing this for the kind of UX programme that I’ve described seems like it could be an important step forward.

If there’s one thing I’d like to see come out of this series, it would be a serious conversation about how GNOME can be more strategic in its outlook and organisation.

This post marks the end of the “what” part of the series. In the next and final part, I’ll be moving onto the “how”: rather than talking about what we should be working on and what our priorities should be, I’ll set out how we ought to be working. This “how” part of the equation is critical: you can have the best strategy in the world, but still fail due to poor processes. So, in the final instalment, we’ll be discussing development process and methodology!

Further Reading

More information about the designs mentioned in this post:

Towards a UX Strategy for GNOME (Part 2)

This post is a part of a short series, in which I’m setting out what I think could be the beginnings of a UX strategy for GNOME. In this, the second post, I’m going to describe a potential GNOME UX strategy in high-level terms. These goals are a response to the research and analysis that was described in the previous post and, it is hoped, point the way forward for how GNOME can achieve new success in the desktop market.

Strategic goals

For me, the main goals of a GNOME UX strategy could be:

1. Deliver quality

If GNOME is going to succeed in today’s desktop market, UX quality has to be job #1.

UX quality includes what the software looks like and how it is designed, but it also refers to how the software functions. Performance and bugs (or the lack of them) are both aspects of UX!

More than anything else, people are looking for a desktop that Just Works: they want a solution that allows them to get their work done without getting in their way. This means having a desktop that is reliable, stable, which does what people want, and which is easy to use.

People value solutions that Just Work. They’re also prepared to abandon them when they don’t Just Work.

To its credit, the GNOME project has historically recognised the importance of Just Works, and it has delivered huge improvements in this area. However, there is still a lot of work to be done.

My sense is that driving up quality is one of the key strategic challenges that the GNOME project needs to face up to; I’ll be returning to this topic!

2. Factor in the cloud

In my previous post, I worte about how the cloud has reconfigured the landscape in which GNOME operates. Accordingly, it’s important for our UX strategy to account for the cloud. There are various ways we can do this:

  • Focus on those bits of the desktop that are used by all users, even if they mainly use a web browser. This includes all the parts of the core system, as well as the most essential desktop apps.
  • Enable and encourage native cloud applications (including Electron and Progressive Web Apps)
  • Add value with high-quality native apps.
  • Integrate with existing cloud services, when it is safe to do so.

The last point might seem counter-intuitive, but it makes sense: in a world where the web is dominant, a fantastic set of native apps can be a powerful differentiator.

At the same time, GNOME needs to be careful when it comes to directly competing with sophisticated web apps and services, and it needs to recognise that, nowadays, many apps aren’t worth doing if they don’t have a cloud/cross-device component.

3. Grow the app ecosystem

The primary purpose of a platform like GNOME is to run apps, so it stands to reason that the number and quality of the apps that are available for the platform is of critical importance.

Recently, Flatpak has allowed the GNOME project to make great progress around application distribution, and this is already positively impacting app availability for GNOME. However, there is a lot of work still to be done, particularly around GNOME’s application development platform. This includes work for both designers and developers.

4. Support modern hardware

One of the things that my research revealed is that, for most users, their choice of desktop OS is thoroughly entwined with hardware purchasing choices, with hardware and software typically being seen as part of the same package. Attracting users to GNOME therefore requires that GNOME be available for, work well with, and be associated with high-quality hardware.

A lot of hardware enablement work is done by distros, but a lot also happens in GNOME, including things like high-definition display support, touchscreen support, screen casting, and more. This is important work!

Do less, prioritise

Any UX strategy should address the question of prioritisation: it ought to be able to determine how resources can be directed in order to have maximum impact. This is particularly important for the GNOME project, because its resources are limited: the core community is fairly small, and there’s a lot of code to maintain.

The idea of prioritisation has therefore both influenced the goals I’ve set out above, as well as how I’ve been trying to put them into practice.

When thinking about prioritisation in the context of GNOME UX, there are various principles that we can follow, including:

  • User exposure, both in terms of the proportion of people that use a feature, and also the frequency with which they use it. Improvements to features that everyone uses all the time have a bigger impact than improvements to features that are only used occasionally by a subset of the user base.
  • User needs and desires: features that are viewed as being highly attractive by a lot of people are more impactful than those which are only interesting to a small subset.
  • Common underpinnings: we can prioritise by focusing on common subsystems and technical components. The key example here is something like GTK, where improvements can surface themselves in all the apps that use the toolkit.

When we decide which design and development initiatives we want to focus on (either by working on them ourselves, or advertising them to potential contributors), principles like these, along with the high-level goals that I’ve described above, can be very helpful.

I also believe that, in some cases, the GNOME project needs to have some hard conversations, and think about giving up some of its existing software. If quality is job #1, one obvious answer is to reduce the amount of software we care about, in order to increase the overall quality of everything else. This is particularly relevant for those parts of our software that don’t have great quality today.

Of course, these kinds of conversations need to be handled delicately. Resources aren’t fungible in an upstream project like GNOME, and contributors can and should be free to work on what they want.

What’s next

In my previous post, I described the research and analysis that serves as inputs to the strategy I’m setting out. In this post I’ve translated that background into a high-level plan: four strategic goals, and an overarching principle of prioritisation.

In the next post, I’m going to introduce a raft of design work which I think fits into the strategy that I’ve started to lay out. GNOME is lucky to have a great design team at the moment, which has been pumping out high-quality design work over the past year, so this is a great opportunity to showcase what we’ve been doing, but what I want to do is also show how it fits into context.

Towards a UX Strategy for GNOME (Part 1)

At the recent GUADEC in Thessaloniki, I gave a talk about some strands of work that I’ve been doing around UX strategy and design/development process. I ended up skipping over some points that I’d wanted to make, and I also had some great conversations with people about the talk afterwards, so I wanted to share an updated version of the talk in blog form.

I’ll be splitting the talk into multiple posts. This first post is about creating a UX strategy for GNOME. As you might expect, this is a plan for how to improve GNOME’s user experience! In particular, it tries to answer the question of which areas and features need to be prioritised.

The approach I’ve taken in creating this strategy follows a fairly standard format: analyse the market, research user needs, identify and analyse competitors, then use that data to design a product which will succeed in the current desktop market. The main goal is to offer a product which meets user needs better than the alternatives.

In later posts in the series, I’m going to show off a set of updated designs for GNOME, which I think are a good place to start implementing the strategy that I’m laying out. For many readers, those later posts will probably be more interesting! However, I do think it’s useful to provide the strategy, in order to provide background and put that work in context.

Data sources

Data and research are an essential part of any robust strategy. For my strategy work, I’ve read market reports and general UX literature. I’ve also done a lightweight competitive analysis exercise, as well as some primary research of my own.

My research consisted of three sets of in-depth interviews. These have been with three different groups of users (not just GNOME users), about what influences their choice of desktop. The participants in those interviews have been skewed towards development and technical users in Europe and the United States, but they did include variation and I think that some of themes that emerged are probably widespread.

Market observations

The following are some of the key lessons that I think I’ve learned through the various research and analysis activities I’ve done over the past year. In my mind, these are all significant observations which can influence our UX strategy, and which certainly influence my thinking when I approach desktop design work.

The state of the desktop market

The desktop market hasn’t seen massive growth in recent years, but it is reasonably stable. Within that, we have seen an increasing emphasis on productivity and enterprise use cases, in part because of the relative weakness of the personal computing segment of the market. I think that there’s currently a renewed recognition of the importance of the desktop for productivity tasks, and as a platform for creation and development.

It should be noted that the personal computing market certainly hasn’t disappeared, and that there has been steady growth in convertible laptop sales (laptops which have a touchscreen and some kind of tablet mode).

The cloud

The cloud has changed the competitive landscape for the desktop. One key development is that, nowadays, most of the key desktop apps people use are cloud-based (this includes browser-based apps, apps which act as an interface to a cloud-based service, and apps which are running locally using web technologies). As a result, they are generally cross-platform.

The rise of the cloud presents GNOME with both opportunities and challenges. On the one hand, it makes GNOME and the Linux desktop far more viable, since it means that people running Linux can access most of the apps they need. Applications are no longer constrained to particular platforms in the way that they used to be (though this can still be a significant factor in some cases).

On the other hand, the cloud presents a challenge for GNOME, in that it becomes harder for us to show and deliver value. For some users, the web is already the only application platform that they use.

Expectations and quality

Another observation about the contemporary software landscape: the general standard of software user experience has significantly increased in recent history. (Largely thanks to improved methodologies and processes, including greater prioritisation of design and the increased use of user testing.)

People nowadays are used to software that does its job well, is easy to use, and generally looks good.

This makes GNOME’s job harder. Being OK is no longer good enough. People’s expectations have been raised: they are less inclined to accept poor quality software than they were in the past, and it’s harder to produce something that excites them.

User requirements

The desktop user interviews that I’ve done over the past year have revealed a number of key requirements that people have for their desktop computers. These include:

  • Reliability and stability
  • Ease of use
  • Software availability
  • Affordability
  • Brand trust
  • User control

A bullet list like this is fairly crude way to present research results, and there’s a lot that I could say about each of these topics. However, for now the main thing to say is that people can and do change desktop platforms according to these criteria. I’ve been told stories about the moment someone decided to switch platform, because they were so sick of something not working the way they needed it to. I’ve also been told about the coping strategies that people use when they haven’t been able to find a desktop which meets their needs. The pain is real, and the struggles people have finding a good desktop are real.

Which brings me on to my main point: without naming names, if you look at the desktop market today, there isn’t a product out there which meets all the user needs I’ve identified. Each one is missing part of the winning formula.

From this perspective, the path for GNOME is clear: if it wants to compete, and out-perform its rivals in the desktop space, it needs to deliver on each of the points I’ve listed above.

Up next…

In the posts that follow, I’m going to lay out a UX strategy which builds on these observations. The next post will describe a set of strategic goals which form the framework for the strategy. From there, I’m going to present a raft of design work, which I think represents a implementable UX plan, before finishing with a post about design and development methodology.