Supporting Aggregation in Fine Grained SoftwareConfiguration ManagementMark C. [email protected] [email protected] [email protected] T. J. Watson Research Center19 Skyline Drive, Hawthorne, NY 10522ABSTRACTFine-grained software configuration management offers sub-stantial benefits for large-scale collaborative software devel-opment, enabling a variety of interesting and useful fea-tures including complexity management, support for aspect-oriented software development, and support for communica-tion and coordination within software engineering teams, asdescribed in [4]. However, fine granularity by itself is not suf-ficient to achieve these benefits. Most of the benefits of finegranularity result from the ability to combine fine-grainedartifacts in various ways: supporting multiple overlappingorganizations of program source by combining fine-grainedartifacts into virtual source files (VSFs); supporting coor-dination by allowing developers to precisely mark the setof artifacts affected by a change; associating products fromdifferent phases of the development process; etc.In this paper, we describe how a general aggregation mech-anism can be used to support the various functionality en-abled by fine grained SCM. We present a set of requirementsthat an aggregation facility must provide in order to yieldthese benefits, and we provide a description of the imple-mentation of such an aggregation system in our experimen-tal SCM system.Categories and Subject DescriptorsD.2.7 [Software Engineering]: Distribution, Maintenance,and Evolution—Version Control; D.2.9 [Software Engi-neering]: Management—Software Configuration Manage-ment; D.2.3 [Software Engineering]: Coding Tools andTechniques; D.2.6 [Software Engineering]: ProgrammingEnvironments—Programmers Workbench; K.6.3 [Managementof Computing and Information Systems]: SoftwareManagement—Software Selection; H.3.3 [Information Stor-age and Retrieval]: Information Search and Retrieval—Retrieval models, search process, selection processPermission to make digital or hard copies of all or part of this work forpersonal or classroom use is granted without fee provided that copies arenot made or distributed for profit or commercial advantage and that copiesbear this notice and the full citation on the first page. To copy otherwise, torepublish, to post on servers or to redistribute to lists, requires prior specificpermission and/or a fee.SIGSOFT 2002/FSE-10, November 18–22, 2002, Charleston, SC, USA.Copyright 2002 ACM 1-58113-514-9/02/0011 ...$5.00.General TermsLanguages, ManagementKeywordsFine grained storage, aggregation, dynamic program orga-nization1. WHY? MOTIVATING AGGREGATIONManaging software artifacts in a software configurationmanagement system is a fundamental part of modern soft-mare engineering practices. Most SCM systems managesoftware artifacts in terms of files, which are relatively coarsegrained entities. Adopting a finer granularity such as indi-vidual methods or functions offers substantial benefits forlarge-scale collaborative software development, particularlyin the areas of complexity management and communica-tion/coordination support for software engineering teams,as described in [4]. However, an SCM tool cannot producethese benefits simply by adopting finer storage granularity.Most of the benefits of fine granularity result from the abilityto combine fine-grained artifacts in various ways: support-ing multiple overlapping organizations of program source bycombining fine-grained artifacts into virtual files; support-ing coordination by allowing developers to precisely markthe set of artifacts affected by a change; associating prod-ucts from different phases of the development process, etc.In the context of an SCM system, aggregation is a facil-ity to allow the creation of versioned objects formed fromcollections of other objects. For example, in a typical SCMsystem, a directory is an aggregate object formed from a col-lection of file objects. In a fine-grained system, aggregatescan be used to represent a wide variety of interesting rela-tionships between collections of versioned artifacts. For ex-ample, in figure 1, we illustrate two overlapping aggregates:one representing a relationship between a UML interactiondiagram and the code artifacts that are participants in theinteraction; and the other representing a set of Z schema ar-tifacts and the code implementing the operations specifiedby the schema.Fine granularity without aggregation support does havevalue. With file-based SCM, all repository facilities (fromlocks to version histories) operate at the file level and above.In these systems, it is hard to assess the cost of integrat-ing change-sets, file locking causes unnecessary bottleneckswhen several developers need access to different sections of agiven source file, and change histories for individual methods99JavaMethodZ SchemaUML InteractionDiagram JavaClassJavaMethodJavaMethodJavaMethodJavaMethodZ SchemaZ SchemaUML InteractionDiagram JavaClassJavaClassProgram RepositoryFigure 1: Aggregates representing versionable cross-cutting relationshipsand functions are difficult to generate (especially if methodsmigrate between files over time). Fine-grained SCM canhelp address all of these problems.However, fine-grained SCM without aggregation also in-troduces substantial complexities into a system. Experi-mental data gathered using our current implementation in-dicates that changing from file to method level granularityincreases the number of managed artifacts by one to twoorders of magnitude. To make fine granularity manageable,especially given the resulting increase in the number of ar-tifacts, both the SCM repository and related developmenttooling must provide mechanisms that support sophisticatedaggregation functionality.Our solution for these issues is based on the comprehen-sive use of aggregates as first-order entities. We claim thatsuch reified aggregates enable a host of useful capabilitiesthat extend well beyond simply making SCM work better,including:• Multidimensional program organization,• Support for distributed development,• Linkage and relationship management for heteroge-neous artifacts,• SCM support for fragment-oriented technologies suchas aspect-oriented programming,• Improved coordination support for collaborative devel-opment, and• Improved lifecycle and process support.Details on how these features can be provided by a fine-grained SCM