Health assessment (HA) & remaining useful life (RUL) estimation, the two essential pillars of the prognostics and health management (PHM) paradigm, help improve industrial equipment reliability while reducing maintenance costs. However, reported works treat HA and RUL estimation as disjoint problems though there exist unexploited similarities among these related issues. Additionally, in practical industrial working scenarios, equipment(s) stay in a normal condition for most of its lifespan, leading to a disproportionate training dataset, hampering the prediction accuracy. To overcome the above problems, we propose a data-driven multi-task learning framework aided by a novel least squares recurrent auxiliary classifier generative adversarial network (LS-R-ACGAN). LS-R-ACGAN employs recurrent neural networks (RNNs) in its generator & discriminator networks for multi-variate fault data generation while overcoming the vanishing gradient problem of ACGANs. Post-data-augmentation, a balanced training dataset, trains a multi-task learning model based on a deep gated RNN (DGRU) for joint HA and RUL estimation. Our simulations use the C-MAPSS dataset for testing the proposed approach’s accuracy. The final results showcase improvements by at least$\sim$3.54% and$\sim$2.38% on the RMSE and Score metric over existing state-of-the-art works suggesting its competitiveness and competence for real-world implementations.Note to Practitioners—This study attacks multiple presumptions concerning the maintenance of complex systems including, ample availability of fault samples alongside normal samples and solving only one of the problems, i.e., health assessment (HA) or remaining useful life (RUL) estimations rather than both. Popular artificial intelligence (AI) based solutions rely heavily upon the quantity of training data for desired performance outcomes. However, in real-life industrial scenarios, fault instances are rare, inherently resulting in an imbalanced dataset. Additionally, it is both labor-intensive and costly to repeat multiple experiments for gathering required data as the equipment(s) pass through short-lived fault states. Thus conventional AI-based solutions may end up producing biased predictions. This work proposes to solve the imbalanced training dataset problem along with joint HA and RUL estimations, in one solution pipeline, currently unexplored in majority of the existing works in the literature. LS-R-ACGAN generates ample diverse fault samples for reducing the degree of imbalance between normal and fault classes. Subsequently, after data augmentation, the balanced training dataset helps train a multi-task learning model for joint HA and RUL estimations. The proposed framework has been implemented and tested on a benchmark dataset proving its superiority over multiple existing methods in the literature.

Railway switches operate in harsh environmental conditions; still, their reliability requirements are high due to safety and economic factors. Once deployed, their maintenance depends on the data collected on their status, and the decisions on due corrective actions. The more regular this data collection and decision cycle is, the better confidence their operator has on effective and proper service. Proactive maintenance, in general, targets exactly this: rather than scheduling maintenance actions based on operating hours or servicing volume, actions should be taken when it is really needed. This requires the effective combination of data collection, analysis, presentation and decision making processes. The MANTIS project proposes a reference architecture for proactive maintenance, supported by the concept of cyber-physical systems. Besides suggesting data collection, processing and presentation methods and tools for this, the results were applied in various domains - including production systems, the energy grid, utility vehicles, or railways. The current paper presents data collection, analysis and presentation concepts related to proactive maintenance, applied on railway switches.

Background Software systems are relying more and more on multi-core hardware requiring a parallel approach to address the problems and improve performances. Unfortunately, parallel development is error prone and many developers are not very experienced with this paradigm also because identifying, reproducing, and fixing bugs is often difficult. Objective The main goal of this paper is the identification of an approach able to: (i) identify solved concurrency-related bugs to characterize them and help retrospective activities; (ii) identify concurrency-related bugs as soon as they are entered in the bug management system to support bug triage phase and allocate them to more experienced developers. Approach To this end, the paper analyzes bugs related to concurrency looking at their specific characteristics using different machine learning methods to automatically distinguish them from other kinds of bugs based on the data available in the issue tracking systems and in the code repositories. Results The overall best models we developed for Apache HTTP Server and MariaDB have a precision of 0.985 and 0.814 and a recall of 0.876 and 0.629 when considering linked bugs (bug reports information in bug repository and the corresponding fix in the version control system) and a precision of 0.978 and 0.779 and a recall of 0.889 and 0.569 when considering only the information from bug reports. Conclusions Such results allow the development of an automated system able to classify such bugs and support developers in the bug triage process.

