Over the past few years, usability of free software has improved slightly. However, most free software even today has many problems in the design process. Let’s take a look at what these problems are and how they can be improved. We will one by one look at each issue that leads to poor usability for free software and discuss how to tackle these problems.
For software to fully achieve the goal of efficiency and user satisfaction, it is vital for the developers to pay close attention to each and every stage of the process of developing the software. It is essential for the developers to keep in mind the design as well as the usability. They must keep in mind that the complicated process of coding is just as important as the design of the software.
For years people have debated whether free software is as satisfying as the software made by significant companies such as Microsoft, etc. Although the idea of free software is very attractive and most of us would probably fall for it instead of paying hundreds of bucks for a fancy one made by Microsoft, but in reality, the phenomenon of free software comes with a lot of problems and there are certain measures that must be taken in order for it to compete successfully without compromising on usability and user satisfaction.
Following are some of the problems regarding free software usability and their proposed solutions:
Lack of strong incentives for the software makers
Most of the software developed for free usage is made by ‘volunteers’ who contribute to manufacturing of the software at various levels. They are volunteer coders and designers and their wages normally do not depend on the sales of the product, since they are not full time employees, unlike the employees of Microsoft or other software manufacturing companies.
In the proprietary software industry the success of the company and the well being of its employees both depend upon user satisfaction and usability efficiency. They make much more money by making products which are high in demand and hence pay attention to user satisfaction. On the other hand, the free software makers lack this incentive and pay little attention to improving usability. The number of users merely affects the financial well being of the developers of free software. Moreover, it is almost impossible to count the exact number of users of free software since it is freely redistributable.
Solution: In order to enhance usability; which is one of the major factors while designing software, it is necessary to trigger motivation among the software developers of the open source software industry. It is very important to give stronger incentives to the employees of open source software developers by giving them certain awards promoting insightful and creative work. A system of estimation of the number of users of particular software should be established in order to help the developers have an idea of user satisfaction and the statistics should be used as an incentive to increase usability.
Lack of attention to the Designing stage
It is a common notion that the most important part of software is its efficiency which in turn depends on the coding and hence, coding is regarded as the most important stage of software development and more attention is paid to the coding process by the open source software developers. However, it is a known fact that the coding process is only as important as the designing of the software and sometimes the significance of the design stage surpasses the significance of the coding process.
Let us look at it this way, the designers are the architects of the software and have the same role as any architect, which is to introduce creativity through their work and make designs which are not only efficient but also comforting and innovative. The coders are the labor force that is responsible for putting the architect’s ideas and vision into action by giving them a physical form. Just like in the building process the presence of a well rounded architect is vital to construct a well rounded building that not only provides shelter but is also a display of innovation, enhancing the satisfaction of the people living in it; the same is metaphorically true for the designers of software.
Solution: Although a lot of attention is paid to the designing process by big software industries such as Microsoft, however there is a visible lack of this in the free software industry and this directly affects the quality of the product and user satisfaction. In order to overcome this problem, developers should pay more attention to the design of their product by hiring more well qualified designers.
Unavailability of volunteer designers
The discussion on the lack of attention by developers to the design of their product brings us to the major reason behind it, which is the unavailability of the volunteer designers in the market. Although, there is a large number of “volunteer coders”, however, there is a major lack of volunteer designers and their unavailability causes a significant lack of creativity and innovation in open source products.
A musician might be a good composer as well but there is a very rare chance of that and most of the time a good musician and a good composer work together to make music that is worth listening to. Similarly, there are only a few coders who are also good designers, but that is very rare because programming and human interface design is very special skills that each requires separate training and a different mindset.
Solution: Free software industry should provide their programmers and designers with highly accessible and up to date training in order to increase the level of design competence. The volunteer designers should be given more incentives, and open source projects should have lead human interface designers as well as lead programmers in order to enhance the quality of their product and user satisfaction.
Design suggestions are not welcomed in projects
It is much easier and common for programmers to respond to the bug reports but the feedback or suggestions on the design are often unwelcome and uninvited in the industry. This is also one of the major reasons for a lack of volunteer designers in the market.
Solution: This problem can be solved by publishing the design specifications on the website and by having the volunteer designer respond to all the queries or suggestions regarding the design on the product via mailing lists, weblog or wikis etc. Also, by setting up an editable issue tracker, instead of an append-only bug tracker, the design suggestions could be more easily catered to.
Usability is difficult to measure
For the software products it is almost impossible to quantify and measure usability, because usability depends on a lot of factors and varies from person to person.
It may be possible to measure the speed at which a software responds to commands or the time it takes to launch or save data or exit. But, the much more complicated qualities such as how many users are able to operate it efficiently or how satisfying it is as compared to the other similar software available in the market or whether or not the software performs up to people’s expectations, are very difficult to measure.
An important tool to measure usability by the software developers is to test the product in user tests, by having a small group of people use the software and then give their feedback which can provide important information about user reaction to the particular software even before it is launched, and changes and improvements can be easily made based on the suggestions and feedback received.
However, free software developers do not have enough time or resources to carry out user tests and they normally ignore this very important stage before the launch of the software.
Solution: Free software developers should pay more attention to the user tests and should encourage the volunteer designers and programmers to respond efficiently to the results of the user tests in order to make their products more efficient. They should also develop and promote other software such as screen capture and video recording which would help run the user tests more proficiently.
Coding before design
It is a common culture among free software developers to pay more attention to the coding process, and hence coding is almost always done before the design is made. The human interface design is a complicated process and needs special attention while making a software, but since coding is given more importance, the programmers conveniently code before the designer gets to work, and later a lot of the suggestions and innovation introduced by the designer goes to waste.
The algorithms and various other features such as the formatting is largely altered by different designs and since designing is done after the coding, it becomes difficult for the programmers to efficiently incorporate the designs developed by the volunteer designers, and they conveniently choose to ignore their suggestions since the most important task of “coding” has already been done! All this leads to chaos and a design mess in the software being developed.
Solution: Free software Developers should establish a culture of design first and code second in order to make their products more competitive and up to date, and the designers and programmers should be paired up to work together as a team.
Too many people working on one thing
Most of the time in free software projects, there is a lack of completive designers and hence a lot of people entitle themselves to giving suggestions on the design on the product as self proclaimed designers. The programmers also sometimes consider their opinions on the overall design as being more important than the opinions and suggestions of the designers.
Solution: Free software projects should have a lead human interface designer who leads the group and incorporates different suggestions into the overall design of the software by keeping in mind the product requirement and ignoring those ideas which are not appropriate for that particular software.
Copying the industry leaders
A lot of times free software developers are unsure of their designs and find it easier and much safer to just copy and follow what Microsoft or other big developers are doing. Sometimes these designs are extraordinary and it is a good idea to follow what is already popular among the users and is largely accepted, but, a lot times there is room for improvement, but the lack of confidence on the part of free software developers leads to repetitive designs and lack of innovation.
Solution: Free software developers should trust their human interface designers and programmers, and encourage them to make innovative software based on user tests and feedback.
Free software developers mostly develop software based on their own requirement and their definition of “good software”, and as a result, design software that is very complicated and “geeky”. They sometimes overlook the fact that most of their customers are not able to comprehend complicated designs and features and get confused. Many non-technical features such as parental control are largely overlooked and the result is overly complicated software which is not satisfying to the common user’s needs.
Solution: Free software developers should focus more on their customer needs and while developing the software, and should always make sure that the software is simple and easy to use without any unnecessary complications.
Paying close attention to the minor details
It is very important for free software developers to pay close attention to the minute details of their software such as the window size modification, or the progress bar etc. However, these details are often neglected by the designers and the programmers and give a very negative impression of the software’s quality. As already discussed, the lack of adequate responsiveness to the design complaints by free software developers allows such minor defects to go unnoticed.
Solution: Free software developers should make sure that the interface designers and programmers pay close attention to the design flaws as well as the feedback received from customers.
In a lot of software projects, involving multiple contributors, there may be dispute and a difference of opinion among the various contributors. Most of the time they resume work but in case of a Free Software with volunteers it is more than likely that the project maintainer will agree to placate a contributor. This results in confusion and mismanagement.
Solution: Free software developers should promote a strong culture of simplicity and must have a project maintainer responsible for aligning different processes of the project efficiently, catering to everyone’s feedback and having authority to implement only those ideas which are in line with the project.
A “Tool Bar” of Fame
A lot of times the software designers expect appreciation for their work, and sometimes demand that their innovative addition to the software must be displayed separately in the software, so that their work doesn’t go unnoticed. This, however, leads to unnecessary detailing and the presence of some impractical menu items.
Solution: Free software developers should appreciate the software designers by offering them incentives/awards, and web publicity via weblog etc. They must never stop asking themselves, “Do we really need this?”
“Release Early, release often”
A common practice by free software developers is the policy of “release early, release often”. This often leads to a hassled release, and as a result, the quality and the design are often compromised. The user’s expectations are generally not met and it leads to negative customer reaction and a fall in the product reliability.
Solution: The process of release should be given proper attention by free software developers, and quality and innovation must never be compromised.
Coordinating Cross Component features
All the functions performed on a computer require coordination among various programs. For example, if you want to print this article, this simple function requires not just your web browser, but the layout engine, the windows manager, an interface toolkit, a printer driver and several other programs to work together in harmony, to perform the simple task of printing this article.
This shows the importance of coordination among the various programs, but in the case of Free Software developers, unlike their proprietary competitors, the teams do not work together and their release cycles often fail to coordinate.
Solution: Free software developers should make sure that their employees coordinate their projects in order for them to be released together to ensure product efficiency.