Visualizing trace of Java collection APIs by dynamic bytecode instrumentation

Object-oriented languages are widely used in software development to help the developer in using dynamic data structures which evolve during program execution. However, the task of program comprehension and performance analysis necessitates the understanding of data structures used in a program. Particularly, in understanding which application programming interface (API) objects are used during runtime of a program. The objective of this work is to give a compact view of the complete program code information at a single glance and to provide the user with an interactive environment to explore details of a given program. This work presents a novel interactive visualization tool for collection framework usage, in a Java program, based on hierarchical treemap. A given program is instrumented during execution time and data recorded into a log file. The log file is then converted to extensible markup language (XML)-based tree format which proceeds to the visualization component. The visualization provides a global view to the usage of collection API objects at different locations during program execution. We conduct an empirical study to evaluate the impact of the proposed visualization in program comprehension. The experimental group (having the proposed tool support), on average, completes the tasks in 45% less time as compared to the control group (not provided with the proposed tool). Results show that the proposed tool enables to comprehend more information with less effort and time. We have also evaluated the performance of the proposed tool using 20 benchmark software tools. The proposed tool is anticipated to help the developer in understanding Java programs and assist in program comprehension and maintenance by identifying APIs usage and their patterns.     

面向方面设计中干涉问题的分析工具

干涉问题是指基础程序和方面之间或者方面之间发生不需要的相互作用,导致最终程序中产生不想要的功能,危害程序的正确性.很难检测和修正在面向方面设计中存在的干涉已经成为推广面向方面技术的阻碍.受到技术自身可扩展能力的局限,现有的基于模型验证技术的工作不能有效地处理功能干涉问题.本文设计开发了一个基于推理验证技术直接检查和去除面向方面设计中功能干涉的工具.它可以根据类和方面的功能规约自动产生确保不发生干涉的条件,并引入交互式证明工具PVS来提高证明过程的自动化程度.证明可以确认设计中没有干涉存在或者为修正干涉问题提供线索.     

Behavioral profiles—a way to model and validate program behavior

Software architecture contains, in addition to its structural part, interaction patterns that can be regarded as part of the architectural solution of the system. The interaction patterns define architecturally significant behavior of the software system. In this paper we propose a visual modeling language, behavioral profiles, for specifying architecturally significant behavioral rules for an application. The language is built on the Unified Modeling Language (UML), which is a visual language widely used in software development. We show how behavioral profiles can be used to support software designers in creating behavioral models that conform to some predefined rules and for ensuring that an application behaves correctly with respect to the rules given in the profiles. A tool called Bebop was built to support software engineers in behavioral profile‐based design and analysis of program behavior. To evaluate the approach and the tools in different application domains, they are utilized in three cases. The size of the applications used in the cases varies from small to quite large software systems, and from academic to industrial ones. The examples demonstrate how the approach presented can be used in practice for different steps in a software engineering process. The examples cover specializing an application framework and monitoring the program execution in run‐time. In addition, they show how behavioral profiles can be used to support guided program comprehension and to validate program execution by analyzing execution traces. Copyright © 2010 John Wiley & Sons, Ltd.     

<Emphasis Type="Italic">RAMBUTANS</Emphasis>: automatic AOP-specific test generation tool

Aspect-oriented programming (AOP) is a programmatic methodology to handle better modularized code by separating crosscutting concerns from the traditional abstraction boundaries. Automated testing, as one of the most demanding needs of the software development to reduce both human effort and costs, is a delicate issue in testing aspect-oriented programs. Prior studies in the automated test generation for aspect-oriented programs have been very limited with respect to the need for both adequate tool support and capability concerning effectiveness and efficiency. This paper describes a new AOP-specific tool for testing aspect-oriented programs, called RAMBUTANS. The RAMBUTANS tool uses a directed random testing technique that is especially well suited for generating tests for aspectual features in AspectJ. The directed random aspect of the tool is parameterized by associating weights to aspects, advice, methods, and classes by controlling object and joint point creations during the test generation process. We present a comprehensive empirical evaluation of our tool against the current AOP test generation approaches on three industrial aspect-oriented projects. The results of the experimental and statistical tests showed that RAMBUTANS tool produces test suites that have higher fault-detection capability and efficiency for AspectJ-like programs.     

Generating CAM aspect-oriented architectures using Model-Driven Development

