Open source software (OSS) development, as any social movement, is driven by its ideologies, namely OSS ideologies [6]. Understanding OSS ideologies could provide significant insights into open source development, since OSS ideologies determine and influence the dynamics and outcomes of open source development [1, 2]. Assessing OSS ideologies within open source projects could bring various benefits to OSS practitioners, e.g., the owners and the maintainers of open source projects could identify important ideological elements that were previously ignored, and could improve open source development accordingly. Therefore, with such an assessment of OSS ideologies, institutional and individual stakeholders who are interested in open source development could make informed decisions when interacting with open source projects.

User eXperience (UX) evaluations play an essential role in the software development process. As the results from such evaluations can drive future releases, it is necessary to identify which factors can substantially change users’ judgments about their experience to have more precise results and understand UX better. This article investigates how interaction sequencing, previous experience, and the number of problems could affect overall satisfaction and the two main UX dimensions: pragmatic and hedonic. We employed three different evaluation methods to evaluate a chatbot-based mobile shopping application. The results revealed that participants with previous experience with similar apps tended to give lower ratings. We also found that as inspectors identify more problems, they tend to rate the pragmatic dimension lower. Finally, we did not identify a significant influence of interaction sequencing on UX evaluation. We discuss the reasons for these results, the implications for practitioners and researchers, and research opportunities.

Attracting and retaining newcomers are critical aspects for OSS projects, as such projects rely on newcomers’ sustainable contributions. Considerable effort has been made to help newcomers by identifying and overcoming the barriers during the onboarding process. However, most newcomers eventually fail and drop out of their projects even after successful onboarding. Meanwhile, it has been long known that individuals’ early career stages profoundly impact their long-term career success. However, newcomers’ early careers are less investigated in SE research. In this paper, we sought to develop an empirical understanding of the relationships between newcomers’ dynamic contribution patterns in their early careers and their technical success. To achieve this goal, we compiled a dataset of newcomers’ contribution data from 54 large OSS projects under three different ecosystems and analyzed it with time series analysis and other statistical analysis techniques. Our analyses yield rich findings. The correlations between several contribution patterns and technical success were identified. In general, being consistent and persistent in newcomers’ early careers is positively associated with their technical success. While these correlations generally hold in all three ecosystems, we observed some differences in detailed contribution patterns correlated with technical success across ecosystems. In addition, we performed a case study to investigate whether another type of contributions, i.e., documentation contribution, could potentially have positive correlations with newcomers’ technical success. We discussed the implications and summarized practical recommendations to OSS newcomers. The insights gained from this work demonstrated the necessity of extending the focus of research and practice to newcomers’ early careers and hence shed light on future research in this direction.

Open source developers, particularly the elite developers who own the administrative privileges for a project, maintain a diverse portfolio of contributing activities. They not only commit source code but also exert significant efforts on other communicative, organizational, and supportive activities. However, almost all prior research focuses on specific activities and fails to analyze elite developers’ activities in a comprehensive way. To bridge this gap, we conduct an empirical study with fine-grained event data from 20 large open source projects hosted on G IT H UB . We investigate elite developers’ contributing activities and their impacts on project outcomes. Our analyses reveal three key findings: (1) elite developers participate in a variety of activities, of which technical contributions (e.g., coding) only account for a small proportion; (2) as the project grows, elite developers tend to put more effort into supportive and communicative activities and less effort into coding; and (3) elite developers’ efforts in nontechnical activities are negatively correlated with the project’s outcomes in terms of productivity and quality in general, except for a positive correlation with the bug fix rate (a quality indicator). These results provide an integrated view of elite developers’ activities and can inform an individual’s decision making about effort allocation, which could lead to improved project outcomes. The results also provide implications for supporting these elite developers.

This Full Paper of Innovative Practice research shows results that could help to avoid some challenges faced by those who seek to learn how to program. To help improve learning, educators need a deep understanding of the obstacles students must overcome; otherwise, teaching strategies will be uncertain. Moreover, a shallow understanding of topics learned in introductory programming courses can negatively influence the learning of future topics. With the above motivation, we conducted 16 semi-structured interviews with instructors who teach introductory programming courses and we also collected diaries kept by 110 students during their studies. The qualitative analysis of these data revealed connections between the studied contents such as dependencies. Our analysis shows that many difficulties arise from the incorrect application of the knowledge necessary in learning new content, usually because the student has not learned earlier topics or learned them superficially. The main contribution of this paper is a theory that describes the connections among topics of learning how to program, showing the influence that knowledge about one can have on others.

