Reusing and Interconnecting Software Components

This article covers some problems, concepts, and approaches relevant to environments for creating, documenting, and maintaining large software systems. The goal is to make programming significantly easier, more reliable, and cost effective by reusing previous code and programming experience to the greatest extent possible. Suggestions given here include: systematic (but limited) use of semantics, by explicitly attaching theories (which give semantics, either formal or informal) to software components with views (which describe semantically correct interconnections at component interfaces); use of generic entities, to maximize reusability; a distinction between horizontal and vertical composition; use of a library interconnection language, called LIL, to assemble large programs from existing entities; support for different levels of formality in both documentation and validation; and facilitation of program understanding by animating abstract data types and module interfaces. ADA is used for examples because it has some convenient features, but the proposals also apply to other languages.

[1]  Cordell Green Research on Knowledge Based Programming and Algorithm Design. , 1981 .

[2]  Joseph A. Goguen,et al.  Putting Theories Together to Make Specifications , 1977, IJCAI.

[3]  Walter F. Tichy Software Development Control Based On System Structure Description , 1980 .

[4]  David Lorge Parnas,et al.  On the Design and Development of Program Families , 2001, IEEE Transactions on Software Engineering.

[5]  Richard N. Taylor,et al.  Steps to an advanced ada programming environment , 1984, ICSE 1984.

[6]  Joseph A. Goguen,et al.  The Semantics of CLEAR, A Specification Language , 1979, Abstract Software Specifications.

[7]  David C. Luckham,et al.  An Overview of Anna, a Specification Language for Ada , 1985, IEEE Software.

[8]  Lee Wendell Cooprider The representation of families of software systems. , 1978 .

[9]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

[10]  David Lorge Parnas,et al.  Information Distribution Aspects of Design Methodology , 1971, IFIP Congress.

[11]  Thomas E. Cheatham,et al.  Reusability Through Program Transformations , 1984, IEEE Transactions on Software Engineering.

[12]  Michael Jackson,et al.  Principles of program design , 1975 .

[13]  José Meseguer,et al.  Universal Realization, Persistent Interconnection and Implementation of Abstract Modules , 1982, ICALP.

[14]  Joseph A. Goguen,et al.  Introducing Institutions , 1983, Logic of Programs.

[15]  Eric J. Golin,et al.  Think Pad: A Graphical system for Program-ming bY Demonstration , 1985, IEEE Software.

[16]  José Meseguer,et al.  Equality, Types, Modules, and (Why not ?) Generics for Logic Programming , 1984, J. Log. Program..

[17]  Walter F. Tichy Software development control based on module interconnection , 1979, ICSE 1979.

[18]  Craig Schaffert,et al.  CLU Reference Manual , 1984, Lecture Notes in Computer Science.

[19]  Richard C. Waters,et al.  FORMALIZING REUSABLE SOFTWARE COMPONENTS , 1983 .

[20]  John C. Reynolds,et al.  Algebraic Methods in Semantics , 1985 .

[21]  José Meseguer,et al.  Principles of OBJ2 , 1985, POPL.

[22]  Yoshihiro Matsumoto,et al.  Some Experiences in Promoting Reusable Software: Presentation in Higher Abstract Levels , 1984, IEEE Transactions on Software Engineering.

[23]  Butler W. Lampson,et al.  A Kernel Language for Abstract Data Types and Modules , 1984, Semantics of Data Types.

[24]  José Meseguer,et al.  PROGRAMMING WITH PARAMETERIZED ABSTRACT OBJECTS IN OBJ. , 1983 .

[25]  Joseph A. Goguen,et al.  Parameterized Programming , 1984, IEEE Transactions on Software Engineering.

[26]  Robert Balzer,et al.  Transformational Implementation: An Example , 1981, IEEE Transactions on Software Engineering.

[27]  Richard N. Taylor,et al.  Steps to an Advanced Ada1Programming Environment , 1985, IEEE Transactions on Software Engineering.

[28]  Rubén Prieto-Díaz,et al.  Module interconnection languages : a survey , 1982 .

[29]  Rod M. Burstall,et al.  Making Programs more Readable , 1980, Symposium on Programming.

[30]  Steven P. Reiss,et al.  PECAN: Program Development Systems that Support Multiple Views , 1984, IEEE Transactions on Software Engineering.

[31]  Jose Meseguer,et al.  Rapid prototyping: in the OBJ executable specification language , 1982 .

[32]  Thomas A. Standish An Essay on Software Reuse , 1984, IEEE Transactions on Software Engineering.

[33]  Joseph A. Goguen,et al.  Mathematical Representation of Hierarchically Organized Systems , 1970 .

[34]  John Darlington,et al.  A Transformation System for Developing Recursive Programs , 1977, J. ACM.

[35]  Martin S. Feather,et al.  A System for Assisting Program Transformation , 1982, TOPL.

[36]  Dana S. Scott,et al.  First Steps Towards Inferential Programming , 1983, IFIP Congress.

[37]  James M. Boyle,et al.  Program Reusability through Program Transformation , 1984, IEEE Transactions on Software Engineering.

[38]  Steven D. Litvintchouk,et al.  Design of Ada Systems Yielding Reusable Components: An Approach Using Structured Algebraic Specification , 1984, IEEE Transactions on Software Engineering.