The ACM Symposium on Document Engineering (DocEng) is now holding its 25th annual meeting, here at the University of Nottingham, historically one of the key centres of document research.It seems appropriate to now look back at the genesis of DocEng and at the evolution of the field to this point.First, what is a "document"?A first order definition might be this: "an artifact designed to be presented to a person".However, this definition is so broad as to include almost every work of art including, for example, a sculpture and as such fails to match common

The Extensible Markup Language (XML) is widely used to store, retrieve, and share digital documents. Recently, a form of Version Control System has been applied to the language, resulting in Version-Aware XML and allowing for enhanced portability and scalability. While Version Control Systems are able to keep track of changes made to documents, we think that there is untapped potential in the technology. In this paper, we define a set of requirements for visualization tools in a modern version control system. We also present an interactive and scalable visualization framework to represent Version-Aware-related data that helps users visualize and understand version control data, delete specific revisions of a document, and access a comprehensive overview of the entire versioning history.

In this paper, we describe an enhancement of the Automated Policy Enforcement eXchange framework (APEX) called eAPEX. eAPEX uses version-control information as the basis for a more incremental approach to scanning document text to determine if security policies are being followed. Where APEX requires a full or deep scan of the document each time an exposure operation is invoked, eAPEX usually requires only a scan of changed elements (deltas). A new scanning approach was designed and implemented. eAPEX works by combining version-aware document technology with a policy database that functions as a cache of security policy results.

The DChanges series of workshops focuses on changes in all their aspects and applications: algorithms to detect changes, models to describe them and techniques to present them to the users are only some of the topics that are investigated. This year, we would like to focus on collaboration tools for non-textual documents.

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.

The DChanges series of workshops focuses on changes in all their aspects and applications: algorithms to detect changes, models to describe them and techniques to present them to the final users are only some of the topics we investigate. The workshop is open to researchers and practitioners from industry and academia. This year, we would like to focus on the application of change-tracking and diff algorithms to documents that are collaboratively edited via the web. We will also follow up on the discussion of DChanges 2015 about algorithms and interfaces to better understand and exploit detected changes, and about standards for modeling and transmitting changes. Particular attention will also be given to the use of diff, change tracking, and versioning techniques in the field of digital humanities.

CISS+ is a new surveillance system designed to aid clinicians seeking to help patients make healthy decisions about their lifestyle and health. It takes clinical records as queries anduses these records to find articles in the scientific literature that describe risk factors relevant to the patients' history and medical state. CISS+ is a revision of the earlier CISS system, which useda simple n-gram text retrieval strategy. CISS+ enhances CISS byusing higher-relevance terms and concepts taken from the UMLS and MetaMap systems and by using automated techniques related to relevance feedback to refine queries. CISS+ was evaluated viaa small set of experimental queries that were sent to other widely available biomedical research search systems. CISS+ returned asmall number of results that had better relevance to the goal of identifying risks factors.

The DChanges series of workshops focuses on changes in all their aspects and applications: algorithms to detect changes, models to describe them and techniques to present them to the final users are only some of the topics we investigate. The workshop is open to researchers and practitioners from industry and academia.

As a software project evolves, so does its build system. Significant effort is necessary to maintain the build system to cope with this evolution, in part because changes to source code often require parallel changes in the build system. Our tool, Formiga, is a build maintenance and dependency discovery tool for the Ant build system. Formiga's primary uses are to automate build changes as the source code is updated, to identify the build dependencies within a software project, and to assist with build refactoring. Formiga is implemented as an IDE plugin, which allows it to recognize when project resources are updated and automatically update the build system accordingly. A controlled experiment was conducted to assess Formiga's ability to assist developers with build maintenance. Subjects responded to scenarios in which various forms of build maintenance and/or knowledge about deliverables and their contents were requested. Subjects completed eleven different build maintenance tasks in both an experimental condition using Formiga and a control condition using only conventional IDE services. The study used a balanced design relative to both task order and use of Formiga. This design also ensured that order balancing was not confounded with the subjects' level of Ant expertise. Formiga was shown to significantly reduce the time required to perform build maintenance while increasing the correctness with which it can be performed for both novice and experienced developers.

With collaborative tools getting more and more widespread, users have started to become accustomized to features like automatic versioning of their documents or the visualization of changes made by other users. The research community, however, sees that the state of the current tools is seriously lack lusting. The second edition of the DChanges workshop focuses on these shortcomings, introducing new ways to produce version-aware documents and merge changes from multiple sources. Other aspects - in particular, the standardization of formats for tracking changes - are discussed, too.

