Search

Commercial participation continues to grow in open source software (OSS) projects and novel arrangements appear to emerge in company-dominated projects and ecosystems. What is the nature of these novel arrangements? Does volunteers’ participation remain critical for these ecosystems? Despite extensive research on commercial participation in OSS, the exact nature and extent of company contributions to OSS development, and the impact of this engagement may have on the volunteer community have not been clarified. To bridge the gap, we perform an exploratory study of OpenStack: a large OSS ecosystem with intense commercial participation. We quantify companies’ contributions via the developers that they provide and the commits made by those developers. We find that companies made far more contributions than volunteers and the distribution of the contributions made by different companies is also highly unbalanced. We observe eight unique contribution models based on companies’ commercial objectives and characterize each model according to three dimensions: contribution intensity, extent, and focus. Companies providing full cloud solutions tend to make both intensive (more than other companies) and extensive (involving a wider variety of projects) contributions. Usage-oriented companies make extensive but less intense contributions. Companies driven by particular business needs focus their contributions on the specific projects addressing these needs. Minor contributors include community players (e.g., the Linux Foundation) and research groups. A model relating the number of volunteers to the diversity of contribution shows a strong positive association between them.

Communication when submitting patches (CSP) is critical in software development, because ineffective communication wastes the time of developers and reviewers, and is even harmful to future product release and maintenance. In distributed software development, CSP is usually in the form of computer-mediated communication (CMC), which is a crucial topic concerned by the CSCW community. However, what to say and how to say in communication including CSP has been rarely studied. To bridge this knowledge gap and provide relevant guidance for developers to conduct CSP, in this study, we conducted an empirical study on the Linux kernel. We found four themes involving 17 expression elements that characterize what to express when submitting patches and three themes of contextual factors that determine how these elements are applied. Considering both expression elements and context, combined with an online survey, we obtained 17 practices for communication. Among them, four practices, such as "provide sufficient reasons" and "provide a trade-off" are the most important but difficult practices, for which we provide specific instructions. We also found that the "individual factors" plays a special role in communication, which may lead to potential problems even in accepted patches. Based on these findings, we discuss the recommendations for different practitioners, including patch submitters, reviewers, and tool designers, and the implications for open source software (OSS) communities and the CSCW researchers.

With the continuous development of the internet, software development (especially global open-source development) is facing critical challenges, such as individual differences in developers distributed worldwide, the increasing difficulty of group collaboration, and the complex ecosystems formed by extensive social participation. These problems exhibit strong sociological characteristics in regard to the activity of software development. This study proposes the concept of software digital sociology that involves mining abundant software-activity data to investigate individual learning, group collaboration, and sustainable ecosystems. We discuss the primary investigation of the critical issues associated with the open-source supply chain and suggest that software digital sociology can inspire software-development researchers to understand the key challenges posed by extensive (computer-mediated) social participation to promote exploration of solutions using a different paradigm.

With the rise of open-source software and package hosting platforms, reusing 3rd-party libraries has become a common practice. Due to various failures during software evolution, a project may remove a used library and replace it with another library, which we call library migration. Despite substantial research on dependency management, the understanding of how and why library migrations occur is still lacking. Achieving this understanding may help practitioners optimize their library selection criteria, develop automated approaches to monitor dependencies, and provide migration suggestions for their libraries or software projects. In this paper, through a fine-grained commit-level analysis of 19,652 Java GitHub projects, we extract the largest migration dataset to-date (1,194 migration rules, 3,163 migration commits). We show that 8,065 (41.04%) projects having at least one library removal, 1,564 (7.96%, lower-bound) to 5,004 (25.46%, upper-bound) projects have at least one migration, and a median project with migrations has 2 to 4 migrations in total. We discover that library migrations are dominated by several domains (logging, JSON, testing and web service) presenting a long tail distribution. Also, migrations are highly unidirectional in that libraries are either mostly abandoned or mostly chosen in our project corpus. A thematic analysis on related commit messages, issues, and pull requests identifies 14 frequently mentioned migration reasons (e.g., lack of maintenance, usability, integration, etc), 7 of which are not discussed in previous work. Our findings can be operationalized into actionable insights for package hosting platforms, project maintainers, and library developers. We provide a replication package at https://doi.org/10.5281/zenodo.4816752.

As a renewable source, solar energy plays an important role in meeting energy demand for human beings and in relieving global warming. In this paper, the concentrated solar heat is utilized to drive the high-endothermic methane reforming with carbon looping. In so doing, the process increases the utilization of CO2 and reduces the carbon emissions as well as saves the extra fuel consumption for combustion, leading to high efficiency of energy utilization. By optimizing this proposed system, the energy efficiency can reach approximate 67.13% with simultaneously reducing CO2 emissions by 34.98% compared with SMR process. Exergy analysis is used to assess the location of irreversibility within process. The maximal part of exergy destroyer was localized in reformer with a contribution of 68%. In addition, the effects of hourly variation of direct normal irradiation on thermodynamic performance and methane conversion on the four typical days (spring equinox, summer solstice, autumn equinox, winter solstice) were analyzed in this work. The current work might be insightful for solar-hydrogen production field.