Global software development (GSD) done by geographically distributed teams of developers is one of the most common ways of developing software nowadays. Though GSD has various benefits, it also introduces challenges that have led to a plethora of research. This paper analyzes research papers published in top software engineering venues in recent years (2009-2018) focusing on team collaboration in order to understand the trend in GSD research. Out of 4,292 papers published in these venues, we found 33 papers that focused on team collaboration in the context of GSD. We study the kinds of data used in these papers and classify them into primary data (i.e., interview and observation data) and secondary data (i.e., repository and communication data) and found that interview data is the dominant type of data in these papers. We also found that the strength of evidence presented in most papers tends to be moderate.

Teaching introductory programming requires knowledge of both content and pedagogy. Pedagogy includes understanding the typical difficulties students face as they learn, as well as recognizing didactic strategies professors can use to help students to overcome these difficulties. Our research aims to improve the pedagogical knowledge instructors have to teach introductory programming courses, especially those new in this area. We conducted 16 semi-structured interviews with instructors who teach introductory programming courses and collected diaries filled by 110 students during their studies. Qualitative analysis of this data revealed a set of difficulties students faced when learning programming basics and a set of didactic strategies professors use to mitigate them. The results were reviewed by senior instructors in order to confirm them and by junior instructors to verify the importance of this material from their perspective. The main contribution of our paper is a set of difficulties faced by students learning programming, a classification of the most harmful challenges, and the didactic strategies usually used to teach and avoid them. Thus, we provide the basis for the pedagogical content necessary to junior and senior professors planning introductory programming courses.

Building up effective teams over a distance is a challenging but common problem in global software engineering. We propose an approach to help build up teams through collaborative online drawing. Our goal is to evaluate how drawing, as one activity that can facilitate expression of personal affective status, can benefit distributed teams. Preliminary results indicate positive effects of collaborative online drawing in increasing team cohesion and positive emotions. We discuss our approach and preliminary results in terms of design implications for future collaborative drawing systems for building up distributed teams.

End-User Development (EUD) has been identified as one approach to address some of the challenges of the Internet of Things (IoT) by enabling people to configure technology to their specific needs and preferences. For this potential to be realized, end-users need appropriate tools to support them and, in order to build such tools, developers need a deeper understanding of what EUD for IoT really means. This paper proposes a framing for EUD for IoT based on semiotic engineering theory for human-centered computing (HCC) and explores how this framing can be used with a concrete example of existing technology. Our contribution is to present a new way of framing research questions in this area, which we illustrate with a brief example.

Baseline trust, which refers to the personality aspect of trust and varies with different individuals, is essential for understanding the development of trust and cooperation in a team. At the same time, informal, non-work-related conversations (aka, cheap talk) have positive influences on the diffusion of trust and cooperation in global software engineering (GSE) practice. This paper seeks to develop an understanding of the influences of individuals' baseline trust on the diffusion of trust and cooperation, in the presence of cheap talk over the Internet. We employ a novel approach, designing a virtual experiment that integrates abstract agent-based modeling and simulation with realistic, empirical network structures and baseline trust data from two large open source projects (Lucene and Google Chromium OS). The results highlight the significant impact of baseline trust on the diffusion of trust and cooperation, for instance, the emergence of non-traditional diffusion trajectories. The results also demonstrate that proper seeding strategies can improve the effectiveness and efficiency of diffusion of trust and cooperation.

Globally distributed collaboration requires cooperation and trust among team members. Current research suggests that informal, non-work related communication plays a positive role in developing cooperation and trust. However, the way in which teams connect, i.e. via a social network, greatly influences cooperation and trust development. The study described in this paper employs agent-based modeling and simulation to investigate the cooperation and trust development with the presence of informal, non-work-related communication in networked teams. Leveraging game theory, we present a model of how an individual makes strategic decisions when interacting with her social network neighbors. The results of simulation on a pseudo scale-free network reveal the conditions under which informal communication has an impact, how different network degree distributions affect efficient trust and cooperation development, and how it is possible to "seed" trust and cooperation development amongst individuals in specific network positions. This study is the first to use agent-based modeling and simulation to examine the relationships between scale-free networks' topological features (degree distribution), cooperation and trust development, and informal communication.

Newcomers' seamless onboarding is important for online communities that depend upon leveraging the contribution of outsiders. Previous studies investigated aspects of the joining process and motivation in open collaboration communities, but few have focused on identifying and understanding the critical barriers newcomers face when placing their first contribution, a period that frequently leads to dropout. This is important for Open Source Software (OSS) projects, which receive contributions from many one-time contributors. Focusing on OSS, our study qualitatively analyzed social barriers that hindered newcomers' first contributions. We defined a conceptual model composed of 58 barriers including 13 social barriers. The barriers were identified from a qualitative data analysis considering different sources: a systematic literature review; open question responses gathered from OSS projects' contributors; students contributing to OSS projects; and semi-structured interviews with 36 developers from 14 different projects. This paper focuses on social barriers and its contributions include gathering empirical evidence of the barriers faced by newcomers, organizing and better understanding these barriers, surveying the literature from the perspective of the barriers, and identifying new potential research streams.

