Abstract Group decision‐making (GDM) processes shape the evolution of open source software (OSS) products, thus playing an important role in the governance of open source software communities. While these GDM processes have attracted the attention of researchers, the rationale behind decisions, that is, how decisions are made that enhance the OSS, have not received much attention. This work bridges this gap by extracting these rationales from a large open source repository comprising 1.55 million emails available in Python development archives. This work makes a methodological contribution by presenting a heuristics‐based rationale extraction system called Rationale Miner that employs information retrieval, natural language processing, and heuristics‐based techniques. Using these techniques, it extracts the rationale behind specific decisions (for example, whether a new module was added based on core developer consensus or a benevolent dictator's pronouncement). This work unearths 11 such rationales behind decisions in the Python community and thus makes a knowledge contribution. It also analyzes the prevalence of these rationales across all PEPs and three sub‐types of PEPs: Process, Informational, and Standard Track PEPs. The effectiveness of our contributions has been positively evaluated using quantitative and qualitative approaches (e.g., comparison against baselines for rationale identification showed up to 47% improvement in the most conservative case, and feedback from the Python steering committee showed the accurate identification of rationales respectively). The approach proposed in this work can be used and extended to discover the rationale behind decisions that remain hidden in communication repositories of other OSS projects, which will make the decision‐making (DM) process transparent to stakeholders and encourage decision‐makers to be more accountable.

Social inclusion is a fundamental feature of thriving societies. This paper first investigates barriers for social inclusion in online Software Engineering (SE) communities, by identifying a set of 11 attributes and organising them as a taxonomy. Second, by applying the taxonomy and analysing language used in the comments posted by members in 189 Gitter projects (with > 3 million comments), it presents the evidence for the social exclusion problem. It employs a keyword-based search approach for this purpose. Third, it presents a framework for improving social inclusion in SE communities.

Cross-community learning incorporates data from different sources to leverage task-specific solutions in a target community. This approach is particularly interesting for low-resource or newly created online communities, where data formalizing interactions between agents (community members) are limited. In such scenarios, a normative system that intends to regulate online interactions faces the challenge of continuously learning the meaning of norm violation as communities' views evolve, either with changes in the understanding of what it means to violate a norm or with the emergence of new violation classes. To address this issue, we propose the Cross-community Adapter Learning (CAL) framework, which combines adapters and transformer-based models to learn the meaning of norm violations expressed as textual sentences. Additionally, we analyze the differences in the meaning of norm violations between communities, using Integrated Gradients (IG) to understand the inner workings of our model and calculate a global relevance score that indicates the relevance of words for violation detection. Results show that cross-community learning enhances CAL's performance while explaining the differences in the meaning of norm-violating behavior based on community members' feedback. We evaluate our proposal in a small set of interaction data from Wikipedia, in which the norm prohibits hate speech.

Abstract Good governance practices are pivotal to the success of Open Source Software (OSS) projects. However, the decision‐making processes that are made available to stakeholders are at times incomplete and may remain buried and hidden in large amounts of software repository data. This work bridges this gap by unearthing enacted decision‐making processes available for Python Enhancement Proposals (PEPs) from 1.54 million email messages that embody decisions made during the evolution of the Python language. This work employs a design science approach in operationalizing a framework calledDeMaP minerthat is used to discover hidden processes using information retrieval and information extraction techniques. It also uses process mining techniques to visualize the processes, and comparative structural analysis techniques to compare different decision processes. The work identifies a richer set of decision‐making activities than those reported on the Python website and in prior research work (48 new decision activities, 199 new pathways and 6 new stages). The extracted decision process has been positively evaluated by a prominent member of the Python steering council. The extracted process can be used for process compliance checking and process improvement in OSS communities. Additionally, the DeMaP Miner framework can be extended and customized to suit other OSS projects, such as the OpenJDK project.

Software Engineering (SE) communities such as Stack Overflow have become unwelcoming, particularly through members’ use of offensive language. Research has shown that offensive language drives users away from active engagement within these platforms. This work aims to explore this issue more broadly by investigating the nature of offensive language in comments posted by users in four prominent SE platforms – GitHub, Gitter, Slack and Stack Overflow (SO). It proposes an approach to detect and classify offensive language in SE communities by adopting natural language processing and deep learning techniques. Further, a Conflict Reduction System (CRS), which identifies offence and then suggests what changes could be made to minimize offence has been proposed. Beyond showing the prevalence of offensive language in over 1 million comments from four different communities which ranges from 0.07% to 0.43%, our results show promise in successful detection and classification of such language. The CRS system has the potential to drastically reduce manual moderation efforts to detect and reduce offence in SE communities.

Governance has been highlighted as a key factor in the success of an Open Source Software (OSS) project. It is generally seen that in a mixed meritocracy and autocracy governance model, the decision-making (DM) responsibility regarding what features are included in the OSS is shared among members from select roles; prominently the project leader. However, less examination has been made whether members from these roles are also prominent in DM discussions and how decisions are made, to show they play an integral role in the success of the project. We believe that to establish their influence, it is necessary to examine not only discussions of proposals in which the project leader makes the decisions, but also those where others make the decisions. Therefore, in this study, we examine the prominence of members performing different roles in: (i) making decisions, (ii) performing certain social roles in DM discussions (e.g., discussion starters), (iii) contributing to the OSS development social network through DM discussions, and (iv) how decisions are made under both scenarios. We examine these aspects in the evolution of the well-known Python project. We carried out a data-driven longitudinal study of their email communication spanning 20 years, comprising about 1.5 million emails. These emails contain decisions for 466 Python Enhancement Proposals (PEPs) that document the language’s evolution. Our findings make the influence of different roles transparent to future (new) members, other stakeholders, and more broadly, to the OSS research community.

A sound Decision-Making (DM) process is key to the successful governance of software projects. In many Open Source Software Development (OSSD) communities, DM processes lie buried amongst vast amounts of publicly available data. Hidden within this data lie the rationale for decisions that led to the evolution and maintenance of software products. While there have been some efforts to extract DM processes from publicly available data, the rationale behind 'how' the decisions are made have seldom been explored. Extracting the rationale for these decisions can facilitate transparency (by making them known), and also promote accountability on the part of decision-makers. This work bridges this gap by means of a large-scale study that unearths the rationale behind decisions from Python development email archives comprising about 1.5 million emails. This paper makes two main contributions. First, it makes a knowledge contribution by unearthing and presenting the rationale behind decisions made. Second, it makes a methodological contribution by presenting a heuristics-based rationale extraction system called Rationale Miner that employs multiple heuristics, and follows a data-driven, bottom-up approach to infer the rationale behind specific decisions (e.g., whether a new module is implemented based on core developer consensus or benevolent dictator's pronouncement). Our approach can be applied to extract rationale in other OSSD communities that have similar governance structures.

Open source software (OSS) communities are often able to produce high quality software comparable to proprietary software. The success of an open source software development (OSSD) community is often attributed to the underlying governance model, and a key component of these models is the decision-making (DM) process. While there have been studies on the decision-making processes publicized by OSS communities (e.g., through published process diagrams), little has been done to study decision-making processes that can be extracted using a bottom-up, data-driven approach, which can then be used to assess whether the publicized processes conform to the extracted processes. To bridge this gap, we undertook a large-scale data-driven study to understand how decisions are made in an OSSD community, using the case study of Python Enhancement Proposals (PEPs), which embody decisions made during the evolution of the Python language. Our main contributions are:

Requirements prioritisation deals with the ranking or classification of user requirements based on their importance. This process is central to releasing a software product with features most favoured by users. While studies have explored the efforts that are dedicated to this cause, these tend to focus on a subset of the solutions that are available in the software engineering domain. Current techniques investigated in the software engineering domain do not consider the strengths inherent in requirements prioritisation techniques developed in other disciplines (e.g. product manufacturing), a gap that should be addressed. The authors thus conducted a comprehensive systematic mapping study and critical evaluation of studies that have provided implementations of requirements prioritisation techniques across multiple disciplines (including software engineering, product manufacturing, and engineering). Among their findings, they observed that while many solutions are targeted, quite often researchers have proposed solutions that were not evaluated. Most solutions were only validated as being operational, and the attributes studied had limited effects on performance outcomes. Their evidence suggests that new techniques may address the requirements prioritisation challenge if they are inspired by hybrid approaches developed across multiple disciplines. In addition, performance trade-offs are to be expected of such techniques, depending on their performance targets.

Abstract In recent years, the notion of electrical energy microgrids (MGs), in which communities share their locally generated power, has gained increasing interest. Typically, the energy generated comes from renewable resources, which means that its availability is variable, ie, sometimes there may be energy surpluses and at other times energy deficits. This energy variability can be ameliorated by trading energy with a connected electricity grid. However, since main electricity grids are subject to faults or other outages, it can be advantageous for energy MGs to form coalitions and share their energy among themselves. In this work, we present our model for the dynamic formation of such MG coalitions. In our model, MGs form coalitions on the basis of complementary weather patterns. Our agent‐based model, which is scalable and affords autonomy among the MGs participating in the coalition (agents can join and depart from coalitions at any time), features methods to reduce overall “discomfort” so that, even when all participating MGs in a coalition experience deficits, they can share energy so that their overall discomfort is reduced. We demonstrate the efficacy of our model by showing empirical studies conducted with real energy production and consumption data.

In many open source software development communities, a significant proportion of development is undertaken by a relatively small number of individuals, the "core members". The stability and longevity of this group of most active developers are crucial for the success of the project. While there has been prior work on identifying key individuals in open source development, little attention has been devoted to the identification of cross-cutting core individuals (boundary spanners) whose responsibilities span across different functional areas of open source development (e.g., who are involved both in development-centric activities and user-centric activities). To address this gap, we propose an approach to identify the core cross-cutting members and their roles within the community through analyzing email communication repositories. We use Social Network Analysis (SNA) tools to identify the most active core members in different forums (that have different focus such as Python-dev that focuses on language evolution and Python Lists that focus on user support), and their activities over time, thus identifying the core developers and their involvement in different community mailing lists. Based on the involvement of a core developer and the overall social structure of the network of core developers, we also present an approach for identifying a potential replacement for a community administrator that steps down. Using email repositories of six main Python forums as the case study domain, we computed several social network analysis metrics to characterize the core developers and their importance in the Python community.

Requirements engineering is assessed as the most important phase of the software development process. This process is especially challenging for app developers, who tend to gather crowd-based feedback after releasing their apps. This feedback is often voluminous, posing prioritization challenges for developers identifying features to fix or add. While previous work has identified frequently mentioned features, and some effort has been dedicated towards providing various prioritization and classification techniques, these do not quite address the prioritization challenge faced by app developers given voluminous app reviews. In fact, there is also need to assess the scale of app reviews' usefulness. We use content analysis and regression to contribute towards this cause by exploring the usefulness of app reviews, and the attributes that predict which app features to fix, respectively. Our outcomes show that reviews tended to either provide information of little value (i.e., no actionable information) or highlighted problems that may directly affect the functionality of app features. For two different apps, we also observe that features that were mentioned the most (the feature frequency attribute) in lower ranked reviews provided by users had the strongest predictive power for identifying severely broken features (as perceived by a developer). However, the ordering did not match with the frequency with which reports were made by users. There were also variances in the attributes that predict which features to fix, for the reviews of different apps. Review mining and prioritization challenges remain given variances in app reviews' content and structure. These findings also point to the need to redesign app review interfaces to consider how reviews are captured.

Platforms such as Stack Overflow are available for software practitioners to solicit help and solutions to their challenges and knowledge needs. This community's practices have in recent times however caused quality-related concerns. Academic work tends to provide validation for the practice and processes of these forums, however, previous work did not review the scale of scientific attention that is given to this cause. We conducted a Systematic Mapping study involving 266 papers from six relevant databases to address this gap. In this preliminary work we explored the level of academic interest Stack Overflow has generated, the publication venues, the topics studied and approaches used. Outcomes show that Stack Overflow has attracted increasing research interest, with topics relating to both community dynamics and human factors, and technical issues. In addition, research studies have been largely evaluative or proposed solutions, though this latter approach tends to lack validation. This signals the need for future work to explore the nature of Stack Overflow research contributions that are provided, and their quality. We outline our research agenda for continuing with such efforts.

Context: Open Source Software (OSS) developers use mailing lists as their main forum for discussing the evolution of a project. However, the use of mailing lists by developers for decision-making has not received much research attention. Objective: We have explored this issue by studying developers' email discussions around Python Enhancement Proposals (PEPs). Method: Our dataset comprised 42,672 emails from six different mailing lists pertaining to PEP development. We performed multiple forms of analysis on these emails, involving both quantitative measures (e.g., frequency) and deeper analysis of specific PEP discussions (i.e., outlier analysis). Results: Out of three PEP types (Informational, Process and Standard Track), Standard Track PEPs attract a large amount of discussion (both in volume and average number of messages per proposal). Our study also identified specific PEP states and topics that generated a disproportionate amount of discussion. Conclusion: Our outcomes point to several opportunities for improving the management of an OSS team based on the knowledge generated from discussions. We have also identified several interesting avenues for future work such as identifying individuals or groups that present persuasive arguments during decision-making.

User-reviews of mobile applications provide information that benefits other users and developers. Even though reviews contain feedback about an app's performance and problematic features, users and app developers need to spend considerable effort reading and analyzing the feedback provided. In this work, we introduce and evaluate QuickReview, an intelligent user interface for reporting problematic app features. Preliminary user evaluations show that QuickReview facilitates users to add reviews swiftly with ease, and also helps developers with quick interpretation of submitted reviews by presenting a ranked list of commonly reported features.

The process by which norms are developed to become policies, the normative decision-making process, is not often explicit to stakeholders of Open Source Software (OSS) projects. Understanding the normative decision-making process is crucial for members if such projects are to evolve and succeed. In this paper, we investigated aspects of the normative decision-making processes of OSS development through the use of Python Enhancement Proposals (PEPs). We compared extracted process models with those that are advertised by the Python community to evaluate the extent to which those processes overlap. In addition, we assess members' involvement and contribution to these processes. Our work used structural and behavioral analysis techniques, and social network analysis metrics. We found that there were differences between the extracted processes and Python's advertised process, with the extracted processes being significantly more complex. These differences also extended to granular models used for managing social and technical aspects of the Python project. Furthermore, some key members were largely responsible for PEPs' success. Our extracted models could go a far way in helping the Python community to quickly understand decision-making processes in Python.

App reviews contain valuable feedback about what features should be fixed and improved. This feedback could be 'mined' to facilitate app maintenance and evolution. While requirements are routinely extracted from post-release users' feedback in traditional projects, app reviews are often generated by a much larger client-base with competing needs and priorities and ad hoc structure. Although there has been interest aimed at exploring the nature of issues reported in app reviews (e.g., bugs and enhancement requests), prioritizing these outcomes for improving and evolving apps hasn't received much attention. In this preliminary study we aim to bridge this gap by proposing three prioritization approaches. Driven by literature in other domains, we identify four attributes (frequency, rating, negative emotions and deontics) that serve as the base constructs for prioritization. Thereafter, using these four constructs, we develop three approaches (individual attribute-based approach, weighted approach and regression-based approach) that may help developers to prioritize features for improvements. We evaluate our approaches in constructing multiple prioritized lists of features using reviews from the MyTracks app. It is anticipated that these prioritized lists could allow developers to better focus their efforts in deciding which aspects of their apps to improve.

When entering a system, an agent should be aware of the obligations and prohibitions (collectively norms) that affect it. Existing solutions to this norm identification problem make use of observations of either norm compliant, or norm violating, behaviour. Thus, they assume an extreme situation where norms are typically violated, or complied with. In this paper we propose a Bayesian approach to norm identification which operates by learning from both norm compliant and norm violating behaviour. We evaluate our approach's effectiveness empirically and compare its accuracy to existing approaches. By utilising both types of behaviour, we not only overcome a major limitation of such approaches, but also obtain improved performance over the state of the art, allowing norms to be learned with fewer observations.

Open Source Software Development (OSSD) often suffers from conflicting views and actions due to the perceived flat and open ecology of an open source community. This often manifests itself as a lack of codified knowledge that is easily accessible for community members. How decisions are made and expectations of a software system are often described in detail through the many forms of social communications that take place within a community. These social interactions form norms which are influential in dictating what behaviors are expected in a community and of the system. In this paper, we provide a tool which mines these social interactions (in the form of bug reports) and extract norms of the system, externalizing this information into a codified form that allows others within the community to be aware of without having witnessed the social interactions.

Social norms facilitate coordination and cooperation among individuals, thus enable smoother functioning of social groups such as the highly distributed and diverse open source software development (OSSD) communities. In these communities, norms are mostly implicit and hidden in huge records of human-interaction information such as emails, discussions threads, bug reports, commit messages and even source code. This paper aims to introduce a new line of research on extracting social norms from the rich data available in software repositories. Initial results include a study of coding convention violations in JEdit, Argo UML and Glassfish projects. It also presents a new life-cycle model for norms in OSSD communities and demonstrates how a number of norms extracted from the Python development community follow this life-cycle model.

In this paper we describe how our previously proposed role model agent mechanism for norm emergence can be applied to artificial agent societies with network topologies that are changing dynamically. Dynamically changing network topologies account fo

Rapid changes in the business environment call for more flexible and adaptive workflow systems. Researchers have proposed that workflow management systems (WfMSs) comprising multiple agents can provide these capabilities. We have developed a multi-agent based workflow system, JBees, which supports distributed process models and the adaptability of executing processes. Modern workflow systems should also have the flexibility to integrate available Web services as they are updated. In this paper, we discuss how our agent-based architecture can be used to bind and access Web services in the context of executing a workflow process model. We use an example from the diamond processing industry to show how our agent architecture can be used to integrate Web services with WfMSs.