In the last years, the state of the art of NLP research has made a huge step forward. Since the release of ELMo (Peters et al., 2018), a new race for the leading scoreboards of all the main linguistic tasks has begun. Several models have been published achieving promising results in all the major NLP applications, from question answering to text classification, passing through named entity recognition. These great research discoveries coincide with an increasing trend for voice-based technologies in the customer care market. One of the next biggest challenges in this scenario will be the handling of multi-turn conversations, a type of conversations that differs from single-turn by the presence of multiple related interactions. The proposed work is an attempt to exploit one of these new milestones to handle multi-turn conversations. MTSI-BERT is a BERT-based model achieving promising results in intent classification, knowledge base action prediction and end of dialogue session detection, to determine the right moment to fulfill the user request. The study about the realization of PuffBot, an intelligent chatbot to support and monitor people suffering from asthma, shows how this type of technique could be an important piece in the development of future chatbots.

Context: Different approaches exist for automated GUI testing of Android applications, each with its peculiarities, advantages, and drawbacks. The most common are either based on the structure of the GUI or use visual recognition.

Android applications do not seem to be tested as thoroughly as desktop ones. In particular, graphical user interface (GUI) testing appears generally limited. Like web-based applications, mobile apps suffer from GUI test fragility, i.e., GUI test classes failing or needing updates due to even minor modifications in the GUI or in the application under test. The objective of our study is to estimate the adoption of GUI testing frameworks among Android open-source applications, the quantity of modifications needed to keep test classes up to date, and their amount due to GUI test fragility. We introduce a set of 21 metrics to measure the adoption of testing tools and the evolution of test classes and test methods, and to estimate the fragility of test suites. We computed our metrics for six GUI testing frameworks, none of which achieved a significant adoption among Android projects hosted on GitHub. When present, GUI test methods associated with the considered tools are modified often, and a relevant portion (70% on average) of those modifications is induced by GUI-related fragilities. On average, for the projects considered, more than 7% of the total modified lines of code between consecutive releases belong to test classes developed with the analyzed testing frameworks. The measured percentage was higher on average than the one required by other generic test code, based on the JUnit testing framework. Fragility of GUI tests constitutes a relevant concern, probably an obstacle for developers to adopt test automation. This first evaluation of the fragility of Android scripted GUI testing can constitute a benchmark for developers and testers leveraging the analyzed test tools and the basis for the definition of a taxonomy of fragility causes and guidelines to mitigate the issue.

The application of tool integration in an industrial use case in the context of the CRYSTAL European project is presented. In particular, the development of a connecting application conceived to provide interoperability between two tools used in the Model-Based design and analysis of aircraft systems is described. The main goal behind this activity is allowing different specialists to use several tools for each specific task, in the context of a seamless Model-Based design process. A practical application of OSLC is proposed to face this problem within an industrial scenario. The work showed that the standard can promisingly address interoperability issues although the tools still provide limited OSLC support.

Nowadays, most recommender systems exploit user-provided ratings to infer their preferences. However, the growing popularity of social and e-commerce websites has encouraged users to also share comments and opinions through textual reviews. In this paper, we introduce a new recommendation approach which exploits the semantic annotation of user reviews to extract useful and non-trivial information about the items to recommend. It also relies on the knowledge freely available in the Web of Data, notably in DBpedia and Wikidata, to discover other resources connected with the annotated entities. We evaluated our approach in three domains, using both DBpedia and Wikidata. The results showed that our solution provides a better ranking than another recommendation method based on the Web of Data, while it improves in novelty with respect to traditional techniques based on ratings.

