Visually localizing design problems with disharmony maps

Assessing the quality of software design is difficult, as “design” is expressed through guidelines and heuristics, not rigorous rules. One successful approach to assess design quality is based on de-tection strategies, which are metrics-based composed logical condi-tions, by which design fragments with specific properties are de-tected in the source code. Such detection strategies, when exe-cuted on large software systems usually return large sets of arti-facts, which potentially exhibit one or more “design disharmonies”, which are then inspected manually, a cumbersome activity. In this article we present disharmony maps, a visualization-based approach to locate such flawed software artifacts in large systems. We display the whole system using a 3D visualization technique based on a city metaphor. We enrich such visualizations with the results returned by a number of detection strategies, and thus render both the static structure and the design problems that affect a subject system. We evaluate our approach on a number of open-source Java systems and report on our findings

Using High-Rising Cities to Visualize Performance in Real-Time

For developers concerned with a performance drop or improvement in their software, a profiler allows a developer to quickly search and identify bottlenecks and leaks that consume much execution time. Non real-time profilers analyze the history of already executed stack traces, while a real-time profiler outputs the results concurrently with the execution of software, so users can know the results instantaneously. However, a real-time profiler risks providing overly large and complex outputs, which is difficult for developers to quickly analyze. In this paper, we visualize the performance data from a real-time profiler. We visualize program execution as a three-dimensional (3D) city, representing the structure of the program as artifacts in a city (i.e., classes and packages expressed as buildings and districts) and their program executions expressed as the fluctuating height of artifacts. Through two case studies and using a prototype of our proposed visualization, we demonstrate how our visualization can easily identify performance issues such as a memory leak and compare performance changes between versions of a program. A demonstration of the interactive features of our prototype is available at https://youtu.be/eleVo19Hp4k.Comment: 10 pages, VISSOFT 2017, Artifact: https://github.com/sefield/high-rising-city-artifac

Code Park: A New 3D Code Visualization Tool

We introduce Code Park, a novel tool for visualizing codebases in a 3D game-like environment. Code Park aims to improve a programmer's understanding of an existing codebase in a manner that is both engaging and intuitive, appealing to novice users such as students. It achieves these goals by laying out the codebase in a 3D park-like environment. Each class in the codebase is represented as a 3D room-like structure. Constituent parts of the class (variable, member functions, etc.) are laid out on the walls, resembling a syntax-aware "wallpaper". The users can interact with the codebase using an overview, and a first-person viewer mode. We conducted two user studies to evaluate Code Park's usability and suitability for organizing an existing project. Our results indicate that Code Park is easy to get familiar with and significantly helps in code understanding compared to a traditional IDE. Further, the users unanimously believed that Code Park was a fun tool to work with.Comment: Accepted for publication in 2017 IEEE Working Conference on Software Visualization (VISSOFT 2017); Supplementary video: https://www.youtube.com/watch?v=LUiy1M9hUK

Code smells detection and visualization: A systematic literature review

Context: Code smells (CS) tend to compromise software quality and also demand more effort by developers to maintain and evolve the application throughout its life-cycle. They have long been catalogued with corresponding mitigating solutions called refactoring operations. Objective: This SLR has a twofold goal: the first is to identify the main code smells detection techniques and tools discussed in the literature, and the second is to analyze to which extent visual techniques have been applied to support the former. Method: Over 83 primary studies indexed in major scientific repositories were identified by our search string in this SLR. Then, following existing best practices for secondary studies, we applied inclusion/exclusion criteria to select the most relevant works, extract their features and classify them. Results: We found that the most commonly used approaches to code smells detection are search-based (30.1%), and metric-based (24.1%). Most of the studies (83.1%) use open-source software, with the Java language occupying the first position (77.1%). In terms of code smells, God Class (51.8%), Feature Envy (33.7%), and Long Method (26.5%) are the most covered ones. Machine learning techniques are used in 35% of the studies. Around 80% of the studies only detect code smells, without providing visualization techniques. In visualization-based approaches several methods are used, such as: city metaphors, 3D visualization techniques. Conclusions: We confirm that the detection of CS is a non trivial task, and there is still a lot of work to be done in terms of: reducing the subjectivity associated with the definition and detection of CS; increasing the diversity of detected CS and of supported programming languages; constructing and sharing oracles and datasets to facilitate the replication of CS detection and visualization techniques validation experiments.Comment: submitted to ARC

On the use of virtual reality in software visualization: The case of the city metaphor

Background: Researchers have been exploring 3D representations for visualizing software. Among these representations, one of the most popular is the city metaphor, which represents a target object-oriented system as a virtual city. Recently, this metaphor has been also implemented in interactive software visualization tools that use virtual reality in an immersive 3D environment medium. Aims: We assessed the city metaphor displayed on a standard computer screen and in an immersive virtual reality with respect to the support provided in the comprehension of Java software systems. Method: We conducted a controlled experiment where we asked the participants to fulfill program comprehension tasks with the support of (i) an integrated development environment (Eclipse) with a plugin for gathering code metrics and identifying bad smells; and (ii) a visualization tool of the city metaphor displayed on a standard computer screen and in an immersive virtual reality. Results: The use of the city metaphor displayed on a standard computer screen and in an immersive virtual reality significantly improved the correctness of the solutions to program comprehension tasks with respect to Eclipse. Moreover, when carrying out these tasks, the participants using the city metaphor displayed in an immersive virtual reality were significantly faster than those visualizing with the city metaphor on a standard computer screen. Conclusions: Virtual reality is a viable means for software visualization