The wide adoption of third-party libraries in software projects is beneficial but also risky. An already-adopted third-party library may be abandoned by its maintainers, may have license incompatibilities, or may no longer align with current project requirements. Under such circumstances, developers need to migrate the library to another library with similar functionalities, but the migration decisions are often opinion-based and sub-optimal with limited information at hand. Therefore, several filtering-based approaches have been proposed to mine library migrations from existing software data to leverage "the wisdom of crowd," but they suffer from either low precision or low recall with different thresholds, which limits their usefulness in supporting migration decisions.In this paper, we present a novel approach that utilizes multiple metrics to rank and therefore recommend library migrations. Given a library to migrate, our approach first generates candidate target libraries from a large corpus of software repositories, and then ranks them by combining the following four metrics to capture different dimensions of evidence from development histories: Rule Support, Message Support, Distance Support, and API Support. We evaluate the performance of our approach with 773 migration rules (190 source libraries) that we borrow from previous work and recover from 21,358 Java GitHub projects. The experiments show that our metrics are effective to help identify real migration targets, and our approach significantly outperforms existing works, with MRR of 0.8566, top-1 precision of 0.7947, top-10 NDCG of 0.7702, and top-20 recall of 0.8939. To demonstrate the generality of our approach, we manually verify the recommendation results of 480 popular libraries not included in prior work, and we confirm 661 new migration rules from 231 of the 480 libraries with comparable performance. The source code, data, and supplementary materials are provided at: https://github.com/hehao98/MigrationHelper.

Context. As a novel coronavirus swept the world in early 2020, thousands of software developers began working from home. Many did so on short notice, under difficult and stressful conditions. Objective. This study investigates the effects of the pandemic on developers' wellbeing and productivity. Method. A questionnaire survey was created mainly from existing, validated scales and translated into 12 languages. The data was analyzed using non-parametric inferential statistics and structural equation modeling. Results. The questionnaire received 2225 usable responses from 53 countries. Factor analysis supported the validity of the scales and the structural model achieved a good fit (CFI = 0.961, RMSEA = 0.051, SRMR = 0.067). Confirmatory results include: (1) the pandemic has had a negative effect on developers' wellbeing and productivity; (2) productivity and wellbeing are closely related; (3) disaster preparedness, fear related to the pandemic and home office ergonomics all affect wellbeing or productivity. Exploratory analysis suggests that: (1) women, parents and people with disabilities may be disproportionately affected; (2) different people need different kinds of support. Conclusions. To improve employee productivity, software companies should focus on maximizing employee wellbeing and improving the ergonomics of employees' home offices. Women, parents and disabled persons may require extra support., Comment: 34 pages, 7 tables, 5 figures, to appear in Empirical Software Engineering

We design and theoretically investigate a surface-enhanced Raman scattering (SERS) sensor based on the hybrid plasmonic grating slot waveguide. The sensor is formed by combining a dielectric deep slot waveguide and a metallic grating slot waveguide. The proposed sensor exhibits a high field enhancement with a maximum enhancement factor of 7580.9 at the wavelength of 785 nm, revealing that the electric field in such hybrid plasmonic grating slot waveguide can be extremely strengthened. To better characterize the performance of the sensor in the SERS application, the total normalized volumetric enhancement factor (TNVEF) is proposed, which is determined by both the | E | 4 -approximation-based volumetric field enhancement and Raman scattered light collection efficiency. The TNVEF is utilized to characterize the influences of the structural parameters on the sensor and further optimize the sensing structure. Such on-chip SERS sensor can be integrated with a micro-laser and a micro-multiplexer on a photonic platform to realize an all-integrated on-chip SERS detection system.

We introduce the convolutional neural network (CNN) to extract the effective information of some complex signals in the fiber sensing, and verify the feasibility in the specific process of fiber Bragg grating (FBG) demodulation. In the experiments, in order to eliminate the cross interference in the energized coil, classical double grating configuration is adopted to distinguish magnetic field and temperature. At the same time, the introduction of thermal induced chirp (TIC) phenomenon produces more wavelength components to achieve more precise demodulation. The signal received by oscilloscope presents complex waveform, and the traditional analytical solution cannot demodulate it precisely, while the deep learning capabilities of neural networks can be leveraged to solve this problem. The one-dimensional (1D) time-series signal is transformed into a two-dimensional (2D) image by using the Gramian angle field (GAF) method. On this basis, the data are augmented according to the characteristics of signal noise. Five classical neural network structures are used to process the data. The root mean square errors (RMSEs) of the demodulation results can achieve 0.3 °C and 17.1 Gs respectively, which are relatively high precision in terms of intensity demodulation. This method can be extended to demodulate 1D frequency domain signals and wavelength domain signals, rendering a demodulation scheme to process some complex signals in optical fiber sensing effectively.

