Change impact analysis is a useful technique for software evolution. It determines the effects of... more Change impact analysis is a useful technique for software evolution. It determines the effects of a source editing session and provides valuable feedbacks to the programmers for making correct decisions. Recently, many techniques have been proposed to support change impact analysis of procedural or object-oriented software, but seldom effort has been made for aspect-oriented software. In this paper we propose a new change impact analysis technique for AspectJ programs. At the core of our approach is the atomic change representation which can precisely capture semantic differences between two versions of an AspectJ program. We also present a change impact model, based on static AsepctJ call graph construction, to determine the impacted program parts, affected tests and their responsible affecting changes. As an application of change impact analysis, we discuss how our model can help programmers locate the exact failure reason by narrowing down those affecting changes when debugging AspectJ programs.
Palus: a hybrid automated test generation tool for java
Abstract In object-oriented programs, a unit test often consists of a sequence of method calls th... more Abstract In object-oriented programs, a unit test often consists of a sequence of method calls that create and mutate objects. It is challenging to automatically generate sequences that are legal and behaviorally-diverse, that is, reaching as many different program states as possible. This paper proposes a combined static and dynamic test generation approach to address these problems, for code without a formal specification.
Change Impact Analysis Based on a Taxonomy of Change Types
Abstract Software change impact analysis (CIA) is a key technique for identifying unpredicted and... more Abstract Software change impact analysis (CIA) is a key technique for identifying unpredicted and potential effects caused by changes made to software. Different change types often have different impact mechanisms, even some changes do not impact other entities in programs in spite of some dependences existed between these entities and the modified entity.
Using lattice of class and method dependence for change impact analysis of object oriented programs
Abstract Software change impact analysis (CIA) is a key technique to identify unpredicted and pot... more Abstract Software change impact analysis (CIA) is a key technique to identify unpredicted and potential effects caused by software changes. In this paper, we propose a new CIA technique based on a compact and effective representation for object oriented programs, called lattice of class and method dependence (LoCMD). This novel representation can effectively capture the dependences between classes and methods.
Abstract To keep a Graphical User Interface (GUI) responsive and active, a GUI application often ... more Abstract To keep a Graphical User Interface (GUI) responsive and active, a GUI application often has a main UI thread (or event dispatching thread) and spawns separate threads to handle lengthy operations in the background, such as expensive computation, I/O tasks, and network requests. Many GUI frameworks require all GUI objects to be accessed exclusively by the UI thread. If a GUI object is accessed from a non-UI thread, an invalid thread access error occurs and the whole application may abort.
The information of execution frequencies of virtual call targets is valuable for program analyses... more The information of execution frequencies of virtual call targets is valuable for program analyses and optimizations of object-oriented programs. However, to obtain this information, most of the existing approaches rely on dynamic profiling. They usually require running the programs with representative workloads, which are often absent in practice. Additionally, some kinds of programs are very sensitive to run-time disturbance, thus are generally not suitable for dynamic profiling.
Abstract Program call graph representation can be used to support many tasks in compiler optimiza... more Abstract Program call graph representation can be used to support many tasks in compiler optimization, program comprehension, and software maintenance. During software evolution, the call graph needs to remain fairly precise and be updated quickly in response to software changes. In this paper, we present an approach to incremental update, instead of exhaustive analysis of the initially constructed call graph in AspectJ software.
Abstract Change impact analysis is a useful technique for software evolution. It determines the e... more Abstract Change impact analysis is a useful technique for software evolution. It determines the effects of a source editing session and provides valuable feedbacks to the programmers for making correct decisions. Recently, many techniques have been proposed to support change impact analysis of procedural or object-oriented software, but seldom effort has been made for aspect-oriented software. In this paper we propose a new change impact analysis technique for AspectJ programs.
ABSTRACT As Aspect-Oriented Programming (AOP) wins more and more popularity, there is increasing ... more ABSTRACT As Aspect-Oriented Programming (AOP) wins more and more popularity, there is increasing interest in using aspects to implement crosscutting concerns in object-oriented software. During software evolution, source code editing and testing are interleaved activities to assure code quality. When regression tests fail unexpectedly after a long session of editing, it may be difficult for programmers to find out the failure causes.
ABSTRACT In an object-oriented program, a unit test often consists of a sequence of method calls ... more ABSTRACT In an object-oriented program, a unit test often consists of a sequence of method calls that create and mutate objects, then use them as arguments to a method under test. It is challenging to automatically generate sequences that are legal and behaviorally-diverse, that is, reaching as many different program states as possible. This paper proposes a combined static and dynamic automated test generation approach to address these problems, for code without a formal specification.
Abstract—Debugging and isolating changes responsible for regression test failures are some of the... more Abstract—Debugging and isolating changes responsible for regression test failures are some of the most challenging aspects of modern software development. Automatic bug localization techniques reduce the manual effort developers spend examining code, for example by focusing attention on the minimal subset of recent changes that results in the test failure, or on changes to components with most dependencies or highest churn.
Unifying Testing-based Automated Software Bug Localization with Markov Logic Network
Today's software systems suffer from poor reliability, with software bugs costing the US Economy ... more Today's software systems suffer from poor reliability, with software bugs costing the US Economy upwards of $60 billion annually. Attempts to reduce the number of bugs in software are estimated to consume 50% to 80% of the development and maintenance effort [7]. Among the tasks required to reduce the number of software bugs, debugging is one of the most time-consuming, and localizing the bugs is the most difficult component of this debugging task.
Abstract Aspect-oriented software development (AOSD) is gaining popularity with the wider adoptio... more Abstract Aspect-oriented software development (AOSD) is gaining popularity with the wider adoption of languages such as AspectJ. However, though the state-of-the-art aspect-oriented programming environment (such as AJDT in the Eclipse IDE) provides powerful capabilities to check the syntactic or grammar errors in AspectJ programs, it fails to detect potential semantic defects in aspect-oriented software systems.
Abstract Aspect-oriented programming (AOP) is gaining popularity with the wider adoption of langu... more Abstract Aspect-oriented programming (AOP) is gaining popularity with the wider adoption of languages such as AspectJ. During AspectJ software evolution, when regression tests fail, it may be tedious for programmers to find out the failure-inducing changes by manually inspecting all code editing. To eliminate the expensive effort spent on debugging, we developed AutoFlow, an automatic debugging tool for AspectJ software.
Background In the last 30 years, software engineering researchers have proposed several definitio... more Background In the last 30 years, software engineering researchers have proposed several definitions of CIA and developed many techniques for CIA. In the early 1980s, the work on impact analysis focused on the so-called ripple effect [10, 11]. The first definition of impact analysis was proposed by Horowitz et al. in 1986 as 'an examination of an impact to determine its parts or elements'[12]. In 1990, Pfleeger et al. presented a model of software maintenance, which took impact analysis as one of its key activities [13].
Concurrent programs often exhibit bugs due to unintended interferences among the concurrent threa... more Concurrent programs often exhibit bugs due to unintended interferences among the concurrent threads. Such bugs are often hard to reproduce because they typically happen under very specific interleaving of the executing threads. Basically, it is very hard to fix a bug (or software failure) in concurrent programs without being able to reproduce it.
HSM-based Change Impact Analysis of Object-Oriented Java Programs
Abstract—Small changes to software are sometimes likely to cause unpredicted and negative effects... more Abstract—Small changes to software are sometimes likely to cause unpredicted and negative effects on other parts of the software, especially for object-oriented Java programs due to the complicated relations between their components. Software Change impact analysis (CIA) is a key technique for identifying these potential effects. Most existing CIA techniques focus on method level without considering various changes at different granularity levels.
Abstract In this paper, we propose a fine-grained coupling metrics suite for aspect-oriented (AO)... more Abstract In this paper, we propose a fine-grained coupling metrics suite for aspect-oriented (AO) systems, to measure software changes during system evolution. We also present a correlation model in terms of intermediate processes, for better evaluating the relation between coupling metrics and system maintainability. To investigate the practicability of our proposed model, we have implemented a coupling metrics analysis tool called AJMetrics and performed an empirical study on eight AspectJ benchmarks.
Uploads
Papers by Sai Zhang