Contributions Welcome

If you are interested in coding for GNOME, but haven’t figured out what to work on, this post is for you.

In my last post, I described an experiment that I’m running for the GNOME 3.14 development cycle. The goal is to make it easier of people to contribute to GNOME, by making it easy to find tasks to work on and getting rapid and effective feedback.

Since I wrote that post, I’ve been working with a number of GNOME application maintainers to get their bugs in a state where it is easy for people to contribute. The result is three apps that have a clear set of bugs that contributors can get to work on today.

Music

Music Screenshot

The Music app has been around for a couple of cycles now. It is currently fairly basic, but manages playback fairly well and gives a really nice view of your music collection. This cycle some big new features are planned, like new and improved search and Last.fm integration.

Music has a great development team around it, and is written in Python.

As of today, there are 32 bugs that are available for contributors. Every one of these is in a state where you can get to work on them, and they have all been reviewed by Vadim (the Music maintainer) and myself – so you can be sure that they are things we want.

Some of the bugs are small and address UI niggles, like bug 723144: which aims to give the Artists view a consistent visual style to other sidebars in GNOME. Other bugs are for bigger features, like allowing you to view and play music stored in ownCloud instances. There’s plenty to choose from, and there should be a bug to suit your tastes.

Music is a really promising app, and there are opportunities to play a serious role as it matures.

Documents

Documents Screenshot

Documents is one of the original GNOME 3 applications. It has come a long way, and has a lot of cool functionality. I’m not sure that people have made the most of this app in the past, but I think that its utility will become much more obvious with a few changes we have planned, particularly when managing document collections.

Debarshi Ray is currently leading the Documents effort. He’s a great guy and an active maintainer. The application is written in JavaScript.

There are 43 available bugs for Documents. They include functional enhancements that will make the application much more useful. Adding the ability to sort documents in different ways is one of these. Another is making the list view more usable.

We also have some nice UI polish planned, such as using a popover for search options and having a smoother full screen mode.

Contacts

Contacts Screenshot

Contacts is one of the older GNOME 3 apps. It is written in Vala, and is maintained by Erick Pérez Castellanos, who is awesome.

This is a nice app that can really shine with a bit of work. Right now there are 60 bugs that are available for contributors. Again, there’s lots of small UI issues: in the spirit of Every Detail Matters, these fixes would make a big difference to the overall user experience. For example:

  • Bug 696384 – porting the contact linking suggestion box to GtkActionBar.
  • Bug 699319 – making the app look better when you don’t have any contacts.
  • Bug 703201 – allowing users to select contacts using the right mouse button.

There are also some fun bugs that will hopefully make Contacts a bit more engaging, such as showing maps and status messages from contacts.

What Next

If you want to get involved in GNOME, these applications, and the lists of bugs I’ve pointed to, are the best place to start. The nice thing about these apps is that small fixes will go a really long way, and they all have active maintainers. It would be fantastic if people could help us to make them shine for 3.14.

If other application maintainers want to get involved in this initiative, just get in touch or follow the procedure I described in my last post.

Posted in bugs, gnome | 12 Comments

Enabling Participation

With 3.12 out the door, it’s time to think about what we want to be doing for 3.14. I have a long list of design projects that I want to work on for the next release, but I also want to spend some time on how the GNOME project is working and how we can improve it.

One of my reoccurring interests is how we, as a project, can ensure that each module is in a healthy state. We want modules to have active developer teams around them, and we want it to be easy for people to get involved – not just because it is good for our software, but also because openness is an important part of our mission.

This interest in helping people to contribute isn’t just reserved for new, inexperienced contributors. There are experienced coders out there who are interested in GNOME but haven’t found a way in. Even members of the GNOME project itself don’t always know how to contribute to different apps and modules.

Making it easy for people to contribute takes work. Simply putting the code online is not enough: we need to provide potential contributors with the information they need, and we need to give them feedback and support as they work. We need to enable them to participate by creating the conditions in which it is easy to contribute.

There are a number of reasons why people sometimes find it difficult to participate, and we aren’t going to solve them all overnight. Thinking about this topic, though, one of the main reasons why people struggle to contribute is that it is difficult, if not impossible, to know which tasks to work on. In my opinion, the way that we manage bugs in GNOME is a major factor here [1].

In GNOME we often don’t do a good job of indicating which bugs we want to be fixed, and we don’t spell out what needs doing to fix them. This leaves potential participants with no way to contribute. A long list of unconfirmed bugs, often with no guidance on what needs to be done to resolve them, is a brick wall. It can be the end of the story for potential contributors.

