Solve Software Engineering Problems Research Articles

Managing Technical Debt Using Intelligent Techniques - A Systematic Mapping Study

Technical Debt (TD) is a metaphor reflecting technical compromises that can yield short-term benefits but might hurt the long-term health of a software system. With the increasing amount of data generated when performing software development activities, an emergent research field has gained attention: applying Intelligent Techniques to solve Software Engineering problems. Intelligent Techniques were used to explore data for knowledge discovery, reasoning, learning, planning, perception, or supporting decision-making. Although these techniques can be promising, there is no structured understanding related to their application to support Technical Debt Management (TDM) activities. Within this context, this study aims to investigate to what extent the literature has proposed and evaluated solutions based on Intelligent Techniques to support TDM activities. To this end, we performed a Systematic Mapping Study (SMS) to investigate to what extent the literature has proposed and evaluated solutions based on Intelligent Techniques to support TDM activities. In total, 150 primary studies were identified and analyzed, dated from 2012 to 2021. The results indicated a growing interest in applying Intelligent Techniques to support TDM activities, the most used: Machine Learning and Reasoning under uncertainty. Intelligent Techniques aimed to assist mainly TDM activities related to identification, measurement, and monitoring. Design TD, Code TD, and Architectural TD are the TD types in the spotlight. Most studies were categorized at automation levels 1 and 2, meaning that existing approaches still require substantial human intervention. Symbolists and Analogizers are levels of explanation presented by most Intelligent Techniques, implying that these solutions conclude a general truth after considering a sufficient number of particular cases. Moreover, we also cataloged the empirical research types, contributions, and validation strategies described in primary studies. Based on our findings, we argue that there is still room to improve the use of Intelligent Techniques to support TDM activities. The open issues that emerged from this study can represent future opportunities for practitioners and researchers.

Применение машинного обучения в программной инженерии: обзор

Today, software is one of the main technologies contributing to the development of society. Therefore, its quality is a major requirement for both the global software industry and software engineering, which deals with all aspects of improving the quality and reliability of software products at all stages of their life cycle. To solve software engineering problems, the use of artificial intelligence methods is becoming increasingly relevant. The article presents a brief description of machine learning methods such as artificial neural networks, support vector machine, decision trees, inductive logic programming and others. Also, examples of the application of these methods to solve some problems of forecasting and quality assessment in software engineering are presented, recommendations for applying machine learning algorithms to solving problems of software engineering are given. The review will be useful by researchers and practitioners as a starting point, because it identifies important and promising areas of research. This will ultimately lead to more effective solving of software engineering problems, providing better, more reliable and cost effective software products. Problems in programming 2019; 4: 92-110

Search‐based software engineering for constructing covering arrays

Search-based software engineering involves the application of optimisation methods to solve software engineering problems. One of the most significant difficulties in testing software systems is the effort needed to build the test suites required to validate a software system, which efficiently exposes faults. Given the importance of the software testing stage, a specific sub-area known as search-based software testing has become relevant in recent years. In this work, a search-based software testing algorithm for constructing covering arrays is proposed. A covering array is a combinatorial structure that can be used as a set of test cases. By utilising this algorithm, the authors reduce the size of 893 test suites.

Automatically classifying source code using tree-based approaches

Analyzing source code to solve software engineering problems such as fault prediction, cost, and effort estimation always receives attention of researchers as well as companies. The traditional approaches are based on machine learning, and software metrics obtained by computing standard measures of software projects. However, these methods have faced many challenges due to limitations of using software metrics which were not enough to capture the complexity of programs.To overcome the limitations, this paper aims to solve software engineering problems by exploring information of programs' abstract syntax trees (ASTs) instead of software metrics. We propose two combination models between a tree-based convolutional neural network (TBCNN) and k-Nearest Neighbors (kNN), support vector machines (SVMs) to exploit both structural and semantic ASTs' information. In addition, to deal with high-dimensional data of ASTs, we present several pruning tree techniques which not only reduce the complexity of data but also enhance the performance of classifiers in terms of computational time and accuracy.We survey many machine learning algorithms on different types of program representations including software metrics, sequences, and tree structures. The approaches are evaluated based on classifying 52000 programs written in C language into 104 target labels. The experiments show that the tree-based classifiers dramatically achieve high performance in comparison with those of metrics-based or sequences-based; and two proposed models TBCNN + SVM and TBCNN + kNN rank as the top and the second classifiers. Pruning redundant AST branches leads to not only a substantial reduction in execution time but also an increase in accuracy.