Simultaneous alternating current (AC) and direct current (DC) measurement is demonstrated with a new fiber sensor that combines fiber Bragg gratings (FBGs) with giant magnetostrictive materials (GMMs). Deformation of GMMs, proportional to the central wavelength shift of FBGs, is different when applying DC and AC to a solenoid where the whole sensing structure is located. DC introduces a constant deformation while AC causes a periodic variation. Therefore, the central wavelength of FBG has a periodic harmonic variation, which makes it possible to demodulate the values of DC and AC at the same time. In addition, the proposed method has potential significance for reducing temperature cross talk caused by the thermal sensitivity of FBGs. The experimental results show that the sensitivity of the AC current can reach up to 0.090576 nm/A in the range of 0 to 1 A, and in different AC environments, the sensitivity of the DC current can reach up to 0.2378 nm/A.

Resolving issues is an essential part of Free/Libre and Open Source Software (FLOSS) development. For large and active projects, there could be hundreds of new issues reported every month, which have mixed quality. To deal with this complexity, the projects developed different protocols of resolving issues (i.e., issue workflows). To help understand existing practice and develop best practice, it’s important to explore how the workflow evolves in the history, e.g., under what circumstances a particular workflow emerges, how efficient and effective it is and whether it can be improved. We build Issue Workflow Explorer (IWE) to help practitioners seek answers. Based on ubiquitous records in issue tracking system, IWE provides functionalities of discovering workflows, quantifying, visualizing and comparing their efficiency and effectiveness. We demonstrate IWE’s effectiveness with two large OSS projects, Mozilla and GNOME. We explore what workflows there are for issue triaging and handling of incomplete issues. We obtain helpful insights for future development, e.g., triage conducted by reporters themselves should be restricted and it is not cost-effective to keep incomplete issue reports open.

Issue tracking data have been used extensively to aid in predicting or recommending software development practices. Issue attributes typically change over time, but users may use data from a separate time of data collection rather than the time of their application scenarios. We, therefore, investigate data leakage, which results from ignoring the chronological order in which the data were produced. Information leaked from the "future" makes prediction models misleadingly optimistic. We examine existing literature to confirm the existence of data leakage and reproduce three typical studies (detecting duplicate issues, localizing issues, and predicting issue-fix time) adjusted for appropriate data to quantify the impact of the data leakage. We confirm that 11 out of 58 studies have leakage problem, while 44 are suspected. We observe biased results caused by data leakage while the extent is not striking. Attributes of summary, component, and assignee have the largest impact on the results. Our findings suggest that data users are often unaware of the context of the data being produced. We recommend researchers and practitioners who attempt to utilize issue tracking data to address software development problems to have a full understanding of their application scenarios, the origin and change of the data, and the influential issue attributes to manage data leakage risks.

Code retrieval and summarization are two tasks often employed by software developers to reuse code that spreads over online repositories. In this paper, we present a neural framework that allows bidirectional mapping between source code and natural language to improve these two tasks. Our framework, BVAE, is designed to have two Variational AutoEncoders (VAEs) to model bimodal data: C-VAE for source code and L-VAE for natural language. Both VAEs are trained jointly to reconstruct their input as much as possible with regularization that captures the closeness between the latent variables of code and description. BVAE could learn semantic vector representations for both code and description and generate completely new descriptions for arbitrary code snippets. We design two instance models of BVAE for retrieval and summarization tasks respectively and evaluate their performance on a benchmark which involves two programming languages: C# and SQL. Experiments demonstrate BVAE’s potential on the two tasks.

Because of the increasing acceptance and possibly expanding market of free/libre open source software (FLOSS), the spectrum and scale of companies that participate in FLOSS development have substantially expanded in recent years. Companies get involved in FLOSS projects to acquire user innovations [3, 12], to reduce costs [8, 11], to make money on complementary services [13], etc. Such intense involvement may change the nature of FLOSS development and pose critical challenges for the sustainability of the projects. For example, it has been found that a company's full control and intense involvement is associated with a decrease of volunteer inflow [13]. Sometimes a project may fail after one company pulls resources from the project [13]. This raises concerns about the domination of one company in a project. In large projects like OpenStack, there are often hundreds of companies involved in contributing code. Despite substantial researches on commercial participation, whether or not one company dominates a project and the impact of such domination has never been explicitly explored. We investigate four main projects of OpenStack, a large ecosystem that has had a tremendous impact on computing and society, to answer the following research questions: Does one company dominate the project's development (RQ1)? If the answer to RQ1 is yes, does the domination affect the community (RQ2)?

In order to reduce cost, get to market faster and utilize global talents, large companies often organize their software development globally (distributed over Internet), a paradigm advocated by Internetware. Considering the complexity of distributed software development, it is important to understand the variation of various tasks, so the projects could work more efficiently on plan formulation, personnel organization, or task allocation. The main goal of this paper is to understand the variations of software development tasks. We conduct an interview with 47 interviewees and a survey with 148 people from 15 projects with different size and domain.Through the analysis of interviews and surveys, we find that a software task could be characterized through three aspects: value, difficulty and centrality. Among them, task value is influenced by the role of stakeholders and project context, and is related to the task difficulty and task centrality. Task difficulty is reflected by technology, domain difference, working relationships, customer related issues, and it is also related to the developers' personalities. Task centrality can be described by customer impact, system-wide impact, team impact and future impact. We believe our results can help project managers to optimize task allocation, or adjust project plan, and thus achieve efficient development.