This is the issue I want to address. Interestingly, though, improvements in this area can also help with other aspects of project management: if we are clear about which bugs we want fixing, it prompts forward planning, and it stimulates discussions about which issues should be prioritised over others. It also creates opportunities for conversations about the direction of modules, which can help to include contributors in taking on leadership roles.

To make it easier for people to participate in GNOME, our bugs need to be organised so that they give clear guidance about where contributions are needed. This requires that we have a different process for how bugs are processed and categorised. I’ve spent some time talking about this with various maintainers, as well as members of the Bug Squad, and I have come up with a set of procedures that could work.

This procedure won’t be for everyone, and I am not proposing that GNOME adopts it on a project-wide basis. What I am suggesting is that a small number of applications try it out for the 3.14 cycle as an experiment (I’m focusing on applications because I think they are the best place for new contributors to get involved). If it has a positive impact, then we can think about involving more applications in the following cycle. If it doesn’t, then that’s fine: we’ll have learnt something.

How it could work

The main goal for the bug management procedure I’ve come up with is to remove uncertainty from bug reports. This is something that we are bad at: thousands of ambiguous bugs sit in Bugzilla, which contributors have little chance of knowing what to do with. The procedure uses this schema for bug reports that are on the path to being fixed:

  • UNCONFIRMED: new bugs that haven’t been validated. These reports are uncertain – they might not correspond to real issues.
  • NEW: reports that have been validated, and therefore correspond to actual issues.
  • NEW with “needs_design” whiteboard: valid bugs that are waiting for a design to be produced in order to fix them.
  • NEW with “available” whiteboard: NEW bugs that are ready to be fixed. These bugs should have an identified solution which has been stated, and they shouldn’t be blocked by other bugs.

In this schema, “available” bugs are the reports that you point potential contributors to. They are items of outstanding work that can be tackled today. You can link to the list of these bugs from your wiki page, blog posts, or IRC topic. Having an available status is also helpful to maintainers: it helps them see which tasks are pending.

This bug schema also makes UNCONFIRMED a meaningful category. These are the bugs that triagers and maintainers need to process in order to give them a definite status. A large or growing number of UNCONFIRMED bugs in your product is a sign that you need to do a sweep through to clean them up.

In this approach to bug management, you need to regularly review bugs that don’t fall into the “available” category, in order to try and resolve them, either by identifying a solution (and therefore making them available) or by closing them as WONTFIX or NOTABUG or so on. It’s a fairly aggressive approach, in which you have to routinely say what is desirable and what isn’t, but in doing so you open the doors to new contributors who know what the project wants and how they can help.

What’s going to happen next

My plan for 3.14 is to trial this bug management approach with a small number of applications. I’m already working with Debarshi on the Documents bugs, which he has blogged about, and I’m also looking at Contacts with Erick. Once one or two more applications are involved, I’ll post an update on how to get involved.

We want to see if this approach helps to attract new contributors and to manage projects more effectively. We also want to see if the bug classification schema needs to be improved in any way. Towards the end of the cycle, I’ll be talking to people to see how they think it went: was it useful? Do any changes need to be made? Would you recommend this approach for other modules?

If you’re an application maintainer and are interested in this initiative, I’d love to hear from you. Also, I really, really want to hear what people think about the classification schema and the process around it.

[1] I realise that, in focusing on bug reports, I am restricting this to code contributions. In doing so, i don’t mean to suggest that patches are the only way to contribute to GNOME. This is merely a way of enabling participation in one – obviously important, but by no means exclusive – area.

Posted in bugs, gnome, project management | 24 Comments

LGM 2014

I have just returned home from this year’s Libre Graphics Meeting, which was held in Leipzig, Germany. As always, it was a great event, which is somewhat unique in bringing together art and design practitioners with programmers and engineers.

LGM is a good opportunity to meet with friends in other projects, especially graphics applications. I was really happy to be able to spend time with members of the GIMP and Inkscape projects, and hope that this will lead to closer ties and working relationships in the future.

GNOME and Libre Graphics have a lot in common. GNOME design uses free tools developed by the Libre Graphics community, and we practice open design in the way that many of those at LGM also do. I think that GNOME also helps to bring people into the Libre Graphics community, and it was nice to see a good contingent of people from GNOME at LGM this year. This is something that Jakub and I talked about in our presentation on the last conference day.

The Libre Graphics community is creative and passionate, and I always feel refreshed after LGM. Big thanks to the organisers for putting on another great conference.

Posted in conferences, design, gnome | Leave a comment

Looking Forward to 3.12

applications

I usually do a review of what is coming in the run up to a release. However, there have been so many blog posts about 3.12 already that I don’t feel I need to go over individual features. If you haven’t read Planet GNOME in a while, now is a good time to check it out: there’s lots of great content on there right now.

