A Coordination Perspective on Software System Design
Total Page：16
File Type：pdf, Size：1020Kb
A Coordination Perspective on Software System Design Chrysanthos Dellarocas Sloan School of Management Massachusetts Institute of Technology Room E53-315, Cambridge, MA 02139, USA Tel: +1 617 258-8115 [email protected] ABSTRACT application. In the rest of the paper, we will use the term In large software systems the identification and proper dependencies to refer to interconnection relationships and management of interdependencies among the pieces of a constraints among components of a software system. system becomes a central concern. Nevertheless, most As design moves closer to implementation, current design traditional programming languages and tools focus on and programming tools increasingly focus on components, representing components, leaving the description and leaving the description of interdependencies among management of interdependencies among components components implicit, and the implementation of protocols implicit, or distributed among the components. This paper for managing them fragmented and distributed in various identifies a number of problems with this approach and parts of the system. At the implementation level, software proposes a new perspective for designing software, which systems are sets of source and executable modules in one or elevates the representation and management of component more programming languages. Although modules come interdependencies to a distinct design problem. A core under a variety of names (procedures, packages, objects, element of the perspective is the development of design clusters etc.), they are all essentially abstractions for handbooks, which catalogue the most common kinds of components. interconnection relationships encountered in software systems, as well as sets of alternative coordination Most programming languages directly support a small set of protocols for managing them. The paper presents primitive interconnection mechanisms, such as procedure SYNTHESIS, a software development environment based on calls, method invocation, shared variables, etc. Such this perspective. A number of experiments performed using mechanisms are not sufficient for managing more complex SYNTHESIS as well as some directions for future research dependencies that are commonplace in today's software are discussed. systems. Complex dependencies require the introduction of more complex managing protocols, typically comprising several lines of code (for example, the existence of a shared Keywords resource dependency might require a distributed mutual component-based software, software interconnection, exclusion protocol). By failing to support separate software architecture, software reuse, coordination protocol abstractions for representing such complex protocols, current programming languages force programmers to distribute and embed them inside the interacting INTRODUCTION components [20] (Figure 1). Furthermore, the lack of means In large software systems the identification and proper for representing dependencies and protocols for managing management of interconnection relationships and them has resulted in a corresponding lack of theories and constraints among various pieces of a system has become systematic taxonomies of interconnection relationships and responsible for an increasingly important part of the ways of managing them. development effort. In many cases, the design, testing, and maintenance of protocols for managing communication, This expressive shortcoming of current languages and tools resource sharing, synchronization and other such is directly connected to a number of practical problems in interconnection relationships takes far more time and effort software design: than the development of the core functional pieces of an Accepted at the International Conference on Software Engineering and Knowledge Engineering (SEKE97), Madrid, Spain, June18-20, 1997. • Discontinuity between architectural and implementation Data Flow models. There is currently a gap between architectural Generate Process representations of software systems (sets of activities Test Data Test Data explicitly connected through rich vocabularies of informal relationships) and implementation-level descriptions of module main( ) module generate ( PIPE pw ) { module process( PIPE pr ) the same systems (sets of modules implicitly connected { ... { ... open_pipe( pwrite, pread ); ... through defines/uses relationships). write( pw, data ); ... read( pr, data ); ... generate( pwrite ); ... close( pw ); ... close( pr ); • } process( pread ); } Difficulties in application maintenance. By not providing } abstractions for localizing information about dependencies, current languages force programmers to distribute the protocols for managing them in a number of Figure 1: Implementation languages often force the different places inside a program. Therefore, in order to distribution of coordination protocols among several code understand or modify a protocol, programmers have to modules. In this example, the implementation code of a look at many places in the program. pipe protocol for managing a single data flow dependency has been distributed among three code modules. • Difficulties in component reuse. Components written in today’s programming languages inevitably contain some fragments of coordination protocols from their original As a response to this situation, this paper proposes a new development environments. Such fragments act as perspective for representing and implementing software undocumented assumptions about the structure of the systems. Unlike current practice, this perspective application where such components will be used. When emphasizes the explicit representation and management of attempting to reuse such a component in a new dependencies among software activities as distinct entities. environment, such assumptions might not match the The perspective is based on the ideas of coordination theory interdependency patterns of the target application. In [12] and the Process Handbook project [3,11]. In order to ensure interoperability, the original assumptions accordance with Malone and Crowston [12], we define then have to be identified, and subsequently replaced or coordination as the act of managing dependencies among bridged with the valid assumptions for the target activities. In this case, the activities we are concerned with application. In many cases this requires extensive code are software components. We will also use the term modifications or the introduction of additional code coordination process or protocol to describe the additional around the component. code introduced into a software system as a result of The preceding discussion forms the motivation for the rest managing some dependency. Using these definitions, the of the paper. As a response to the problems identified in principles of our coordination perspective on software this section, we introduce the principles of our coordination system design can be stated as follows: perspective on software system design. Following that, we • Explicitly represent software dependencies. Software describe SYNTHESIS, a prototype software development environment which embodies the principles of the systems should be described using representations that coordination perspective. We present our experience with clearly separate the core functional pieces of an application from their interdependencies, providing using SYNTHESIS to facilitate software reuse. We discuss related work, describe some future directions of the project, distinct abstractions for each. and conclude the paper with a summary of our findings. • Build design handbooks of component integration. The A COORDINATION PERSPECTIVE ON field knowledge on component integration should be SOFTWARE SYSTEM DESIGN organized in systematic taxonomies that provide guidance The practical problems discussed in the previous section are to designers and facilitate the generation of new rooted in the failure of most current programming knowledge. Such taxonomies will catalogue the most languages and methodologies to recognize the identification common kinds of interconnection relationships and management of dependencies among software encountered in practice. For each relationship, they will components as a design problem in its own right. This contain sets of alternative coordination protocols for shortcoming translates to inadequate support for making managing it. In that way, they can form the basis for interconnection assumptions embedded inside components design handbooks of component integration, similar to more explicit, inability to localize information about the well-established handbooks that assist design in more interconnection protocols, and a lack of theories and mature engineering disciplines. systematic taxonomies of software interconnection The long-term goal of this research is to develop concrete relationships and ways of managing them. software development tools and methodologies based on Prerequisite application architectures at both the specification and the Activities Dependencies implementation level. File Viewer It provides separate language entities for representing Retrieve View Files Filenames software activities and dependencies. SYNOPSIS language Open Start DB Viewer elements are connected together through ports. Ports Select provide a general mechanism for representing abstract Prereq Files Prereq component interfaces. All elements of the language can Retrieve View contain an arbitrary number of attributes. Attributes encode Flow Filename Flow New File additional properties