Recommender systems are software tools used to generate and provide suggestions for items and other entities to the users by exploiting various strategies. Hybrid recommender systems combine two or more recommendation strategies in different ways to benefit from their complementary advantages. This systematic literature review presents the state of the art in hybrid recommender systems of the last decade. It is the first quantitative review work completely focused in hybrid recommenders. We address the most relevant problems considered and present the associated data mining and recommendation techniques used to overcome them. We also explore the hybridization classes each hybrid recommender belongs to, the application domains, the evaluation process and proposed future research directions. Based on our findings, most of the studies combine collaborative filtering with another technique often in a weighted way. Also cold-start and data sparsity are the two traditional and top problems being addressed in 23 and 22 studies each, while movies and movie datasets are still widely used by most of the authors. As most of the studies are evaluated by comparisons with similar methods using accuracy metrics, providing more credible and user oriented evaluations remains a typical challenge. Besides this, newer challenges were also identified such as responding to the variation of user context, evolving user tastes or providing cross-domain recommendations. Being a hot topic, hybrid recommenders represent a good basis with which to respond accordingly by exploring newer opportunities such as contextualizing recommendations, involving parallel hybrid algorithms, processing larger datasets, etc.

The increase in the amount of structured data published on the Web using the principles of Linked Data means that now it is more likely to find resources on the Web of Data that represent real life concepts. Discovering and recommending resources on the Web of Data related to a given resource is still an open research area. This work presents a framework to deploy and execute Linked Data based recommendation algorithms to measure their accuracy and performance in different contexts. Moreover, application developers can use this framework as the main component for recommendation in various domains. Finally, this paper describes a new recommendation algorithm that adapts its behavior dynamically based on the features of the Linked Data dataset used. The results of a user study show that the algorithm proposed in this paper has better accuracy and novelty than other state-of-the-art algorithms for Linked Data.

Context-aware Recommender Systems aim to provide users with the most adequate recommendations for their current situation.However, an exact context obtained from a user could be too specific and may not have enough data for accurate rating prediction.This is known as the data sparsity problem.Moreover, often user preference representation depends on the domain or the specific recommendation approach used.Therefore, a big effort is required to change the method used.In this paper we present a new approach for contextual pre-filtering (i.e. using the current context to select a relevant subset of data).Our approach can be used with existing recommendation algorithms.It is based on two ontologies: Recommender System Context ontology, which represents the context, and Contextual Ontological User Profile ontology, which represents user preferences.We evaluated our approach through an offline study which showed that when used with well-known recommendation algorithms it can significantly improve the accuracy of prediction.

Engineering green software-intensive systems is critical in our drive towards a sustainable, smarter planet. The goal of green software engineering is to apply green principles to the design and operation of software-intensive systems. Green and self-greening software systems have tremendous potential to decrease energy consumption. Moreover, enterprise software can and should be re-thought to address sustainability issues using innovative business models, processes, and incentives. Monitoring and measuring the greenness of software is critical towards the notion of sustainable and green software. Demonstrating improvement is paramount for users to achieve and affect change. Thus, the theme of GREENS 2015 is Towards a Green Software Body of Knowledge. The GREENS workshop series brings together researchers and practitioners to discuss both the state-of-the-art and state-of-the-practice in green software, including novel ideas, research challenges, methods, experiences, and tools to support the engineering of sustainable and energy efficient software systems.

Summary Recommender systems (RS) are software tools that use analytic technologies to suggest different items of interest to an end user. Linked Data is a set of best practices for publishing and connecting structured data on the Web. This paper presents a systematic literature review to summarize the state of the art in RS that use structured data published as Linked Data for providing recommendations of items from diverse domains. It considers the most relevant research problems addressed and classifies RS according to how Linked Data have been used to provide recommendations. Furthermore, it analyzes contributions, limitations, application domains, evaluation techniques, and directions proposed for future research. We found that there are still many open challenges with regard to RS based on Linked Data in order to be efficient for real applications. The main ones are personalization of recommendations, use of more datasets considering the heterogeneity introduced, creation of new hybrid RS for adding information, definition of more advanced similarity measures that take into account the large amount of data in Linked Data datasets, and implementation of testbeds to study evaluation techniques and to assess the accuracy scalability and computational complexity of RS. Copyright © 2015 John Wiley & Sons, Ltd.

This paper presents EC-Indexer a new approach for Business Process indexing based on execution traces extracted from event-log files. Additionally, a tool implementing the proposed similarity mechanism was developed in order to evaluate the effectiveness by common measures as precision, recall, and f-measure. The results showed that even when the EC-Indexer approach scored low values of recall, it could reach high values of precision while reducing the execution time.