Open source software ecosystems evolve ways to balance the workload among groups of participants ranging from core groups to peripheral groups. As ecosystems grow, it is not clear whether the mechanisms that previously made them work will continue to be relevant or whether new mechanisms will need to evolve. The impact of failure for critical ecosystems such as Linux is enormous, yet the understanding of why they function and are effective is limited. We, therefore, aim to understand how the Linux kernel sustains its growth, how to characterize the workload of maintainers, and whether or not the existing mechanisms are scalable. We quantify maintainers' work through the files that are maintained, and the change activity and the numbers of contributors in those files. We find systematic differences among modules; these differences are stable over time, which suggests that certain architectural features, commercial interests, or module-specific practices lead to distinct sustainable equilibria. We find that most of the modules have not grown appreciably over the last decade; most growth has been absorbed by a few modules. We also find that the effort per maintainer does not increase, even though the community has hypothesized that required effort might increase. However, the distribution of work among maintainers is highly unbalanced, suggesting that a few maintainers may experience increasing workload. We find that the practice of assigning multiple maintainers to a file yields only a power of 1/2 increase in productivity. We expect that our proposed framework to quantify maintainer practices will help clarify the factors that allow rapidly growing ecosystems to be sustainable.

Code contributions in Free/Libre and Open Source Software projects are controlled to maintain high-quality of software. Alternatives to patch-based code contribution tools such as mailing lists and issue trackers have been developed with the pull request systems being the most visible and widely available on GitHub. Is the code contribution process more effective with pull request systems? To answer that, we quantify the effectiveness via the rates contributions are accepted and ignored, via the time until the first response and final resolution and via the numbers of contributions. To control for the latent variables, our study includes a project that migrated from an issue tracker to the GitHub pull request system and a comparison between projects using mailing lists and pull request systems. Our results show pull request systems to be associated with reduced review times and larger numbers of contributions. However, not all the comparisons indicate substantially better accept or ignore rates in pull request systems. These variations may be most simply explained by the differences in contribution practices the projects employ and may be less affected by the type of tool. Our results clarify the importance of understanding the role of tools in effective management of the broad network of potential contributors and may lead to strategies and practices making the code contribution more satisfying and efficient from both contributors' and maintainers' perspectives.

Whereas most research on Internetware has focused on new technologies for keeping track of a changing Internet, little attention has been paid to the software development process. A large portion of the software running the Internet is open source software. Open source software is developed both by volunteers and commercial companies, often jointly. Companies get involved in open source projects for commercial reasons, and bring with them a commercial software development process. Thus, it is important to understand how commercial involvement affects the software development process of open source projects. This article presents case studies of three open source application servers that are being developed jointly by a volunteer community and one primary software company. We are interested in better understanding developer behavior, specifically task distribution and performance, based on whether the developer is an external contributor, e.g., a volunteer working in their spare time, or a commercial developer from inside the primary backing company who is being paid for their time. To achieve this, we look at issue reporting as an example of commercial involvement in open source projects. In particular, we investigate the distribution of tasks among volunteers and commercial developers by studying the source of reported issues and quantify the task performance on user experience via the issue resolution speed. We construct measures based on historical records in issue tracking repositories. Our results show that, with intensified commercial involvement, the majority of issue reporting tasks would be undertaken by commercial developers, and issue resolution time would be reduced, implying a better user experience. We hope our methods and results provide practical insights for designing an efficient hybrid development process in the Internetware environment.

Although CD23-dependent transcytosis of IgE and IgE-derived immune complexes across respiratory epithelial cells is likely to play a pivotal role in the initiation and development of airway allergic inflammation, there is currently a lack of physiological support for this phenomena to suggest that the targeting of CD23 could be used as a means of therapeutic intervention. The present study was designed to detect the CD23 expression in the nasal mucosa of allergic rhinitis (AR) murine model by immunohistochemistry and western blotting, and to investigate whether intranasal anti-CD23 treatment could inhibit allergen-induced upper airway inflammation in the AR model. This is the first report to show that CD23 was constitutively expressed in murine nasal epithelial cells, and its expression was significantly up-regulated in the AR murine model. In vivo, the up-regulation of CD23 expression was correlated with increased serum IL-4 levels. Following intranasal anti-CD23 treatment, nasal symptoms were alleviated and histopathologic examination showed a significant decrease in eosinophilic infiltration. Meanwhile, ELISA analysis showed levels of serum leukotriene C4 (LTC4), eosinophil cation protein (ECP), ovalbumin (OVA)-specific IgE and IL-4 also significantly decreased, as were LTC4 and OVA-specific IgE in the nasal lavage fluid. Furthermore, Western blotting analysis showed that ECP expression in the nasal mucosa was down-regulated. Finally, flow cytometric analysis revealed anti-CD23 treatment inhibited Th2 cell responses. These results indicate that intranasal anti-CD23 treatment can reduce allergic responses in a murine model of allergic rhinitis.

