Coakley et al. described how they developed Version Aware Word Documents, which is an enhanced document representation that includes a detailed version history that is self-contained and portable. However, they were not able to adopt the unique-ID-based techniques that have been shown to support efficient merging and differencing algorithms. This application note describes how it is possible to adapt existing features of MS Word's OOXML representation to provide a system of unique element IDs suitable for those algorithms. This requires taking over Word's Revision Save ID (RSID) system and also defining procedures for specifying ID values for elements that do not support the RSID mechanism. Important limitations remain but appear surmountable.

Securing sensitive digital documents (such as health records, legal reports, government documents, and financial assets) is a critical and challenging task. Unreliable Internet connections, viruses, and compromised file storage systems impose a significant risk on such documents and can compromise their integrity especially when shared across domains while they are shared in offline fashion.

In software product line engineering, core assets are shared among multiple products. Core assets and products generally evolve independently. Developers need to capture evolution in both contexts and to propagate changes in both directions between the core assets and the products. We propose a version control system to support product line engineering by supporting the evolution of product line, product derivation, and change propagation from core assets to products and vice versa.

A document often goes through many revisions before it is finalized. In the normal document creation process, newer revisions overwrite older ones and only the final revision is kept. At any stage of document creation, it might be desirable to see how the document came to its current form or to revert back to a previous revision. Conventional version control tools such as CVS could help authors do exactly this. However, these tools are unlikely to be adopted by non-technical document authors due to the overhead of managing a repository and the tools' learning curves.

XML has become the standard document representation for many popular tools in various domains. When multiple authors collaborate to produce a document, they must be able to work in parallel and periodically merge their efforts into a single work. While there exist a small number of three-way XML merging tools, their performance could be improved in several areas and they lack any form of user interface for resolving conflicts.

BACKGROUND: Microarray has been widely used to measure the relative amounts of every mRNA transcript from the genome in a single scan. Biologists have been accustomed to reading their experimental data directly from tables. However, microarray data are quite large and are stored in a series of files in a machine-readable format, so direct reading of the full data set is not feasible. The challenge is to design a user interface that allows biologists to usefully view large tables of raw microarray-based gene expression data. This paper presents one such interface--an electronic table (E-table) that uses fisheye distortion technology. RESULTS: The Fisheye Viewer for microarray-based gene expression data has been successfully developed to view MIAME data stored in the MAGE-ML format. The viewer can be downloaded from the project web site http://polaris.imt.uwm.edu:7777/fisheye/. The fisheye viewer was implemented in Java so that it could run on multiple platforms. We implemented the E-table by adapting JTable, a default table implementation in the Java Swing user interface library. Fisheye views use variable magnification to balance magnification for easy viewing and compression for maximizing the amount of data on the screen. CONCLUSION: This Fisheye Viewer is a lightweight but useful tool for biologists to quickly overview the raw microarray-based gene expression data in an E-table.

In an integrated development environment, the ability to manage the evolution of a software system in terms of logical abstractions, compositions, and their interrelations is crucial to successful software development. This paper presents a novel framework and infrastructure, Molhado, upon which to build object-oriented software configuration management (SCM) services in a SCM-centered integrated development environment. Key contributions of this paper include a product versioning model, an extensible, logical, and object-oriented system model, and a reusable product versioning SCM infrastructure, that allow new types of objects to be implemented as extensions of the system model's basic entities. Versions and configurations of objects are managed at different levels of abstraction and granularity. A new SCM-centered editing environment or development environment for a specific development paradigm can be rapidly realized by re-using Molhado's infrastructure and implementing new object types and their associated tools. This paper also demonstrates our approach in creating prototypes of SCM-centered development environments for different paradigms.

In traditional software, engineering tools, software configuration management (SCM) is the dominant approach to manage the evolution of a software system. However, the evolution of Web-based applications presents special challenges that have not been well addressed by existing SCM systems. They often treat hyperlinked Web documents as a set of text files in a file .system and disregard crucial structures in a Web-based application such as internal structure, navigational structure, logical structure, and compositional structure among Web objects. Key limitations include their inadequacy to represent Web object semantics and their inability to manage changes to those important structures among objects making up a Web application. This paper presents a novel SCM-centered development environment for Web-based applications, named WebSCM. With WebSCM, Web developers can manage fine-grained, structural evolution of Web objects and important structures among them at different levels of abstraction (e.g. conceptual, navigational, presentation, and implementation levels). This paper also describes the motivation for this environment as well as its user interfaces, features, and implementation.

Software development is a dynamic process where engineers constantly modify and refine their systems. As a consequence, everything evolves including designs, system's architectural structure, and implementation source code. Software evolution can easily make architectural traceability relationships between software architectural entities and corresponding source code become out of date. This paper suggests the use of object-oriented software configuration (SCM) and version management technology to manage versions of architectural structure/entities, source code, and the traceability relationships among them. The resulting architectural SCM system, MolhadoArch, always keeps architectural entities version-consistent with source code. Consistent configurations are maintained not only among source code but also with the high-level software architecture. MolhadoArch supports the management of both planned and unplanned evolution of software architecture.

Internal structures of software artifacts, especially program source code, are very important to software engineers in developing and maintaining a high-quality software. However, existing version control and configuration management systems often treat a software system as a set of files in directories on a file system. They usually disregard the logical structures of documentations and program source code and treat them as a set of lines for version control. Therefore, it creates burdensome for ordinary developers because the implementation domain (logical level) and the version control domain (file level) require different mental models. This paper describes the fine-grained version control tool of the software concordance environment that is flexible to manage the evolution of many different structural levels in a software document.

Software development is a dynamic process where engineers constantly modify and refine their systems. As a consequence, everything evolves including designs, system's architectural structure, and implementation source code. This paper contributes a novel approach to manage architectural evolution of software systems at the logical level. Key to Molhado architectural software configuration management (SCM) system is its architectural system model in which the architectural concepts are integrated into the system model to enable the management of unplanned evolution of software architecture. Via our product versioning SCM approach, consistent configurations are maintained not only among source code but also with the high-level software architecture. Molhado's architectural system model can also be extended to support different architectural description languages and architectural styles.

In this research demonstration, we describes Molhado, a research prototype of an architectural software configuration management (SCM) system that captures the evolution of system architecture, logical structures, and implementation source code in a natural and cohesive manner.

Researchers in Web engineering have regularly noted that existing Web application development environments provide little support for managing the evolution of Web applications. Key limitations of Web development environments include line-oriented change models that inadequately represent Web document semantics and in ability to model changes to link structure or the set of objects making up the Webapplication. Developers may find it difficult to grasp how theoverall structure of the Web application has changed over time and may respond by using ad hoc solutions that lead to problems of maintain ability, quality and reliability. Web applications are software artifacts, and as such, can benefit from advanced version control and software configuration management (SCM)technologies from software engineering. We have modified an integrated development environment to manage the evolution and maintenance of Web applications. The resulting environment is distinguished by itsfine-grained version control framework, fine-grained Web contentchange management, and product versioning configuration management, in which a Web project can be organized at the logical level and itsstructure and components are versioned in a fine-grained manner aswell. This paper describes the motivation for this environment as well as its user interfaces, features, and implementation.