Self-expression and interpersonal sharing of emotion have been shown to strengthen groups. However, how to accomplish such interpersonal sharing in public settings is a challenge. In a pilot study of a prototype system, we sought to facilitate public self-expression and sharing of affective information. We followed five design principles around the concept of art-mediated self-expression and created a collective doodling installation. The pilot trial demonstrated positive results around engagement of end users. As we reflected on the results from this trial, we found implications for building trust and collaboration in teams.

Trust is an integral element of any collaboration. We sought to investigate the interplay among trust, risk, and reliance within the context of Global Systems Engineering (GSE) teams. To this end, we conducted an empirical study of individuals' processes and considerations when presented with hypothetical scenarios that required long-term and short-term commitments, in addition to relinquishing control to others in their team. In this paper, we present the results of our 1-1 interviews of 57 individuals collaborating in GSE teams within five organizations. Our results suggest that study participants often readily trust their peers and those higher in the organizational hierarchy when no long-term commitment is required, and the participant retains control of the scenario. Our study findings also suggest that this finding does not necessarily extend to scenarios in which their decision entailed loss of control and thus higher risk and reliance. Our investigation of an individual's decision-making processes and the influence of trust on these processes provide us with insights that can be used to refine GSE managers' strategies and guide future research.

Trust remains a challenge in globally distributed development teams. In order to investigate how trust plays out in this context, we conducted a qualitative study of 5 multi-national IT organizations. We interviewed 58 individuals across 10 countries and made two principal findings. First, study participants described trust in terms of their expectations of their colleagues. These expectations fell into one of three dimensions: that socially correct behavior will persist, that team members possess technical competency, and that individuals will demonstrate concern for others. Second, our study participants described trust as a dynamic process, with phases including formation, dissolution, adjustment and restoration. We provide new insights into these dimensions and phases of trust within distributed teams which extend existing literature. Our study also provides guidelines on effective practices within distributed teams in addition to providing implications for the extension of software engineering and collaboration tools.

Trust is generally considered a key element of effective and productive distributed team collaborations. In this paper, we report the results of our investigation into the factors that engender trust in Global Systems Engineering (GSE) teams in five multinational organizations. We extend our previous work by conducting a new field study focused solely on factors that engender trust and identify the implications of these factors. Our work provides significant contributions to practitioners, researchers and tool developers. Managers working in study field sites have confirmed that our findings will be used to inform future team management strategies. Our results can also be used to structure and guide future research in this field, as it identifies gaps in existing literature. Finally, our findings can be used to inform the development of future tools that aim to support collaborative work in general and GSE teams specifically.

We seek to provide design principles for software tools intended to support the development of trust in distributed teams. As such, we present a "design space" for such tools that consists of three elements: trust factors, collaborative traces, and visual representations. Trust factors are aspects of work shown in the research literature to influence one's perceived trustworthiness of their team members. Collaborative traces are representations of past and current work done by team members manipulating project artifacts. Collaborative traces provide information about a trust factor. Visual representations consist of a set of visual abstractions of the collaborative traces arranged in a layout that provides users with the ability to formulate accurate perceptions of their team members' trustworthiness with respect to a particular trust factor. Because the eventual goal of this research is to produce visual interfaces that support the development of trust, we apply elements from the design space to the design of three example visualizations. We conclude by assessing the value of the model and outlining future work.

Previous research has shown that diversity within distributed collaborative teams can lead to innovation, but trust must exist for the open expression of innovative ideas and establishment of idea credibility. Initial trust is pivotal for distributed teams where team members have never met face-to-face and have only a very limited time to accomplish a task. Our goal is to determine if knowing specific information about other team members could enhance initial trust and improve productivity and satisfaction in idea generation and idea evaluation sessions. In an experiment, we showed that cognitive and affective trust could be successfully enhanced by presenting relevant information elements, such as domain expertise and personal hobbies, and could have positive effects on the quality and quantity of ideas in idea generation sessions as well as the satisfaction of the participants with the rating result in idea evaluation sessions. However, participants receiving personal information often misconstrue this as professional competency. We also describe gender differences observed in the idea generation sessions and discuss how to better design future systems for supporting idea generation and idea evaluation activities.

