Software Reuse by Specialization of Generic Procedures Through Views

A generic procedure can be specialized, by compilation through views, to operate directly on concrete data. A view is a computational mapping that describes how a concrete type implements an abstract type. Clusters of related views are needed for specialization of generic procedures that involve several types or several views of a single type. A user interface that reasons about relationships between concrete types and abstract types allows view clusters to be created easily. These techniques allow rapid specialization of generic procedures for applications.

[1]  Gordon S. Novak,et al.  Software reuse through view type clusters , 1992, Proceedings of the Seventh Knowledge-Based Software Engineering Conference.

[2]  Alexander A. Stepanov,et al.  The Ada® Generic Library: Linear List Processing Packages , 1989 .

[3]  Daniel M. Yellin,et al.  Protocols and the Semiautomatic Construction of Software Adaptors , 1994, OOPSLA 1994.

[4]  Ian M. Holland,et al.  Specifying Reusable Components Using Contracts , 1992, ECOOP.

[5]  Timothy W. Finin,et al.  Enabling Technology for Knowledge Sharing , 1991, AI Mag..

[6]  Ali Mili,et al.  Reusing Software: Issues and Research Directions , 1995, IEEE Trans. Software Eng..

[7]  Fritz Friedrich Hille.  Data Abstraction and Program Development Using MODULA Two , 1989 .

[8]  D. W. Barron.  A Mathematical Theory of Global Program Optimization , 1974 .

[9]  David Turner.  An overview of Miranda , 1986, SIGP.

[10]  R Harrison,et al.  The Modula-2 software component library , 1990 .

[11]  P. Gács,et al.  Algorithms , 1992 .

[12]  Edsger W. Dijkstra,et al.  A Discipline of Programming , 1976 .

[13]  Robert Balzer,et al.  A 15 Year Perspective on Automatic Programming , 1985, IEEE Transactions on Software Engineering.

[14]  Mary Shaw,et al.  Abstraction and verification in Alphard: Defining and specifying iteration and generators , 1977 .

[15]  Harold Ossher,et al.  Subject-oriented programming: a critique of pure objects , 1993, OOPSLA '93.

[16]  Franco P. Preparata,et al.  Introduction to discrete structures , 1973 .

[17]  J. J. Horning,et al.  Introduction to LCL, A Larch/C Interface Language , 1991 .

[18]  S. Pfleeger,et al.  Introduction to discrete structures , 1985 .

[19]  Stephen Wolfram,et al.  Mathematica: a system for doing mathematics by computer (2nd ed.) , 1991 .

[20]  Will Tracz,et al.  LILEANNA: a parameterized programming language , 1993, [1993] Proceedings Advances in Software Reuse.

[21]  P. Abrahams,et al.  A mathematical theory of global program optimization , 1975 .

[22]  Micha Sharir,et al.  An Automatic Technique for Selection of Data Representations in SETL Programs , 1981, TOPL.

[23]  Scott Myers.  Difficulties in Integrating Multiview Development Systems , 1991, IEEE Softw..

[24]  Dennis Volpano,et al.  The templates approach to software reuse , 1989 .

[25]  Harold Ossher,et al.  Extending Objects to Support Multiple Interfaces and Access Control , 1990, IEEE Trans. Software Eng..

[26]  Peter Freeman.  Automating software design , 1974, Computer.

[27]  Philippe Kruchten,et al.  Software Prototyping using the SETL Programming Language , 1984, IEEE Software.

[28]  Ake Wikstrom,et al.  Functional programming using standard ML , 1987 .

[29]  Frederick P. Brooks,et al.  No Silver Bullet: Essence and Accidents of Software Engineering , 1987 .

[30]  David Gries,et al.  A Note on Graham's Convex Hull Algorithm , 1987, Inf. Process. Lett..

[31]  Michael Ian Shamos,et al.  Computational geometry: an introduction , 1985 .

[32]  David Gries,et al.  A new notion of encapsulation , 1985, ACM SIGPLAN Notices.

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

[34]  Charles Simonyi,et al.  Intentional Programming - Innovation in the Legacy Age , 1996 .

[35]  Douglas R. Smith,et al.  KIDS: A Semiautomatic Program Development System , 1990, IEEE Trans. Software Eng..

[36]  Elaine Kant,et al.  Understanding and Automating Algorithm Design , 1985, IEEE Transactions on Software Engineering.

[37]  Charles Rich.  A Formal Representation For Plans In The Programmer's Apprentice , 1982, On Conceptual Modelling.

