8 research outputs found
The role of Artificial Intelligence in Software Engineering
There has been a recent surge in interest in the application of Artificial Intelligence (AI) techniques to Software Engineering (SE) problems. The work is typified by recent advances in Search Based Software Engineering, but also by long established work in Probabilistic reasoning and machine learning for Software Engineering. This paper explores some of the relationships between these strands of closely related work, arguing that they have much in common and sets out some future challenges in the area of AI for SE. © 2012 IEEE
Sapienz: Multi-objective automated testing for android applications
We introduce Sapienz, an approach to Android testing that uses multi-objective search-based testing to automatically explore and optimise test sequences, minimising length, while simultaneously maximising coverage and fault revelation. Sapienz combines random fuzzing, systematic and search-based exploration, exploiting seeding and multi-level instrumentation. Sapienz significantly outperforms (with large effect size) both the state-of-the-art technique Dynodroid and the widely-used tool, Android Monkey, in 7/10 experiments for coverage, 7/10 for fault detection and 10/10 for fault-revealing sequence length. When applied to the top 1, 000 Google Play apps, Sapienz found 558 unique, previously unknown crashes. So far we have managed to make contact with the developers of 27 crashing apps. Of these, 14 have confirmed that the crashes are caused by real faults. Of those 14, six already have developer-confirmed fixes
The relationship between search based software engineering and predictive modeling
Search Based Software Engineering (SBSE) is an approach to software engineering in which search based optimization algorithms are used to identify optimal or near optimal solutions and to yield insight. SBSE techniques can cater for multiple, possibly competing objectives and/or constraints and applications where the potential solution space is large and complex. This paper will provide a brief overview of SBSE, explaining some of the ways in which it has already been applied to construction of predictive models. There is a mutually beneficial relationship between predictive models and SBSE. The paper sets out eleven open problem areas for Search Based Predictive Modeling and describes how predictive models also have role to play in improving SBSE
Cooperative Based Software Clustering on Dependency Graphs
The organization of software systems into subsystems is usually based on the
constructs of packages or modules and has a major impact on the maintainability of
the software. However, during software evolution, the organization of the system is
subject to continual modification, which can cause it to drift away from the original
design, often with the effect of reducing its quality.
A number of techniques for evaluating a system's maintainability and for controlling
the effort required to conduct maintenance activities involve software clustering.
Software clustering refers to the partitioning of software system components
into clusters in order to obtain both exterior and interior connectivity between these
components. It helps maintainers enhance the quality of software modularization
and improve its maintainability.
Research in this area has produced numerous algorithms with a variety of
methodologies and parameters. This thesis presents a novel ensemble approach
that synthesizes a new solution from the outcomes of multiple constituent clustering
algorithms. The main principle behind this approach derived from machine
learning, as applied to document clustering, but it has been modified, both conceptually
and empirically, for use in software clustering. The conceptual modifications
include working with a variable number of clusters produced by the input algorithms
and employing graph structures rather than feature vectors. The empirical
modifications include experiments directed at the selection of the optimal cluster merging criteria. Case studies based on open source software systems show that
establishing cooperation between leading state-of-the-art algorithms produces better
clustering results compared with those achieved using only one of any of the
algorithms considered
Log Event Filtering Using Clustering Techniques
Large software systems are composed of various different run-time components, partner
applications and, processes. When such systems operate they are monitored so that audits can be
performed once a failure occurs or when maintenance operations are performed. However, log files
are usually sizeable, and require filtering and reduction to be processed efficiently. Furthermore, there
is no apparent correspondence of how logged events relate to particular use cases the system may be
performing. In this thesis, we have developed a framework that is based on heuristic clustering
algorithms to achieve log filtering, log reduction and, log interpretation. More specifically we define
the concept of the Event Dependency Graph, and we present event filtering and use case
identification techniques, that are based on event clustering. The clustering process groups together
all events that relate to a collection of initial significant events that relate to a use case. We refer to
these significant events as beacon events. Beacon events can be identified automatically or semiautomatically
by examining log event types or event names against event types or event names in the
corresponding specification of a use case being considered (e.g. events in sequence diagrams).
Furthermore, the user can select other or additional initial clustering conditions based on his or her
domain knowledge of the system. The clustering technique can be used in two possible ways. The
first is for large logs to be reduced or sliced, with respect to a particular use case so that, operators can
better focus their attention to specific events that relate to specific operations. The second is for the
determination of active use cases where operators select particular seed events of interest and then
examine the resulting reduced logs against events or event types stemming from different alternative
known use cases being considered, in order to identify the best match and consequently provide
insights on which of these alternative use cases may be running at any given time. The approach has
shown very promising results towards the identification of executing use cases among various
alternative ones in various runs of the Session Initiation Protocol
Multi-objective Search-based Mobile Testing
Despite the tremendous popularity of mobile applications, mobile testing still relies heavily on manual testing. This thesis presents mobile test automation approaches based on multi-objective search. We introduce three approaches: Sapienz (for native Android app testing), Octopuz (for hybrid/web JavaScript app testing) and Polariz (for using crowdsourcing to support search-based mobile testing). These three approaches represent the primary scientific and technical contributions of the thesis. Since crowdsourcing is, itself, an emerging research area, and less well understood than search-based software engineering, the thesis also provides the first comprehensive survey on the use of crowdsourcing in software testing (in particular) and in software engineering (more generally). This survey represents a secondary contribution. Sapienz is an approach to Android testing that uses multi-objective search-based testing to automatically explore and optimise test sequences, minimising their length, while simultaneously maximising their coverage and fault revelation. The results of empirical studies demonstrate that Sapienz significantly outperforms both the state-of-the-art technique Dynodroid and the widely-used tool, Android Monkey, on all three objectives. When applied to the top 1,000 Google Play apps, Sapienz found 558 unique, previously unknown crashes. Octopuz reuses the Sapienz multi-objective search approach for automated JavaScript testing, aiming to investigate whether it replicates the Sapienz’ success on JavaScript testing. Experimental results on 10 real-world JavaScript apps provide evidence that Octopuz significantly outperforms the state of the art (and current state of practice) in automated JavaScript testing. Polariz is an approach that combines human (crowd) intelligence with machine (computational search) intelligence for mobile testing. It uses a platform that enables crowdsourced mobile testing from any source of app, via any terminal client, and by any crowd of workers. It generates replicable test scripts based on manual test traces produced by the crowd workforce, and automatically extracts from these test traces, motif events that can be used to improve search-based mobile testing approaches such as Sapienz
Software restructuring: understanding longitudinal architectural changes and refactoring
The complexity of software systems increases as the systems evolve. As the degradation of the system's structure accumulates, maintenance effort and defect-proneness tend to increase. In addition, developers often opt to employ sub-optimal solutions in order to achieve short-time goals, in a phenomenon that has been recently called technical debt. In this context, software restructuring serves as a way to alleviate and/or prevent structural degradation. Restructuring of software is usually performed in either higher or lower levels of granularity, where the first indicates broader changes in the system's structural architecture and the latter indicates refactorings performed to fewer and localised code elements. Although tools to assist architectural changes and refactoring are available, there is still no evidence these approaches are widely adopted by practitioners. Hence, an understanding of how developers perform architectural changes and refactoring in their daily basis and in the context of the software development processes they adopt is necessary. Current software development is iterative and incremental with short cycles of development and release. Thus, tools and processes that enable this development model, such as continuous integration and code review, are widespread among software engineering practitioners. Hence, this thesis investigates how developers perform longitudinal and incremental architectural changes and refactoring during code review through a wide range of empirical studies that consider different moments of the development lifecycle, different approaches, different automated tools and different analysis mechanisms. Finally, the observations and conclusions drawn from these empirical investigations extend the existing knowledge on how developers restructure software systems, in a way that future studies can leverage this knowledge to propose new tools and approaches that better fit developers' working routines and development processes