Journal of Intelligent Information Systems

, Volume 2, Issue 2, pp 165–197 | Cite as

A case-based approach to software reuse

  • Gilles Fouqué
  • Stan Matwin


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.


case-based reasoning compositional software reuse dataflow analysis program slicing program specification case base improvement inductive logic programming software testing 


Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.


  1. Aho, A.V., Sethi, R., and Ullman, J.D. (1986).Compiler Principles, Techniques, and Tools. New York: ACM Press.Google Scholar
  2. Barletta, R., and Mark, W. (1988). Explanation-Based Indexing of Cases.Proc. Spring Symp. Series: Explanation Based-Learning, Stanford, CA, pp. 127–136.Google Scholar
  3. Bassett, P.G. (1987). Frame-Based Software Engineering.IEEE Software.,4-4 9–16.Google Scholar
  4. 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
  5. 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
  6. 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.Google Scholar
  7. 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
  8. Fisher, D., and Yoo, J. (1991). Combining Evidence of Deep and Surface Similarity.Proc. 8th Int. Workshop Machine Learning, Evanston, IL, pp. 46–50.Google Scholar
  9. Fouqué, G., and Matwin, S. (1993). Compositional Software Reuse with Case-Based Reasoning.Proc. 9th IEEE Conf. AI for Applications, Orlando, FL.Google Scholar
  10. 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.Google Scholar
  11. 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
  12. Harandi, M.T., and Ning, J.Q. (1990). Knowledge-Based Program Analysis.IEEE Software, 7-1, 74–81.Google Scholar
  13. Horwitz, S., Reps, T., and Binkley, D. (1990). Interprocedural Slicing Using Dependence Graphs.IEEE Trans. Software Eng. 12-1, 26–60.Google Scholar
  14. 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.Google Scholar
  15. Kozaczynski, W., Ning, J., and Sarver, T. (1992). Program Concept Recognition.Proc. 7th Knowledge-Based Software Engineering Conf., McLean, VA, pp. 216–225.Google Scholar
  16. Krueger, C.W. (1992). Software Reuse.ACM Computing Survey, 24-2, 131–183.Google Scholar
  17. Lapointe, S., Ling, C., and Matwin, S. (1992), Constructive Inductive Logic Programming. To appear, Proc.IYCA193, Chambéry.Google Scholar
  18. Mac Cabe, T. (1976). A Complexity Measure.IEEE Trans. Software Eng. 2-4, 308–320.Google Scholar
  19. MacKeilar, B.K., and Maryanski. F. (1989) A Knowledge Base for Code Reuse by Similarity.Proc. Computer Software Applications Conf., pp. 634–641.Google Scholar
  20. Minton, S. (1990).Learning Search Control Knowledge: An Explanation-Based Approach. Boston: Kluwer Academic.Google Scholar
  21. Muggleton, S. (1987). Duce, An Oracle Based Approach to Constructive Induction.Proc. 10th Int. Joint Conf. Artif. Intell., Milan, Italy, pp. 287–292.Google Scholar
  22. 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.Google Scholar
  23. 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
  24. Myers, G.J. (1979). The Art of Software Testing. In R.C. Canning and D.J. Couger (Eds.), New York: Wiley.Google Scholar
  25. 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
  26. 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.Google Scholar
  27. Press, W.H., Flannery, B.P., Teukolsky, S.A., and Vetterling, W.T., (1988).Numerical Recipes in C. Cambridge: Cambridge University Press.Google Scholar
  28. Prieto-diaz, R. (1987). Classification of Reusable Modules.IEEE Software, 4-1, 6–16.Google Scholar
  29. Prieto-Diaz, R. (1991). Implementing Faceted Classification for Software Reuse.Comm. ACM, 34-5, 89–97.Google Scholar
  30. 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.Google Scholar
  31. Riesbeck, C., and Schank, R. (1989).Inside Case-Based Reasoning. Hillsdale, NJ: Lawrence Erlbaum.Google Scholar
  32. 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.Google Scholar
  33. 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.Google Scholar
  34. Toda, I. (1992). How to Prevent the Coming Software Crisis.IEEE Software, 9-3, 14.Google Scholar
  35. Weiser, M. (1984). Program Slicing.IEEE Trans. Software Eng., 10-4, 352–357.Google Scholar
  36. Weyuker, E.J. (1990). The Cost of Data Flow Testing: An Empirical Study.IEEE Trans. Software Eng., 16-2, 121–128.Google Scholar

Copyright information

© Kluwer Academic Publishers 1993

Authors and Affiliations

  • Gilles Fouqué
    • 1
  • Stan Matwin
    • 1
  1. 1.Ottawa Machine Learning Group, Department of Computer ScienceUniversity of OttawaOttawaCanada

Personalised recommendations