[38]  David Garlan,et al.  Synthesizing programming environments from reusable features , 1989 .

[39]  David Alex Lamb,et al.  IDL: sharing intermediate representations , 1987, TOPL.

[40]  Don S. Batory,et al.  The design and implementation of hierarchical software systems with reusable components , 1992, TSEM.

[41]  Lawrence S. Kroll.  Mathematica--A System for Doing Mathematics by Computer. , 1989 .

[42]  Don S. Batory,et al.  Reengineering a complex application using a scalable data structure compiler , 1994, SIGSOFT '94.

[43]  Lawrence Charles Paulson,et al.  ML for the working programmer , 1991 .

[44]  Trucy Levine.  Reusable software components , 1997, ALET.

[45]  Michael J. C. Gordon,et al.  The Denotational Description of Programming Languages , 1979, Springer New York.

[46]  Gordon S. Novak,et al.  Negotiated Interfaces for Software Reuse , 1992, IEEE Trans. Software Eng..

[47]  James M. Purtilo,et al.  Module reuse by interface adaptation , 1991, Softw. Pract. Exp..

[48]  Bjarne Stroustrup,et al.  The C++ programming language (2nd ed.) , 1991 .

[49]  Gordon S. Novak.  Conversion of Units of Measurement , 1995, IEEE Trans. Software Eng..

[50]  Reinhold Friedrich Hille.  Data abstraction and program development , 1985 .

[51]  Maurice Herlihy,et al.  A Value Transmission Method for Abstract Data Types , 1982, TOPL.

[52]  M. Arbib,et al.  Arrows, Structures, and Functors: The Categorical Imperative , 1975 .

[53]  Richard C. Waters,et al.  The programmer's apprentice , 1990, ACM Press frontier series.

[54]  Franco P. Preparata,et al.  Introduction to Discrete Structures for Computer Science and Engineering , 1973 .

[55]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[56]  Andrew A. Berlin,et al.  Compiling scientific code using partial evaluation , 1990, Computer.

[57]  Don S. Batory,et al.  Scalable software libraries , 1993, SIGSOFT '93.

[58]  Stuart H. Zweben,et al.  Reusable Software Components , 1991, Adv. Comput..

[59]  Daniel M. Yellin,et al.  Interfaces, protocols, and the semi-automatic construction of software adaptors , 1994, OOPSLA '94.

[60]  Gordon S. Novak,et al.  Creation of Views for Reuse of Software with Different Data Representations , 1995, IEEE Trans. Software Eng..

[61]  J. Craig Cleaveland,et al.  An introduction to data types , 1986 .

[62]  Michael J. C. Gordon,et al.  The denotational description of programming languages - an introduction , 1979 .

[63]  Charles W. Krueger,et al.  Software reuse , 1992, CSUR.

[64]  共立出版株式会社.  コンピュータ・サイエンス : ACM computing surveys , 1978 .

[65]  Carroll Morgan.  Data Refinement by Miracles , 1988, Inf. Process. Lett..

[66]  Gordon S. Novak,et al.  Generating programs from connections of physical models , 1994, Proceedings of the Tenth Conference on Artificial Intelligence for Applications.

[67]  Olivier Danvy,et al.  Tutorial notes on partial evaluation , 1993, POPL '93.

[68]  Dennis M. Volpano,et al.  The Transform - a New Language Construct , 1990, Struct. Program..

[69]  Joseph A. Goguen,et al.  Reusing and Interconnecting Software Components , 1986, Computer.

[70]  Grady Booch,et al.  Software Component with ADA , 1987 .

[71]  Jeannette M. Wing,et al.  Signature matching: a key to reuse , 1993, SIGSOFT '93.

[72]  Franco P. Preparata,et al.  Computational Geometry , 1985, Texts and Monographs in Computer Science.

[73]  Alexander A. Stepanov,et al.  The Ada® Generic Library , 1989, Springer Compass International.

[74]  G. S. Novak.  Data abstraction in GLISP , 1983, SIGPLAN '83.

[75]  David Garlan,et al.  Views for Tools in Integrated Environments , 1986, Advanced Programming Environments.

[76]  Gordon S. Novak.  GLISP: A Lisp-Based Programming System with Data Abstraction , 1983, AI Mag..

[77]  Joseph A. Goguen,et al.  Principles of parameterized programming , 1989 .

[78]  Gordon S. Novak,et al.  Composing reusable software components through views , 1994, Proceedings KBSE '94. Ninth Knowledge-Based Software Engineering Conference.

[79]  J. G. Novak.  GLISP User''s Manual , 1983 .