Empowering Software Engineers in Human-Centered Design Ahmed Seffah and Alina Andreevskaia Human-Centered Software Engineering Group Department of Computer Science, Concordia University Email:
[email protected]
Abstract Usability is about to become the quality measure of today’s interactive software including Web sites, and mobile appliances. User-centered design approach emerges from this need for developing more usable products. However, interactive systems are still designed and tested by software and computer engineers unfamiliar with UCD and the related usability engineering techniques. While most software developers may have been exposed with basic concepts such as GUI design guidelines, few developers are able to understand the human/user-centered design (UCD) toolbox at a level that allows them to incorporate it into the software development lifecycle. This paper describes an approach for skilling developers and students enrolled in an engineering program in critical user-centered design techniques and tools. The proposed approach starts from the analysis of the usability and software engineer’s work context, identifies critical UCD skills and then associates relevant learning resources with each of the identified skills. Our approach suggests a list of patterns for facilitating the integration the UCD skills into the software engineering lifecycle.
1. Motivation Too often, human-centered engineering techniques remain the province of visionaries and a few enlightened software engineers, rather than the everyday practice of common software developers. One barrier to the wider practice of the human-centered design approach is that its structure and techniques are still relatively unknown, under-used, difficult to master, and essentially not well integrated in software development teams. While many developers may take a course on basic concepts of user interface design such as task analysis or heuristic evaluation, few of them have an understanding of the complete UCD toolbox at a level that allows them to
incorporate it into the whole software development lifecycle. Software engineers need a cost-effective educational framework to understand and master user-centered design in their own language and cultural context. They often don’t understand why and how the usability and user problems should drive the development of the whole system they implement. They also argue that ‘if users have a problem with the application they just have to consult the help system we provide. If the help system is also difficult to use, they take a look to the guided tour tutorial’. This approach has many consequences including an increase in the development and maintenance costs. Such situation stems mainly from the lack of means, i.e. the cultural barrier between usability practitioners and software engineers. This cultural obstacle should be a key topic in any course about user interface, usability and usercentered design. Well-trained software engineers in UCD should have gained design skills in a multidisciplinary environment that involves end-users, requires the use of several methods, and handles the inconsistencies that can exist between these diverse methods. They should also develop an appreciation of the human-centered design approach including the importance and impact of usability as a quality factor as well as the difficulties and specificities of designing user interface. They should also know how to make a tradeoff in design decisions involving different dialogue types and input/output devices. An appropriate case study is also required to understand the resources available for design, to maximize the benefits and costs of developing user interface prototypes, as well as to evaluate system usability using different techniques. Finally, engineers building interactive systems must know the limits of their knowledge and in particular when and how to work with external human factor consultants, usability champions or teams. They should know the difficulty of measurement and the complexity of making decisions based on data gathered during tests. We should show how the principles underlying human-centered design philosophy could or should be applied to a large variety of
3URFHHGLQJVRIWKHWK,QWHUQDWLRQDO&RQIHUHQFHRQ6RIWZDUH(QJLQHHULQJ ,&6(¶ ,(((
user interfaces, including traditional GUI, Web applications, PDA and mobile applications. To make UCD education more effective within a software engineering curriculum, current courses must be aligned with a new method of apprenticeship capable of empowering and sustaining self-learning in a teamoriented environment. Furthermore, this new approach must take into account software engineering students’ background, skills, and interests. Dayton et al. [2] recommended apprenticeship with an experienced user interface designer as the best way for a programmer to learn HCI design on the job. Another idea is to establish several "usability advocates" within the company. Dayton and others suggested a 3-day user interface design workshop in which the project team works with end-users and conclude that this is a successful method of training developers. Such an idea is easily transferable to the academic setting by considering an industry case study.
2. Major steps in designing a skill-oriented course The development of a skill-oriented course involved three stages, geared towards understanding what are UCD knowledge and techniques proposed and used by UCD experts, what skills software engineers need to become accomplished UCD practitioners, and what are learning resources that can cost-effectively address these skills. This approach was originally developed and validated in the PRISE project. PRISE — In French, Programme de Réorientation des Ingénieurs Sans Emploi; in English, A Curriculum for Retraining Unemployed Engineers — is a skill-oriented training program. PRISE was developed by the Computer Research Institute of Montreal (CRIM) in collaboration with the Quebec Ministry of Industry, Sciences, and Technologies, the Quebec Engineers Corporation, and several information technology and engineering companies in the Montreal area. The objective of the program was to retrain in software development more than 300 unemployed engineers in groups of 20 during 1999. For each group, the training duration was fixed at one year, alternating intensive skill-oriented training sessions in CRIM’s continuing training center with practical work in companies participating in the program.
2.1. Identifying critical skills In identifying the UCD skills, our first step was to analyze the varying contexts and software development teams in which usability engineers work. The next substep was to identify the skills that developers need to perform the different UI design activities. For this analysis, we used the following sources from both the HCI and software engineering education communities:
- University course evaluation forms completed by the students in the course we have been teaching during the last 8 years, including raw feedback from both software developers and students; - The results of different surveys on the training practices in software development organizations, as well as on the relevance of software engineering and computer science education [8]; - The skill structures for software engineers [3]; [5]; - The results of different workshops and surveys dedicated to HCI education and/or curriculum development for computer science; - An analysis we made of different courses including those based on the recommendations of ACMSIGCHI curriculum (http://www.acm.org/sigchi/cdg) including the one that has been a source of inspiration for us [6]; - The classical textbooks and related booksites on HCI; - The recent books on UCD have been also taken into account for validating the skills we identified; - The software engineering body of knowledge, SWEBOK (www.swebok.org), was also a valuable source for understanding where exactly usability concerns and related UCD techniques and knowledge should be placed and integrated with existing software development knowledge to maximize the benefits gained from both. We identified three groups of skills. The first group, prerequisite skills, is required for any student taking a course on UCD. These skills should be acquired prior to studying UCD, because subsequent learning depends on them: 1. Mastering the basic principles, foundations, and standards of software development methodologies 2. Having a considerable experience in using computers as well as good programming experience using rapid development tools and GUI builders The second group, specific skills, assume a general understanding of the development lifecycle and provide the ability to perform key tasks during all phases of the UCD lifecycle as defined, for example in the ISO 13407 standard. 1. HCI design difficulties and challenges. Understanding UCD design as a multidisciplinary design field which has its difficulties and challenges 2. UCD philosophy. Mastering the human-centered design philosophy, its foundations, terminology, facts, principles and processes 3. Expert-based evaluation. Reviewing and evaluating, without users, early design concepts and lowfidelity prototypes including task models and scenarios
3URFHHGLQJVRIWKHWK,QWHUQDWLRQDO&RQIHUHQFHRQ6RIWZDUH(QJLQHHULQJ ,&6(¶ ,(((
4. User characteristics, tasks, and UI requirements. Gathering, analyzing and specifying user characteristics, their tasks, their work environment and the usability/UI requirements 5. Screen layout and visual design. Choosing and designing screen layouts, information spaces, as well as visual metaphors and representations 6. Interaction design. Modeling and specifying the human-computer dialog, the system feedback and selecting the appropriate interaction styles and devices 7. Prototyping. Developing low, mid and high fidelity prototypes including mockups, storyboards, software and paper prototypes 8. User-based testing. Planning and conducting usability tests with end-users before, during and after the development and deployment 9. Patterns and guidelines. Gathering, disseminating and using users’ experiences and best design practices via design patterns, guidelines and style guides 10.Wizards, help, online support systems. Developing user support resources including wizards, online help systems, training resources and electronic performance support systems 11.GUI design. Applying human-centered design techniques and tools to GUI and office desktop applications 12.Web design. Applying human-centered design techniques and tools to Web applications including Web sites, E.Commerce and Virtual Communities 13.Mobile applications design. Applying humancentered design techniques and tools to mobile and wireless applications including PDAs and wireless telephones The third group, generic skills, is applicable to many UCD steps. These skills are also called “soft skills” [5]: 1. Integrating UI design and usability engineering techniques in the software development lifecycle and methods 2. Writing, formatting, and presenting technical documentation related to requirements, design and testing to a general audience 3. Conducting investigations and cost-benefit studies on software and usability tools and technologies 4. Communicating and working in a multidisciplinary team and in particular with clients, end-users and human factors engineers These generic skills are also listed in ACM HCI curriculum as well as in the industry survey conducted by the Software Productivity Center (http://www.spc.ca/). We believe that by focusing on such skills, UCD educators can contribute significantly to overcoming this weakness in software engineering education in general. Software developers taking a course on UCD should learn how to
involve and interact with end-users and stakeholders during the entire software development lifecycle. Figure 1 shows a partial view of the skill map we defined. It defines the order in which the skills can be presented. This map is a directed graph where vertices correspond to skills and edges represent the order in which skills can be introduced. Some skills have to be presented in a predefined sequence that can’t be altered (the corresponding arcs are solid); others can be introduced in more than one order (optional sequences are shown with dashed arrows). Each vertex of the skill graph has to be visited once and none can be visited more than once.
HCIdesigndifficulties andchallenges
UCDphilosophy
Skill 3
Skill 2
Expert-based evaluation
Skill 1 Skill 4 Screenlayoutand visual design Skill 5
Prototyping Use-based testing
Skill 6
Interactiondesign
Skill 7
Skill 9
Patternsand guidelines
Skill 8
Skill 10
Wizards, help, online support systems
Skill 12
Skill 13
GUIdesign Skill 11
Usercharacteristics, tasks, and UIrequirements
Mobileapplications design
Webdesign Skill 14
UCDinsoftwareengineering lifecycle
Figure 1. The UCD Skill Map.
2.2 Definition grid The second step in our approach involved completing a definition grid for each identified skill. Each definition includes, among other things, the knowledge and concepts most often used by UCD experts and practitioners working in software development organizations. It should provide also a description of the main steps of the development process in which the skill is required. The performance criteria that we use to measure the quality of the work done by the usability expert should be also described. Table 1 presents a typical skill definition grid.
3URFHHGLQJVRIWKHWK,QWHUQDWLRQDO&RQIHUHQFHRQ6RIWZDUH(QJLQHHULQJ ,&6(¶ ,(((
Table 1: A Sample Skill Definition Grid Typical work situation Description of the skill Gathering, analyzing and specifying user characteristics, Based on business requirement documentation their tasks, their work environment and the usability/UI End users, stakeholders, usability expert, are directly requirements involved
Concepts and knowledge - Task analysis techniques including GOMS - Context of use, scenario, user archetypes - User, functional, user interface, usability requirements - Structured and unstructured interviews, focus groups, ethnographic studies, field observations, requirement reviews Major activities From the Usability Engineering Lifecycle [23] 1. Defining user characteristics including the mental models of their work processes and products 2. Analyzing of the users’ current job and tasks 3. Describing the context of use including platform capabilities and constraints 4. Specifying the usability goals 5. Defining, eventually, a list of general design principles (style guides)
2.3 Associating learning resources with skills Finally, our approach associates a set of learning resources with each skill. From the learner’s perspective, we should offer different types of resources that can be used to either achieve a greater understanding of a skill or to obtain further information about it. Furthermore problem solving–oriented resources should be available on the spot and just-in-time, and designed to help developers learn and execute major UCD activities. Examples and scaffolded examples [11], introduced as powerful tools for teaching object-oriented technology, are some of the avenues we investigated. In total we developed and selected from different sources 84 resources including six major case studies. Among these case studies, there is one that we developed recently and that presents a psychometric and heuristic evaluation for assessing CASE tools learnability and usability [7]. This case study is a good starting point in helping software engineers to realize the importance and impact of usability in their own context. It is also an excellent framework in which software organizations and engineers can learn and pick up from UCD and at the same time improve the usabilityto-software engineers collaboration to manage the diversity of notations and tools they generally use. We also designed a project that aims to be an integrative framework for providing skills to developers in user interface requirements, prototyping and usability testing. The project begins by getting to know the intended users, their tasks, and the context in which the system will
Constraints and standards that must be respected Consideration of the international standards and organization-specific procedures used for humancentered design Performance criteria - Appropriate use of requirements tools and techniques - Consideration of quality criteria including consistency, completeness, readability of requirements - Use of appropriate vocabulary and terminology - Respect of the procedures specified in international standards and/or company-specific procedures
be used. Only then, a task analysis and contextual inquiry is performed, followed by low-fidelity prototyping and rough usability studies, ending with a high-fidelity prototype that can be user tested more rigorously. Here again, Greenberg’s and Sheiderman’s courses have been a starting point for the development of our project [6].
3. Patterns as resources for encapsulating and transferring UCD knowledge to developers In the area of user interfaces design, guidelines and usability patterns have been proposed as a medium to encapsulate user experiences and best design practices. It has been also reported that patterns are useful for a variety of reasons [4]. They are considered, by expert user interface designers, as a medium for transferring, by means of software development tools, the design knowledge of human factors and user interface designers to software engineers unfamiliar with usability engineering. Within our approach, we have been using three different categories of patterns: - HCI (Human Computer Interface) patterns that are proven user experience solutions to a common usability problem. Different HCI pattern languages have been developed and are being used as an alternative/complementary design tool to guidelines [12].
3URFHHGLQJVRIWKHWK,QWHUQDWLRQDO&RQIHUHQFHRQ6RIWZDUH(QJLQHHULQJ ,&6(¶ ,(((
- Usability patterns that describe human-centered design best practices. Such patterns, which are similar to process patterns [1], can be used as a Lingua Franca [4] in the sense that they have also the potential to support the whole design process. - Pedagogical patterns that implement effective learning and teaching strategies. Many groups devoted themselves to the development of pattern languages for user interface design such as “Common Ground”, “Experience”, and “Amsterdam” play a major role in this field and wield significant influence [12]. For example, the convenient tool bar patters aims to help the user reach the most useful and frequently visited pages at any time throughout from any page. It can include home page, search, feedback, etc. This pattern can be used as a learning resource to master the two following skills 9 and 10 (see figure 1). A Process pattern encapsulates good design practices shared among UCD practitioners. It describes UCD activities in the format of why, when, and how. For example, Building a Low-Fidelity Prototype patterns describe why and when a paper prototype can be used to validate user requirements. This pattern can be as a learning resource/strategy for illustrating skills 2 and 3. Lilly and Manns [9] introduced the concept of
Name Intent
-
Forces
-
Solution
-
Applicability Resulting Context
-
pedagogical patterns as a promising way to teach objectoriented technology to traditional software developers. Pedagogical patterns play the same role in teaching and learning as design patterns play in software development. Specifically, a pedagogical pattern describes an abstract teaching approach from which contextualized training strategies can be generated, so that subsequent educators are not forced to start over when they design new courses and learning resources [9]. In our approach, we consider pedagogical patterns as the essence of learner-centered education in that they describe best practices for transmitting UCD skills to developers. Pedagogical patterns enable learners to build their understanding through a process of successive elaboration and integration. Pedagogical patterns should not only provide help in using learning resources or developing them, but also provide support for understanding UCD concepts and applying related methods by providing pedagogical examples and templates, assessing performance, and so on. For example, the DIRR (Design-Implement-RedesignReimplement) pattern described in Table 6 attempts to explain new concepts and methods based on legacy concepts (for instance, learning object-oriented fundamental concepts using structured software design methods).
Table 2: An example of a pedagogical pattern Design-Implement-Redesign-Reimplement (DIRR) Pattern Explain new concepts and methods (e.g. UCD techniques) based on old concepts (e.g. Object-Oriented Methods). It is often hard to get students to make the paradigm shift from functional programming to object oriented programming. The lecture-lab pedagogy provides a "concept" and "use" approach which can prevent the student from separating the "concept" from a specific "use". The DIRR pattern provides "relearning" methodology for reinforcing new concepts. The students are asked to design and implement programming solutions using their current paradigm. This is followed by a discussion of how the solution can be redesigned using concepts from the new paradigm. Finally, the students reimplement their solution using the new paradigm concepts. Use the Design-Implement-Redesign-Reimplement pattern to bridge the gap from an old paradigm to a new paradigm. Provides students with first hand experience of both the "old way" and "new way" of developing solutions. Students gain practical insight into how new concepts relate to their pre-established concepts. Solving a problem more than one way often leads to deeper understanding of the concepts being addressed. Questions arising from the students will tend to focus on the "why" things are done rather than on "how" they are done.
Another example of similar pattern to DIRR is New Pedagogy for New Paradigms pattern. It captures a good practice on how to teach something new to the students. The DIRR and New Pedagogy for New Paradigms patterns are very useful for bridging software and usability
engineering concepts and practices. Another important category of pedagogical patterns includes those that can help a professor to develop, select and deliver learning resources. To a certain extent, these patterns are a professor’s teaching experiences.
3URFHHGLQJVRIWKHWK,QWHUQDWLRQDO&RQIHUHQFHRQ6RIWZDUH(QJLQHHULQJ ,&6(¶ ,(((
4. Validation and conclusion The approach for developing and delivering a skilloriented course on human-centered design presented in this paper is the result of 8 years of investigation. The first version of the skill map was developed between 1995 and 1999 when the first author was an adjunct professor at the University of Quebec at Montreal. He was mainly teaching a course on user interface design for both graduate and undergraduate computer science students. Between January 2000 and June 2002 at Concordia University, other colleagues and we have been using the skills, the learning resources and patterns in different courses. Some of our courses include the bachelor of electrical engineering, computer science, and software engineering, as well as the graduate diploma in computer science, the master of applied computer science and the graduate certificate in user interface design for software systems. The size of each of these classes was between 36 and 60 students. We also designed and offered an industry-oriented tutorial on UCD for software practitioners. In total, around 400 persons have been enrolled in our courses and tutorials during the four last years. In the beginning of each class, we present our approach and the skill map to students. Based on their feedback, we define the order in which the skills should be presented. We also selected the main resources that we called required or mandatory resources from the large repository we developed. Of course, students have also a free access to all the other resources in the databases during the term. After each term, we always collected students’ feedback using a questionnaire. Such evaluation has been used to refine the list of skills and to develop new learning resources and patterns. To facilitate the management, we also developed a Web site, called Human-centered Design for Software Engineers: Techniques, Tools and Applications. This Website provides a unique access to the learning resources, patterns, as well as to an extended list of readings and references including links to textbooks sites and wellknown Websites on UCD engineering. Based on a usability test we conducted, a new version of this Website is under construction. At each step of the development of our course, we have been gathering and integrating in the course the students’ feedback via structured and informal interviews. In one sentence, we applied the user and learner-centered design philosophy [10] to the development of the course itself including the definition of skills, patterns and resources. In observing and interviewing the different groups of students in our courses thus far, we discovered that we must develop more realistic case studies and examples. Pedagogical patterns need to be developed for evaluating the learner’s evolution
and performance, and others for the customization of the curriculum for different educational contexts and audiences. We expect that nurturing continuous learning of UCD skills will be the most popular approach within the engineering educators community. We also expect they will be a major factor in educating the software workforce in developing more usable interactive systems. We are also revising and extending the list of resources and skills in the light of the recent published books on humancentered design and usability engineering.
5. References [1] Ambler S.W., Process Patterns: Building Large-Scale Systems Using Object Technology, SIGS Books, Cambridge University Press, July 1998. [2] Dayton, T., et al. (1993). Skills needed by user-centered design practitioners in real software development environments: Report on the CHI’92 workshop. SIGCHI Bulletin 25(3): 16-31. [3] Denning, P.J., “Educating the New Engineers.” Comm. ACM Vol. 35(12). December 1992, pp.88-97
[4] Erickson T., Lingua Franca for Design: Sacred Places and Pattern Languages, DIS 2000: Proceedings of Designing Interactive Systems, New York, August 17-19, 2000, ACM Press. [5] European Informatics Skills Structure, Council of European Professional Informatics Societies, London, 1992, http://www.cepis.org. [6] Greenberg, S., Teaching Human Computer Interaction to Programmers. ACM Interactions, 3(4), pp. 62-76, July-August 1996, ACM Press. [7] Kline, R. A. Seffah, H. Javahery, M. Donayee and J. Rilling, Quantifying Developer Experiences via Heuristic and Psychometric Evaluation Symposium on
[8]
[9]
[10]
[11]
[12]
3URFHHGLQJVRIWKHWK,QWHUQDWLRQDO&RQIHUHQFHRQ6RIWZDUH(QJLQHHULQJ ,&6(¶ ,(((
Proceedings of 2002 IEEE Symposia on Human Centric Computing Languages and Environments (HCC 2002), Arlington, VA, September 3-6, 2002. Lethbridge, T., “A Survey of the Relevance of Computer Science and Software Engineering Education,” Proc. 11th Conf. Software Eng. Education and Training, IEEE Computer Soc. Press, Los Alamitos, Calif., 1998, pp.56-66. Manns, M.L., “Pedagogical Patterns: Successes in Teaching Object Technology,” ECOOP'96 Educator's Symposium. 1996. Norman, D. A. and Draper, S. W. (Eds.), User Centered System Design: New Perspectives on Human-Computer Interaction. Hillsdale, NJ: Erlbaum, 1986. Rosson B., and Carroll, J.M., Scaffolded examples for learning object-oriented design. Communications of the ACM. 39(4), May 1996, pp. 46-47. Tidwell J., “Common Ground: A Pattern Language for Human-Computer Interface Design,” 1997, http://www.mit.edu/~jtidwell/common_ground.html
