Automated Tool for Software Requirements Inspection

The software inspection process is a very cost effective method of identifying defects in documents produced during the software life cycle, leading to higher quality software with lower field failures. Manual inspections are labor intensive and dependent on human factors (e.g., preparation, moderation, and cooperation among development and quality assurance teams). An automated software inspection tool replaces a labor intensive manual approach of performing the inspection process. An automated inspection tool will offer greater efficiencies than any techniques involving manual inspections. Automation allows stakeholders (e.g., authors, inspectors) to closely work in coordination using the tool. Authors can host documents, view comments posted by inspectors, assign users and delete them. Inspectors can participate in the inspection process by validating against a set of guidelines and detect faults in a specific frame of time using different fault and error based inspection techniques. It is human to err, and as a result some of the faults may be overlooked. Hence, provisions are made for iterative inspection cycles to maximize the number of defects found and minimize the number of overlooked ones

Rapid Software Development Life Cycle in Small Projects

Small software projects are becoming more usual nowadays. Whether a small project is conducted privately or professionally, the management of the project and its phases is much easier with proper tools and frameworks. The research target of this thesis is to find out a proper life cycle model for small software projects. This thesis is conducted for Softwarehouse, a professional division of IT services in the University of Turku. The official guide for Scrum framework is adhered in software development but when it comes to formally managing various phases of a software project (planning, design, implementation, testing, reviewing etc.) there is room for improvement. Managing software projects with a proper set of tools and procedures would be beneficial as Softwarehouse works on many projects concurrently. The intended life cycle model has to be formal and heavy enough so that the benefits of agile project management can be received. However too rigid a model can be too arduous and exhausting to use, which could result in the decrease of Softwarehouse’s production volume. Therefore the model has to be light enough to maintain rapid software development and creative atmosphere within the Softwarehouse. This thesis begins by giving outline of existing software development life cycle models and followed by relevant literary exploration. After this the research case is explained in greater detail. These give the foundation and rationale to propose a suitable model. The model is experimented empirically and reviewed by partaking personnel. The results are reviewed and discussed. Finally topics for future research are suggested

Translating Video Recordings of Mobile App Usages into Replayable Scenarios

