Software developers use computers not only for writing programs — they also use them to communicate and collaborate with one another. Software development is very much a social activity: collaboration and communication activities can have a powerful impact on the success of software projects.
Computer-support for these activities is not restricted to remote companies or distributed projects — even co-located teams use software that supports group communication and collaboration in their daily work.
The first mention of using a computer for human interaction was in 1945, in Vannevar Bush’s essay As We May Think. Bush describes a device he calls the memex. The memex provides access to a large encyclopedia that humans can influence and shape, allowing them to exchange data with another. Another milestone publication is an article by Licklider and Taylor from 1968, in which the authors describe how a computer can be used for communication.
In the same year, Douglas Engelbart presented what many people today call “The Mother Of All Demos” — a demonstration of what were cutting edge research projects back then, all things we take granted (and I use almost daily) today: video conferencing, hypermedia, a collaborative real-time editor, and many more:
Computer-Supported Cooperative Work — CSCW — is a line of research concerned with how social interactions — communication, collaboration, or coordination — are influenced by technical systems. In the 1970s, it became clear that computers were needed to support collaboration. However, research in computer science and software engineering was not yet prepared to answer what the requirements for such a system should be. Knowing how to build software was not enough — some understanding of how people interact and collaborate was missing.
In this situation, Irene Greif and Paul Cashman organized a CSCW workshop, which would coin the term CSCW for a discipline that works in understanding such requirements. Whereas research in this area is referred to as CSCW, the technology and systems that implement CSCW concepts are often called groupware.
Ellis et al. define groupware as follows:
“Computer-based systems that support groups of people engaged in a common task (or goal) and that provide an interface to a shared environment” are called groupware.
The goal of groupware is to support communication, collaboration, and coordination for groups of people.
This definition of groupware does not provide a clear-cut differentiator. Instead, groupware is regarded as a continuum along multiple dimensions, two of which are the common task and the shared workspace.
These dimensions can be used to classify an application on the groupware spectrum. For example, because of missing environmental cues, email is considered to be low on the groupware spectrum. Conversely, a collaborative text editor is high on the groupware spectrum, as it supports a group achieving a common task: creating, editing, or reviewing a document.
Grudin mentions the organization as the largest entity that could be the subject of CSCW, respectively groupware. However, since his definition, another type of systems has emerged that is also relevant to CSCW research: social media, which often encompass whole communities and are not focused on supporting their users to achieve a common task.
So that we can talk about social media, let’s consider first what media are:
Media are storage and transmission channels or tools used to store and deliver information or data.
Social media, then, are those media that allow exchanges between large numbers of users.
By the way: you should follow me on Twitter here.
Modern social media are often implemented as web sites or smartphone apps. Kietzmann et al. provide an overview of the functional building blocks that can be found in social media, noting that not every social media service will contain every building block:
- Identity lets users disclose information about themselves to other users.
- Conversations support communication between users of the social medium.
- Sharing allows users to exchange, distribute, and receive content.
- Presence enables users to know how accessible another users is — e.g. with regard to their geographical location or the task they are currently working on.
- Relationships allow users to create connections between themselves that are persisted in the social medium.
- Reputation lets users estimate others’ and their own standing among their peers.
- Groups allow users to form sub-communities.
Social media are available for a variety of purposes. For example, content repositories allow users to exchange a certain type of content — e.g. music, videos, or photographs — with one another. YouTube is an example for a content repository for videos. Microblogs, such as Twitter, let users post short texts in a public space. Question & answer (Q&A) sites (e.g. Stack Overflow) let users post and answer questions, sometimes focused on a specific topic. Social network sites (SNS) like Facebook are focused on letting users create relationships between each other. Social coding sites such as GitHub are a combination of content repositories and social network sites targeted at software developers.
Social network sites are particular, as their defining features can be added to any other social media site. Ellison and boyd define SNS as follows:
“A social network site is a networked communication platform in which participants 1) have uniquely identifiable profiles that consist of user-supplied content, content provided by other users, and/or system-provided data; 2) can publicly articulate connections that can be viewed and traversed by others; and 3) can consume, produce, and/or interact with streams of user-generated content provided by their connections on the site.”
Thus, from the examples mentioned before, GitHub is a social network site: members of the site have a profile; they can follow other users and inspect whom another user follows; and they are provided with a stream of updates from users and projects they follow on the site. Whereas Stack Overflow, the Q&A site for software developers, does not allow persistent connections between users. Thus, Stack Overflow is not a social network site.
Modeling Social Cues
When creating groupware, social media, or related systems, it is important to appropriately support social processes. One set of approaches to this is concerned with modeling social cues — signals that are taken for granted in interactions that take place in the physical world, but are not available by default when interacting through computer systems.
For example, colleagues who are co-located in an office room and are working on reorganizing the chapters of a book by physically rearranging hard copies will notice when one of them picks up a chapter. This allows them to react, for example by preventing the colleague to do so because they disagree wit the change. Below, I’ll discuss research areas that are concerned with making such social cues explicit in computer systems.
In supporting communication, collaboration, and coordination, awareness support has become an important tool. Dourish and Bellotti first defined it as “an understanding of the activities of others, which provides a context for your own activity.”
Today, CSCW distinguishes the following different types of awareness:
- Group awareness informs members of a collaborating team about what other members are working on and what their current status is.
- Workspace awareness refers to information about a team’s shared workspace, often presented in a spatial manner. This can include artifacts, their editing histories, and the availability of team members.
- Contextual awareness can be provided in addition: based on the current context, it filters the available awareness information to contain only that which is relevant to the user in their current context (e.g. their location, current task, or most closely worked with colleagues).
- Peripheral awareness — similar to contextual awareness — refers not to an additional kind of awareness information, but to a way of displaying existing information. A system supporting peripheral awareness displays awareness information not as a central entity, but in the periphery of a user’s workspace, allowing them to concentrate on their current task, but providing a space to switch to for awareness information.
Many modern awareness systems automatically collect and publish awareness information about an individual. Therefore, a recurring issue is the amount of awareness information a system should provide. Too much information could overwhelm users, but too little information might cease to be useful. This is likely a trade-off that must be balanced for each application, kind of task, and social context.
To choose which social cues to model in a system and how to represent them, Erickson et al. argue that the physical world should be the reference. This is where humans have evolved their capabilities to interpret social signals, therefore computer systems should be designed so that these capabilities can assist users of computer systems as well. This approach is called social translucence, referring to making some social cues visible, but hiding others that would disturb the users’ goals.
Erickson et al. distinguish three aspects in their approach: visibility makes social cues explicit; this creates awareness; and awareness, in turn, creates accountability. Relating to the example about rearranging book chapters above, making the act of picking up a book chapter chapter visible would make colleagues aware of it. The colleague picking up the chapter would know that her colleagues are aware of it, creating accountability.
Social Translucence Over Social Networks
Social translucence was created with the physical world as the ideal space after which to model computer systems. However, according to Gilbert, this approach breaks down in social media and on social network sites. These systems are structured by their users’ social networks — the connections between them — which have no equivalent in the physical world.
Even though this allows these systems to scale, it also creates problems that cannot easily be addressed by social translucence.
Gilbert provides an extension of social translucence that allows addressing such problems even when social networks are used to structure group communication. His approach, for now, is based on a consideration of triads in social networks — relationships between three actors, in this case as a directed graph. By listing the possible configurations and examining them with regard to one of the three traits from social translucence (visibility; awareness; accountability), Gilbert’s approach discovers design problems that have not yet been addressed.
As another approach to address the shortcomings of social translucence with regard to social media, Stuart et al. created their social transparency framework. It is a theoretical framework that can guide the design and analysis of software systems through which individuals communicate, collaborate, or coordinate.
The authors identify three dimensions of transparency that can be used to increase or decrease the perceived degree of transparency of a system. Changes in each of the dimensions can affect the social processes supported by a system in several ways.
- Identity Transparency is the degree to which the identity of the participants of an information exchange is visible to other participants. Users might be completely anonymous, identifiable only by nicknames, or by their real names. Reputation signals may help in identifying the credibility of a participant. For example, software developers use identity cues present in social media to assess each other, informing their decisions of whether to initiate a collaboration or not.
- Content Transparency refers to “the visibility of the origin and history of actions taken on information.” That is, for content in a software system, it describes the degree to which the recipient can determine the source of the content, which states it was in before, and which users were responsible for these states. For example, the social coding site GitHub displays all prior versions of an artifact and connects them to the users responsible for them.
- Interaction Transparency is the degree to which information exchanges between a sender and a receiver can be observed by a third party. For example, Twitter users are able to passively follow exchanges between other users they follow.
Different degrees of transparency in these three dimensions can have diverse effects. For example, users that have to use their real names in a software system will feel more accountable for their actions, but might also be more reluctant to post controversial opinions. Receivers of content will interpret information differently based on where it came from, so the presence or absence of reputation signals will influence the credibility of a source.
In addition to such first order effects, second order effects — i.e., effects of effects — complicate the targeted application of transparency. For example, if the popularity of information and information sources is transparent, a community of users may tend to prefer only popular content, thereby silencing niche opinions.
Among these effects, it has been shown that the motivations and behaviors of a system’s users can be influenced positively. For example, users of social network sites are more likely to engage in a behavior if they have observed their peers exhibiting the behavior before. Publicly visible extrinsic rewards such as badges or public ranking lists can motivate developers to try out new practices and technologies.
These and similar effects can be used in a systematic manner to, for example, improve the adoption of software engineering practices.
CSCW in Software Engineering
I’ll now discuss existing approaches from software engineering that use the modeling of social cues in collaboration systems to support software development.
Several features known from groupware and mentioned above are present in collaboration tools for software engineering. Here are some examples:
Awareness support in distributed development: Steinmacher et al. conducted a systematic literature review about awareness support for distributed software development. They find that collaboration tools supporting awareness features are becoming more numerous. Coordination is supported by the most tools, a communication focus however is less prominent. Workspace awareness elements play a central role in distributed software development.
Awareness through dashboards and feeds: In an industry study by Treude et al., the authors investigate the use of dashboards and feeds in software development. They find that these tools increase awareness in projects. Dashboards support individual as well as collective processes. Feeds are rather used to track work at a small scale.
Trust in distributed teams: Because of cultural differences, distributed teams encounter challenges in building up trust. Even though it can build up in the co-located teams of a distributed project’s sites, trust between sites can be hard to achieve. According to Mikawa et al., informal conversations and spontaneous brainstorming are some key factors that support building up trust, but are not supported by the often task-driven collaboration tools. For example, developers will only initiate video conferences to achieve certain goals, leaving no room for informal talk that could support inter-site trust. As we’ve seen previously, such informal communication can be facilitated by modeling social cues.
Collaboration tools for distributed development: Lanubile et al. provide an overview of collaboration tools used in global software engineering. While they mention the important part social media can play in facilitating informal communication, they also present several more traditional collaboration tools. The authors discuss web-based tools for requirements engineering, software design, and testing — demonstrating that collaboration tools exist for many areas of software engineering.
Stakeholder involvement for requirements engineering: Lohmann et al. created a Web platform to support requirements engineering activities. Namely, their system implements several features known from social media to increase stakeholders’ engagement in requirements engineering. As it is targeted at the earlier stages of requirements gathering and discussion, the system uses social media features such as commenting and rating to foster informal exchanges.
Conflict detection and notifications for coordination: Brun et al. present a tool that can detect possible collaboration conflicts in version control repositories. When the tool detects a new commit from another developer that could create a conflict with the work of the tool’s user, it provides a warning. This workspace awareness enables software developers to avoid conflicts in using version control.
Peripheral visualizations for coordination: Lanza et al. present a set of visualization that provide awareness information to developers. Similar to the approach by Brun et al., their tool enables developers to become aware of possible merge conflicts in a shared codebase. However, instead of technically detecting possible conflicts, Lanza et al. provide visualizations that are present in developers’ peripheral workspace at all times. These visualizations allow developers to realize when someone else is working on the same code, and according to a qualitative study are effective in prompting discussion between developers — thereby avoiding complicated merge conflicts.
Expert discovery based on source code involvement: Guzzi and Begel present CARES, a collaboration tool integrated into the IDE that helps software developers find and communicate with experts on the source code they are currently working on. The authors find that their tool makes it easier and faster for developers to find and contact others who might be able to help them with a problem. This was especially the case when developers did not know whom they should contact. And by now, “reviewer suggestions” are a regular feature of GitHub’s pull requests:
Communication and knowledge management in issue trackers: Bertram et al. investigated the use of issue trackers in co-located software development. According to the authors, issue trackers are used to communicate and coordinate work with involvement from diverse stakeholders, such as customers, project managers, quality assurance, and the developers themselves. Even though the primary use case for an issue tracker seems to be tracking defects and providing prioritized task lists, Bertram et al. find that they serve as important repositories of organizational knowledge.
Social media have changed how developers create software. Software engineers connect with, provide help to, collaborate with, and learn from one another with unprecedented ease. Relatedly, Begel et al. show that social media can support team processes in software engineering. I’ll now give a few examples of social media used in software engineering:
Collaborative documentation: Wikis and blogs were among the first social media that were used by software developers. They are mostly used for requirements engineering, documentation, and to communicate high-level concepts. Blogs and Q&A sites facilitate collaborate learning and augment official API documentation.
Microblogs: Twitter can help developers stay aware of bleeding edge technologies, learn tools and practices, and connect with peers. Some developers consciously use several strategies to manage noise and volume.
Question & Answer Sites: Stack Overflow is a Question & Answer Site targeted at software developers. Members can post questions, provide answers and comments, and rate both questions and answers. The site uses gamification concepts — “the use of game design elements in non-game contexts” — to encourage and reward participation. Remarkably, a question asked on the site has a median answer time of 11 minutes in 2011.
Social coding sites: GitHub and similar sites provide source code hosting with version control for software developers. However, these sites are also social network sites and provide a high degree of social transparency. Members are able to easily find out who they are interacting with, whom everyone else is interacting with, and who has interacted with which artifacts. This transparency influences the behavior of software developers. For specific software engineering practices, the social transparency found on GitHub can have a large impact: e.g., it can help communicating requirements for tests, and can prompt and motivate developers to provide tests with their contributions.
Developer profile aggregators: Using all the data that is available about an individual online, sites like Masterbranch and Coderwall create aggregate profiles for software developers. These sites use gamification to motivate developers to try out new technologies and allow them to discover new contacts and technologies.
To support social processes, designers of collaboration systems attempt to model social cues. Awareness and social translucence are useful approaches for systems restricted to a certain number of users, but break down when social networks are used to structure applications — as is often the case in social media, for example. Social transparency is a theoretical framework for designing and analyzing such systems.
Many tools and services supporting social processes are already used in software development: in open source projects, but also by people working in the same building or even in the same room. With remote work on the rise, understanding how to build and use collaboration tools will become ever more important.
But the tools are just one aspect.
How do we build organizations that can thrive in a remote setup? What strategies, practices, and methods do we need to create and keep alive the company culture that we want?
Have you ever worked remotely? How has that influenced how you work? If you’ve always worked in a physical office — how do the collaboration tools you use change what you do?
I’m excited to learn more — what are your experiences? Please share them below. ❤️