Aspect-Oriented Software Development promotes the separation of those concerns that cut across several components and/or are tangled with the base functionality of a component, through all phases of the software lifecycle. The benefit of identifying these crosscutting concerns (aspects) at the architectural level in particular is to improve the architecture design and its subsequent evolution, before moving onto detailed design and implementation. However, software architects are not usually experts on using specific AO architecture notations. Therefore, the aim of this paper is to provide support to define and specify aspect-oriented (AO) architectures using non-AO ones as the source. We will use the Model-Driven Development approach to transform a component-based architecture model into an AO architecture model. The CAM (component and aspect model) model and the DAOP–ADL language are the proposals used for modelling and specifying AO architectures. We will show how we automated part of the process and the tool support.     

Measuring the performance of aspect oriented software: A case study of Leader/Followers and Half-Sync/Half-Async architectures

The aim of this work is to measure the impact of aspect-oriented programming on software performance. Thus, we hypothesized as follow: adding aspects to a base program will affect its performance because of the overhead caused by the control flow switching, and that incremental effect on performance is more obvious as the number of join points increases. To test our hypotheses we carried out a case study of two concurrent architectures: Half-Sync/Half-Async and Leader/Followers. Aspects are extracted and encapsulated and the base program performance was compared to the aspect program. Our results show that the aspect-oriented approach does not have significant effect on the performance and that in some cases an aspect-oriented program even outperforms the non-aspect program. We also investigated the effect of cache fault rate on performance for both aspect and non-aspect programs. Based on our experiments, the results demonstrate that there is a close correlation between the cache fault rate and performance, which may be in favor of aspect code if some aspects are frequently accessed. Additionally, the introduction of a large number of join points does not have significant effect on performance.     

Factors influencing beliefs for adoption of a learning analytics tool: An empirical study

Present research and development offer various learning analytics tools providing insights into different aspects of learning processes. Adoption of a specific tool for practice is based on how its learning analytics are perceived by educators to support their pedagogical and organizational goals. In this paper, we propose and empirically validate a Learning Analytics Acceptance Model (LAAM) of factors influencing the beliefs of educators concerning the adoption a learning analytics tool. In particular, our model explains how the usage beliefs (i.e., ease-of-use and usefulness perceptions) about the learning analytics of a tool are associated with the intention to adopt the tool. In our study, we considered several factors that could potentially affect the adoption beliefs: i) pedagogical knowledge and information design skills of educators; ii) educators' perceived utility of a learning analytics tool; and iii) educators' perceived ease-of-use of a learning analytics tool. By following the principles of Technology Acceptance Model, the study is done with a sample of educators who experimented with a LOCO-Analyst tool. Our study also determined specific analytics types that are primary antecedence of perceived usefulness (concept comprehension and social interaction) and ease-of-use (interactive visualization).     

The city metaphor in software visualization: feelings,emotions, and thinking

Software visualization is a program comprehension technique used in the context of software maintenance, reverse engineering, and software evolution analysis. In the last decade, researchers have been exploring 3D representations for visualizing programs. Among these representations, one of the most popular is the city metaphor, which represents a target program as a city. Recently, this metaphor has been also implemented in interactive software visualization tools using Virtual Reality (VR) in an immersive 3D environment medium. We report the results of a study to assess the city metaphor implemented in a VR-based tool and in a 3D-based tool with respect to users’ feelings, emotions, and thinking. To this end, we contrasted these tools with a non-visual exploration tool (i.e., Eclipse). The main result of our study is: the use of the city metaphor implemented in a VR-based tool positively affects users’ feelings and emotions, while the thinking about this implementation is positive and comparable with that of a traditional 3D implementation of the city metaphor and it is slightly better than the thinking about a non-visual exploration tool (i.e., Eclipse).

     

An Overview of 3D Software Visualization

Software visualization studies techniques and methods for graphically representing different aspects of software. Its main goal is to enhance, simplify and clarify the mental representation a software engineer has of a computer system. During many years, visualization in 2D space has been actively studied, but in the last decade, researchers have begun to explore new 3D representations for visualizing software. In this article, we present an overview of current research in the area, describing several major aspects like: visual representations, interaction issues, evaluation methods and development tools. We also perform a survey of some representative tools to support different tasks, i.e., software maintenance and comprehension, requirements validation and algorithm animation for educational purposes, among others. Finally, we conclude identifying future research directions.     

Theories, tools and research methods in program comprehension: past, present and future