This paper proposes an adaptation to the open source environment (Linux Kernel and OpenSolaris) of a model for predicting which bugs get fixed in the Microsoft Windows operating system.We have analyzed the entire bug repositories containing 16,136 bug reports reported in about 8 years of activity of the project (from 2002 to 2010) for the Linux Kernel and 16,301 bug reports reported in about 3 years of activity of the project (from 2007 to 2010) for OpenSolaris.According to the data analyzed and the descriptive models produced, we have found that (a) bugs reported by people with better reputation and bugs in which more people are involved are more likely to get fixed, (b) reassigning or re-opening bugs are not affecting the fix likelihood, and (c) managing bugs in the same location increases the fix likelihood.The predictive model defined has a precision of 61% and a recall of 39% for the Linux Kernel and a precision of 76% and a recall of 73% for OpenSolaris.These results are comparable with the ones for Microsoft Windows.document.

The reputation of lightweight software development processes such as Agile and Lean is damaged by practitioners that claim benefits of such processes that are not true. Teams that want to demonstrate their seriousness, could benefit from matching their processes to the CMMI model, a recognized model by industry and the public administration. CMMI stands for Capability Maturity Model Integration and provides a reference model to improve and evaluate processes according to their maturity based on best practices. On the other hand, particularly in a lightweight software development process, the costs of a CMMI appraisal are hard to justify since its advantages are not directly related to the creation of value for the customer. This paper presents Jidoka4CMMI, a tool that — once a CMMI appraisal has been conducted — allows the documentation of the assessment criteria in form of executable test cases. The test cases, and so the CMMI appraisal, can be repeated anytime, without additional costs. The use of Jidoka4CMMI increases the benefits of conducting a CMMI appraisal. We hope that this encourages practitioners using lightweight software development processes to assess their processes using a CMMI model.

Web Services (WS) are software components accessible over the Internet through a well-defined set of standards. When consumers invoke a service, they expect to receive a valid response. However, the problem is to determine the structure of a valid request [21]. WS specifications are used to solve this problem since they are considered the primary piece of information for building service requests. Unfortunately, existing specifications do not provide enough support for this type information (e.g., WSDL) or there is little support on the client side (e.g., OWL-S). In this paper we address this issue by implementing a technique to reduce the number of faulty requests. We specifically propose an approach for extending WSDL with service input parameters rules that help consumers and integrators to verify their calls on the client side.

ABSTRACT This paper describes the challenges of handling changing requirements in software companies. This empirical investigation deals with the different sources of changes and with the different approaches to requirements evolution. We have considered the point of view of 35 managers of software companies interviewed through a questionnaire. The final results highlight some areas to improve requirements engineering and requirements management. Copyright © 2013 John Wiley & Sons, Ltd.

In the last decade, there has been increasing interest in pair programming (PP). However, despite the existing work, there is still a lack of substantial evidence of the effects of PP in industrial environments. To address this issue, we have analyzed the work of a team of 17 industrial developers for 14 months. The team is part of the IT department of a large Italian manufacturing company; it adopts a customized version of extreme programming (XP). We have investigated the effects of PP on software quality in five different scenarios. The results show that PP appears to provide a perceivable but small effect on the reduction of defects in these settings.

Pair Programming is one of the most studied and debated development techniques. However, at present, we do not have a clear, objective, and quantitative understanding of the claimed benefits of such development approach. All the available studies focus on the analysis of the effects of Pair Programming (e.g., code quality, development speed, etc.) with different findings and limited replicability of the experiments. This paper adopts a different approach that could be replicated in an easier way: it investigates how Pair Programming affects the way developers write code and interact with their development machine. In particular, the paper focuses on the effects that Pair Programming has on developers' attention and productivity. The study was performed on a professional development team observed for ten months and it finds out that Pair Programming helps developers to eliminate distracting activities and to focus on productive activities.

Developers use tools to develop software systems and always alleged better tools are being produced and purchased. Still there have been only limited studies on how people really use tools; these studies have used limited data, and the interactions between tools have not been properly elaborated. The advent of the AISEMA (Automated In-Process Software Engineering Measurement and Analysis) systems [3] has enabled a more detailed collection of tools data. Our "new idea" is to take advantage of such data to build a simple model based on an oriented graph that enables a good understanding on how tools are used individually and collectively. We have empirically validated the model analyzing an industrial team of 19 developers for a period of 10 months.

Novices' activities can be very different from those of experienced developers. The analysis of tool usage can propose early insights on novices integration in the team and also provide a method to compare their activities with experts. In this work we compare novices and experts in terms of tool usage, both in solo and in Pair Programming (PP). At the end of the integration process, novices activities are aligned to experts ones. Data for this study have been collected in an industrial team of 17 developers for a period of 10 months. The usage of AISEMA (Automated In-Process Software Engineering Measurement and Analysis) systems allowed us to have continuous, accurate and low cost measurement for our analysis.