Automated software design using ant colony optimization with semantic network support

Software design is an important task that needs to be well performed. In this paper, a method for automated software design using search-based software engineering approach is proposed. This approach can solve software engineering problems using search algorithms. Ant colony optimization is used as the meta-heuristic search algorithm in both single-objective and multi-objective modes. Input data are the analysis phase artifacts and the output is in the form of early life cycle class diagram. To provide human designer's background knowledge, a semantic network is used that is built upon the textual documents of analysis phase plus other resources like WordNet. This semantic network is used to name the output classes, and also to determine structural relations between classes. The proposed method is evaluated by some case studies and results are reported. The evaluation results show that using background knowledge beside optimization algorithm helps to achieve better results.

Developing tools as plug‐ins: TOPI 2012 special issue

SUMMARYOur knowledge as to how to solve software engineering problems is increasingly being encapsulated in tools. These tools are at their strongest when they operate in a preexisting development that can provide integration with existing elements such as compilers, debuggers, profilers, and visualizers as well as numerous other development and, often, runtime tools. However, building tools as plug‐ins can be challenging and raise many questions: How do they interact with the core environment? How do they interact with other existing plug‐ins, especially as each developer may choose a different set of plug‐ins. How can we share tools across different and future core development environments? How do we evaluate the usefulness of the tools? The series of workshops on Developing Tools as Plug‐ins (TOPI) tries to address these questions. Researchers are invited to present position papers spotting the medium‐term and long‐term challenges of developing tools as plug‐ins as well as research contributions identifying recent successful tools as plug‐ins, characteristics of good plug‐ins and reports of the main difficulties in implementing plug‐ins in current platforms. This issue includes extended versions of the best papers presented at TOPI 2012. Copyright © 2014 John Wiley & Sons, Ltd.

Developing tools as plug‐ins: TOPI 2011 special issue editorial

SUMMARYOur knowledge of how to solve software engineering problems is increasingly being encapsulated in tools. These tools are at their strongest when they operate in a pre‐existing integrated development environment (IDE). This approach allows integration with existing elements such as compilers, debuggers, profilers, visualizers, and numerous other development and, often, runtime tools. Tools and environments to increase software quality and productivity have always been an important aspect of software engineering. A plug‐in is a modern way for incrementally adding new tools into existing environments. However, building tools as plug‐ins can be challenging. How do they interact with the core environment? How do they interact with one another ‐ especially since each developer may choose a different set of plug‐ins? How can we share tools across different, and future, core development environments?

Philosophy Applying in Information Engineering

With the computer software and technology continuously improving, because of various factors influencing, computer engineers are very tough on how to improve the quality of software products, this is a bottleneck problem we must solve. We think that the information engineering combining with the philosophy thought would make engineer’s ideas suddenly enlightened. We find a method and model to solve software engineering problems from the philosophical Angle, and put forward the importance of information philosophy in the study of information engineering by standing at this altitude of the information engineering. As a new field, information philosophy provides a unified, convergence theory frame, it can satisfy the requirement of further specialized. Information philosophy will become most exciting and productive philosophy research field in our era's.

Project Management in Enterprise

The article discusses how the knowledge of management and artificial intelligence can be used for controlling the budgets and schedules of software projects. The first part of this paper gives an outline of the problems involved in software project management regarding the planning and control of processes and project teams. Next, an overview of changes in management is presented, followed by a description of a method for how these ideas can be used to solve software engineering problems. Consequently, an example is presented of a decision-support system, designed to aid project-team managers in planning and controlling budgets and schedules and helping the team members to adjust.

Role Models — Patterns of Agent System Analysis and Design

Due to their autonomy and social behaviour, agents will play important roles in emerging enterprises; they will fill key positions and provide essential capabilities. This paper describes role modelling as a software engineering technique for specifying, analysing, and designing systems on the basis of the roles that the agents will play. This paper builds on our earlier research in patterns of agent systems. A pattern is a useful solution to a reoccurring problem in a particular context; patterns can be used to solve software engineering problems in analysis, design, and implementation. This paper explains how object-oriented role models can be extended to represent patterns of agent interaction that can then be employed to engineer agent systems. Role theory deals with collaboration and co-ordination. Roles have also been applied to distributed systems management, and to agent and robot systems. However, there has to date not been a methodology for realising these representations in an automated or semi-automated system, due to the lack of adequate formalism and corresponding abstractions in software. Role models rectify this situation for software analysis, design, and implementation.