It is worth looking at what the individual features in 3.12 add up to though. A release is more than the sum of its parts, and this is especially true of 3.12.

One important thing you will see in 3.12 is that, more and more, GNOME’s core applications are coming together. Videos will look and behave like a GNOME 3 app: it will let you browse your content, and it offers a modern, streamlined viewing experience. gedit has also had the GNOME 3 treatment. It has retained all its existing functionality, but in a more compact interface [1]. Many of the other apps have also matured of course, Software and Web in particular.

The other big news for 3.12 is that a number of significant gaps have been filled in. For a long time people have wanted to be able to manually organise their apps: now they can with the new apps folder feature. We’ve also added functionality to make installing sofware updates easier and more convenient, as well as the addition of wired networking controls to the system status area.

There are also major developments in the developer space, with the new notifications API, new GTK+ widgets, new capabilities for launching processes, and improved documentation. I think that 3.12 is probably our strongest for developers in a long time.

Finally, and for me perhaps most significantly, 3.12 looks set to be the best quality release so far. Signs of ongoing improvements are everywhere. There are performance gains for startup and (hopefully) memory usage, the theme and animations in the shell has been refined in quite a few subtle ways, high-resolution display support has been extended, and a great many bugs have been fixed. As each release comes and goes, GNOME 3 gets better and better, and 3.12 is no exception.

There’s plenty more that I could mention about this release, of course, and the release notes will provide full details, but what is important is the progress that GNOME is making. 3.12 feels like another significant upgrade, and is another release where it feels like things are coming together more and more.

[1] The other day I did a quick comparison, and found that the chrome in the new version is around 60 pixels shorter than before. That’s an impressive space saving, and makes the app much more focused on what you are editing.

Posted in developer experience, gnome, gnome3 | 6 Comments

Popovers & You

GTK+ has been getting some really nice new features in recent times. Over the past few releases the list new of widgets has come to include things like ListBoxes and FlowBoxes, stacks and stack switchers, revealers and header bars. Now, in the upcoming 3.12 release, there will be another new widget: popovers. This is something that those of us who work on GNOME design have wanted for a while, and it’s exciting to finally have them.

Of course, once you have a new interface widget, you need to know what to do with it, so I thought I’d write a bit about how to design with popovers. If you’re an application developer or designer and you’re not sure what popovers are for or how to use them, then this post is for you.

What is a popover, anyway?

popovers

Popovers are containers that appear over a parent window. They have some significant characteristics:

  • They are generic containers, meaning that they can contain a variety of widget types (just like a dialog).
  • They have arrow points which are always directed at a specific interface element. Often, this is a button, icon or thumbnail, and the popover appears when this is pressed. (This isn’t always the case though, as one of the later examples indicates.)
  • They cannot be moved and have a fixed position.

Popovers are used to show additional controls or information. As such, they are an example of a widget that allows you to practice “progressive disclosure” in your application. This essentially means hiding non-essential or infrequently used interface elements slightly out of the way. Progress disclosure helps to keep your UI focused by giving more attention to the most important elements. As my favourite part of the HIG states:

“Every extra piece of information or interface control competes with the truly relevant bits of information and distracts the user from important information. Hence, don’t clutter your interface, and don’t overload the user with buttons, menu options, icons, or irrelevant information. Instead, use progressive disclosure and other techniques to limit what the user sees at any given moment.”

The next time you are adding extra controls or information to a UI, you might want to think: “maybe I should put this in a popover”.

When to use popovers

Popovers are one of a number of ways to achieve progressive disclosure, and there are a number of other widgets that can be used in a similar way. In particular, they are similar to dialog windows, so you might find yourself being uncertain about whether to use a dialog or a popover. There are a few things to consider here.

  1. What is the size and complexity of the content you want to display? A popover should generally be small and simple, so if you have a lot of information or controls to disclose, a dialog window is often better: they are nicer than popovers at larger sizes, and you can use tabs to break them up into sections.
  2. Is there a specific element that can act as the source of the popover? If the answer is no, you should use a dialog, since they don’t have to point to something.
  3. Do any of the established conventions for dialogs apply in this case? There are certain interaction patterns where dialogs are the established convention, such as presenting confirmation checks or application preferences. It is best not to abandon the conventions that people are familiar with for dialogs, as this will help your users understand what is happening.

If you can answer these questions and a popover still seems like a good idea, you may well want to use one. In fact, popovers have a number of advantages over dialogs when used correctly. They aren’t as disruptive, since dialogs require a bigger focus shift and give the users more new UI to interpret. In contrast, popovers don’t change the frame in which the user is working, and are generally a more subtle visual presence. This involves less severe context switches and a smoother user experience.

