Jump to navigation Jump to search
This webpage collects research tools to support software evolution. If you are the author of such a tool, or are aware of such a tool, please update this page. (Note: Commercial tools will not be considered.)
- ArchView, developed at the University of Zurich, is a tool that provides user configurable views for trend analysis and hot-spot detection. It follows the principle of measurement mapping representing source code entities such as packages or classes with Kiviat diagrams. For each entity it visualizes multiple metrics from several releases and thereby shows the trend of that entity. Spotting the trend the user can learn a number of visual patterns that allow him to detect the hot-spots and unstable entities. The tool is used in the software evolution analysis domain but not limited to that.
- BugCrawler is a tool written in Smalltalk for analyzing the evolution of large software systems. The tool is based on interactive visualizations and software metrics. The information used for rendering the views is based on the software system itself, CVS logfiles and Bugzilla problem reports.
- CCFinderX is a code-clone detector, which detects code clones (duplicated code fragments) from source files written in Java, C/C++, COBOL, VB, C#.
- ChangeDistiller, developed at the University of Zurich, is an Eclipse Plugin to extract source code changes based on tree differencing. Subsequent abstract syntax tree revisions of Java files are converted into generic tree data structures and compared to compute the basic tree edit operations that transform an original into a modified tree. The tree edit operations and the source code information from the AST are used to classify the source code changes according to our taxonomy of source code changes.
- Chronia is a tool to explore the CVS history of software systems. It features a measure for code ownership and a distance between files regarding their commit history (using Hausdorff distance and dendrogram seriation). In our research, we identified a taxonomy of common development patterns, as e.g., Monologue, Dialog, Familiarization, Takeover, Bug fix, etc.
- CodeCrawler is a language independent reverse engineering tool combining metrics and software visualization.
- DupLoc is a tool for detecting duplicated code.
- eROSE is a plugin for Eclipse that guides programmers along related changes. If you change f() and other people have changed f() together with g() in the past, eRose will detect this and suggest "Programmers who changed function f() also changed function g()." All eRose needs is a CVS repository; we designed eRose to be as efficient and unobstrusive as possible.
- Evolution Radar is a tool for analyzing the evolution of software systems from the logical coupling perspectives. The visualization technique integrates both file-level and module-level logical coupling information. The tool facilitates an in-depth analysis of the logical couplings at all granularity levels, and leads to a precise characterization of the system modules in terms of their logical coupling dependencies.
- Fame is an EMOF compliant meta-environment available for Smalltalk, Java, and Python. Fame is based on the FM3 Meta-Metamodel (a subset of EMOF) and uses MSE File Format to exchange all of meta-metamodel, metamodels and models. The main authors of Fame are Adrian Kuhn and Toon Verwaest. Fame is part of the Moose platform.
- Fetch (Fact Extraction Tool CHain) is a tool chain for software analysis, targetting the exploration of large C/C++/Java software systems for (i) dependency analysis; (ii) pattern detection; (iii) visualization; (iv) metric calculation and similar types of static analysis. Multi-version analysis is supported as well.
- Google Eclipse Search (GES)  is the result of integrating the Google Desktop Search (GDS) engine into IBM's Eclipse development environment to improve searching in software projects in a manner similar to searching the internet or your own desktop.
- Hapax  is an information retrievel tool to analyze the vocabulary of software systems, i.e. how classes and methods are related by topic rather than structure. Hapax is language independent and its approach uses a combination of LSA (latent semantic indexing), SVD (singular value decomposition) and hierarchical clustering.
- IntensiVE  is an environment that supports the definition, manipulation and verification of intensionally defined sets of source code entities (called intensional views), and relations between such sets (called intensional relations). The IntensiVE tool suite enables software developers to document and verify structural regularities in the source code, and to co-evolve these regularities with the code when either of them evolves.
- iPlasma  is an integrated environment for quality analysis of object-oriented software systems that includes support for all the necessary phases of analysis: from model extraction (including scalable parsing for C++ and Java) up to high-level metrics-based analysis, and detection of code duplication.
- JCosmo  is an outdated tool that detects code smells in Java source code. It can be used to review the quality of the analyzed code and indicate regions that could benefit from refactoring.
- JRipples , developed by Maksym Petrenko and Vaclav Rajlich at Wayne Stat University, is based on the philosophy of "intelligent assistance", which requires close cooperation between the programmer and the tool. The tool analyzes the program, keeps track of the inconsistencies, and automatically marks the components to be visited by the programmer.
- Makao (Makefile Architecture Kernel featuring Aspect Orientation)  is a re(verse-)engineering framework for build systems. It provides support for visualising, querying, filtering, refactoring and validation of build systems. It takes a trace generated by a GNU Make (or ClearMake) process, and makes the build dependency graph explicit to the build re(verse)-engineer. This graph can then be interacted with through a build-aware graph manipulation framework (based on GUESS).
- MetricViewEvolution  visualizes metrics and evolution data for UML models.
- MOMENT2-GT  is a graph-based model transformation tool that uses term rewriting to perform graph rewriting. MOMENT2-GT uses the Eclipse Modeling Framework as its metamodeling front-end and Maude as the back-end term rewriting system. MOMENT2-GT transformation definition language is based on the QVT Relations language, including support for OCL.
- Mondrian  is a novel information visualization engine that lets the visualization be specified via a script. It is built in VisualWorks Smalltalk, and the scripting language is the Smalltalk language. It is based on a graph model and works directly with the objects to be represented. Mondrian was developed by Michael Meyer and Tudor Girba and is part of the Moose platform.
- Moose  is collaborative research platform for software analysis and information visualisation. Moose was first conceived in 1997 at Software Composition Group. Since then, the Moose community has grown and spread to several European universities. Research around Moose has led to over 100 scientific publications.
- PAS (Partitioned Annotations of Software)  is a web-based medium that records a programmer's comprehension of a particular program and makes it available to the programmer's teammates. PAS divides annotations for individual software components into specialized partitions so programmers can easily find the specific information they need.
- Ptidej (Pattern Trace Identification, Detection, and Enhancement in Java)  is a tool suite to evaluate and to enhance the quality of object-oriented programs, promoting the use of patterns, either at the language-, design-, or architectural-levels, including the DECOR2 method for the detection and correction of design defect. More on our research on patterns and quality.
- Reflectivity  provides extensions to the standard reflection features of Smalltalk for both structural and behavioral reflection:
Structural reflection is extended by sub-method reflection: the structure of method bodies has as a first class and causally connected representation that can easily be extended and annotated.
Behavioral reflection is provided by a new and improved version of Geppetto, a realization of Partial Behavioral Reflection as pioneered by Reflex.
Reflectivity is built by Marcus Denker. Reflectivity is built in Squeak.
- S3M Assess : The S3M Assessment support software (S3MAssess) isan be used to support and document your S3M assessments. You can choose the key process area that you want to assess. It contains all the level 0,1 and 2 practices and prompts you with the question and allows you to document the assessment results.
- S3M DSS : The S3M Decision Support Software (S3MDSS) can be used to help you understand how to resolve your software maintenance problems. It is a knowledge base that contains all the level 0,1 and 2 practices of the maturity model and has been developed to answer the end-user, customer, software maintainer and maintenance manager questions. The questions are answered (Yes/No) and the system gradually guides you towards a specific practice of the S3M model to try to help you pin point the best practice required to help with this issue.
- SHriMP  is a tool designed for visualizing and exploring software architecture and any other information space. It is a domain-independent visualization technique designed to enhance how people browse and explore complex information spaces, including large software programs and complex knowledge-bases. <a href="http://www.thechiselgroup.org/creole">Creole</a> is an Eclipse plugin that uses SHriMP to allow you to explore your Java code visually.
- Softwarenaut  is a prototype tool used to explore techniques for software exploration. The environment is currently using as a source of data input the Moose reengineering platform.
- YARN (Yet Another Reverse-engineering Narrative)  is a prototype tool for modeling, extracting, and animating the architectural evolution of a software system. YARN mines the source code changes of the target system, and generates YARN ÒballsÓ (animations) that a viewer can unravel (watch). The animation is based on a static layout of the modules connected by animated edges that model the changing dependencies. The edges can be weighted by the number of dependencies or the importance of the change.