Current Software Development Research Articles

Heuristics-based mediation for building smart architectures at run-time

Smart architectures are increasingly being used in current software development. Smart user interfaces, smart homes, or smart buildings are becoming common examples in the new era of smart cities. Software architectures usually related to these domains need to be adapted and reconfigured at run-time, for example, to provide new services, react to user interaction, or due to changes decided from the business logic of the application. Component-based techniques are a suitable way to carry out this kind of adaptation, as dynamic reconfiguration operations can be applied to the architecture. In this paper, we address run-time generation of component-based applications, taking the abstract definitions of their architecture as a reference, in addition to a set of available components. The process calculates the best configuration of components from the abstract definition by applying a trading approach based on an adapted A* algorithm. This algorithm uses heuristics based on syntactic and semantic information obtained from the component definitions. A case study related to mashup user interfaces formed by coarse-grained components is also explained. In short, the results show the usefulness of heuristics and suitable execution times for building the best configurations.

Virtual instrument designed for data acquisition

Current software development directions open up a world of possibilities, especially in the engineering field. Present paper is meant to highlight the advantages and in particular the ease of using virtual instrumentation facilities, with a proper and adequate design and implementation of desired instrument. In this idea we bring into discussion a design for virtual instrument which can be used for data acquisition that can be stored for further simulations according to the needs required by the process in discussion.

Empirical Validation of OO Metrics Impact on Changeability

In the context of current software development, where changes to an application are made from one sprint to another, it’s more and more necessary for developers to be able to easily change the existing code. Starting from the existing literature and using two commercial projects with multiple versions and different architecture we are trying to confirm a correlation between a possible changeability indicator and variations of OO metrics. In our research we managed to provide empirical evidence of the relation between certain OO metrics that can be computed for a system and the changeability quality attribute.

Modelling multi-criticality vehicular software systems: evolution of an industrial component model

Software in modern vehicles consists of multi-criticality functions, where a function can be safety-critical with stringent real-time requirements, less critical from the vehicle operation perspective, but still with real-time requirements, or not critical at all. Next-generation autonomous vehicles will require higher computational power to run multi-criticality functions and such a power can only be provided by parallel computing platforms such as multi-core architectures. However, current model-based software development solutions and related modelling languages have not been designed to effectively deal with challenges specific of multi-core, such as core-interdependency and controlled allocation of software to hardware. In this paper, we report on the evolution of the Rubus Component Model for the modelling, analysis, and development of vehicular software systems with multi-criticality for deployment on multi-core platforms. Our goal is to provide a lightweight and technology-preserving transition from model-based software development for single-core to multi-core. This is achieved by evolving the Rubus Component Model to capture explicit concepts for multi-core and parallel hardware and for expressing variable criticality of software functions. The paper illustrates these contributions through an industrial application in the vehicular domain.

MATHEMATICAL MODELING USING COORDINATION MECHANISMS FOR MULTI-AGENT SYSTEMS IN SERVICE ORIENTED ARCHITECTURE

In software engineering, formal methods are mathematical based techniques used to provide the specification, development, and verification of software systems prior to the implementation. The formal methods have been used widely in software development because of its promising benefits in coherence degree and coordination between activities of software application. Coordination is a common issue in distributed cross-platform communications, which implemented in agent-based software. The study of the coordination problem is an important issue in the multi-agent system. In the current software development industry, most software products are produced with the expectation that the application will provide intelligent coordination with the minimum level of interruption. This case is not always acceptable especially for the critical system especially those that deal with complex communications that involved multiple types of participants where the partner application needs to know about the basic guide and specification of each other. The proposed solution is dealing with one of these issues as it evaluates the coordination between the partner applications where the accuracy of responding is involved. For this reason, we modeled the proposed system mathematically using Coordination mechanisms to validate and verify the system for cross-platform communications in SOA system.

SR-UML: Quality Visualization in Software Design

The current requirements of software are intensively based on load sharing, on-demand services, cascading requirements, redundancy for reliability and executing on heterogeneous environments. It needs precise architectural details for development of such software systems. These are large scale software systems with complex interactions amongst the constituent components. Testing for performance and conformance to quality requires perspective modeling fordesigning critical systems. The analysis of these systems is focused on dynamic or execution time behavior for achieving quality. In the same context, this paper redefines Functional Flow Specification for dynamic analysis of critical and collaborating systems. Functional Flow based modeling is a mature concept in the domain of system engineering but is rarely applicable to software systems. Functional Flow Block Reliability Diagram (FFBRD) is a notation for abstract view of the system evolution and interactions. This adopts the specification format of UML and system modeling conventions of SysML specially Enhanced Functional Flow Block Diagram (EFFBD). The flow of data and control are so designed that it best suits the approaches for quality analysis like system reliability. The method proposed is System Reliability with UML or SR-UML for generating test through FFBRD. It also caters to the need of designing software in a familiar formalization for extending, translating and simulating with existing algorithms. From the results collected through various scenarios, we can conclude that SR-UML is instrumental in process improvement of current software development methods.

