Department of Electrical and Computer Engineering


GUI-based SCM transaction supports

An important module in Molhado infrastructure is product versioning transaction support module. New SCM-centered development environments can be developed by reusing this module. The module provides GUI-based transaction supports for developers to commit changes.

First of all, the user can open an existing project. After selecting the current (working) version from a project history window, the system displays the overall system structure and its components in a project structure window. The version that is initially displayed in the project structure window is called the base version. From this window, users can graphically modify the system's overall logical structure and components. The user can choose to edit any component and an appropriate component editor will be invoked such as structured Java program, XML, HTML, SVG graphics, UML diagrams, or plain text editors. All of these editors are structure-based, and version-savvy. Depending on the software development framework chosen, a project structure window will display different forms of system structures such as architectural design diagrams, UML design diagrams, entity relationship (ER) diagrams, or control hierarchies. In software systems with simple designs, a project can directly represent the source code structures at the implementation level such as class/package or program/directory structures.

Figure 1. A Project Structure Window displays the system architecture

Figure 2. A Project Structure Window displays file-directory hierarchy

If any modification is made to the project at this base version, a new version would be temporarily created, branching from the base version. The word ``modified'' attached to the base version name signifies that the state of the project at the temporary version has not been recorded yet. The user can choose to discard any derived (temporary) version, or to capture the state of the project at a version. Capturing changes a temporary version into a captured one. A unique name as well as date, authors, and descriptions can be attached to the newly captured version for later retrieval. The captured version plays the role of a checkpoint that the user can retrieve and refer to and it becomes the new base version of the project structure window. However, no data is saved to disk after a capture. While working on one version, the user can always switch to work on (view or modify) any other version. If the user modified the project at the new working version, an additional derived version will be branched off from that new version. If the user moves the mouse focus to a window, the working version is automatically set to the version that window is displaying. The user can also explicitly select a different version from the project history window and open it. Any windows showing the old version (even an uncaptured one) are still available should the user want to do additional work on that version. This switching feature allows the user to work on many versions at the same time during one session.

The user may commit changes at any time. Upon issuing this command, the user is asked which uncaptured, temporary versions should be saved and the chosen versions are then saved to the file system along with any already captured versions. Only the differences are stored. The user may also save complete version snapshots, which can improve version access time. All changes in architecture and implementations are integrally saved and related to each other. In current system, each user has his own data files for the project and they can be stored anywhere in a file system. Each user do not see changes made by others. Therefore, no locking mechanism is needed. Users can share data files and use merging tools to collaborate. We are implementing a more centralized repository similar to CVS with an ``official'' version graph. If the user wants to branch from a version, he will just need to copy files of the desired version to his own workspace and work on them. The user can create many ``private'' versions that others will not see and copy meaningful versions back to the repository.