Search

Mashups are web applications that expedite software development by reusing existing resources through integrating multiple application programming interfaces (APIs). Recommending the appropriate APIs plays a critical role in assisting developers in building such web applications easily and efficiently. The proliferation of publicly available APIs on the Internet has inspired the community to adopt various models to accomplish the recommendation task. Until present, considerable efforts have been made to recommend the optimal set of APIs, delivering fruitful results and achieving varying recommendation performance. This paper presents a timely review on the topic of API recommendations for mashup creation. Specifically, we investigate and compare not only traditional data mining approaches and recommendation techniques but also more recent approaches based on network representation learning and deep learning techniques. By analyzing the merits and pitfalls of existing approaches, we pinpoint a few promising directions to address the remaining challenges in the current research. This survey provides a timely comprehensive review of the API recommendation research and could be a useful reference for relevant researchers and practitioners. [ABSTRACT FROM AUTHOR]

Software size estimation is a vital activity of software project planning and management. Early software size estimation is a challenging task due to the limited information available during the early phases of software development. The goal of this paper is to construct and validate early software size estimation models based on four analysis-to-design adjustment factor (ADAF)-adjusted analysis class diagram metrics (i.e. ADAF-adjusted number of classes, ADAF-adjusted number of attributes, ADAF-adjusted number of methods and ADAF-adjusted number of relationships) using stepwise multiple linear regression and leave-one-out cross-validation. Furthermore, the prediction accuracy of the best-performing proposed model is also compared with the model based on objective class points. The results of this comparison reveal that our proposed method reduces errors significantly (i.e. on average, 16% reduction in mean absolute residual and 24% reduction in mean squared error). [ABSTRACT FROM AUTHOR]

In this paper, we present CALSAGOS : Clustering ALgorithmS Applied to Galaxies in Overdense Systems which is a PYTHON package developed to select cluster members and to search, find, and identify substructures. CALSAGOS is based on clustering algorithms, and was developed to be used in spectroscopic and photometric samples. To test the performance of CALSAGOS , we use the S-PLUS's mock catalogues, and we found an error of 1–6 per cent on member selection depending on the function that is used. Besides, CALSAGOS has a F 1-score of 0.8, a precision of 85 per cent and a completeness of 100 per cent in the identification of substructures in the outer regions of galaxy clusters (r > r 200). The F 1-score, precision, and completeness of CALSAGOS fall to 0.5, 75, and 40 per cent when we consider all substructure identifications (inner and outer) due to the function that searches, finds, and identifies the substructures works in 2D, and cannot resolve the substructures projected over others. [ABSTRACT FROM AUTHOR]

Correctness of the designed system is one of the most important issues in the software development process. Therefore, various tests have been defined and designed to help software teams develop software with little or no problem. Finding a proper link between test class and the class under the test is an important but difficult task. Finding this relation helps the developers to conduct regression tests more efficiently. In this paper, we seek to propose a model for recovering traceable links between test classes and the classes under the test. The proposed method encompasses three parts: (1) method for extracting keywords and the measure of similarity of a specific part of code, (2) backward chain method based on a rule-based system, (3) using hybrid model to find traceable links between test classes and the code under test. This study uses three open-source and one industrial source projects to conduct experiments. The results are satisfactory compared to previous studies. [ABSTRACT FROM AUTHOR]

Feature models (FMs) are widely used to describe software product lines (SPL). They specify common and variation points in the domain of the SPL. Because of their wide domain coverage, FM development requires extensive domain analysis and important domain expertise that is often hard to acquire. These development requirements motivated us to propose, in this paper, a top-down method that extracts automatically an FM from functional requirements of product variants. Besides its automation, its novelty stems from the use of semantic information mined through natural language processing techniques to extract potential features from each product variant. To account for name variations, our method harmonizes the names of the features extracted from the product variants by using a classification technique to group similar features. In addition, to determine the feature type, it uses the formal concept analysis technique to distinguish mandatory from optional features. Furthermore, to structure the FM, it uses a set of semantic criteria to determine the constraints among the features. The paper reports on a quantitative and a comparative evaluation of the method on existing FMs, and it examines the conformity of the generated FMs to the input functional requirements, based on experts' feedbacks. [ABSTRACT FROM AUTHOR]