Healthy Code Reveals the Problem and Solution

Source code reveals abstractions from two places: the problem and the solution. It's easier to design and evolve a system when you understand each of them separately before you combine them in code. With skill, it's possible to separate those concerns in the code. Declarative understanding of the abstractions is the most useful and easy to convey. However, current software development processes rarely guide developers to do this.

Mining Reusable Software Components from Object-Oriented Source Code using Discrete PSO and Modeling Them as Java Beans

Object-based software development in the IT-industry during the last decade has focused on reusing the already developed elements. Current software development models and technologies promote software reuse by utilizing component-oriented programming. Component-oriented programming provides more effective reuse as compared to its object-oriented language counterpart. This is because a component provides more abstractness in terms of the functionality in contrast to the object-oriented software element (e.g. class/ interface). The component-based development is highly dependent on the availability of the component library that contains well-defined and already tested functionality in terms of the available components. However, the suitable availability of such component library is still a problem. The lack of a suitable component library is tackled either by designing new components from scratch or by identifying them from the existing software systems. These identified components must be transformed as per component models, such as a Java Bean, in order to increase software reuse and faster software development, and little research has been carried out in this direction. Although many approaches have been proposed to identify components from existing systems and build a component library. But, such approaches lack in transforming the identified components as per specifications of a component model. Further identification of reusable elements also needs to be more accurate and efficient. Accuracy is dependent on the structural and semantic properties of a component. A component can consist of a single or a group of individual elements of the software, and thus identifying components from a set of all elements becomes an exponentially growing problem. Such problems can be more efficiently solved using metaheuristic algorithms. Therefore, this paper targets identifying accurately the components from a singular existing software system and transform those identified components to the Java Bean component model standard. The component identification approach of this paper is based on clustering the underlying software system by utilizing a metaheuristic search-based PSO algorithm. The clusters are identified as a group containing 2/ 3/ 4 software elements. Moreover, the used fitness function is based on the structural (based on usage for member variables) and semantic relations belonging to a software. Since the PSO algorithm is generally applied to continuous problems, whereas our formulated component identification problem is discrete (due to the representation of particles) in nature. Therefore, we have also provided a mechanism through which the PSO algorithm is modified to become applicable to discrete problems. From the obtained clusters (components), the interfaces of the components are identified by identifying independent chains in call-graphs of the underlying components. Finally, these components are transformed as per the Java Bean component model specifications. The proposed approach is validated experimentally on 7 open-source object-oriented Java software systems and results are compared with competitive approaches. The obtained results confirm the correctness of the transformed component and hence their reusability.

Interdisciplinary Technical Exercises for Informatics Teacher Students

More and more of today’s devices are electronic and software operated. Since they measure the signals of the real world and act as a result of processing, informatics is getting closer to interdisciplinary fields. The technology of everyday devices, automotive industry, Industry 4.0, Internet of Things (IoT) are based al-so on engineering, physics, electronics, biology and other fields besides informatics. Accordingly, the in-terdisciplinarity is important in education too, it is essential to teach related solutions of technology for the informatics teacher students since they will certainly need it during their teaching practice. Although the development of technology is still very rapid, the main principles of operation remain the same, so education should focus on this rather than on the teaching of a current software development environ-ment or hardware realization. Following this idea, we have worked out several laboratory exercises for our programme of informatics teacher students. During their work they construct some circuits, write the code and practice the fundamental methods of embedded software development. We report on how they could understand and learn the most important principles during working on an educational, a commer-cial, an industrial and a medical field related exercise. The associated experience-based learning helps sys-tematic understanding and development of creativity. Based on our experience, students are getting more self-confident by the use of modern technical systems, which we consider particularly important.

Re-examining the relationship between ease of use and usefulness for the net generation

The technology acceptance model, and extensions of it, suggests a causal relationship between the perceived ease of use and usefulness of an information technology system. Using a dataset based on the responses from 247 undergraduate business students in relation to their use of an educational technology system, we compared competing structural equation models of technology acceptance. We found support for our hypotheses indicating that, while ease of use is important, it does not determine perceived usefulness. Task-technology fit is, however, a direct causal antecedent of perceived usefulness and this relationship is modified by perceived ease of use. The results of this study suggest that technology acceptance models may need to be revised to consider changes in users’ perceptions and behaviour related to the use of mobile computing technology and current software development practices.

40 Years Journey of Function Point Analysis: Against Real-time and Multimedia Applications

