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]

Abstract: It is widely accepted that users should be involved in the development of interactive systems. However, involving users in interactive systems development is challenging, especially in product development. The organizational culture is a key factor affecting the successes and failures of organizational change and development efforts. This paper shows how user involvement is intertwined with the organizational cultures in a case study of five software development organizations. User involvement is indirect in the case organizations, and labeled as usability work. Using cross case analysis, four ‘cultures of usability work’ are identified. The cultures have distinct cultural characteristics, employ different approaches to usability work, and have different preferences and strategies for the prospective facilitation of usability work. Sensitivity to the cultural context is identified as an important consideration in the facilitation of usability work, and culturally compatible strategies for usability work in different cultural settings are identified. The paper concludes that there might not be one ‘best, universally valid, context free way’ of introducing and carrying out usability work in software product development organizations. [Copyright &y& Elsevier]

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]

Abstract: Group awareness is critical to improving the collaboration efficiency of a group, especially when teammates are geographically separated while working on the web. Previous studies have focused mainly on enhancing the awareness of the current working status of teammates, such as web pages being viewed, or other web activities, and they seldom take into account past working/browsing information, such as web pages visited or past web activities. However, the awareness of this kind of historical information can be useful for group collaboration. In this paper, we propose a novel approach to sharing web page visitation information among teammates. We present the design and implementation of our prototype, named Shared Browsing History. We then describe two user studies in which three groups with eight participants each used the prototype. The results of these studies show that our approach was effective in enhancing participants’ group awareness and improved group collaborative efficiency in programming and software development tasks. [Copyright &y& Elsevier]

Composing large enterprise applications from reusable software components has become a major software development technique. Components are considered as black boxes and are composed together by their provided and required services. In comparison to other software development approaches, this allows for rapid development, clean and explicit architectures, and easy component reuse. Currently, there are several systems that support development and composition of components: service component architecture and Fractal are two well-known ones. At first sight, both have the same goals and provide very similar means to developers. In this paper, we briefly present both systems and then we focus on an in-depth comparison and evaluation of them. [ABSTRACT FROM AUTHOR]

Abstract: When we develop an input device for users to communicate with computers, we have to take into account that end-users must consider the utilization of the device to be effective, efficient and satisfactory. Users whose expectations are unmet by the interface will tend to abandon it. In this paper we present a vision-based interface for motor-impaired users; a multidisciplinary group developed this interface. The user’s preferences are a critical issue when selecting an access device; therefore, user requirements should be included in the design. Usability evaluation should be integrated into relevant phases of software development. In order to evaluate the design, we present a process with multiple user studies at different development stages. We describe the combination of a development project and its implementation, with user experience considerations embedded in the process. Finally, we studied the performance of the interface through several tests, paying special attention to satisfaction and fatigue. From our results we observed that although several users found the interface tiring, their satisfaction level was encouraging, suggesting the interface is usable. [Copyright &y& Elsevier]

Abstract: Agile software development promotes feedback, discipline and close collaboration between all members of the development team, and de-emphasises documentation, ‘big design up front’ and hierarchical processes. Agile teams tend to be co-located and multi-disciplinary, and rely heavily on face-to-face communication and seemingly simple physical artefacts to support interaction. In this paper we focus on the functionality of two key physical artefacts – the story card and the Wall – which, individually and in combination, underpin the team’s activity. These artefacts have two main roles – one which enables a shared understanding of requirements and one which facilitates the development process itself. We consider these roles from two perspectives: a notational perspective and a social perspective. This discussion shows how the two perspectives – the notational and the social – intertwine and are mutually supportive. Any attempt to replace these physical artefacts with alternative support for an agile team needs to take account of both perspectives, and the complex relationships between them. [Copyright &y& Elsevier]

Abstract: This paper investigates the relationship between software development methodologies and usability. The point of departure is the assumption that two important disciplines in software development, one of software development methods (SDMs) and one of usability work, are not integrated in industrial software projects. Building on previous research we investigate two questions; (1) Will software companies generally acknowledge the importance of usability, but not prioritise it in industrial projects? and (2) To what degree are software development methods and usability perceived by practitioners as being integrated? To this end a survey in the Norwegian IT industry was conducted. From a sample of 259 companies we received responses from 78 companies. In response to our first research question, our findings show that although there is a positive bias towards usability, the importance of usability testing is perceived to be much less than that of usability requirements. Given the strong time and cost pressures associated with the software industry, we believe that these results highlight that there is a gap between intention and reality. Regarding our second research question our survey revealed that companies perceive usability and software development methods to be integrated. This is in contrast to earlier research, which, somewhat pessimistically, has argued for the existence of two different cultures, one of software development and one of usability. The findings give hope for the future, in particular because the general use of system development methods are pragmatic and adaptable. [Copyright &y& Elsevier]

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]

Abstract: Recently, research in individual differences and in particular, learning and cognitive style, has been used as a basis to consider learner preferences in a web-based educational context. Modelling style in a web-based learning environment demands that developers build a specific framework describing how to design a variety of options for learners with different approaches to learning. In this paper two representative examples of educational systems, Flexi-OLM and INSPIRE, that provide learners a variety of options designed according to specific style categorisations, are presented. Experimental results from two empirical studies performed on the systems to investigate learners'' learning and cognitive style, and preferences during interaction, are described. It was found that learners do have a preference regarding their interaction, but no obvious link between style and approaches offered, was detected. Derived from an examination of this experimental data, we suggest that while style information can be used to inform the design of learning environments that accommodate learners'' individual differences, it would be wise to recommend interactions based on learners'' behaviour. Learning environments should allow learners or learners'' interaction behaviour to select or trigger the appropriate approach for the particular learner in the specific context. Alternative approaches towards these directions are also discussed. [Copyright &y& Elsevier]