Modern computing platforms have progressed to deploying more secure software with various defensive techniques such as code signing and application whitelisting. However, the adversary, on the other hand, has been developing offensive techniques including using legitimate digital certificates in their attacks. In this paper (extended version of a paper published in the conference DSN 2015), we propose a new security mechanism for software systems that extends the Windows integrity mechanism and code signing technique. Our security mechanism gives rise to three major benefits. First, it prevents a wide range of attacks such as DLL hijacking and DLL injection, and mitigates the impact of shellcode that is executed by successful software vulnerability exploitation. It also prevents the use of untrusted plugins such as web browser add-ons. Second, it achieves developer-enforced security at the software component level so that components cannot be abused by malware. Third, it ensures a flexible environment where untrusted applications and software components are allowed to be loaded/executed at a low integrity level with restricted access permissions to system resources. We have implemented a prototype and carried out a thorough evaluation, showing the advantages of our proposed mechanism in mitigating real world malware attacks and preventing unauthorised software use as well as demonstrating the ease of adoption for software developers. [ABSTRACT FROM AUTHOR]

It is commonly believed that human-centred design (HCD) approach is very beneficial to interactive systems development. However, not much is known about the state of HCD practice in developing countries, especially the sub-Saharan Africa. This paper explores the state of HCD practice in three Nigerian software companies. We used the interview technique to explore two key issues. First, the perception of humans as a component of sociotechnical systems, and second, how HCD process is being approached in software companies. A cross-case analysis of the three companies was performed and the usability maturity model-human-centredness scale was used to determine the state of maturity of the three companies. The outcomes of this study reveal that HCD practice is currently at the least stage of maturity in the three companies and user involvement is not practiced in the right manner. The outcomes of the study suggest the need for reflective HCD practice and localizing human–computer interaction approaches to contexts. [ABSTRACT FROM AUTHOR]

Software development requires adequate methods for requirements engineering, design, development, testing and maintenance. The more complex the system is, the more sophisticated methods should be applied. A significant part of software projects is short on appropriate requirements engineering, communication, development and testing method, furthermore, verification and validation processes; i.e., not the right method is applied, and the project turns into ad hoc design and development decisions. This paper introduces our quality assured model-driven requirements engineering and software development method. The method is based on the modeling of the software requirements in a way that these models can be used to automatically generate several artifacts during the engineering process. This method is continuously developed during the last 12 years driven by our software projects. In the last two years, we have developed new tool support and also reworked the method. In this paper, as an experience report, we introduce the method: a framework to specify software requirements with four domain-specific languages and automated solutions to process the models. We focus on the requirements engineering method of the whole development cycle. We also report the lessons learned and share our best practices on the field of model-driven requirements engineering and software development. [ABSTRACT FROM AUTHOR]

Agent-oriented technology is arguably one of the most substantial advances in software development. Several platforms and architectures have been developed to deal with its conception and the advantages that it entails. Of these architectures, the belief-desire-intention architecture is amongst the most prominent. This architecture utilizes a series of beliefs known to the agent in order to fulfil its desires given its intentions. Regardless of the agent platform or architecture, however, they all share the common trait of complexity. In sight of this, an increasing amount of research has been done in relation to model-driven approaches to their development. One such model-driven approach is the dynamic non-functional requirements-based approach. This approach utilizes a series of non-functional requirements to control the agents decision-making process, using the extended non-functional requirements framework as its underlying model. This paper presents the inclusion of a unique change management system through out this model-driven approach. This system is capable of categorizing changes, assigning them priorities based on various dynamics and determining their optimal incorporation time. To our knowledge, this is the first time that a change management model has been used in relation to model-driven agent creation. This approach is verified using a randomized empirical-based evaluation. [ABSTRACT FROM AUTHOR]

There has been long-standing interest in automatically generating test sequences from a finite state machine (FSM) and more recently this has been extended to the case where there are multiple physically distributed testers and so we are testing from a multi-port FSM. This paper explores the problem of generating a controllable preset distinguishing sequence (PDS) from a multi-port FSM, motivated by the fact that many FSM-based test generation algorithms use PDSs. We prove that it is generally undecidable whether a multi-port FSM has a controllable PDS but provide a class of multi-port FSMs for which the problem is decidable. We also consider the important case where there is an upper bound ℓ on the length of PDSs of interest, proving that controllable PDS existence is PSPACE-hard and in EXPSPACE. In practice the upper bound ℓ is likely to be a polynomial in terms of the size of the multi-port FSM and in this case controllable PDS existence is NP-Complete. [ABSTRACT FROM AUTHOR]