For various project of software development, the size, effort, and cost are essential aspects for planning schedules and control software development to achieve the preferred outcome. These aspects require a method to measure software accurately and reliably. Function Point Analysis is used as a standard method for that purpose. It is now 40 years old since Albrecht founded it in 1979. Bringing its advantages and some of the drawbacks from earlier versions, this method is now faced with current software development needs, namely, the real-time and the multimedia applications. Broadly translated our findings indicate that current software development does not only focus on system functionality, but non-functional factors also begin to influence the value of a system for the users. Therefore, in 40 years journey of Function Point Analysis, this method is not adequate for current software development, especially in real-time and multimedia applications because of the inability to measure non-functional factors.

Virtual Reality and Its Application in Military

In recent years, the virtual reality technology has been greatly developed and applied to many fields, its application extends to product design, education and training, military and aerospace, entertainment and leisure fields. This article summarizes the current developments in hardware and software of virtual reality technology and its application in the military field, and then analyzes the future development trends of the application of virtual reality in military.

HPC software capability landscape in China

Hardware, applications, and software are equally important to the comprehensive strength of a country in the high-performance computing (HPC) arena. China has made significant progress in developing HPC systems in recent years. The nation’s first win of the Gordon Bell Prize at Supercomputing 2016 (SC16) also represents an accomplishment in HPC applications. China’s subsequent win in 2017 shows that the 2016 accomplishment was no accident. However, lacking adequately reliable and scalable application software remains the biggest challenge for China. Scientists and engineers who can develop algorithms and software to effectively use supercomputers are in short supply. The present report describes the current HPC software development landscape in China, including government projects and leading universities/research organizations/companies in terms of developing application software and programming frameworks (middleware), as well as examples of self-developed software in the application areas of energy and physics, aerospace, manufacturing, weather and climate, biotechnology (biotech), material science, artificial intelligence (AI), and data analytics. In addition, China’s demand and supply of HPC experts are analyzed. Data for this report were generated during the first half of 2017. Some modifications to the text have been added to account for new information through the end of 2017.

A proposed Framework for Software Process Improvement: Extending CMMI-DEV model Using Six Sigma and Quality Function Deployment Techniques

Software Process Improvement (SPI) has become the key to the survival of many software development organizations. Many international SPI models/standards, such as; ISO, Capability Maturity Model Integrated (CMMI), SPICE, Trillium…etc, are developed for SPI. Numerous software development companies have chosen to utilize CMMI to access and improve their current software development process, because CMMI is one of the most widespread and acknowledged SPI models. Unfortunately, CMMI does not provide a systematic way of determining to improve the process. That is, CMMI defines what to but leaving how to do to organizations. Thus, it is desirable to have a means to guide the companies in the development of action plans and appropriate tools for SPI. These actions should be based on the software process requirements from relevant sources. Therefore, this research proposes a SPI-CMMI framework that provides an overall process improvement strategy to be implemented in any software development organization more effectively and comprehensively. The proposed model based on applying assessment and improvement procedures through adopting the CMMI-DEV 1.3 model using six sigma approach and Quality Function Deployment (QFD) technique.

Guest Editorial Special Issue on Computational Intelligence for Software Engineering and Services Computing

The papers in this special section focus on computational intelligence for software engineering and services computing. Recently, there has been an increasing demand for complex systems in distributed and mobile environments. The development of these complex software systems is challenging, especially while dealing with dynamic, imprecise and uncertain information and environments. In the recent years, an emerging paradigm is to focus on the investigation and integration of computational intelligence tools into current software development practices to address the growing complexity of software systems and improving their robustness. This emerging paradigm uses various techniques from the computational intelligence literature (e.g., knowledge-transfer and data-driven search, fuzzy logic, machine learning, evolutionary computation, etc.) to address problems related to requirements engineering, services computing, cloud computing, Internet of Things (IoT), quality of services, software testing, model-driven engineering, etc.

Finding parallel patterns through static analysis in C++ applications

Since the ‘free lunch’ of processor performance is over, parallelism has become the new trend in hardware and architecture design. However, parallel resources deployed in data centers are underused in many cases, given that sequential programming is still deeply rooted in current software development. To address this problem, new methodologies and techniques for parallel programming have been progressively developed. For instance, parallel frameworks, offering programming patterns, allow expressing concurrency in applications to better exploit parallel hardware. Nevertheless, a large portion of production software, from a broad range of scientific and industrial areas, is still developed sequentially. Considering that these software modules contain thousands, or even millions, of lines of code, an extremely large amount of effort is needed to identify parallel regions. To pave the way in this area, this paper presents Parallel Pattern Analyzer Tool, a software component that aids the discovery and annotation of parallel patterns in source codes. This tool simplifies the transformation of sequential source code to parallel. Specifically, we provide support for identifying Map, Farm, and Pipeline parallel patterns and evaluate the quality of the detection for a set of different C++ applications.