ICT accounts for approximately 2% of world CO2 emissions, a figure equivalent to aviation, according to Gartner estimates. In the remaining 98% software counts for both operationalizing the private sector in doing its business and the public sector in supporting the society, as well as delivering enduser applications that permeate personal life of individuals and families. Software can contribute to decrease power consumption (i.e., become greener) in at least two ways. First, by being more energy efficient, hence using fewer resources and causing fewer CO2 emissions. Second, by making its processes more sustainable, i.e. decreasing the emissions of governments, companies and individuals. To this end, enterprise software must be rethought to address sustainability issues and support innovative business models and processes. The special theme of the second edition of GREENS is “Leveraging energy efficiency to software users”. This workshop brings together software engineering researchers and practitioners to discuss the state-of-the-art and state-of-the-practice in green software, as well as research challenges, novel ideas, methods, experiences, and tools to support the engineering of sustainable and energy efficient software systems.

Context: Defects are an ineludible component of software, Defect Density (DD) - defined as the number of defects divided by size - is often used as a related measure of quality. Project managers and researchers alike would benefit a lot from overview DD figures from software projects, the former for decision making the latter for state-of-the-practice assessment. Objective: In this paper, we collect and aggregate DD figures published in literature, in addition we characterize DD as a function of different project factors in terms of central tendency and dispersion. The factors considered include development mode -open vs. closed source-, programming language, size, and age. Results: We were able to identify 19 papers reporting defect density figures concerning 109 software projects. The mean DD for the studied sample of projects is 7.47 post release defects per thousand lines of code (KLoC), the median is 4.3 with a standard deviation of 7.99. Development mode, is characterized by statistically meaningful different DD, the same for Java vs. C. Besides, in the studied sample large projects exhibited lower DD than medium and small projects. Conclusion: The study is a first step in collecting and analyzing DD figures for the purpose of characterizing one important aspect of software quality. These figures can be used both by researchers and project managers interested to evaluate their projects. Further work is needed to extend the data set and to identify predictors of defect density.

The purpose of this study is to analyze the reliability growth of Open Source Software (OSS) versus software developed in-house (i.e. Closed Source Software, CSS) using Software Reliability Growth Model. This study uses 22 datasets containing failure data of CSS and 18 datasets containing defect data of OSS projects. The failure data are modelled by eight SRGM (Musa Okumoto, Inflection S-Shaped, Goel Okumoto, Delayed S-Shaped, Logistic, Gompertz, Yamada Exponential, and Generalized Goel Model). These models are chosen due to their widespread use. The results can be summarized as follows All selected SRGM fit to defect data of the OSS projects in the same manner as that of CSS. OSS reliability grows similarly to that of CSS. Musa Okumoto and Inflection S-Shaped perform well for CSS, while for OSS Inflection S-Shaped and Gompertz are good performers. SRGM can be used for reliability characterization of OSS projects.

Context: A common assumption in software engineering is that a more structured process delivers higher quality products. However, there are limited empirical studies that support this assumption. Objective: In this paper we analyze 61 projects looking for a relationship between process structured and quality of the product. The structure is considered under two dimensions: level of maturity (as measured by the CMMI assessment model) and type (e.g. TSP, RUP). The quality of the product is measured in terms of Defect Density (DD) defined as the number of delivered defects divided per size. Results: We found a small and statistically not significant difference of DD between the projects developed under CMMI and those that are not developed under CMMI. Considering the CMMI levels, the pair (CMMI 1, CMMI 3) is characterized by a statistically significant different DD. CMMI 1 exhibiting higher DD than CMMI 3. By comparing different software processes with each other we found that Hybrid process exhibits statistically significant lower DD than Waterfall. Conclusion: Software process in either dimension, level of maturity and type has an impact on the software quality but smaller than one might expect.

Most software systems are complex and composed of a large number of artifacts. To realize each different artifact specific techniques are used resorting to different abstractions, languages and tools. Successful composition of different elements requires coherence among them. Unfortunately constraints between artifacts written in different languages are usually not formally expressed nor checked by supporting tools; as a consequence they can be a source of problems. In this paper we explore the role of the relations between artifacts written in different languages by means of a case study on the Hadoop open source project. We present the problem introducing its terminology, we quantify the phenomenon and investigate its relation with defect proneness.