We sought to understand the role that Web 2.0 technologies play in supporting the development of trust in globally distributed development teams. We found the use of Web 2.0 technologies to be minimal, with less than 25% of our participants reporting using them and many reporting the disadvantages of adopting them. In response, we sought to understand the factors that led to the use and non-use of these technologies in distributed development teams. We adopted a mix of qualitative and quantitative methods to analyze data collected from 61 interviewees representing all common roles in systems development. We discovered six factors that influenced the use and non-use of Web 2.0 technology. We present a proclivity model to frame our findings as well as our conclusions about the interrelationships between the results of our qualitative and quantitative analyses. We also present implications for the design of collaboration tools, which could lead to greater support and usage by distributed developers.

The earlier a conflict is detected, the easier it is to resolve-this is the main precept of workspace awareness. Workspace awareness seeks to provide users with information of relevant ongoing parallel changes occurring in private workspaces, thereby enabling the early detection and resolution of potential conflicts. The key approach is to unobtrusively inform developers of potential conflicts arising because of concurrent changes to the same file and dependency violations in ongoing parallel work. This paper describes our research goals, approach, and implementation of workspace awareness through Palantír and includes a comprehensive evaluation involving two laboratory experiments. We present both quantitative and qualitative results from the experiments, which demonstrate that the use of Palantír, as compared to not using Palantír 1) leads to both earlier detection and earlier resolution of a larger number of conflicts, 2) leaves fewer conflicts unresolved in the code base that was ultimately checked in, and 3) involves reasonable overhead. Furthermore, we report on interesting changes in users' behavior, especially how conflict resolution strategies changed among Palantír users.

Person-to-person knowledge sharing is considered a key aspect of any effective collaboration. Many studies have investigated what motivates team members to share knowledge, but few have explored the role trust plays in knowledge seeking and acceptance. We conducted an empirical field study to investigate trust in distributed teams and its influence on knowledge seeking and acceptance practices in a Fortune 500 organization. Our main objective in this study was to investigate what factors determine who will be sought when knowledge is needed, and what the criteria are for knowledge acceptance in person-to-person knowledge sharing. Study findings provide a substantial understanding of knowledge-seeking practices, knowledge-acceptance needs, and the role trust plays in these practices and needs. In this paper, we discuss these findings and their implications on future tool support.

The concept of awareness plays a pivotal role in research in Computer-Supported Cooperative Work. Recently, software engineering researchers interested in the collaborative nature of software development have explored the implications of this concept in the design of software development tools. A critical aspect of awareness is the associated coordinative work practices of displaying and monitoring actions. This aspect concerns how colleagues monitor one another's actions to understand how these actions impact their own work and how they display their actions in such a way that others can easily monitor them while doing their own work. In this paper, we focus on an additional aspect of awareness: the identification of the social actors who should be monitored and the actors to whom their actions should be displayed. We address this aspect by presenting software developers' work practices based on ethnographic data from three different software development teams. In addition, we illustrate how these work practices are influenced by different factors, including the organizational setting, the age of the project, and the software architecture. We discuss how our results are relevant for both CSCW and software engineering researchers.

Collaborative brainstorming can be a challenging but important part of creative group problem solving. Mind-mapping has the potential to enhance the brainstorming process but has its own challenges when used in a group. We introduce GroupMind, a collaborative mind-mapping tool that addresses these challenges and opens new opportunities for creative teamwork, including brainstorming. We present a semi-controlled evaluation of GroupMind and its impact on teamwork, problem solving and collaboration for brainstorming activities. GroupMind performs better than using a traditional whiteboard in both interaction group and nominal group settings for the task involving memory recall. The hierarchical mind-map structure also imposes important framing effects on group dynamics and idea organization during the brainstorming process. We also present design ideas to assist in the development of future tools to support creative problem solving in groups.

Our study on a community of knowledge management (KM) practitioners in the aerospace industry reveals challenges in the dissemination of KM concepts and tools. In this paper, we identify four reasons: (1) disparity of the community's stated purpose and the actual motives of its members; (2) multidisciplinary nature of KM; (3) unique characteristics of the aerospace industry and its engineering culture and (4) adoption of preferred or recommended solutions provided by chosen reference groups rather than a grounded approach. In particular, we address the issues in promoting recommended ideas and tools by chosen reference groups in work organizations without fully understanding work practices.