Web applications' traffic demand fluctuates widely and usually unpredictably. The common practice of provisioning a fixed capacity would either result in unsatisfied customers (when the resources allocated to a specific customer are too low) or waste valuable capital investment (when the resources allocated to a specific customer are too much). By leveraging an infrastructure cloud's on-demand, pay-per-use capabilities, we finally can match the system's capacity with the demand in real time. Although the static client-side load balancing mechanism has been used by many clusters, it does not suit the cluster which needs to change nodes and load balancing policies in runtime. This paper proposes a dynamic client-side load balancing mechanism. By integrating technologies such as distributed cluster-view maintenance and control flow, this mechanism not only has good scalability but also introduces many dynamic features into the client-side load balancing, providing effective support for the nodes' dynamic join and exit as well as the adaptive adjustment of the load balancing policies. Since the framework has been implemented in an open-source JEE application server named PKUAS, this paper also describes some key implementation features and analyzes the evaluation results of the experiments to show the effectiveness of the mechanism from different aspects.

Uncontrolled overload is one of the major causes of the system’s decline in reliability and performance for web applications. It also harms the construction of trustworthy software. This paper presents a degradation-based mechanism to adaptively control overload in complex, dynamic web applications. In our mechanism, the bottlenecks in the application’s performance are determined by internally monitoring the performance and resource utilization state of the application, which is decomposed into a set of services. After locating the bottlenecks, two decision algorithms are proposed to dynamically and adaptively generate proper degradation plans without delay. By degrading the service which consumes critical resources and has a low priority from the perspective of business logic, the application can keep providing key services even when overload occurs. We implement a prototype and conduct a case study on a wiki application. We also evaluate our approach and demonstrate its effectiveness in simulated overload cases. Through handling overload, we make a breakthrough in building trustworthy software in an open, dynamic and rapidly changing environment.

Many studies analyze issue tracking repositories to understand and support software development. To facilitate the analyses, we share a Mozilla issue tracking dataset covering a 15-year history. The dataset includes three extracts and multiple levels for each extract. The three extracts were retrieved through two channels, a front-end (web user interface (UI)), and a back-end (official database dump) of Mozilla Bugzilla at three different times. The variations (dynamics) among extracts provide space for researchers to reproduce and validate their studies, while revealing potential opportunities for studies that otherwise could not be conducted. We provide different data levels for each extract ranging from raw data to standardized data as well as to the calculated data level for targeting specific research questions. Data retrieving and processing scripts related to each data level are offered too. By employing the multi-level structure, analysts can more efficiently start an inquiry from the standardized level and easily trace the data chain when necessary (e.g., to verify if a phenomenon reflected by the data is an actual event). We applied this dataset to several published studies and intend to expand the multi-level and multi-extract feature to other software engineering datasets.

This paper presents the detailed experiment setups and data analysis results of the ambient vibration testing of two irregular high-rise buildings done by a joint research team from the University of British Columbia and Tongji University. Two full-scale tests were conducted in May 2015 at the Siping Campus of Tongji University, Shanghai, China. The first Multi-Functional Building (MFB) has 21 stories with a typical floor height of 4 m. The structure shows significant irregularity in both plane and vertical direction, where every three floors combine into one L-shaped unit and the L-shape floor rotates 90° along the height of the building. The second building tested is the Shanghai International Design Center (SIDC). SIDC is an h-shape asymmetry double tower structure consists of main tower (25 story) and secondary tower (12 story). The two towers are rigidly connected with steel truss system between the 11th and 12th floors. Considering the complexities and irregularities of the two buildings, it is essential to study their dynamic properties and the associated principal modes of vibration. Several modal analysis techniques were adopted to determine the modal parameters of two buildings.

The Shanghai Tower is one of the super-tall buildings under construction in the world and will be the tallest structure in China after completion. The building stands approximately 632 m and has 128 stories. It was designed with a double curtain wall system, where a triangular outer facade gradually shrinks and twists clockwise at approximately 120° along the height of the building. On May 8th, 2015, an Ambient Vibration testing was performed on the building in its final stages of construction by a collaborative team from the University of British Columbia and Tongji University. The full-scale test had several purposes that included the evaluation of the current instrumentation techniques and the identification of the dynamic properties of the tower. A set of seven GPS-timed velocity/acceleration recorders was utilized, where two measurements were taken on almost every 15 floors in each setup. This paper presents the signal processing results by using the Frequency Domain Decomposition (FDD) and the Enhanced Frequency Domain Decomposition (EFDD) techniques. The most significant lateral and torsional mode shapes and associated periods of vibration were determined within the frequency range of 0.1–2 Hz. The results will provide useful information for further finite element model update.