Program comprehension research can be characterized by both the theories that provide rich explanations about how programmers understand software, as well as the tools that are used to assist in comprehension tasks. In this paper, I review some of the key cognitive theories of program comprehension that have emerged over the past thirty years. Using these theories as a canvas, I then explore how tools that are commonly used today have evolved to support program comprehension. Specifically, I discuss how the theories and tools are related and reflect on the research methods that were used to construct the theories and evaluate the tools. The reviewed theories and tools are distinguished according to human characteristics, program characteristics, and the context for the various comprehension tasks. Finally, I predict how these characteristics will change in the future and speculate on how a number of important research directions could lead to improvements in program comprehension tool development and research methods. Dr. Margaret-Anne Storey is an associate professor of computer science at the University of Victoria, a Visiting Scientist at the IBM Centre for Advanced Studies in Toronto and a Canada Research Chair in Human Computer Interaction for Software Engineering. Her research passion is to understand how technology can help people explore, understand and share complex information and knowledge. She applies and evaluates techniques from knowledge engineering and visual interface design to applications such as reverse engineering of legacy software, medical ontology development, digital image management and learning in web-based environments. She is also an educator and enjoys the challenges of teaching programming to novice programmers.     

Do background colors improve program comprehension in the #ifdef hell?

Software-product-line engineering aims at the development of variable and reusable software systems. In practice, software product lines are often implemented with preprocessors. Preprocessor directives are easy to use, and many mature tools are available for practitioners. However, preprocessor directives have been heavily criticized in academia and even referred to as “#ifdef hell”, because they introduce threats to program comprehension and correctness. There are many voices that suggest to use other implementation techniques instead, but these voices ignore the fact that a transition from preprocessors to other languages and tools is tedious, erroneous, and expensive in practice. Instead, we and others propose to increase the readability of preprocessor directives by using background colors to highlight source code annotated with ifdef directives. In three controlled experiments with over 70 subjects in total, we evaluate whether and how background colors improve program comprehension in preprocessor-based implementations. Our results demonstrate that background colors have the potential to improve program comprehension, independently of size and programming language of the underlying product. Additionally, we found that subjects generally favor background colors. We integrate these and other findings in a tool called FeatureCommander, which facilitates program comprehension in practice and which can serve as a basis for further research.     

面向方面软件重构等价性形式化证明方法

软件重构在不改变程序行为的情况下通过对代码进行小的改进以提升设计,使之更容易理解和维护,面向方面的程序设计是软件开发的新技术,为了有效实施面向方面的软件重构,需要开发者识别面向方面程序的转化规则。然而,由于使用的AOP语言没有形式化的语义定义,难以确认转化和重构的程序运行行为。本文对MCI操作语义的面向方面的扩展使之支持程序的方面特征的描述,定义了两个程序的观测等价,讨论了AspectJ的形式语义模型的建立,在MCI的语义下形式化地精确证明了Add Before-executing编程规则的观测等价性,其基本原理和方法可以适用于其他规则的证明,通过上述工作提出了面向方面重构的程序和它的面向对象程序原型等价性的证明方法。     

Automated test generation technique for aspectual features in AspectJ

ContextAspect-oriented programming (AOP) has been promoted as a means for handling the modularization of software systems by raising the abstraction level and reducing the scattering and tangling of crosscutting concerns. Studies from literature have shown the usefulness and application of AOP across various fields of research and domains. Despite this, research shows that AOP is currently used in a cautious way due to its natural impact on testability and maintainability.ObjectiveTo realize the benefits of AOP and to increase its adoption, aspects developed using AOP should be subjected to automated testing. Automated testing, as one of the most pressing needs of the software industry to reduce both effort and costs in assuring correctness, is a delicate issue in testing aspect-oriented programs that still requires advancement and has a way to go before maturity.MethodPrevious attempts and studies in automated test generation process for aspect-oriented programs have been very limited. This paper proposes a rigorous automated test generation technique, called RAMBUTANS, with its tool support based on guided random testing for the AspectJ programs.ResultsThe paper reports the results of a thorough empirical study of 9 AspectJ benchmark programs, including non-trivial and larger software, by means of mutation analysis to compare RAMBUTANS and the four existing automated AOP testing approaches for testing aspects in terms of fault detection effectiveness and test effort efficiency. The results of the experiment and statistical tests supplemented by effect size measures presented evidence of the effectiveness and efficiency of the proposed technique at 99% confidence level (i.e. p < 0.01).ConclusionThe study showed that the resulting randomized tests were reasonably good for AOP testing, thus the proposed technique could be worth using as an effective and efficient AOP-specific automated test generation technique.     

Execution trace analysis through massive sequence and circular bundle views

An important part of many software maintenance tasks is to gain a sufficient level of understanding of the system at hand. The use of dynamic information to aid in this software understanding process is a common practice nowadays. A major issue in this context is scalability: due to the vast amounts of information, it is a very difficult task to successfully navigate through the dynamic data contained in execution traces without getting lost.In this paper, we propose the use of two novel trace visualization techniques based on the massive sequence and circular bundle view, which both reflect a strong emphasis on scalability. These techniques have been implemented in a tool called Extravis. By means of distinct usage scenarios that were conducted on three different software systems, we show how our approach is applicable in three typical program comprehension tasks: trace exploration, feature location, and top-down analysis with domain knowledge.     