Οπτική αναπαράσταση και αξιολόγηση ποιότητας αντικειμενοστρεφούς λογισμικού με χρήση διαδικτυακών εργαλείων

Πτυχιακή εργασία--Πανεπιστήμιο Μακεδονίας, Θεσσαλονίκη, 2018.Περιλαμβάνει βιβλιογραφικές αναφορές (σ. 48-49)ΠΤΥ ΕΠ 001/2018Η ραγδαία αύξηση τόσο της δημοφιλίας των αντικειμενοστρεφών έργων, της πολυπλοκότητας αυτών και των προγραμματιστών που εργάζονται ή συνεισφέρουν σε αυτά, μας τονίζει την σημαντικότητα εύρεσης λύσεων σε προβλήματα όπως είναι η κατανόηση μεγάλων ή παλιών συστημάτων λογισμικού αλλά και ο εύκολος έλεγχος της ποιότητας τους. Αυτό σημαίνει ότι όσο μεγαλώνει ένα έργο τόσο πιο δύσκολο είναι να διατηρηθεί ο έλεγχος και η κατανόηση πάνω σε αυτό από τους υπάρχοντες προγραμματιστές πόσο μάλλον από νέους προγραμματιστές που έρχονται σε επαφή μαζί του είτε για την ανάπτυξη του είτε για την συντήρηση του. Τα παραπάνω προβλήματα αποτελούν πήγες υψηλού κόστους είτε λόγο μειώσεις της παραγωγικότητας είτε λόγο τής δυσκολίας για συντήρηση συστημάτων με πολλά προβλήματα κακής σχεδίασης. Με γνώμονα τα παραπάνω η συγκεκριμένη εργασία προσφέρει την δυνατότητα για οπτική αναπαράσταση ενός οποιοδήποτε αντικειμενοστρεφούς έργου ανοιχτού λογισμικού σε μορφή γράφου ώστε να γίνονται ευκολά αντιληπτά τα διάφορα υποσυστήματα και οι σχέσεις μεταξύ τους. Ακόμη γίνεται συνδυαστική αναπαράσταση διαφόρων μετρικών ανάλυσης ποιότητας, κλιμακώνοντας το μέγεθός των κόμβων με βάση επιλεγμένων μετρικών, φιλτράροντας τούς με βάση συγκεκριμένες τιμές, είτε επιλέγοντας ποιοι κομβόι θα εμφανιστούν ανάλογα με το είδος της σχέσεις τους με τον επιλεγμένο κόμβο. Χρησιμοποιώντας τις παραπάνω δυνατότητες και με βάση τις αρχές της αντικειμενοστρεφούς σχεδίασης αναλύονται ακόμη στρατηγικές εντοπισμού προβλημάτων κακής σχεδίασης.Undoubtedly there is a rapid increase in the popularity of object-oriented projects along with their complexity, size and the programmers that work or contribute on them. This tendency emphasizes the importance of finding solutions in problems such as the understanding of large or legacy systems and the assurance of the project’s quality. This means that as the project grows, the more difficult it is for the developers to maintain the control and the understanding on it. The above problems result on high expenses either due to the lack of productivity or due to the increased effort that is expected for maintaining a system with many poor design problems. Driven by these problems and needs the main goal of this bachelor thesis is to offer a graph visualization of any object-oriented open source project in order for the various subsystems and the relations amongst them to be easily perceived. Furthermore, the representation includes various quality metrics for the project analysis, and you could scale the nodes according the selected metrics, filter the nodes based a specific value or even choose which nodes should appear based on their relation with a selected node. There are also detecting strategies that we could follow for bringing to the surface design problems, based on the above capabilities and the application of object-oriented principles

Code Park: A New 3D Code Visualization Tool and IDE

We introduce Code Park, a novel tool for visualizing codebases in a 3D game-like environment. Code Park aims to improve a programmer\u27s understanding of an existing codebase in a manner that is both engaging and fun to be appealing especially for novice users such as students. It achieves these goals by laying out the codebase in a 3D park-like environment. Each class in the codebase is represented as a 3D room-like structure. Constituent parts of the class (variable, member functions, etc.) are laid out on the walls, resembling a syntax-aware wallpaper . The users can interact with the codebase using an overview, and a first-person viewer mode. They also can edit, compile and run code in this environment. We conducted three user studies to evaluate Code Park\u27s usability and suitability for organizing an existing project. Our results indicate that Code Park is easy to get familiar with and significantly helps in code understanding. Further, the users unanimously believed that Code Park was an engaging tool to work with