In this paper, we report the findings of an empirical investigation into decision making processes (DMPes) in distributed teams. We conducted the study in a Fortune 500 organization with a total of sixteen respondents who participated in an hour-long interview. Our analysis of the DMP reported by our respondents suggests that there is a strong organizational culture that supersedes local and individual culture. We also found that while decisions are predominately made in consultation with team members, the leader is usually the decision maker regardless of team distribution or size. The role the leader plays in the DMP implies that greater consideration should be given to assigning a team leader and also the DMP in place. It is also significant that we did not find any evidence of support mechanisms to the DMP leading us to conclude that this possibility needs to be explored by the organization. Our data also suggests that the DMP is chosen ad-hoc and is not explicitly articulated in this organization, which may benefit from documentation.

Trust has long been a contentious issue in human endeavours. It is not readily given nor gained, more so when strangers are involved. It often becomes an issue during distributed development where individuals are expected to interact with strangers they may not ldquomeetrdquo during the project lifetime. Trust was spontaneously raised by respondents in an empirical study of practices within distributed development and is reported in this paper. A qualitative analysis of study data suggests that trust typically becomes an issue in large teams when developers are to deliver an innovative product. We also found that it is more likely to be an issue the greater the diversity (of culture, language, time zone...etc.) within the team. Finally the data also suggests that developers more readily trust an authoritative team member (e.g. team leader), even if remote. Data suggests these factors can act as positive and negative forces to influence trust within distributed teams. These forces are reported in this paper together with proposed approaches that can promote equilibrium of the net forces.

The principle of information hiding has been very influential in software engineering since its inception in 1972. This principle prescribes that software modules hide implementation details from other modules in order to reduce their dependencies. This separation also decreases the dependency among software developers implementing these modules, thus simplifying the required coordination. A common instantiation of this principle widely used in the industry is in the form of application programming interfaces (APIs). While previous studies report on the general use and benefits of APIs, they have glossed over the detailed ways in which APIs facilitate the coordination of work. In order to unveil these mechanisms, we performed a qualitative study on how practitioners use APIs in their daily work. Using ethnographic data from two different software development teams, we identified three roles played by APIs in the coordination of software development projects. These roles are described using three metaphors: APIs as contracts, APIs as boundaries, and APIs as communication mechanisms. As contracts, APIs allow software developers to work in parallel and independently. As a communication mechanism, APIs facilitate communication among software developers by giving them something specific to talk about. At the same time, APIs establish the boundaries between developers, and, accordingly, what should be talked about. This paper also reports on problems the studied teams face when using APIs to coordinate their work. Based on these results, we draw theoretical implications for collaborative software engineering.

Different approaches and tools have been proposed to support change impact analysis, i.e., the identification of the potential consequences of a change, or the estimation of what needs to be modified to accomplish a change. However, just a few empirical studies of software developers' actual change impact analysis approaches have been reported in the literature. To minimize this gap, this paper describes an empirical study of two software development teams. It describes, through the presentation of ethnographic data, the strategies used by software developers to handle the effect of software dependencies and changes in their work. The concept of impact management is proposed as an analytical framework to present these practices and is used to suggest avenues for future research in change impact analysis techniques.

In spite of the modularization benefits supported by the Aspect-Oriented programming paradigm, different usability issues have hindered its adoption. The decoupling between aspect definitions and base code, and the compile-time weaving mechanism adopted by different AOP languages, require developers to manage the consistency between base code and aspect code themselves. These mechanisms create opportunities for errors related to aspect weaving invisibility and non-local control characteristics of AOP languages. This paper describes XE (Extreme Editor), an IDE that supports developers in managing these issues in the functional aspect-oriented programming domain.

In this paper, we present results from our empirical evaluations of a workspace awareness tool that we designed and implemented to augment the functionality of software configuration management systems. Particularly, we performed two user experiments directed at understanding the effectiveness of a workspace awareness tool in improving coordination and reducing conflicts. In the first experiment, we evaluated the tool through text-based assignments to avoid interference from the well-documented impact of individual differences among participants, as these differences are known to lessen the observable effect of proposed tools or to lead to them having no observable effect at all. This strategy of evaluating an application in a domain that is known to have less individual differences is novel and in our case particularly helpful in providing baseline quantifiable results. Upon this baseline, we performed a second experiment, with code-based assignments, to validate that the tool's beneficial effects also occur in the case of programming. Together, our results provide quantitative evidence of the benefits of workspace awareness in software configuration management, as we demonstrate that it improves coordination and conflict resolution without inducing significant overhead in monitoring awareness cues.