Mining software repositories to understand and improve software development is a common approach in research and practice. The operational data obtained from these repositories often do not faithfully represent the intended aspects of software development and, therefore, may jeopardize the conclusions derived from it. We propose an approach to identify problematic values based on the constraints of software development and to correct such values using data redundancies. We investigate the approach using issue and commit data of Mozilla project. In particular, we identified problematic data in four types of events and found the fraction of problematic values to exceed 10% and rapidly rising. We found the corrected values to be 50% closer to the most accurate estimate of task completion time. Finally, we found that the models of time until fix changed substantially when data were corrected, with the corrected data providing a 20% better fit. We discuss how the approach may be generalized to other types of operational data to increase fidelity of software measurement in practice and in research.

Globally distributed software development projects are on the rise. However, 69% of cross-regional projects fail completely or partially, because of lack of cross-cultural understanding. This paper presents a qualitative study of the impact of communication on Global Software Development (GSD) within firms due to cultural differences. In particular, we provide a model of problems and solutions related to communication of German/Chinese and American/Chinese collaborations in GSD. The model was derived using grounded theory to study six globally distributed software development projects. The results may not only help companies understand cultural problems, but also help them overcome these problems. To this end, we discuss the solutions adopted by the multinational software companies that we studied.

Micro-practices are actual (and usually undocumented or incorrectly documented) activity patterns used by individuals or projects to accomplish basic software development tasks, such as writing code, testing, triaging bugs, or mentoring newcomers. The operational data in software repositories presents the tantalizing possibility to discover such fine-scale behaviors and use them to understand and improve software development. We propose a large-scale evidence-based approach to accomplish this by first creating a mirror of the projects in the open source universe. The next step would involve the inductive generalization from in-depth studies of specific projects from one side and the categorization of micro-practices in the entire universe from the other side.

Context: Every software development project uses folders to organize software artifacts. Goal: We would like to understand how folders are used and what ramifications different uses may have. Method: In this paper we study the frequency of folders used by 140k Github projects and use regression analysis to model how folder use is related to project popularity, i.e., the extent of forking. Results: We find that the standard folders, such as document, testing, and examples, are not only among the most frequently used, but their presence in a project is associated with increased chances that a project's code will be forked (i.e., used by others) and an increased number of forks. Conclusions: This preliminary study of folder use suggests opportunities to quantify (and improve) file organization practices based on folder use patterns of large collections of repositories.

Effectiveness of software development process depends on the accuracy of data in supporting tools. In particular, a customer issue assigned to a wrong product team takes much longer to resolve (negatively affecting user-perceived quality) and wastes developer effort. In Open Source Software (OSS) and in commercial projects values in issue-tracking systems (ITS) or Customer Relationship Management (CRM) systems are often assigned by non-developers for whom the assignment task is difficult. We propose PAR (Product Assignment Recommender) to estimate the odds that a value in the ITS is incorrect. PAR learns from the past activities in ITS and performs prediction using a logistic regression model. Our demonstrations show how PAR helps developers to focus on fixing real problems, and how it can be used to improve data accuracy in ITS by crowd-sourcing non-developers to verify and correct low-accuracy data. http://youtu.be/IuykbzSTj8s

Triage is of great interest in software projects because it has the potential to reduce developer effort by involving a broader base of non-developer contributors to filter and augment reported issues. Using issue tracking data and interviews with experienced contributors we investigate ways to quantify the impact of triagers on reducing the number of issues developers need to resolve in two OSS projects: Mozilla and Gnome. We find the primary impact of triagers to involve issue filtering, filling missing information, and determining the relevant product. While triagers were good at filtering invalid issues and as accurate as developers in filling in missing issue attributes, they had more difficulty accurately pinpointing the relevant product. We expect that this work will highlight the importance of issue triage in software projects and will help design further studies on understanding and improving triage practices.

While people get used to surfing web, managing the overload of web applications has become a critical problem for application providers. Targeting overload issue of complex, dynamic web applications, this paper presents an adaptive service degradation approach. Our approach attempts to automatically locate the bottleneck inside the applications and generate proper degradation plans in real time. This is accomplished through internally monitoring the performance and resource utilization state of the application, which is decomposed into a set of services. By dynamic controlling the bottleneck of resource utilization, the application can keep providing key services even when overload occurs, for example, by degrading only the service which consumes critical resources and has a low priority from the perspective of business logic. We implement a prototype and conduct a case study with a business application. The case study demonstrates the approach is effective when overload occurs.

Software evolves all the time because of the changing requirements, in particular, in the diverse Internet environment. Evolution history recorded in software repositories, e.g., Version Control Systems, reflects people's software development practice. Exploring this history could help practitioners to reuse the best practices therefore improve productivity and software quality. Because of the difficulty of collecting and standardizing data, most existing work could only utilize small project set. In this study, we target the open source software universe to build a universal code evolution model for large-scale data. We consider code evolution from two aspects: code version changing history in a single project and code reuse history in the whole universe. In the model, files/modules are built as nodes, and relations (version change or reuse) between files/modules are built as connections. Based on the model, we design and implement a code evolution review framework, i.e., Code Evolution Reviewer (CER), which provides a series of data interfaces to review code evolution history, in particular, code version changing in single project and code reuse among projects. Further, CER could be utilized to explore best practices across large-scale project set.