The advance in web services (WS) and service oriented architecture (SOA) applications has led to the development of new types of systems in which different heterogeneous components and platforms can connect and collaborate to solve a business problem. This advancement adds a new level of abstraction to the existing stack of technologies and development methodologies, but it adds also new challenges. One such a big challenge is testing. From the client prospective, a Web Service is a black box that needs to be tested before being used, mainly to confirm the claims of services' providers about the quality of their services. By calling a WS, we delegate part of our business logic to an external provider to do it for us. Thus, we have no control of what could happen during the execution of that part of the business logic. To this end, many testing approaches and techniques have been proposed in the literature to address various aspects related to WS testing. In our effort to improve WS testing infrastructures, we propose a framework for service integrators to collaborate during Web Services testing by making test suites open to the public and share testing results.

In this paper we present a study on how pair programming (PP) facilitates the introduction of new developers (novices) in a team. Data has been collected non-invasively on how people paired in an industrial team of developers for 10 months; during such time novices joined the team. We focused on spontaneous PP, that is, on PP occurring when developers think it is most effective. Social network analysis techniques are used to analyze developers interactions and infer possible conclusions. It appears that initially PP is used to initiate novices, then it is drastically reduced to be resumed eventually when novices ldquofeelrdquo they have reached a significant level of maturity in the team. These phases are coherent with available works on group development and confirm existing findings on the importance of PP in the introduction of novices in teams, and, more generally, on team dynamics.

Automated systems for measurement and analysis are not adopted on a large scale in companies, despite the opportunities they offer. The fear of the ldquobig brotherrdquo and the lack of reports giving insights into the real adoption process and concrete usages in industry are barriers to this adoption. We report on a case-study on the adoption and long-term usage (2 years of running system) of such a system in a company focusing on the adoption process and the related challenges we encountered.

Test-driven development (TDD) is a development discipline prescribing writing tests beforehand writing the implementation code, which then shall pass the tests. Several criticisms addressed TDD's capability of delivering well-structured code, mainly because of the short focus on the features needed right now without much looking forward. So the main threat possibly introduced by TDD lies in the lack of maintainability and evolvability of the resulting system. The goal of the working session is to gather opinions, studies, and mostly experiences related to the maintenance implications of TDD adoption. The working session will be organized around position papers presented and discussed by the participants.

Task switching occurs frequently during the work of software developers. While there are already several approaches aiming at assisting developers in recovering their contexts of previous tasks, they generally rely on the developer to identify the beginning of each task. We propose a new technique for automatically splitting a development session into task-related subsections, based on the interaction of the developer with the IDE. The technique also shows potential benefits for automatic concern detection and for suggestions for code investigation. We present the technique, the results of a study conducted for its initial validation, and we discuss the additional potential benefits under investigation.

Estimation of development effort without imposing overhead on the project and the development team is of paramount importance for any software company. This study proposes a new effort estimation methodology aimed at agile and iterative development environments not suitable for description by traditional prediction methods. We propose a detailed development methodology, discuss a number of architectures of such models (including a wealth of augmented regression models and neural networks) and include a thorough case study of Extreme Programming (XP) in two semi-industrial projects. The results of this research evidence that in the XP environment under study the proposed incremental model outperforms traditional estimation techniques most notably in early phases of development. Moreover, when dealing with new projects, the incremental model can be developed from scratch without resorting itself to historic data.

The development of a software project often requires more time and effort than originally expected. However, at end of a project, it is hard to determine which components required more time or were more complex than what was originally planned. In addition, project managers are interested to know what could have happened if some requirements were dropped or if they were implemented in different time sequencing. Lagrein is a tool that supports managers and developers in answering such kind of questions.

This paper presents an empirical analysis of the Open Source development process from the point of view of the involvement of the developers in the production process. The study focuses on how developers contribute to projects in terms of involvement, size and kind of their contribution. Data have been collected from 53 Open Source projects and target application domains include different areas: web and application servers, databases, operating systems, and window managers. Collected data include the number of developers, patterns of code modifications, and evolution over the time of size and complexity. The results of this study show evidence that there are recurrent patterns in Open Source software development and these patterns are common to all the projects considered even if there are no superimposed processes for development, application domains are different, and there are contributions from people spread across the world.