Due to the increasing scale and complexity of software products, software maintenance especially on bug resolution has become a challenging task. Generally in large-scale software programs, developers depend on software artifacts (e.g., bug report, source code and change history) in bug repositories to complete the bug resolution task. However, a mountain of submitted bug reports every day increase the developers' workload. Therefore, 'How to effectively resolve software defects by utilizing software artifacts?' becomes a research hotspot in software maintenance. Considerable studies have been done on bug resolution by using multi-techniques, which cover data mining, machine learning and natural language processing. In this paper, we present a literature survey on tasks, challenges and future directions of bug resolution in software maintenance process. Our investigation concerns the most important phases in bug resolution, including bug understanding, bug triage and bug fixing. Moreover, we present the advantages and disadvantages of each study. Finally, based on the investigation and comparison results, we propose the future research directions of bug resolution. [ABSTRACT FROM AUTHOR]

In software product lines development, it is sometimes important to provide a flexible binding time for features such that developers can choose between static or dynamic feature activation. For example, software products designed for devices with constrained resources may use a static binding time to avoid the performance overhead introduced by dynamic binding time activation. However, other devices can exploit binding time flexibility to support products with a dynamic binding time for some of their features. To implement this kind of flexibility in a modular way, we can define AspectJ-based idioms. Researchers have proposed Edicts, an idiom based on AspectJ and design patterns. In this article, we argue that this idiom leads to an increase in code duplication, scattering, tangling and size, which can hamper code reuse, maintenance and understanding. To mitigate such issues, this paper proposes three idioms based on aspect-oriented programming to implement flexible feature binding. We apply our three idioms, along with Edicts, to implement a flexible binding time for features in four different applications. By doing so, we were able to assess the resulting implementations by using software metrics that judge code-quality factors. Our evaluation suggests that our idioms reduce the above-mentioned problems when implementing flexible feature binding for the selected features. [ABSTRACT FROM AUTHOR]

Triggered by our occasionally tense field experiences relating to the implementation and institutionalization of usability in design engineering organizations that are characterized by traditional engineering education and thinking, we have earlier suspected that the activities associated with human-centered design were orthogonal to the design engineering practices otherwise in place. While noting that other human factors professionals have had comparable challenges relating to multidisciplinary design, we have, however, reached a point where we rather are suggesting that the ontological, epistemological and methodological grounding of classic design engineering, under some circumstances, could be the direct cause for friction between that discipline and that of human factors. In a way taking our own medicine, we have thus arrived at a place where we are realizing the need for an ethnographical exploration and improved understanding of classic design engineering fundamentals, appreciating that a more successful and fruitful interaction and cooperation with that essential discipline very well could spring from a deeper and more nuanced understanding of the mindset of the classic design engineer. The main part of the present paper pivots around developing such an insight, hoping to contribute to the effective, efficient and satisfactory outcome of multidisciplinary cooperation for those who find themselves being tasked with human-centric work in traditional engineering organizations. [ABSTRACT FROM AUTHOR]

Motivation Metabolomics is a data analysis and interpretation field aiming to study functions of small molecules within the organism. Consequently Metabolomics requires researchers in life sciences to be comfortable in downloading, installing and scripting of software that are mostly not user friendly and lack basic GUIs. As the researchers struggle with these skills, there is a dire need to develop software packages that can automatically install software pipelines truly speeding up the learning curve to build software workstations. Therefore, this paper aims to provide MetumpX, a software package that eases in the installation of 103 software by automatically resolving their individual dependencies and also allowing the users to choose which software works best for them. Results MetumpX is a Ubuntu-based software package that facilitate easy download and installation of 103 tools spread across the standard metabolomics pipeline. As far as the authors know MetumpX is the only solution of its kind where the focus lies on automating development of software workstations. Availability and implementation https://github.com/hasaniqbal777/MetumpX-bin. Supplementary information Supplementary data are available at Bioinformatics online. [ABSTRACT FROM AUTHOR]