Micro-processes (or micro-patterns) are fine-scale practices used by software projects to accomplish key tasks: reporting and resolving issues, debugging code, mentoring newcomers, and so forth. It is a challenge to discover micro-patterns that may guide the practice across projects. We propose a large-scale evidence based approach. The first step is to collect data from Internet and build a standardized public repository that mirrors the open source universe. In the second step, we could start from specific projects and then generalize the findings across the universe, or, we could target the whole universe projects first and then cluster the findings. Examples are given about how it is proceeded.

Off-The-Shelf (COTS) software components have been extensively used by applications over the world. However, COTS components always carry issues that might and sometimes only take place at runtime, in particular, when combined with other components. This might bring serious trouble for the application's dependability. Based on the industry experiences that lots of faulty components usually occupy excessive resources, this paper proposes an approach to localize the faulty components in an application automatically through analyzing the resource usage of components. Once a faulty component interferes with the application's performance, our approach generates an anomaly report, localizes the faulty component, and enables component level recovery to remove the negative impact. We have implemented a prototype and demonstrated its effectiveness on the well-known JPetStore benchmark with performance overhead of less than 3%.

Human factor has been ignored in many of the existing research, which leads to a superficial understanding of the problems facing practitioners. Large-Scale open source software repositories open an opportunity to do digital archeology of software. Researchers and practitioners could investigate human factors with large quantities of data, which may lead to new insights into current software practices and therefore opportunities to improve software quality and project productivity.

Software developers need to develop technical and social skills to be successful in large projects. We model the relative sociality of developer as a ratio between the size of her communication network and the number of tasks she participates in. We obtain both measures from the problem tracking systems. We use her workflow peer network to represent her social learning, and the issues she has worked on to represent her technical learning. Using three open source and three traditional projects we investigate how the project environment reflected by the sociality measure at the time a developer joins, affects her future participation. We find: a) the probability that a new developer will become one of long-term and productive developers is highest when the project sociality is low; b) times of high sociality are associated with a higher intensity of new contributors joining the project; c) there are significant differences between the social learning trajectories of the developers who join in low and in high sociality environments; d) the open source and commercial projects exhibit different nature in the relationship between developer's tenure and the project's environment at the time she joins. These findings point out the importance of the initial environment in determining the future of the developers and may lead to better training and learning strategies in software organizations.

Outsourcing and offshoring lead to a rapid influx of new developers in software projects. That, in turn, manifests in lower productivity and project delays. To address this common problem we study how the developers become fluent in software projects. We found that developer productivity in terms of number of tasks per month increases with project tenure and plateaus within a few months in three small and medium projects and it takes up to 12 months in a large project. When adjusted for the task difficulty, developer productivity did not plateau but continued to increase over the entire three year measurement interval. We also discovered that tasks vary according to their importance(centrality) to a project. The increase in task centrality along four dimensions: customer, system-wide, team, and future impact was approximately linear over the entire period. By studying developer fluency we contribute by determining dimensions along which developer expertise is acquired, finding ways to measure them, and quantifying the trajectories of developer learning.

The transfer of entire projects to offshore locations, the aging and renewal of core developers in legacy products, the recruiting in fast growing Internet companies, and the participation in open source projects, present similar challenges of rapidly increasing newcomer competence in software projects. In particular, culture differences, communication complexity, and the rapid influx of developers with little or no project knowledge common in these phenomena pose practical and research questions for software engineering. For example, how do different cultures impact project learning? Are there best practices for competence-enhancing communication? How to learn from the experiences of top developers to improve the training of newcomers? What resources and tools can be provided to help newcomers learn faster and become more productive? These questions sketch a project-learning-focused agenda needed to address outlined challenges. We propose how emerging measurement methods utilizing rich data in software repositories and the theoretical frameworks based on cognitive and organizational science may be applied to address these challenges and to improve understanding of how humans learn.

The open, dynamic and ever-changing characteristics of Internet have attracted much attention to carry out research on Internetware. Current researches mainly focus on the framework of the Internetware. However, there are a variety of issues facing the Internetware development today with more joint work distributed over the world, and how should we improve the efficiency of such development? In order to resolve this issue we investigate three open source projects from J2EE platform domain: JBossAS, JOnAS, and Apache Geronimo to find out that, in the sampled projects, how many people will involve the Internetware development, how they allocate the work, and how the speed to resolve the issues reported by the customer. By answering five research questions referred from the Apache study, we proposed four hypotheses: (1) Open source Interware development will have a core of developers who will create approximately 80% or more of the new functionality. The group will be no larger than 30 people; (2) In a specific server-side domain, the group who will repair defects and report issues will have the equal or even smaller number people compared to the core group; (3) Commercial support can attract more volunteers to the open source Internetware projects; (4) Open Source Internetware developments exhibit very rapid responses to customer issues.