Ariadne is a novel visualization tool that allows end users to explore the socio-technical relationships in software development projects. Essentially the visualization is a variant of a social network graph. It is based on the observation that dependencies between software components create dependencies between the developers implementing those components. This relationship emerged in our own and other researcherspsila field studies of software projects. Large software development projects require management of dependencies by managers and developers to ensure the smooth coordination of work. We sought to evaluate our visualization to assess its utility. Although we had some informal trials with potential end users, we sought a deeper analysis before further refinement of the tool and evaluation on a larger scale. Usability inspection methods provided one potential avenue. Moreover, such inspection methods yield a kind of rationale not directly derived from human subjects evaluations. We report on the application of these inspection methods and discuss the implications of their results in the context of usability evaluations for visual interfaces.

One of the reasons large-scale software development is difficult is the number of dependencies that software engineers face. These dependencies create a need for communication and coordination that requires continuous effort by developers. Empirical studies, including our own, suggest that technical dependencies among software components create social dependencies among the software developers implementing those components. Based on this observation, we developed Ariadne, a plug-in for Eclipse. Ariadne analyzes software projects for dependencies and collects authorship information about projects relying on configuration management repositories. Ariadne can "translate" technical dependencies among components into social dependencies among developers. We have created visualizations to convey dependency information and the presence of coordination problems identified in our previous work. We believe the information conveyed in the visualizations will prove useful for software developers.

Knowledge management (KM) remains an anomaly in most corporations today. Critics call KM a fad of the 1990s, whereas supporters claim KM is actively evolving. Our work examines the disciplinary rhetoric of KM: how is it that practitioners of KM seek to legitimize their field in the corporate world? We focus on practitioners in the aerospace industry and their forum. We argue that this forum serves as a hub for constructing KM's legitimacy. Our two year ethnography traces the rhetorical strategies utilized by informants in and out of a professional community to legitimize KM as discipline in the aerospace industry.

Workspace awareness has emerged as a new coordination paradigm in configuration management, enabling early detection of potential conflicts by providing developers with information of relevant, parallel activities. The focus of our work is on detecting and mitigating direct and indirect conflicts by sharing information about ongoing code changes. In this paper, we discuss the results of user experiments designed as a broad and formative evaluation of workspace awareness, specifically focusing on whether users detect conflicts as they arise and act to mitigate potential problems. Our results confirm that workspace awareness promotes active self-coordination among users and can lead to an improved end-product in terms of the number of unresolved conflicts remaining in the code.

In this paper we present a tool to facilitate the work of managers of global software development projects. This tool explores the relationship between software dependencies and coordination of work and uses social networks to suggest potential coordination problems for managers. The overall architecture of the tool is described as well as the theoretical and empirical motivations for the tool.

The focus of our approach to the usability considerations of privacy and security has been on providing people with information they can use to understand the implications of their interactions with a system, as well as, to assess whether or not a system is secure enough for their immediate needs. To this end, we have been exploring two design principles for secure interaction: visualizing system activity and integrating configuration and action. Here we discuss the results of a user study designed as a broad formative examination of the successes and failures of an initial prototype based around these principles. Our response to the results of this study has been twofold. First, we have fixed a number of implementation and usability problems. Second, we have extended our visualizations to incorporate new considerations regarding the temporal and structural organization of interactions.

Many studies have evaluated different uses of collaborative software. Typically, the research has focused on the shortcomings and, sometimes, the ways end users succeed or fail to work around these shortcomings. In a recent field study, surprisingly, a group demonstrated unimpaired dexterity using a full range of collaborative software. Some interesting lessons emerged from observing these “perfect ” collaborators. Lessons include implications for more typical or “less than perfect ” end users, especially around the adoption of collaboration technology. Also, there is a general, but subtle, lesson that studying successful users of technology (or “ideal end users ” as we put it) can be as valuable as studying those who struggle with technology and highlight its shortcomings.

In our research, we have been concerned with the question of how to make relevant features of security situations visible to users in order to allow them to make informed decisions regarding potential privacy and security problems, as well as regarding potential implications of their actions. To this end, we have designed technical infrastructures that make visible the configurations, activities, and implications of available security mechanisms. This thus allows users to make informed choices and take coordinated and appropriate actions when necessary. This work differs from the more traditional security usability work in that our focus is not only on the usability of security mechanism (e.g., the ease-of-use of an access control interface), but how security can manifest itself as part of people's interactions with and through information systems (i.e., how people experience and interpret privacy and security situations, and are enabled or constrained by existing technological mechanisms to act appropriately). In this paper, we report our experiences designing, developing, and testing two technical infrastructures for supporting this approach for usable security.