Version control systems provide a methodology for maintaining changes to a document over its lifetime and provide better management and control of evolving document collections, such as source code for large software systems. However, no version control system supports similar functionalities for office documents.

The evolution in media support within W3C standards has led to the development of HMTL5. HTML5 provides extensive support for audio/video/timed-text within an interoperable browser context.

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.

For over 40 years, system response time has been a topic of interest and controversy in computer science. Since the late 1960s, the field has seen numerous studies conducted and articles written addressing the issue. Many factors were measured in these studies including: users’ accuracy and error rates with different levels of system response time, user performance speed and the efficiency of the commands used, how user interactions with the computer changed as a result of changes in system response time, how their bodies reacted physiologically to those same changes and even how happy, satisfied, anxious or annoyed they were as system response times changed. In this paper, we summarize the major issues in system response time research and look at what can be concluded from them. Generally, researchers have suggested specific response-time guidelines based on the complexity of the task or the type of interaction with the computer. We suggest that rather than system response time being task- or expectation-focused, instead interactions with a computer fall into two categories: control tasks and conversational tasks. For control tasks, immediate response times are necessary for optimal user performance whereas for conversational tasks, some delays may be necessary to maintain the optimal pacing of the on-going conversation. The location and duration of these delays will depend on both task complexity and user expectations. Future system response time research is needed to further quantify limits of delay detection, and the location and duration of inter-task delays to optimize user performance and satisfaction with computers.

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.

This paper describes the implementation and evaluation of a program that uses active recruiting and peer-led team learning to try to increase the participation and success of women and minority students in undergraduate computer science. These strategies were applied at eight universities starting in the fall of 2004. There have been some impressive results: We succeeded in attracting under-represented students who would not otherwise have taken a CS course.Evaluation shows that participation in our program significantly improves retention rates and grades, especially for women.Students in the program, as well as the students who served as peer leaders, are uniformly enthusiastic about their experience.

This working session will be a roundtable discussion of document engineering education. The working session's goal is to allow educators and researchers to share their experiences in teaching topics related to document engineering. The hope is that these discussions will stimulate the development of common resources, including syllabi, reading lists, and exercises in order to facilitate the spread of document engineering as a viable topic for study.

The Contextractor is an XSLT-based transformation system that gathers information from extended UML models to produce XML Schemas that model the information captured by an application and define a query language that allows the submission of queries over the captured content.

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.

wVIEW is an automated system for generating Web applications that relies extensively on document representations and transformations. wVIEW adopts the widely accepted hypermedia design principle that content navigation and presentation are separate concerns. Each of these aspects of the design process is controlled by separate declarative specifications. Only the first specification the content structure specification which is described using UML must be provided. However the wVIEW user is free to add extensions and customizations to both the data and navigation models in order to make the final application suit specific needs. This paper describes the wVIEW approach and the current prototype which focuses on the data and navigation modelling aspects. The paper discusses experiences in using XSLT as the primary development tool and shows examples how the enhancements planned to XSLT address some limitations of the application generation process.

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.

Since the source code is only one of many types of documents that must be maintained as a software system evolves, modern software development could be improved by better interoperability between source code and other software documents. The Software Concordance is a prototype programming environment that uses hypermedia services and a uniform document model to achieve this interoperability. The Software Concordance editor allows developers to enhance their inline documentation with multimedia objects and hyperlinks, while still supporting advanced program analysis including lexing, parsing and type checking. We motivate the need for environments like the Software Concordance, describe the design and implementation of its program editor, and discuss lessons learned while creating it. The system is based on a uniform, Web compatible document model for both program source code and nonprogram software documents and a corresponding API. Important technical problems addressed by this research include creating a persistent representation of program lexemes that the analysis suite considers to be ephemeral (such as keywords), providing a simple incremental parsing system, and embedding multimedia in source code without disrupting program analysis. Based on insight gained in the process of implementing the document API, a new approach to the design of a more suitable program analysis infrastructure is suggested.

Video-on-demand (VOD) designs typically feature either request or broadcast architectures. Both have limitations. Request architectures experience a limit in the number of clients that can be adequately serviced. Broadcast architectures require large, often unavailable, bandwidth. In addition, it is difficult to limit viewing to a target audience. In this paper, we present a new architecture for a metropolitan VOD service that we name requestcasting. Our architecture combines the two general approaches of request and broadcast, but not their respective limitations. With the requestcast architecture, we implement an improved pyramid broadcasting protocol. Our synchronized method of employing pyramid broadcasting is key to providing robust VOD service.