A method engineering approach to developing aspect-oriented modelling processes based on the OPEN process framework

Aspect-oriented software development (AOSD) is an approach to software development in which aspect-oriented techniques are integrated with traditional (mainly OO) development techniques. Identifying the appropriate method components for supporting aspect-oriented development is facilitated by the use of a method engineering approach. We demonstrate this approach by using the OPEN Process Framework (OPF) to identify previous deficiencies in the method fragments stored in the OPF repository so that the enhanced OPF repository is able to fully support AOSD.     

基于编译技术的程序可视化

程序可视化的目的是使程序的内部结构以及行为可视化更容易被理解。程序可视化工具有助于程序员理解程序的实际行为和其开发的深层的系统，以及调试程序或者测试程序所用资源。特别是对于正在学习初级编程的人，程序可视化工具能帮助他们学习一个程序是如何被编译和执行的。因此,有必要进行关于程序执行可视化的研究。介绍了一种以编译技术，主要是以词法分析和语法分析为基础的开发程序可视化工具的方法，并给出了C语言程序执行可视化工具的实例，以说明该方法的实用性。该工具是在程序执行特征测试工具的基础上，将其词法分析器和词法分析器加以修改而实现的。     

An objective-oriented approach to program comprehension using multiple information sources

Program comprehension is a key activity throughout software maintenance and reuse. The knowledge acquired through comprehending programs can guide engineers to perform various kinds of software maintenance and reuse tasks. The effective comprehension strategy and the associated efficient approach, as well as the sophisticated tool support, are the indispensable elements for an entire solution to program comprehension to reduce the high costs of this nontrivial activity. This paper presents an objective-oriented comprehension strategy, contrasting to the traditional comprehensive understanding strategy in the literature. It is a kind of on-demand understanding for specific tasks and more effective in practice. In addition, using multiple information sources to understand programs is proposed with the corresponding framework. From these two points of views, we propose a feature-oriented program comprehension approach using requirement documentation. This approach aims at a specific category of feature-related software maintenance and reuse tasks. Case studies are conducted to evaluate the proposed solution. Results from the studied cases show that the experimental prototype provides more explicit advices for software engineers when performing these tasks.     

Reasoning about Action Systems using the B-Method

The action system formalism has been succesfully used when constructing parallel and distributed systems in a stepwise manner within the refinement calculus. Usually the derivation is carried out manually. In order to be able to produce more trustworthy software, some mechanical tool is needed. In this paper we show how action systems can be derived and refined within the B-Toolkit, which is a mechanical tool supporting a software development method, the B-Method. We describe how action systems are embedded in the B-Method. Furthermore, we show how a typical and nontrivial refinement rule, the superposition refinement rule, is formalized and applied on action systems within the B-Method. In addition to providing tool support for action system refinement we also extend the application area of the B-Method to cover parallel and distributed systems. A derivation towards a distributed load balancing algorithm is given as a case study.     

A bidirectional-transformation-based framework for software visualization and visual editing

Software visualization and visual editing are important and practical techniques to improve the development of complex software systems. A challenge when applying the two technologies is how to realize the correspondence, a bidirectional relationship, between the data and its visual representation correctly. Although many tools and frameworks have been developed to support the construction of visual tools, it is still compli- cated and error-prone to realize the bidirectional relationship. In this paper, we propose a model-driven and bidirectional-transformation-based framework for data visualization and visual editing. Our approach mainly focuses on 1） how to define and manage graphical symbols in the model form and 2） how to specify and im- plement the bidirectional relationship based on the technique of bidirectional model transformation. Then, a prototype tool and four case studies are presented to evaluate the feasibility of our work.     

How Does Software Visualization Contribute to Software Comprehension? A Grounded Theory Approach

Despite their ability to synthesize vast amounts of information, software visualization tools are not widely adopted in the software engineering industry. In an effort to investigate the underlying reasons, we conducted a usability study to investigate the affordances of software visualization techniques for the maintenance of complex software systems. Expert programmers were asked to carry out programming tasks with or without using a software visualization tool while their screens and eye gaze patterns were recorded. Statistical analysis of task performance data showed that participants who used the software visualization tool outperformed the control group in terms of task completion time and accuracy. However, quantitative analysis of performance measures did not reveal in what ways software visualizations contributed to this improvement. In an effort to identify the cognitive strategies that underlie this quantitative performance difference, process models grounded in qualitative analysis of eye-tracking data were constructed. The process models indicated that software visualizations guided the subjects in the experiment group toward following specific software comprehension strategies, which account for the difference observed in task performance data.