SeeSoft

SeeSoft, and related system SeeSys, visualize various textual aspects of evolving large and complex software systems. Such aspects involve software complexity metrics, number and scope of modifications, number and types of bugs and dynamic program slices. Managers of such system development projects need to be able to gain overview information of the system development activity. Analysts need to know how to restructure the code during the next development cycle. Testers need to know what has changed in order to test the new features and bug fixes.

Implementation
SeeSoft is implemented using the information from version control systems. These systems keep track of every single line of code, including the dates of changes and reasons for changes and the developer who changed the code. The motivation behind SeeSoft is to display as much information as possible by using pixels to represent information, and to use as many pixels on a screen as possible.

Views

Line representation. The traditional view of SeeSoft represents each line of source code as a single colored line on the screen. Lines are grouped in rectangles to represent each file. Thus, longer rectangles represent larger files. Line length can show the length of the line and indentation in the source code, thus enabling the rough control structures to be viewed on the screen. Line color can be used to represent a variety of aspects, including the date of origination, date of change, id of the person who changed the line, which lines are bug fixes, nesting complexity, and the number of times the line was executed during testing.
Pixel representation. One or several pixels can also be used to represent each line of source code in the system, thus taking up less room on the screen. The pixels can be colored as the lines are colored.
File summary representation. Files can be summarized in a small area by representing each file as a colored rectangle with a plot inside. For example, the plot could represent the sizes of four quartiles of the file. The color can represent various metrics, such as amount of code for new functionality or bug fixes.
Hierarchical representation. SeeSys represents each subsystem of a system as a block, with directories as rectangles inside that block. The representation is similar to a treemap. The sizes of the blocks and rectangles correspond to their code sizes. Directories can further be sub-divided into file rectangles. Color and fill of each rectangle can represent a variety of metrics, such as the amount of new code, the amount of bug fixes, and the size of the directory over different versions.

For each of these views, the user is provided with controls to change colors and change or narrow what the colors represent. This allows a user to quickly focus on the detail they want in the manner that they want.

Examples
SeeSoft and SeeSys were written at AT&T Bell Laboratories to be used on a production system that is several million lines of code and has been evolving for many years. Their goal was to aid in the management and development of such systems. To that end, users can perform a variety of activities using the above views. For example, user could browse code or mulitple code statistics in different levels of abstraction. This can give both an overview and detailed view of code complexity and current development. Users can also compare different releases statically, or by animating the changes over time. Users can also use these views to do code profiling and view execution hot spots or dynamic program slices to aid in development or tuning performance. The following are various screen shots of SeeSoft and SeeSys showing the use of the above views:

This is a view of fifty-two files comprising 15, 255 lines of code. Both the pixel and line representation are being used for the files. In the inner browser window, the pixel representation is used to access a more detailed line representation, which then can access a particular line of the code. The color in this view represents the age of the code, with newer lines shown in red and older lines in blue.

This is a file summary representation. Each file is represented as a rectangle, with the rectangle size corresponding rougly to the file size. Inside, each color bar represents the code in the file, with the color of the bar representing the age of the code (blue represents old code and red the new). This view would give a quick summary of which files have older, more stable code and which files are full of new development.

This is a hierarchical representation of subsystems. Each subsystem is drawn as a rectangle with a label. The size of the rectangle corresponds to the number of lines of code in the subsystem at the subsystem's largest. The color corresponds to the current size of the subsystem. Thus, subsystem O is black, signifying that it is no longer in the current version of the system.

This is a view showing both hierarchical, pixel and line representations of the same information. This view shows the differences between two version of the system. Added lines are green, deleted lines red, and changed lines are yellow. Unchanged lines are gray.