Examples

We’ve been utilising popovers in our application designs for some time, so I thought that it might be instructive to end this post with some examples from our mockups. Hopefully this will give you a better idea about some of the possibilities they present.

A filter menu

This is taken from our mockups for a new character map application. Here a popover is used to allow a filter to be selected for the view (in this case, selecting a font). In the past we would have had to have used a combobox or a dialog for this. A popover is better than either option: it is easier to scroll and search than a combobox, and less disruptive than a dialog.

filter-menu

Note that the popover header shown in this mockup currently isn’t possible, although you could implement something quite similar without it.

Gear menus

Gear menus are a common pattern in GNOME applications. Previously we have used a menu that is activated by a button for this. Popovers are a much nicer way to present a button menu though. Not only can popovers be used as a simple replacement for button menus, but you can also supplement the menu with other controls. In this example, taken from our latest Nautilus mockups, the menu has been prefaced with a pair of buttons and a slider. This makes the menu more compact and interesting, and the slider is a more appropriate control for setting the zoom level than menu items.

gear-menu

A word of caution when using popovers in this way: be careful not to make the popover too complex by loading them with lots of different types of widget. As a rule of thumb, use no more than three different widget types.

Editing Selections

One really nice way to use popovers is for editing controls. Here, the popover can appear in relation to the selection. The great thing about this is that it avoids showing controls until they are needed, so you don’t have toolbars full of insensitive buttons. It also emphasises the context specific nature of the controls that are being presented.

You can already see how this can work in the Notes app, which has had its own popovers implementation for a while. Here’s one of our early mockups for that:

notes-single

And here is a similar pattern for Sudoku controls:

sudoku

Have Fun!

Popovers are an extremely flexible widget, which means that they lend themselves to creative design. They are a really nice way to inject interest and originality into applications, I’m really looking forward to seeing how people end up using them. If anyone has any questions about how to design with popovers, I’d be happy to offer advice.

Posted in design, gnome, gnome-ux, gnome3, gtk+ | 6 Comments

Help Me! (Yet another docs hackfest blog post.)

Over the past couple of years, I’ve tried to sit down and do some work with the awesome GNOME docs team on a number of occasions, but something always seemed to get in the way. So I was really happy to be able to spend three days with them at this week’s documentation hackfest.

One of the things I looked at during the hackfest was the design of Yelp, our help application. Shaun McCance and I talked about how we can make it more consistent with our other GNOME 3 style applications, and we’ve also been working on designs for an improved “start screen” – so that the content of the help browser looks more engaging.

Help Start Screen

Documentation isn’t always about “help”. To me, our documentation is an opportunity to let people learn about the functionality we provide, to master tips and tricks that will help them be more productive, and find out about the cool new features that have recently been added. As work progresses on the help, I hope that these other aspects of the documentation start to come through more strongly.

The hackfest also gave me an opportunity to participate in some interesting discussions about developer documentation. Documentation is obviously an important part of the GNOME application developer experience, and is something that we really need to improve if we want to stimulate the creation of great applications for GNOME. These conversations generated some pretty cool ideas about how to quickly create helpful developer documentation, and how to tie our existing documentation together in a more cohesive way. I’m hopeful that we’ll be able to take those ideas forward in the coming weeks and months.

Many thanks to the University of East Anglia for providing a great venue. The Ziggurats are awesome.

Posted in design, gnome, gnome-ux, gnome3, hackfest | Leave a comment

Nautilus Next

Nowadays, digital content is all about the cloud. Indeed, in GNOME we’ve been pushing to integrate with cloud-based content through our new content apps, like Documents, Photos, Music and Videos. This is important work and needs to continue.

However, local files are still central to the way that many people work, and are an essential part of lots of workflows. This means that, while cloudy things are important, it is also important that we pay attention to the experience of working with local files in GNOME. It is for this reason that a group of us has been working on a plan to improve the state of Nautilus, our venerable file browser.

The new designs are fairly extensive and cover a lot of ground. In the rest of this post I’ll try to describe as much as I can. As always, they are not set in stone and will evolve. Questions, comments and feedback are most welcome, and will help us to develop them further.

Lists & Grids

list

The most important thing in the Files app is, well, your files. If Nautilus is going to provide the kind of experience that we want it to, it needs to do a better job at making your files easy to recognise, look good, and take centre stage. This requires lists and grids that have even spacing, helpful zoom levels, and big, clear thumbnails.

grid