Visualization of the Static aspects of Software: a survey

International audienceSoftware is usually complex and always intangible. In practice, the development and maintenance processes are time-consuming activities mainly because software complexity is difficult to manage. Graphical visualization of software has the potential to result in a better and faster understanding of its design and functionality, saving time and providing valuable information to improve its quality. However, visualizing software is not an easy task because of the huge amount of information comprised in the software. Furthermore, the information content increases significantly once the time dimension to visualize the evolution of the software is taken into account. Human perception of information and cognitive factors must thus be taken into account to improve the understandability of the visualization. In this paper, we survey visualization techniques, both 2D- and 3D-based, representing the static aspects of the software and its evolution. We categorize these techniques according to the issues they focus on, in order to help compare them and identify the most relevant techniques and tools for a given problem

Eyes Of Darwin : une fenêtre ouverte sur l'évolution du logiciel

De nos jours, les logiciels doivent continuellement évoluer et intégrer toujours plus de fonctionnalités pour ne pas devenir obsolètes. C'est pourquoi, la maintenance représente plus de 60% du coût d'un logiciel. Pour réduire les coûts de programmation, les fonctionnalités sont programmées plus rapidement, ce qui induit inévitablement une baisse de qualité. Comprendre l’évolution du logiciel est donc devenu nécessaire pour garantir un bon niveau de qualité et retarder le dépérissement du code. En analysant à la fois les données sur l’évolution du code contenues dans un système de gestion de versions et les données quantitatives que nous pouvons déduire du code, nous sommes en mesure de mieux comprendre l'évolution du logiciel. Cependant, la quantité de données générées par une telle analyse est trop importante pour être étudiées manuellement et les méthodes d’analyses automatiques sont peu précises. Dans ce mémoire, nous proposons d'analyser ces données avec une méthode semi automatique : la visualisation. Eyes Of Darwin, notre système de visualisation en 3D, utilise une métaphore avec des quartiers et des bâtiments d'une ville pour visualiser toute l'évolution du logiciel sur une seule vue. De plus, il intègre un système de réduction de l'occlusion qui transforme l'écran de l'utilisateur en une fenêtre ouverte sur la scène en 3D qu'il affiche. Pour finir, ce mémoire présente une étude exploratoire qui valide notre approche.Software must continuously evolve and integrate more functionalities to remain useful. Consequently, more than 60% of a software system's cost is related to maintenance. To reduce this cost, programming must performed faster, witch leads to a decrease of the system code's quality. Therefore, understanding software evolution is becoming a necessity to prevent code decay and to increase the system life span. To ease software understanding, we perform a cross analysis of the historical data extracted from a version control system, with quantitative data that we obtain from the source code. However, the significant amount of data generated by this kind of analysis makes it necessary to have tools to support the maintainer’s analysis. First, tools help because examining them manually is impossible. Second, they help because automatics methods are not accurate enough. We present a new semiautomatic approach to help analysis. Our 3D visualization system, Eyes Of Darwin, uses a cityscape metaphor to show software's evolution on a single view. It integrates an occlusion reduction system, witch turns the screen to an open window on the 3D world. We conclude, with an exploratory study in order to validate our approach

Locating Potential Aspect Interference Using Clustering Analysis

Software design continues to evolve from the structured programming paradigm of the 1970s and 1980s and the object-oriented programming (OOP) paradigm of the 1980s and 1990s. The functional decomposition design methodology used in these paradigms reduced the prominence of non-functional requirements, which resulted in scattered and tangled code to address non-functional elements. Aspect-oriented programming (AOP) allowed the removal of crosscutting concerns scattered throughout class code into single modules known as aspects. Aspectization resulted in increased modularity in class code, but introduced new types of problems that did not exist in OOP. One such problem was aspect interference, in which aspects meddled with the data flow or control flow of a program. Research has developed various solutions for detecting and addressing aspect interference using formal design and specification methods, and by programming techniques that specify aspect precedence. Such explicit specifications required practitioners to have a complete understanding of possible aspect interference in an AOP system under development. However, as system size increased, understanding of possible aspect interference could decrease. Therefore, practitioners needed a way to increase their understanding of possible aspect interference within a program. This study used clustering analysis to locate potential aspect interference within an aspect-oriented program under development, using k-means partitional clustering. Vector space models, using two newly defined metrics, interference potential (IP) and interference causality potential (ICP), and an existing metric, coupling on advice execution (CAE), provided input to the clustering algorithms. Resulting clusters were analyzed via an internal strategy using the R-Squared, Dunn, Davies-Bouldin, and SD indexes. The process was evaluated on both a smaller scale AOP system (AspectTetris), and a larger scale AOP system (AJHotDraw). By seeding potential interference problems into these programs and comparing results using visualizations, this study found that clustering analysis provided a viable way for detecting interference problems in aspect-oriented software. The ICP model was best at detecting interference problems, while the IP model produced results that were more sporadic. The CAE clustering models were not effective in pinpointing potential aspect interference problems. This was the first known study to use clustering analysis techniques specifically for locating aspect interference