Skip to main content
SpringerLink
Log in

A case-based approach to software reuse

  • Published:
Journal of Intelligent Information Systems Aims and scope Submit manuscript

Abstract

This software reuse system helps a user build programs by reusing modules stored in an existing library. The system, dubbed caesar (Case-basEd SoftwAre Reuse), is conceived in the case-based reasoning framework, where cases consist of program specifications and the corresponding C language code. The case base is initially seeded by decomposing relevant programs into functional slices using algorithms from dataflow analysis. caesar retrieves stored specifications from this base and specializes and/or generalizes them to match the user specification. Testing techniques are applied to the construct assembled by caesar through sequential composition to generate test data which exhibits the behavior of the code. For efficiency, inductive logic programming techniques are used to capture combinations of functions that frequently occur together in specifications. Such combinations may be stored as new functional slices.

This is a preview of subscription content, log in via an institution to check access.

Access this article

Log in via an institution

Price excludes VAT (USA)
Tax calculation will be finalised during checkout.

Instant access to the full article PDF.

Institutional subscriptions

Similar content being viewed by others

References

  • Aho, A.V., Sethi, R., and Ullman, J.D. (1986).Compiler Principles, Techniques, and Tools. New York: ACM Press.

    Google Scholar 

  • Barletta, R., and Mark, W. (1988). Explanation-Based Indexing of Cases.Proc. Spring Symp. Series: Explanation Based-Learning, Stanford, CA, pp. 127–136.

  • Bassett, P.G. (1987). Frame-Based Software Engineering.IEEE Software.,4-4 9–16.

    Google Scholar 

  • Biggerstaff, T.J., and Perlis, A.J. (1989). Introduction. In T.J. Biggerstaff, and A.J. Perlis (Eds.),Software Reusability, Vol. 1. New York: ACM Press, pp. xv-xxv.

    Google Scholar 

  • Carbonell, J.G. (1986). Derivational Analogy: A Theory of Reconstructive Problem Solving and Expertise Acquisition. InMachine Learning 2: An Artificial Intelligence Approach. San Mateo, CA: Morgan Kaufmann, pp. 371–392.

    Google Scholar 

  • Drummond, C., Ionescu, D., and Holte, R. (1992). Automatic Goal Extraction from User Actions When Browsing Software Libraries.Proc. Canadian Conf. Electrical and Computer Engineering, Toronto, Ont, pp. WA 6.31.1–WA 6.31.4.

  • Duchier, D. (1992). Reuse and Non-Monotonie Design of User Interfaces. TR-92-17, University of Ottawa Department of Computer Science, Ottawa, Ontario.

    Google Scholar 

  • Fisher, D., and Yoo, J. (1991). Combining Evidence of Deep and Surface Similarity.Proc. 8th Int. Workshop Machine Learning, Evanston, IL, pp. 46–50.

  • Fouqué, G., and Matwin, S. (1993). Compositional Software Reuse with Case-Based Reasoning.Proc. 9th IEEE Conf. AI for Applications, Orlando, FL.

  • Fouqué, G., and Vrain, C. (1992). Building a Tool for Software Code Analysis: A Machine Learning Approach.Proc. 4th Conf. Advanced Information Systems Engineering, Manchester, UK.

  • Hammond, K.J. (1989). Case-Based Planning: Viewing Planning as a Memory Task. In K. Forbus, R.A. Brooks, and M. Wilensky (Eds.), San Diego: Academic Press.

    Google Scholar 

  • Harandi, M.T., and Ning, J.Q. (1990). Knowledge-Based Program Analysis.IEEE Software, 7-1, 74–81.

    Google Scholar 

  • Horwitz, S., Reps, T., and Binkley, D. (1990). Interprocedural Slicing Using Dependence Graphs.IEEE Trans. Software Eng. 12-1, 26–60.

    Google Scholar 

  • Kass, A.M., and Leake, D.B. (1988). Case-Based Reasoning Applied to Constructing Explanations.Proc. Case-based Reasoning Workshop, Clearwater Beach, FL, pp. 190–208.

  • Kozaczynski, W., Ning, J., and Sarver, T. (1992). Program Concept Recognition.Proc. 7th Knowledge-Based Software Engineering Conf., McLean, VA, pp. 216–225.

  • Krueger, C.W. (1992). Software Reuse.ACM Computing Survey, 24-2, 131–183.

    Google Scholar 

  • Lapointe, S., Ling, C., and Matwin, S. (1992), Constructive Inductive Logic Programming. To appear, Proc.IYCA193, Chambéry.

  • Mac Cabe, T. (1976). A Complexity Measure.IEEE Trans. Software Eng. 2-4, 308–320.

    Google Scholar 

  • MacKeilar, B.K., and Maryanski. F. (1989) A Knowledge Base for Code Reuse by Similarity.Proc. Computer Software Applications Conf., pp. 634–641.

  • Minton, S. (1990).Learning Search Control Knowledge: An Explanation-Based Approach. Boston: Kluwer Academic.

    Google Scholar 

  • Muggleton, S. (1987). Duce, An Oracle Based Approach to Constructive Induction.Proc. 10th Int. Joint Conf. Artif. Intell., Milan, Italy, pp. 287–292.

  • Muggleton, S., and Buntine, W. (1988). Machine Invention of First-Order Predicates by Inverting Resolution.Proc. 5th Int. Conf. Machine Learning, Ann Arbor, MI, pp. 339–352.

  • Muggleton, S., and Feng, C. (1990). Efficient Induction of Logic Programs. In S. Muggleton, (Ed.),Inductive Logic Programming. London: Academic Press, pp. 281–298.

    Google Scholar 

  • Myers, G.J. (1979). The Art of Software Testing. In R.C. Canning and D.J. Couger (Eds.), New York: Wiley.

    Google Scholar 

  • Neighbors, J.M. (1989). DRACO: A Method for Engineering Reusable Software Systems. In T.J. Biggerstaff, and A.J. Perlis (Eds.),Software Reusability, Vol. 1. New York: ACM Press, pp. 295–319.

    Google Scholar 

  • Ould-Brahim, H., and Matwin, S. (1992). Reusing Database Queries in Analogical Domains.Proc. 7th Knowledge-Based Software Engineering Conf., McLean, VA, pp. 80–89.

  • Press, W.H., Flannery, B.P., Teukolsky, S.A., and Vetterling, W.T., (1988).Numerical Recipes in C. Cambridge: Cambridge University Press.

    Google Scholar 

  • Prieto-diaz, R. (1987). Classification of Reusable Modules.IEEE Software, 4-1, 6–16.

    Google Scholar 

  • Prieto-Diaz, R. (1991). Implementing Faceted Classification for Software Reuse.Comm. ACM, 34-5, 89–97.

    Google Scholar 

  • Redmond, M. (1989). Combining Case-Based Reasoning, Explanation-Based Learning, and Learning from Instruction.Proc. 6th Int. Workshop Machine Learning, Ithaca, NY, pp. 20–22.

  • Riesbeck, C., and Schank, R. (1989).Inside Case-Based Reasoning. Hillsdale, NJ: Lawrence Erlbaum.

    Google Scholar 

  • Rist, R.S. (1992). Plan Identification and Re-use in Programs.Proc. Spring Symp. Series: Computational Considerations in Supporting Incremental Modification and Reuse, Stanford, CA, pp. 67–72.

  • Silverstein, G., and Pazzani, MJ. (1991). Relational Clichés: Constraining Constructive induction during Relational Learning.Proc. 8th Int. Conf. Machine Learning, Evanston, IL, pp. 203–207.

  • Toda, I. (1992). How to Prevent the Coming Software Crisis.IEEE Software, 9-3, 14.

    Google Scholar 

  • Weiser, M. (1984). Program Slicing.IEEE Trans. Software Eng., 10-4, 352–357.

    Google Scholar 

  • Weyuker, E.J. (1990). The Cost of Data Flow Testing: An Empirical Study.IEEE Trans. Software Eng., 16-2, 121–128.

    Google Scholar 

Download references

Author information

Author notes

  1. Gilles Fouqué

    Present address: Department of Computer Science, University of California @ Los Angeles, 90024, Los Angeles, CA

Authors and Affiliations

  1. Ottawa Machine Learning Group, Department of Computer Science, University of Ottawa, KIN 6N5, Ottawa, Ontario, Canada

    Gilles Fouqué & Stan Matwin

Authors
  1. Gilles Fouqué
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. Stan Matwin
    View author publications

    You can also search for this author in PubMed Google Scholar

Rights and permissions

Reprints and permissions

About this article

Cite this article

Fouqué, G., Matwin, S. A case-based approach to software reuse. J Intell Inf Syst 2, 165–197 (1993). https://doi.org/10.1007/BF00965876

Download citation

  • Issue Date:

  • DOI: https://doi.org/10.1007/BF00965876

Keywords

Search

Navigation