Information hiding is one of the most important and influential principles in software engineering. It prescribes that software modules hide implementation details from other modules in order to decrease the dependency between them. This separation also decreases the dependency among software developers implementing modules, thus simplifying some aspects of collaboration. A common instantiation of this principle is in the form of application programming interfaces (APIs). We performed a field study of the use of APIs and observed that they served many roles. We observed that APIs were successful indeed in supporting collaboration by serving as contracts among stakeholders as well as by reifying organizational boundaries. However, the separation that they accomplished also hindered other forms of collaboration, particularly among members of different teams. Therefore, we think argue that API's do not only have beneficial purposes. Based on our results, we discuss implications for collaborative software development tools.

The theme and title for this panel is inspired by Donald Schon's writings about the reflective practitioner in which he describes professional practice as being a process of reflection in action. Ill-defined problems including design decisions lead to breakdowns, which become opportunities for reflection and modification of practice. This panel seeks to provide ICSE attendees with a broad cross section of the history, state of the art, and open issues with some of the methods and tools directed at supporting reflective software practitioners.

The principle of information hiding has been very influential in software engineering since its inception in 1972. This principle prescribes that software modules hide implementation details from other modules in order to decrease their interdependencies. This separation also decreases the dependency among software developers implementing modules, thus simplifying some aspects of collaboration. A common instantiation of this principle is in the form of application programming interfaces (APIs). We performed a qualitative study on how practitioners use APIs in their daily work. Although particularly interested in aspects of collaboration, we report all findings about their observed use. The findings include mundane observations that are predicted by theory, ways that APIs support collaborative software development. But the findings also include some surprises, ways that APIs hinder collaboration. The surprises indicate directions for further improvement of collaborative software development practices and tools.

Software development is typically cooperative endeavor where a group of engineers need to work together to achieve a common, coordinated result. As a cooperative effort, it is especially difficult because of the many interdependencies amongst the artifacts created during the process. This has lead software engineers to create tools, such as configuration management tools, that isolate developers from the effects of each other's work. In so doing, these tools create a distinction between private and public aspects of work of the developer. Technical support is provided to these aspects as well as for transitions between them. However, we present empirical material collected from a software development team that suggests that the transition from private to public work needs to be more carefully handled. Indeed, the analysis of our material suggests that different formal and informal work practices are adopted by the developers to allow a delicate transition, where software developers are not largely affected by the emergent public work. Finally, we discuss how groupware tools might support this transition.

End users of software have the right to systems that are both useful and usable, a property termed usability in the software and human-computer interaction communities. Unfortunately, it is not obvious what methods or techniques developers of software should adopt in order to achieve good usability in a product. There are a confounding number of questions. How can different points of view among end users be incorporated into a software development process? What does it mean to treat software developers as end users, namely of software tools? How do the limitations of software practice, such as minimizing time to release, affect what information can be collected and used to make usability decisions? This paper presents a variety of possibilities for supporting all the end users' views in a software development activity. Both tools and methods are suggested, roughly organized according to the different activities in software development. Moreover, end users are defined to be a variety of stakeholders in a software development project, including at the very least the end users of a product but also developers who are end users of software tools.

at U.C. Irvine hosted a workshop on the state of the art in automated software engineering. Its goal was to bring together ASE researchers for informal presentations of current work, with the hope of identifying emerging trends and challenges. The workshop started with an invited talk by P. Dourish. His talk pointed out the futility of requirements. In a context of ever evolving requirements, it is mandatory for software to be very adaptable. Automated software engineering may provide a solution to this flexibility demand, especially if deployed on the user’s site. Requirements was actually one the major topics discussed at the workshop with talks by R. Hall and S. Fickas who point out growing challenges of validating requirements and systems. Another major topic is to master the complexity of software engineering tasks and artifacts. This complexity is reflected in the diversity of models and notations used to describe software, tools and knowledge. It also requires the development of efficient tool support and tool infrastructure. These topics were addressed by the talks of J. Grundy, D. Redmiles, S. Henninger, F. Shipman and Y. Ledru. These position papers are available on line 1. The rest of this report gives their abstracts. Abstracts of the position papers

The thorny problem of usability has been recognized in the security community for many years, but has, so far, eluded systematic solution. We characterize the problem as a gap between theoretical and effective levels of security, and consider the characteristics of the problem. The approach we are taking focuses on visibility -- how can we make relevant features of the security context apparent to users, in order to allow them to make informed decisions about their actions and the potential implications of those actions?