The purpose of this study is to compare the fitting (goodness of fit) and prediction capability of eight Software Reliability Growth Models (SRGM) using fifty different failure Data sets. These data sets contain defect data collected from system test phase, operational phase (field defects) and Open Source Software (OSS) projects. The failure data are modelled by eight SRGM (Musa Okumoto, Inflection S-Shaped, Goel Okumoto, Delayed S-Shaped, Logistic, Gompertz, Yamada Exponential, and Generalized Goel Model). These models are chosen due to their prevalence among many software reliability models. The results can be summarized as follows: Fitting capability: Musa Okumoto fits all data sets, but all models fit all the OSS datasets. : Prediction capability: Musa Okumoto, Inflection S-Shaped and Goel Okumoto are the best predictors for industrial data sets, Gompertz and Yamada are the best predictors for OSS data sets. : Fitting and prediction capability: Musa Okumoto and Inflection are the best performers on industrial datasets. However this happens only on slightly more than 50% of the datasets. Gompertz and Inflection are the best performers for all OSS datasets.

Abstract—Background: a systematic review identifies, evalu-ates and synthesizes the available literature on a given topic using scientific and repeatable methodologies. The significant workload required and the subjectivity bias could affect results. Aim: semi-automate the selection process to reduce the amount of manual work needed and the consequent subjectivity bias. Method: extend and enrich the selection of primary studies using the existing technologies in the field of Linked Data and text mining. We define formally the selection process and we also develop a prototype that implements it. Finally, we conduct a case study that simulates the selection process of a systematic literature published in literature. Results: the process presented in this paper could reduce the work load of 20 % with respect to the work load needed in the fully manually selection, with a recall of 100%. Conclusions: the extraction of knowledge from scientific stud-ies through Linked Data and text mining techniques could be used in the selection phase of the systematic review process to reduce the work load and subjectivity bias. I.

Background: Effective use of bug finding tools promise to speed up the process of source code verification and to move a portion of discovered defects from testing to coding phase.However, many problems related to their usage, especially the large number of false positives, could easily hinder the potential benefits of such tools.Aims: Assess the percentage and type of issues of a popular bug-finding tool (FindBugs) that are actual defects.Method: We analyzed 301 Java Projects developed at a university with FindBugs, collecting the issues signalled on the source code.Afterwards, we checked the precision of issues with information on changes, we ranked and validated them using both manual inspection and validation with tests failures.Results: We observed that a limited set of issues have high precision and conversely we identified those issues characterized by low precision.We compared findings first with our previous experiment and then to related work: results are consistent with both of them.Conclusions: Since our and other empirical studies demonstrated that few issues are related to real defects with high precision, developers could enable only them (or prioritize), reducing the information overload of FindBugs and having the possibility to discover defects earlier.Furthermore, the technique presented in the paper can be adopted to other tools on a code base with tests to find issues with high precision that can be checked on code in production to find defects earlier.

Software repositories are analyzed to extract useful information on software characteristics. One of them is external quality. A technique used to increase software quality is automatic static analysis, by means of bug finding tools. These tools promise to speed up the verification of source code; anyway, there are still many problems, especially the high number of false positives, that hinder their large adoption in software development industry. We studied the capability of a popular bug-finding tool, FindBugs, for defect prediction purposes, analyzing the issues revealed on a repository of university Java projects. Particularly, we focused on the percentage of them that indicates actual defects with respect to their category and priority, and we ranked them. We found that a very limited set of issues have high precision and therefore have a positive impact on code external quality.