The designs feature new lists and grids, which should hopefully be possible with GTK’s new grid and list widgets. The grids we have in mind will be responsive, so that the content will scale to fit the size and shape of the window (without large spaces between cells or gutters on one side). Lists will feature thumbnails and have separators between rows to aid readability.

gear-menu

The designs also include mockups for an updated view “menu”. This contains all the existing options, except with nicer controls.

Previews

preview

Being able to inspect the content of a file is often essential to identifying it, such as when you have lots of similar photos, or PDFs with unhelpful file names. Nautilus already has a previewing feature, but it functions as an optional extra and can easily be missed. The new designs make previewing much more central to the browsing experience. They also include actions alongside previews, so that you can quickly act on the file that’s in front of you.

One thing that you can’t see in this mockup – we also want to make it possible to browse between files from the preview – so you can flip back and forth between images or documents in order to compare them.

Generating previews like this may well require new infrastructure. Specifically, it is likely that we will need a new library for generating previews.

Places

Many of the ideas for the new sidebar design came from the awesome António Fernandes.

The main objective for the places sidebar is to make it more focused on the things you care about. Right now, the sidebar automatically includes every available volume and drive. This can lead to a cluttered sidebar which contains lots of items that you never use. These often get in the way and distract from the items that you use all the time.

add-drive

We want to rebalance the sidebar: more things you care about, less things you don’t. To achieve this, we want to make adding drives to the sidebar a manual action. In this way you will be able to customise the sidebar to your needs.

Clarification: manual addition won’t be necessary for removable drives – they will be automatically added to the sidebar as they are now. Also, once an internal volume or remote drive is added, it will persistent even when it’s not mounted.

A new add drive dialog is a key part of the new sidebar design. This will allow you to quickly add both local and remote locations to the sidebar all from the same dialog. It is also an attempt to clean up the various network browsing features that are currently available in Nautilus, and consolidate these features into one place.

The reimagined sidebar also contains a new feature which will be really handy: starred files. Being able to mark items that you want to keep track of is such as obvious feature, and I’m sure it will be useful to many people. In UI terms it’s a fairly simple thing to do.

Selections

selection-mode

Selection mode is a design pattern that we’re using extensively in the other GNOME 3 applications. It’s nice because it makes contextual actions much more discoverable. It also allows us to use single click (rather than the undiscoverable and inconsistent double-click) throughout.

The best way to think of the use of selection mode here is as a discoverable context menu. Existing methods of selecting multiple items, like holding ctrl and shift in combination with the mouse button, will continue to work.

Added Discoverability

new-folder

It’s amazing how many undiscoverable conventions that we acclimatise ourselves to, and an old app like Nautilus has a lot of them. At some point in the past, we all learned to double-click to open, to press return to finish naming a new folder, or that Ctrl+V pastes content into the current location. All of this is totally unobvious to new users, of course, and there can be embarrassing moments when you watch someone use an app like Nautilus for the first time.

The new Nautilus designs bring a lot of hidden functionality to the surface, and they make an effort not to assume prior knowledge. Much of the functionality that is currently hidden in the background has been brought to the surface: there are visible buttons for common tasks like pasting items or creating folders, for example. Simple things – like using a dialog for creating new folders – are designed to eliminate basic usability bugs.

Content Selection

Finally, this brings us back to content selection. A next generation replacement for the existing file selection dialog is something that has been mooted for a long while. To make it happen, a number of other long-term initiatives need to come together: the new set of content selection applications needs to come together, and we need the previewing library that I mentioned about above.

This latest round of Nautilus design work was in part motivated to keep these content selection plans moving forward, and the Nautilus designs were developed at the same time as a new set of content selection mockups. This is to ensure that the file browser keeps in step with our longer term plans.

content-selection1

The new content chooser is designed to allow you to select content items from a range of sources. These can be local files or content items that are stored in the cloud. This is where the various new content applications come in – each one is designed to act as a cloud-based content provider. With this approach, you should be able to use the Photos app to select images from Flickr, for example.

content-selection2

The initial view provides a grid of recently used items. After that, you can choose a particular content provider. Content apps can then present their own content. Notice that, after opting to view files, the familiar places sidebar from Files slides in.

content-selection3

What You Can Do

If you want to help us make these designs a reality, there are many things that we need help with, both large and small. I will be busy turning the designs into bug reports over the coming weeks, and will be keeping the design page up to date as the plans take shape. You can subscribe to the page if you want to follow what’s happening. Otherwise, just get in touch. We would love to hear from you, even if you are just interested.

Comments on this post are now closed. Thanks for all the fantastic feedback.

Posted in design, gnome-ux, gnome3 | 118 Comments