The Unified Modeling Language (UML) is a family of design notations that is rapidly becoming a de facto standard software design language. UML provides a variety of useful capabilities to the software designer, including multiple, interrelated design views, a semiformal semantics expressed as a UML meta model, and an associated language for expressing formal logic constraints on design elements. The primary goal of this work is an assessment of UML's expressive power for modeling software architectures in the manner in which a number of existing software architecture description languages (ADLs) model architectures. This paper presents two strategies for supporting architectural concerns within UML. One strategy involves using UML "as is," while the other incorporates useful features of existing ADLs as UML extensions. We discuss the applicability, strengths, and weaknesses of the two strategies. The strategies are applied on three ADLs that, as a whole, represent a broad cross-section of present-day ADL capabilities. One conclusion of our work is that UML currently lacks support for capturing and exploiting certain architectural concerns whose importance has been demonstrated through the research and practice of software architectures. In particular, UML lacks direct support for modeling and exploiting architectural styles, explicit software connectors, and local and global architectural constraints.

Empirical evaluation of software systems in actual usage situations is critical in software engineering. Prototyping, beta testing, and usability testing are widely used to refine system requirements, detect anomalous or unexpected system and user behavior, and to evaluate software usefulness and usability. The World Wide Web enables cheap, rapid, and large-scale distribution of software for evaluation purposes. However, current techniques for collecting usage data have not kept pace with the opportunities presented by Web-based deployment. This paper presents an approach and prototype system that makes large-scale collection of usage data over the Internet a practical possibility. A general framework for comparing software monitoring systems is presented and used to compare the proposed approach to existing techniques.

Software architecture descriptions are high-level models of software systems. Some researchers have proposed special-purpose architectural notations that have a great deal of expressive power but are not well integrated with common development methods. Others have used mainstream development methods that are accessible to developers, but lack semantics needed for extensive analysis. We describe an approach to combining the advantages of these two ways of modeling architectures. We present two examples of extending UML, an emerging standard design notation, for use with two architecture description languages, C2 and Wright. Our approach suggests a practical strategy for bringing architectural modeling into wider use, namely by incorporating substantial elements of architectural models into a standard design method.

Expectation-Driven Event Monitoring (EDEM) provides developers with a platform for creating software agents to collect usage data and increase user involvement in the development of interactive systems. EDEM collects information that is currently lost regarding actual usage of applications to promote improved usability and a more empirically grounded design process.

Software architectures are high-level design representations of software systems that focus on composition of software components and how those components interact.Software architectures abstract the details of implementation and allow the designer to focus on essential design decisions.Regardless of notation, designers are faced with the task of making good design decisions, which demands a wide range of knowledge of the problem and solution domains.Argo is a software architecture design environment that supports designers by addressing several cognitive challenges of design.In this paper we describe how Argo supports decision making by automatically supplying knowledge that is timely and relevant to decisions at hand.

No abstract available.

Object-oriented (OO) technology has been heralded as a solution to the problems of software engineering. The claims are that OO technology promotes understandability, extensibility, evolvabilty, reusability, and maintainability of systems and that OO systems are easy to understand and use. However, this technology has not been as successful as expected. An analysis of experiences and empirical studies reveals that the problem is not the technology per se but that the technology provides no support to software developers in performing the processes the technology requires. We present a cognitive model of software development that details the challenges software developers face in using OO technology. The model focuses on three aspects of software development—evolution, reuse and redesign, and domain orientation. We motivate this model with a variety of firsthand experiences and use it to assess current OO technology. Further, we present tools and evaluations that substantiate parts of this model. The model and tools indicate directions for future software development environment, looking beyond the technological possibilities of OO languages and beyond the context of individual developers and projects.

An approach that embeds human-computer cooperative problem-solving tools into knowledge-based design environments that work in conjunction with human software designers in specific application domains is described. This human-centered approach takes advantage of peoples' ability to understand and incrementally reformulate their problems, while allowing them to contribute to the gradual improvement of the underlying knowledge base. The notion of evolution circumvents the inability of the original builders of a design environment to anticipate all future needs and knowledge for complete coverage of a domain. The access and development of knowledge is supported in a cycle of location, comprehension, and modification. Modification includes the evolution of the knowledge base and tools. A framework for building such tools and mechanisms is described and illustrated in terms of three systems: CATALOGEXPLORER, EXPLAINER, and MODIFIER. User studies of these systems demonstrate the promise and the limitations of the design environment approach.>

Traditional information access systems generally assume that a well-articulated query exists, and that once an object is found, it can be readily understood. Although this assumption works for retrieving text objects, in more complex domains, such as retrieving software objects for reuse, queries must be incrementally constructed and support is needed for comprehending what is retrieved. Therefore, information access methods need support for query construction and relevance evaluation as an integral part of the location process. Two prototype systems are described for supporting this need: CODEFINDER for query construction and EXPLAINER for explanations of program examples. These systems interact to support the processes of locating and comprehending software objects for reuse.