An international survey on risk management in software development with off-the-shelf (OTS) components is reported upon and discussed. The survey investigated actual risk-management activities and their correlations with the occurrences of typical risks in OTS component-based development. Data from 133 software projects in Norway, Italy, and Germany were collected using a stratified random sample of IT companies. The results show that OTS components normally do not contribute negatively to the quality of the software system as a whole, as is commonly expected. However, issues such as the underestimation of integration effort and inefficient debugging remain problematic and require further investigation. The results also illustrate several promising effective risk-reduction activities, e.g., putting more effort into learning relevant OTS components, integrating unfamiliar components first, thoroughly evaluating the quality of candidate OTS components, and regularly monitoring the support capability of OTS providers. Five hypotheses are proposed regarding these risk-reduction activities. The results also indicate that several other factors, such as project, cultural, and human-social factors, have to be investigated to thoroughly deal with the possible risks of OTS-based projects.

Component-based software development (CBSD) is becoming more and more important since it promotes reuse to higher levels of abstraction. As a consequence, many components are available being either open-source software (OSS) or commercial-off-the-shelf (COTS). However, it is still unclear how the decision for acquiring OSS or COTS components is made in practice. This paper describes an empirical study on why project decision-makers selected COTS instead of OSS components, or vice versa. The study was performed as an international survey in Norway, Italy and Germany. It focused on decision making on using off-the-shelf (OTS) components. We have gathered answers from 83 projects using only COTS components and 44 projects using only OSS components. Results of this study show significant differences and commonalities of integrating OSS or COTS components. Moreover, the study illustrates several research questions that warrant future research.

Test-driven development (TDD) is based on formalizing a piece of functionality as a test, implementing the functionality such that the test passes, and iterating the process. This paper describes a controlled experiment for evaluating an important aspect of TDD: in TDD, programmers write functional tests before the corresponding implementation code. The experiment was conducted with undergraduate students. While the experiment group applied a test-first strategy, the control group applied a more conventional development technique, writing tests after the implementation. Both groups followed an incremental process, adding new features one at a time and regression testing them. We found that test-first students on average wrote more tests and, in turn, students who wrote more tests tended to be more productive. We also observed that the minimum quality increased linearly with the number of programmer tests, independent of the development strategy employed.

Software entities (software products or processes) are characterized by many attributes, each one in its turn can be measured by one or more measures. In several cases the software entities have to be evaluated as a whole, thus raising the problem of aggregating measures to give an overall, single view on the software entity. This paper presents a method to aggregate measures, which works by comparing the product/process with predefined, ideal entities, or profiles. Profiles are defined starting from ranges of values on measures of attributes. The method is based on two main phases, namely definition of the evaluation model and application of the evaluation model. It is presented through a simplified case study that deals with evaluating the level of quality of an asset to decide whether to accept it in a reuse repository. A plausible way of how the method could be applied to process maturity assessment is also provided. The advantages of the method are that it allows using ordinal scales, while it deals explicitly with preferences expressed, implicitly or explicitly, by the evaluator.

For original paper see ibid., p. 474. This is a clear example of how research in software engineering can progress when empirical methods are applied. Menzies and Di Stefano apply a number of data mining tools to the data set. While, inmost cases, their results are in agreement with ours, in some cases they are not. Our first and main observation is that our interpretation of the data set is based not only on the data set itself but also on the knowledge gathered during the interviews with project members. The main problem with the data set is its size: 23 data points. Although this data set is the largest one available about reuse projects, it is too limited to base analysis only on data mining techniques; data mining is usually applied to data sets with thousands if not millions of data points.

IN the recent years, the wireless Internet has become reality. Access is wireless via personal (such as Bluetooth), local (Wi-Fi), or global (cellular) networks. A variety of mobile terminals can be used, PC-like (PDAs, laptops, tablet PCs), or phone-like (smart phones, mobile phones). Several applications are being and will be developed, either to adapt existing ones to the new infrastructure, or to support mobile services, such as travel information, roadside assistance, etc. This scenario raises new engineering challenges, both at the connectivity and at the application level. This special issue deals with the latter, and stems from work done by the guest editors in the domain. The key question is: What is the impact of the wireless Internet on building applications—or what is specific to software engineering for the wireless Internet, as pointed out in the title. From an application developer point of view the challenges include:

Software artifacts are characterised by many attributes, each one in its turn can be measured by one or more measures. In several cases the software artifact has to be evaluated as a whole, thus raising the problem of aggregating measures to give an overall, single view on the artifact.This paper presents a method to aggregate measures, that works comparing the artifact with predefined, ideal artifacts, or profiles. Profiles are defined starting fromranges of values on measures of attributes. The method is based on two main phases, namely definition of the evaluation model and application of the evaluation model, and is presented in a simplified case study that deals with evaluating the level of quality of an asset to decide if accepting it in a reuse repository. The advantages of the method are that it allows using ordinal scales, while it deals explicitly with preferences expressed, implicitly or explicitly, by the evaluator.

This paper aims at identifying some of the key factors in adopting or running a company-wide software reuse program. Key factors are derived from empirical evidence of reuse practices, as emerged from a survey of projects for the introduction of reuse in European companies: 24 such projects performed from 1994 to 1997 were analyzed using structured interviews. The projects were undertaken in both large and small companies, working in a variety of business domains, and using both object-oriented and procedural development approaches. Most of them produce software with high commonality between applications, and have at least reasonably mature processes. Despite that apparent potential for success, around one-third of the projects failed. Three main causes of failure were not introducing reuse-specific processes, not modifying nonreuse processes, and not considering human factors. The root cause was a lack of commitment by top management, or nonawareness of the importance of those factors, often coupled with the belief that using the object-oriented approach or setting up a repository seamlessly is all that is necessary to achieve success in reuse. Conversely, successes were achieved when, given a potential for reuse because of commonality among applications, management committed to introducing reuse processes, modifying nonreuse processes, and addressing human factors.

This paper presents an empirical study in an industrial context on the production of software using a framework. Frameworks are semicomplete applications, usually implemented as a hierarchy of classes. The framework is developed first, then several applications are derived from it. Frameworks are a reuse technique that supports the engineering of product lines. In the study, we compare quality (in the sense of rework effort) and productivity in traditional and framework-based software production. We observe that the latter is characterized by better productivity and quality, as well as a massive increase in productivity over time, that we attribute to the effect of learning the framework. Although we cannot extrapolate the results outside the local environment, enough evidence has been accumulated to stimulate future research work.

No abstract available.

The work described in this paper is an investigation of COTS-based software development within a particular NASA environment, with an emphasis on the processes used. Fifteen projects using a COTS-based approach were studied and their actual process was documented. This process is evaluated to identify essential differences in comparison to traditional software development. The main differences, and the activities for which projects require more guidance, are requirements definition and COTS selection, high level design, integration and testing.

Develops a domain engineering approach and the supporting tools to define software product lines. The approach is composed of a process and a notation. The notation is an extension of UML (Unified Modeling Language), while the process is influenced by the Synthesis and FAST domain engineering methods. Supporting tools have been built on top of a commercial CASE tool for UML. This paper focuses on the domain analysis part of the approach and specifically on the notation and tools to support it. The approach is being applied to sub-domains of the guidance, navigation and control domain, which are a set of functionalities used on-board satellites developed by the NASA Goddard Space Flight Center.

No abstract available.

Object-oriented programming, through the use of a library of standard classes and their inheritance relationships, offers a consistent framework to specify, design, and prototype the software architecture of complex discrete event control systems. This work applies such a framework to computer integrated manufacturing, proposing a unified view to represent the hierarchical control structure of a commonly accepted reference model. The results are a library of classes (called G++ and based on the C++ programming language) to express concurrency and to support an extended client server paradigm, and a new design methodology.>

Production scheduling on a flexible manufacturing system is a mixed continuous combinatorial optimization problem. Closed queueing network analysis is the technique we used to solve the continuous problem. Around it a rule based module has been established to heuristically solve the combinatorial problem. Two schedulers have been implemented, considering shorter or longer intervals of time, both based on the new solution paradigm for production scheduling.

Prot nets are an extension to Petri nets, since they can be given a sophisticated semantics by assigning formal inscriptions to the objects of the net. In several applications to CIM (computer integrated manufacturing) systems they proved to give suitable support to object oriented programming, operational specification and rapid prototyping. In this work we present a graphical language, based on Prot nets, for building the specification of discrete event simulation models, and we illustrate its application to the simulation of a manufacturing cell.