1 A Change Support Model for Distributed Collaborative Work (original) (raw)
Related papers
An Inconsistency Management Support System for Collaborative Software Development
IEICE Transactions on Information and Systems, 2014
In collaborative software developments, many change processes implementing change requests are executed concurrently by different workers. The fact that the workers do not have sufficient information about the others' work and complicated dependencies among artifacts can lead to unexpected inconsistencies among the artifacts impacted by the changes. Most previous studies concentrated only on concurrent changes and considered them separately. However, even when the changes are not concurrent, inconsistencies may still happen if a worker does not recognize the impact of the changes made by other workers on his changes or the impact of his changes on other workers' changes. In addition, the changes in a change process are related to each other through their common target of realizing the change request and the dependencies among the changed artifacts. Therefore, to handle inconsistencies more effectively, we concentrate on both concurrent and non-concurrent changes, and the context of a change, i.e. the change process containing the change, rather than the ongoing changes only. In this paper, we present an inconsistency awareness mechanism and a Change Support Workflow Management System (CSWMS) that realizes this mechanism. By monitoring the progress of the change processes and the ongoing changes in the client workspaces, CSWMS can notify the workers of a (potential) inconsistency in advance along with the context of the inconsistency, that is, the changes causing the inconsistency and the change processes containing these changes. Based on the information provided by CSWMS, the workers can detect and resolve inconsistencies more easily and quickly. Therefore, our research can contribute to building a safer and more efficient collaborative software development environment.
Enhancing collaborative synchronous UML modelling with fine-grained versioning of software artefacts
Journal of Visual Languages and Computing, 2007
Software development teams are composed of people with different knowledge and skills, who contribute to a project from often widely dispersed locations. Software development in geographically distributed environments creates software engineering challenges due to the interaction among members of distributed teams and the management of consistency and concurrency among project artefacts. In this paper, we propose Synchronous collaborative modelling Tool Enhanced with VErsioning management (STEVE) a collaborative tool supporting distributed Unified Modelling Language (UML) modelling of software systems. The tool provides a communication infrastructure enabling the concurrent editing of the same UML diagram at the same time by distributed developers. Complex UML diagrams are decomposed and managed in a fine-grained hierarchy of sub-artefacts, thus providing change and configuration management functionalities for both the diagram and the graphical objects. Thus, software predefined diagram components can be consistently reused and shared across different diagrams of a given project.
Modelling versions in collaborative work
Iet Software/iee Proceedings - Software, 1997
This paper addresses the problem of version management for cooperative systems. We first describe a basic version model -a domain model capturing the idea of a version and the relationships between versions, whether electronic or physical, implicitly or explicitly stored. This is a 'modal' model in that it takes into account the context of use of these versions. The model is then extended to model version managers, which are both versioned entities themselves and also include their own models of versions. Finally, we see how V-Web, a system for versioning web pages, fits within the framework of our model. url for related work: http//www.soc.staffs.ac.uk/\~cmtajd/topics/versions/ 3.
Computer, 1996
oftware projects change rapidly, which makes efficient change management a major challenge for S the software industry. This challenge was poorly met for years because of rudimentary tools. Source code changes, for example, were managed with stand-alone, file-based version control systems. Other changes-in text specification and planning documents, cost estimates, test libraries, graphics and illustrations, and bug inventorieswere managed with limited tools that rarely communicated across domains. It has been recognized since at least 1990 that for many projects, source code isn't the only deliverable that changes. Frequently, the number ofwords created to deal with a software project significantly exceed the size of the source code, and the words change more rapidly. Bug reports, for example, undergo constant change during software development and maintenance as bugs are reported, tested, k e d , and documented. Modern change management, or configuration control, tools must encompass changes affecting every kind of software deliverable and artifact: requirements, project plans, project cost estimates, contracts, design, source code, user documents, illustrations and graphics, test materials, and bug reports. Ideally, these tools would use hypertext to handle cross-references among deliverables so that when something changes, corresponding material is modified appropriately.
A generic model for semantics-based versioning in projects
IEEE Transactions on Systems, Man, and Cybernetics, 2000
Large projects generally involve a number of phases and evolve over a period of time. Several revisions of the individual artifacts consisting of the project take place during the various phases. These revisions and refinements are normally captured as different versions using configuration/version management tools. But the semantics of these refinements with respect to the project are not captured by existing mechanisms. In addition to the above, a change in the semantics of a project artifact may require suitable changes in other related artifacts. Existing mechanisms for configuration management do not provide mechanisms for change propagation based on the change semantics. In this paper, we propose a generic model for semantics-based version management in projects, which can be built over existing tools. The model also provides support for capturing how changes propagate in a project. We then elucidate the generality of the model by applying it to a project involving a CAD framework and a software development project
Change Management Support for Large Software Systems
1986
This technical report consists of three related papers in the area of management of source code changes for large software systems. Infuse: A Toolfor Automatically Managing and Coordinating Source Changes in Large Systems presents Infuse, a software engineering environment that automatically panitions the source code files to be changed in order to limit the complexity of change propagation and negotiation of conflicting changes. Workspaces and Experimental Databases: Automated Support for Cooperation Among Programmers describes Infuse in more detail, focusing on the interactions between Infuse and source code modification tools. Smarter Recompilation presents an algorithm that could be used by Infuse or other software engineering environments to reduce recompilation costs after source code changes.
Consistency Management of Heterogeneous Software Artifacts
International Journal of Computer Applications, 2013
The development of complex software systems involves the participation of many stakeholders (e.g. customers, users, analysts, designers, and developers) who collaborate in publishing numerous heterogeneous software artifacts such as source code, analysis models and design, unit tests, XML deployment descriptors, the user guides, among many others. Since these artifacts are spread over several designs sites and therefore stored in several version managers. In this context it becomes very difficult to ensure their consistency and manage the impact of their evolution out the development process. In this article we propose a unified meta-model to represent the different elementary operations built on a set of heterogeneous artifacts and establish a uniform formalism to express consistency rules as logical constraints based on the meta-model construction. Our approach allowing us to deal with consistency between different artifacts whatever their kind. We will validate our approach by building a eclipse plug-in (in progress) that will provide an interface to declare the rules of consistency and check engine to detect violations of constraints listed previously.
Model&Metamodel, Metadata and Document Repository for Software and Data Integration
Lecture Notes in Computer Science, 2008
Model-based software engineering (MBSE) projects require and generate numerous artifacts. While MBSE methodology and design tools have reached certain maturity level, the issue of artifact persistence and management has been somewhat left in the background. We present design and implementation of the repository that supports storing and managing of artifacts such as metamodels, models, constraints, metadata, specifications, transformation rules, code, templates, configuration or documentation, and their metadata.
Awareness of Concurrent Changes in Distributed Software Development
Lecture Notes in Computer Science, 2008
Traditional software development tools such as CVS and Subversion do not inform users about concurrent modifications while they work on shared projects in their local workspaces. We propose an awareness mechanism that informs users about location of concurrent changes at the level of class, method and line. Developers are provided with a preview of the concurrent changes made by other contributors on the project. They can continue to change and test their code without the need to integrate concurrent changes. We present the underlying algorithms of our proposed awareness mechanism.
Towards a version control model with uncertain data
2011
Abstract Content-based online collaborative platforms and office applications are widely used for collaborating and exchanging data, in particular in the form of XML-based electronic documents. Usually, a version control system is built-in in these applications to support collaboration and to properly manage document evolution. However, most version control models require error-prone and time-consuming manual management of conflicts and uncertainties, thus heavily affecting collaborative work.