Although trivial in principle, direct comparison of galaxy clusters X-ray observations to numerical hydro– N-body simulations is not always simple, because of many possible artefacts introduced by the instrument response, sky background and instrumental noise. To address these problems, we constructed the software package x-mas (X-ray Map Simulator), a tool devoted to simulate X-ray observations of galaxy clusters obtained from hydro– N-body simulations. One of the main features of x-mas is the ability to generate event files following the same standards used for real observations. This implies that its simulated observations can be analysed in the same way as – and with the same tools of – real observations. In this paper we present how the x-mas package works, and discuss its application to the simulation of Chandra ACIS-S3 observations. Using the results of high-resolution hydro– N-body simulations, we generate fake Chandra observations of a number of simulated clusters. We then compare some of the main physical properties of the input data to those derived from the simulated observations after performing a standard imaging and spectral analysis. We find that, because of the sky background, the lower surface brightness spatial substructures, which can be easily identified in the simulations, are no longer detected in the simulated observations. We also show that, when a cluster has a complex (i.e. not isothermal) thermal structure along the line of sight, then the projected spectroscopic temperature obtained from the observation is significantly lower than the emission-weighed value inferred directly from hydrodynamical simulation. This implies that much attention should be paid in the theoretical interpretation of observed temperatures. [ABSTRACT FROM AUTHOR]

In this paper we present a process model for developing usable cross-cultural websites. Compatible with ISO 13407, the process model documents an abstraction of the design process focusing on cultural issues in development. It provides a framework in which a variety of user-based and expert-based techniques for analysis and design are placed within the life-cycle of website development. In developing the model, we relate practical approaches to design with theories and models of culture and discuss the relevance of such theories to the practical design process. In particular we focus on four key concerns: how an audit of local website attractors can inform the design process; the concept of a cultural fingerprint to contrast websites with the cultural needs of local users; the problems associated with user evaluation; and cross-cultural team development. We then show their relation to our process model. We conclude by summarising our contribution to date within the field. [Copyright &y& Elsevier]

Brain–body interfaces (BBIs) have been shown through a number of studies to be useful assistive technology devices for recreation and communication. However, severely motor impaired persons with no other means of interacting with their environment have had difficulties using the standard communication software for the Cyberlink, the commercially available BBI device which we used in our studies. We have therefore developed a simple Yes/No program, drawing on a range of design and evaluation approaches from Human–Computer Interaction research. This paper presents the first extensive evaluation of this program. Its evaluation combines formal assessments with observations from users, carers and technology and mental health professionals who are involved in the research. Our conclusions are that the performance of severely impaired individuals cannot be readily separated from that of novice unimpaired users, that worthwhile results can be achieved with the Yes/No program, but at the moment the cost of using a Cyberlink is too high for most assistive technology contexts. However, for severely impaired individuals, Cyberlink use may be the only form of recreation and communication available to them, and thus the current limitations of the technology are acceptable for this user population. [Copyright &y& Elsevier]

During component-based and object-oriented software development, software classes exhibit relationships that complicate integration, including method calls, inheritance and aggregation. Classes are integrated and tested in specific orders, where each class is added and tested one by one to see if it integrates successfully. A difficulty arises when cyclic dependencies exist—the functionality that is used by the first class to be tested must be mimicked by creating ‘stubs’ (sometimes called ‘mock objects’), an expensive and error-prone operation. This problem is generally called the class integration and test order (CITO) problem, and solutions must fully be automated for integration and testing to proceed smoothly and efficiently. This paper describes new techniques and algorithms to solve the CITO problem. New results include improved edge weights to more precisely model the cost of stubbing, and the use of node weights, which allows more information to be used. These weights are derived from quantitative measures of couplings between the integrated and the stubbed classes. Also, a new algorithm for computing the integration and test orders is presented. The technique is compared with an existing approach and found to be cheaper, get the same results when using edge weights exclusively, and yield better results when using node weights. [ABSTRACT FROM AUTHOR]

In this paper, we will present a design technique for user and database interaction based on UML. User interaction will be modeled by means of UML state diagrams, and database interaction by means of UML sequence diagrams. The proposed design technique establishes how to integrate both diagrams in order to describe the user interface and database interaction of a business software system. A case study of an Internet Book Shopping system will be shown to illustrate the proposal. [ABSTRACT FROM AUTHOR]

Software systems grow each day in size and complexity. In an effort to manage increasing complexity and to maximize the reuse of code, the software engineering community has, in recent years, put considerable effort into the design and development of component-based software methodologies and tools. Inspired by the notion of connector (Allen and Garlan (1994) Formal connectors. Technical report CMU-CS-94-115, Carnegie Mellon University, PA, USA) in software architecture and the ‘Design by Contract’ metaphor proposed by Meyer ((2000) Object-Oriented Software Construction. Prentice Hall, USA), this paper presents a methodology for component composition, coordination and dynamic adaptation. Our proposal is based on connectors enriched with contracts, making software architecture more explicit at the implementation level. Those connectors will be components in our system. Therefore, we can use subtyping techniques for connectors development and we could offer a set of generic connectors implementing standard behavior patterns. In addition, the connectors will use semantic web techniques and a Prolog machine to solve functional adaptation problems, such us name or parameters mismatching of a service, at run-time. [ABSTRACT FROM AUTHOR]