The usability of open source software: analysis and prospects

Open source communities have successfully developed many pieces of software although most computer users only use proprietary applications. The usability of open source software is often regarded as one reason for this limited distribution. In this paper we review the existing evidence of the usability of open source software and discuss how the characteristics of opensource development influence usability. We describe how existing human-computer interaction techniques can be used to leverage distributed networked communities, of developers and users, to address issues of usability. Authors’ note This chapter is a revised version of a paper first published in 2003. Since then the Mozilla Firefox web browser has been publicly released and widely adopted by end users, competing well against Microsoft‟s once dominant Internet Explorer. One reason for the success of Firefox is its excellent usability. This shows that it is possible for open source applications to be usable. However, such cases remain rare. We believe that the claims in this paper remain true and that Firefox is an honourable exception of what can be done by a group of determined and skilled usability advocates firmly embedded at the heart of a development process. Introduction Open source communities have successfully developed many pieces of software. Most of this software is used by technically sophisticated users, in software development or as part of the larger computing infrastructure. Although the use of open source software is growing, the average user computer user typically only interacts directly with proprietary software. There are many reasons for this situation; one of which is the perception that open source software is less usable. This chapter examines how the open source development process influences usability and suggests usability improvement methods that are appropriate for community-based software development on the Internet. The rationale behind the user-centred design approach within human-computer interaction (HCI) emphasises that software developers cannot easily design for typical users. At first glance this suggests that open source developer communities will not easily live up to the goal of replacing proprietary software on the desktop of most users (Raymond, 1998). However, as we discuss in this paper, the situation is more complex and there are a variety of potential approaches: attitudinal, practical and 2 technological. In this chapter we provide a summary of the issues of open source usability, a more detailed description of the same topic is also available (Nichols and Twidale, 2003). We first review the existing evidence of the usability of open source software (OSS). We then outline the ways in which the characteristics of open source development influence the software. Finally, we describe how existing HCI techniques can be used to leverage distributed networked communities to address issues of usability. Is there an open source usability problem? Open source software has gained a reputation for reliability, efficiency and functionality that surprised many in the software engineering world. The Internet facilitated the coordination of volunteer developers around the world to produce open source solutions that are market leaders in their sector (e.g. the Apache webserver). However most of the users of these applications are relatively technically sophisticated and the average desktop user is still using commercial software (Lerner and Tirole, 2002). There are several explanations for this situation: inertia, interoperability, interacting with existing data, user support, organisational purchasing decisions etc. In this chapter we consider one possible expflanation: that (for most potential users) open source software has poorer usability. Usability is typically described in terms of five characteristics: ease of learning, efficiency of use, memorability, error frequency and severity, and subjective satisfaction (Nielsen, 1993). Usability is separate from the utility of software (whether it can perform some function) and from other characteristics such as reliability and cost. Software, such as compilers and source code editors, which is used by developers, does not appear to represent a significant usability problem for OSS. In the following discussion we concentrate on software (such as word processors, e-mail clients and web browsers) which is aimed predominantly at the average user. That there are usability problems with OSS is not significant by itself; all interactive software has problems. The issue is: how does software produced by an open source development process compare with other approaches? Unfortunately it is not easy to arrange a controlled experiment to compare the alternative engineering approaches; however it is possible to compare similar tasks on existing software programs produced in different development environments. The only study we are aware of that does such a comparison is Eklund et al. (2002), using Microsoft Excel and StarOffice (this particular comparison is made more problematic by StarOffice‟s proprietary past). There are many difficulties in performing a fair comparison but ultimately user testing of the software, as with Eklund et al. (2002), must be the acid test. However, as has been shown by the Mozilla Project (Mozilla, 2002), it may take several years for an open source project to reach comparability and premature negative comparisons should not be taken as indicative of the whole approach. Additionally, the public nature of open source development means that the early versions are visible, whereas the distribution of embryonic commercial software is usually restricted. Although there are few formal studies of open source usability there are several suggestions that open source software usability is a significant issue (Behlendorf, 1999; Raymond, 1999; Manes, 2002; Nichols et al., 2001; Thomas 2002; Frishberg et al., 2002). Raymond (1999) re-iterates the central message of user-centred design (Norman and Draper, 1986): developers need specific external help to cater for the average user. The HCI community has developed several tools and techniques for this purpose: usability inspection methods, interface guidelines, testing methods, participatory design, inter-disciplinary teams etc. (Nielsen, 93). The increasing attention being paid to usability in open source circles (Frishberg et al., 2002) suggests that it may be passing through a similar phase to that of proprietary software in the 1980s. 3 As the user base of OSS widens to include many non-developers, projects will need to apply HCI techniques if they wish their software to be used on the desktop of the average user. There is recent evidence (Benson et al., 2002; Biot, 2002) that some open source projects are adopting techniques from previous proprietary work, such as explicit user interface guidelines for application developers (Benson et al., 2002). It is difficult to give a definitive answer to the question: is there an open source usability problem? The existence of a problem does not necessarily mean that all OSS interfaces are bad or that OSS is doomed to have hard to use interfaces, just a recognition that the interfaces ought to be and can be made better. The opinions of several commentators and the actions of companies, such as Sun‟s involvement with GNOME, are strongly suggestive that there is a problem, although the academic literature (e.g. Feller and Fitzgerald, 2002) is largely silent on the issue (Frishberg et al. (2002) and Nichols et al. (2001) are the main exceptions). However, in order to suggest HCI approaches that mesh with the practical and social characteristics of open source developers (and users) it is necessary to examine the aspects of the development process that may have a negative impact on usability. Usability and open source software development They just don't like to do the boring stuff for the stupid people! (Sterling, 2002) To understand the usability of current OSS we need to examine the current software development process. It is a truism of user-centred design that the development activities are reflected in the developed system. Drawing extensively from two main sources (Nichols et al., 2001; Thomas, 2002), we present here a set of features of the OSS development process that appear to contribute to the problem of poor usability. In addition there are some features that are shared with the commercial sector that help to explain why if OSS usability is no worse than proprietary systems, nor is it any better. This list of features is not intended to be complete but to serve as a starting point in addressing these issues. We note that there would seem to be significant difficulties in „proving‟ whether several of these hypotheses are correct. Developers are not typical end-users This is a key point of Nielsen (1993), and is one shared with commercial systems developers. Teaching computer science students about usability issues is, in our experience, chiefly about helping them to try and see the use of their systems through the eyes of other people unlike themselves and their peers. In fact, for many more advanced OSS products, developers are indeed users, and these esoteric products with interfaces that would be unusable by a less technically skilled group of users are perfectly adequate for their intended elite audience. Indeed there may be a certain pride in the creation of a sophisticated product with a powerful, but challenging to learn interface. Mastery of such a product is difficult and so legitimates membership of an elite who can then distinguish itself from so-called „lusers‟ (Raymond and Steele, 1991, p. 364). Trudelle (2002) comments that „the product [a web browser] should target people whom they [OSS contributors] consider to be clueless newbies. ‟ However when designing products for less technical users, all the traditional usability problems arise. In the Greens