Software systems must evolve, or they risk losing market share to competitors. However, evolving such a system is extraordinarily difficult, complicated, and time consuming. In this case, how to reuse the existing features of the previous version and reduce the code redundancy is a really appealing problem. For example, in order to support EJB3.0, many application server vendors have to evolve their existing EJB2.x containers to comply with the new standards. However, the code redundancy between both of the container versions not only increases the development cost, but also increases the maintenance cost when the software are modified because of potential problems or new requirements. In this paper, we propose an empirical reuse approach for software evolution and demonstrate it in a real EJB container evolution project.

Internetware is proposed as a new software paradigm to cope with the open, dynamic and ever-changing Internet environment for applications. The incarnated characteristics of Internetware promote the operating platform to be more dynamic and adaptable. As an operating platform, PKUAS (Peking University Application Server) has been successfully applied in various fields. However, its inexplicit module boundary, insufficient lifecycle management and absent dependency management, make it hardly meet challenges. In this paper we refactor PKUAS into PKUAS II by introducing OSGi (Open Services Gateway Initiative) to achieve a better dynamic capability. First, PKUAS II adopts service component oriented model as its structure so that the boundary among modules can be explicitly explained, and the continuous lifecycle management and dynamic dependency management can get supported. PKUAS II is able to upgrade without interruption of service and extend on the fly with new services. Second, PKUAS II supports application--aware customization, which can dynamically generate a just enough application server for the application at runtime, to satisfy different applications' requirements and reduce resource costs. Last but not least, some evaluations have been done, which show that PKUAS II is more flexible and dynamic without significant performance overhead, and might support Internetware better.

In order to support EJB3.0, many open-source application server vendors have implemented a new container which is independent with the existing EJB2.x one. However, the functional redundancy between both of the containers increases the maintenance cost when the software are modified because of problems or new requirements. This paper proposes a Dual-container to support EJB2.x and EJB3.0 in a unified architecture. Software engineering perspective is applied, three principles including greatest-common-divisor, lease-common-multiple, and transparent intrusion, are presented to guide the construction of the architecture. We implemented the Dual-container in an open-source J2EE application server. The evaluation results show that the Dual-container is effective in reducing the functional redundancy and increasing the maintainability. We demonstrate that in a comparative analysis.

A clustering based niching particle swarm optimization is constructed in this paper by using a clustering method named “density based” clustering. l-best PSO and a clustering algorithm is processed synchronously in this new algorithm. When the number of particles in a cluster reach the set least particle number of a subswarm, a niching is formed based on this cluster. This algorithm can conquer the disadvantage of NichePSO by forming niching with different size and shape.

Dynamic component updating, which allows a running system to be updated without interrupting its execution, has been recognized as an important requirement for distributed systems. However, most of existing approaches complicate the component development by making the component’s updating logic mixed with its business logic. This paper proposes a flexible and lightweight approach for supporting dynamic component updating. Our approach allows multiple versions of a component to co-exist with the support of runtime version management mechanism. Multiple polices are provided to coordinate behaviors of different component versions. In this way, seamless system updating can be achieved and the reliability during updating is also guaranteed. Moreover, our approach separates the component’s updating logic from its business logic and little burden are placed on developers. The experimental results show that the performance overhead is trivial.

In recent years, Java Enterprise Edition (Java EE) technologies keep expanding with more and more features. The customization of application server is becoming multifarious owing to different environments and domains. And delivering a continuous evolving application server is more frequent and costly. However, current application servers cannot meet such requirements, due to their inexplicit module boundary, insufficient lifecycle management and relatively absent dependency management. In this paper, we propose an approach to make an application server well structured and dynamic. Guided by this approach, we implemented a prototype, namely PKUAS II. The evaluations show that a flexible, customizable and dynamic application server can be developed without an adverse effect on the performance.

In the service-oriented architecture, the components deployed on application servers are published as web services. Though many researches focus on how to authorize at the web service level currently, there is little work involving the authorization gap between the service and its component implementation. This paper tries to bridge the gap by proposing a service-oriented trust management model, which expands the application server?s capability to deal with more complex trust relationship between service users and services, and supplies a flexible trust management mechanism to integrate authentication and authorization together. Moreover, the model provides a finer granularity access control, sustains delegation between users, and has a certain extent reasoning capability. The model has been implemented in a J2EE application server, and the experiment has demonstrated that the model has high flexibility and scalability.

While component software continues to grow in size and complexity, it becomes increasingly difficult to ensure qualities for component services, especially at run-time. This paper focuses on a framework on middleware for dynamic re-configuration of components of different qualities from the view of trust. Firstly, a trust management model is built, in which the management framework and measurement model are presented. Secondly, the reconfiguration algorithm is described based on the model. Thirdly, the trust management is implemented as a kind of public services and some tools on a J2EE-compliant middleware platform, i.e., PKUAS. Finally, the related work is discussed and compared with our research.