SAFFRON: A Semi-Automated Framework for Software Requirements Prioritization

Due to dynamic nature of current software development methods, changes in requirements are embraced and given proper consideration. However, this triggers the rank reversal problem which involves re-prioritizing requirements based on stakeholders' feedback. It incurs significant cost because of time elapsed in large number of human interactions. To solve this issue, a Semi-Automated Framework for soFtware Requirements priOritizatioN (SAFFRON) is presented in this paper. For a particular requirement, SAFFRON predicts appropriate stakeholders' ratings to reduce human interactions. Initially, item-item collaborative filtering is utilized to estimate similarity between new and previously elicited requirements. Using this similarity, stakeholders who are most likely to rate requirements are determined. Afterwards, collaborative filtering based on latent factor model is used to predict ratings of those stakeholders. The proposed approach is implemented and tested on RALIC dataset. The results illustrate consistent correlation, similar to state of the art approaches, with the ground truth. In addition, SAFFRON requires 13.5-27% less human interaction for re-prioritizing requirements.

A user-oriented resource scheduling method for improving agile software pattern in cloud environment

The crowdsourcing, as a service pattern in cloud environment, usually aims at the cross-disciplinary cooperation and creating value together with customers and becomes increasingly prevalent. Software process, as a kind of software development and management strategy, is defined as a series of activities implemented by software life cycle and provides a set of rules for various phases of the software engineering to achieve the desired objectives. With the current software development cycle getting shorter, facing more frequent needs change and fierce competition, a new resource management pattern is proposed to respond to these issues agilely by introducing the crowdsourcing service to agile software development for pushing the agility of software process. Then, a user-oriented resource scheduling method is proposed for rational use of various resources in the process and maximizing the benefits of all parties. From the experimental results, the proposed pattern and resources scheduling method reduces greatly the resource of project resource manager and increases the team resource utilization rate, which greatly improves the agility of software process and delivers software products quickly in crowdsourcing pattern.

The growing need for microservices in bioinformatics

Objective: Within the information technology (IT) industry, best practices and standards are constantly evolving and being refined. In contrast, computer technology utilized within the healthcare industry often evolves at a glacial pace, with reduced opportunities for justified innovation. Although the use of timely technology refreshes within an enterprise’s overall technology stack can be costly, thoughtful adoption of select technologies with a demonstrated return on investment can be very effective in increasing productivity and at the same time, reducing the burden of maintenance often associated with older and legacy systems. In this brief technical communication, we introduce the concept of microservices as applied to the ecosystem of data analysis pipelines. Microservice architecture is a framework for dividing complex systems into easily managed parts. Each individual service is limited in functional scope, thereby conferring a higher measure of functional isolation and reliability to the collective solution. Moreover, maintenance challenges are greatly simplified by virtue of the reduced architectural complexity of each constitutive module. This fact notwithstanding, rendered overall solutions utilizing a microservices-based approach provide equal or greater levels of functionality as compared to conventional programming approaches. Bioinformatics, with its ever-increasing demand for performance and new testing algorithms, is the perfect use-case for such a solution. Moreover, if promulgated within the greater development community as an open-source solution, such an approach holds potential to be transformative to current bioinformatics software development. Context: Bioinformatics relies on nimble IT framework which can adapt to changing requirements. Aims: To present a well-established software design and deployment strategy as a solution for current challenges within bioinformatics Conclusions: Use of the microservices framework is an effective methodology for the fabrication and implementation of reliable and innovative software, made possible in a highly collaborative setting.

Attributes Contributing to Students' Use of Quality Software Development Practices

In 2001 the “McCracken group”, through a multi-institutional study, concluded that many students finishing their introductory programming courses could not program due to a lack of problem solving skills. In 2004 Lister established that students have a fragile grasp of skills to read and interpret code. Humphrey suggests that educators must shift their focus from the programs that the students create to the data of the processes the students use. This paper addresses the problem of poor performing students through an investigation of their quality appraisal techniques (QATs) and development processes. Firstly, a survey was conducted to determine the current software development practices used by a group of undergraduate Computer Science students. Numeric data collected revealed that the current practices used by the majority of students would not be sufficient to produce quality programs. Secondly, a case study was conducted to gain a deeper understanding of the various factors that are likely to influence students’ intention to use QATs. Analysis of numeric data collected through a survey revealed that students’ intentions to use QATs are driven by ease of use, compatibility, usefulness, result demonstrability, subjective norm and career consequences. Thirdly, an experiment was conducted to determine students’ perceptions on the use of process measurement data to improve their current software development practices. Analysis of numeric and narrative data revealed that performance measurement data could provide students with useful information to adopt proper development practices.