Screen recordings of mobile applications are easy to obtain and capture a wealth of information pertinent to software developers (e.g., bugs or feature requests), making them a popular mechanism for crowdsourced app feedback. Thus, these videos are becoming a common artifact that developers must manage. In light of unique mobile development constraints, including swift release cycles and rapidly evolving platforms, automated techniques for analyzing all types of rich software artifacts provide benefit to mobile developers. Unfortunately, automatically analyzing screen recordings presents serious challenges, due to their graphical nature, compared to other types of (textual) artifacts. To address these challenges, this paper introduces V2S, a lightweight, automated approach for translating video recordings of Android app usages into replayable scenarios. V2S is based primarily on computer vision techniques and adapts recent solutions for object detection and image classification to detect and classify user actions captured in a video, and convert these into a replayable test scenario. We performed an extensive evaluation of V2S involving 175 videos depicting 3,534 GUI-based actions collected from users exercising features and reproducing bugs from over 80 popular Android apps. Our results illustrate that V2S can accurately replay scenarios from screen recordings, and is capable of reproducing $\approx$ 89% of our collected videos with minimal overhead. A case study with three industrial partners illustrates the potential usefulness of V2S from the viewpoint of developers.Comment: In proceedings of the 42nd International Conference on Software Engineering (ICSE'20), 13 page

Variationally consistent computational homogenization of chemomechanical problems with stabilized weakly periodic boundary conditions

A variationally consistent model-based computational homogenization approach for transient chemomechanically coupled problems is developed based on the classical assumption of first-order prolongation of the displacement, chemical potential, and (ion) concentration fields within a representative volume element (RVE). The presence of the chemical potential and the concentration as primary global fields represents a mixed formulation, which has definite advantages. Nonstandard diffusion, governed by a Cahn–Hilliard type of gradient model, is considered under the restriction of miscibility. Weakly periodic boundary conditions on the pertinent fields provide the general variational setting for the uniquely solvable RVE-problem(s). These boundary conditions are introduced with a novel approach in order to control the stability of the boundary discretization, thereby circumventing the need to satisfy the LBB-condition: the penalty stabilized Lagrange multiplier formulation, which enforces stability at the cost of an additional Lagrange multiplier for each weakly periodic field (three fields for the current problem). In particular, a neat result is that the classical Neumann boundary condition is obtained when the penalty becomes very large. In the numerical examples, we investigate the following characteristics: the mesh convergence for different boundary approximations, the sensitivity for the choice of penalty parameter, and the influence of RVE-size on the macroscopic response

Graph-based Temporal Analysis in Digital Forensics

Establishing a timeline as part of a digital forensics investigation is a vital part of understanding the order in which system events occurred. However, most digital forensics tools present timelines as histogram or as raw artifacts. Consequently, digital forensics examiners are forced to rely on manual, labor-intensive practices to reconstruct system events. Current digital forensics analysis tools are at their technological limit with the increasing storage and complexity of data. A graph-based timeline can present digital forensics evidence in a structure that can be immediately understood and effortlessly focused. This paper presents the Temporal Analysis Integration Management Application (TAIMA) to enhance digital forensics analysis via information visualization (infovis) techniques. TAIMA is a prototype application that provides a graph-based timeline for event reconstruction using abstraction and visualization techniques. A workflow illustration and pilot usability study provided evidence that TAIMA assisted digital forensics specialists in identifying key system events during digital forensics analysis

State of Refactoring Adoption: Towards Better Understanding Developer Perception of Refactoring

Context: Refactoring is the art of improving the structural design of a software system without altering its external behavior. Today, refactoring has become a well-established and disciplined software engineering practice that has attracted a significant amount of research presuming that refactoring is primarily motivated by the need to improve system structures. However, recent studies have shown that developers may incorporate refactoring strategies in other development-related activities that go beyond improving the design especially with the emerging challenges in contemporary software engineering. Unfortunately, these studies are limited to developer interviews and a reduced set of projects. Objective: We aim at exploring how developers document their refactoring activities during the software life cycle. We call such activity Self-Affirmed Refactoring (SAR), which is an indication of the developer-related refactoring events in the commit messages. After that, we propose an approach to identify whether a commit describes developer-related refactoring events, to classify them according to the refactoring common quality improvement categories. To complement this goal, we aim to reveal insights into how reviewers develop a decision about accepting or rejecting a submitted refactoring request, what makes such review challenging, and how to the efficiency of refactoring code review. Method: Our empirically driven study follows a mixture of qualitative and quantitative methods. We text mine refactoring-related documentation, then we develop a refactoring taxonomy, and automatically classify a large set of commits containing refactoring activities, and identify, among the various quality models presented in the literature, the ones that are more in-line with the developer\u27s vision of quality optimization, when they explicitly mention that they are refactoring to improve them to obtain an enhanced understanding of the motivation behind refactoring. After that, we performed an industrial case study with professional developers at Xerox to study the motivations, documentation practices, challenges, verification, and implications of refactoring activities during code review. Result: We introduced SAR taxonomy on how developers document their refactoring strategies in commit messages and proposed a SAR model to automate the detection of refactoring. Our survey with code reviewers has revealed several difficulties related to understanding the refactoring intent and implications on the functional and non-functional aspects of the software. Conclusion: Our SAR taxonomy and model, can work in conjunction with refactoring detectors, to report any early inconsistency between refactoring types and their documentation and can serve as a solid background for various empirical investigations. In light of our findings of the industrial case study, we recommended a procedure to properly document refactoring activities, as part of our survey feedback

Investigating Effective Inspection of Object-Oriented Code

Since the development of software inspection over twenty-five years ago it has become established as an effective means of detecting defects. Inspections were originally developed at a time when the procedural paradigm was dominant but, with the Object- Oriented (OO) paradigm growing in influence and use, there now exists a lack of guidance on how to apply inspections to OO systems. Object-oriented and procedural languages differ not only in their syntax but also in a number of more profound ways - the encapsulation of data and associated functionality, the common use of inheritance, and the concepts of polymorphism and dynamic binding. These factors influence the way that modules (classes) are created in OO systems, which in turn influences the way that OO systems are structured and execute. Failure to take this into account may hinder the application of inspections to OO code. This thesis shows that the way in which the objectoriented paradigm distributes related functionality can have a serious impact on code inspection and, to address this problem, it develops and empirically evaluates three code reading techniques