Managing the Evolution of .NET Programs

  • Susan Eisenbach
  • Vladimir Jurisic
  • Chris Sadler
Part of the Lecture Notes in Computer Science book series (LNCS, volume 2884)

Abstract

The component-based model of code execution imposes some requirements on the software components themselves, and at the same time lays some constraints on the modern run-time environment. Software components need to store descriptive metadata, and the run-time system must access this ‘reflectively’ in order to implement dynamic linking. Software components also undergo dynamic evolution whereby a client component experiences the effects of modifications, made to a service component even though these occurred after the client was built.

We wanted to see whether the dynamic linking mechanism implemented in Microsoft’s .NET environment could be utilized to maintain multiple versions of components. A formal model was developed to assist in understanding the .NET mechanism and in describing our way of dealing with multiple versions. This showed that .NET incorporates all the features necessary to implement such a scheme and we constructed a tool to do so.

References

  1. 1.
    Ancona, D., Zucca, E.: A Primitive calculus for module systems. In: PPDP Proceedings (September 1999)Google Scholar
  2. 2.
    Anderson, R.: The End of DLL Hell (January 2000), http://msdn.microsoft.com/
  3. 3.
    Rausch, A.: Software Evolution in Componentware using Requirements/Assurances Contracts, Limerick, Ireland, May 2000, pp. 147–156. ACM Press, New York (2000)Google Scholar
  4. 4.
    Cardelli, L.: Program Fragments, Linking, and Modularization. In: POPL 1997 Proceedings (January 1997)Google Scholar
  5. 5.
    Diller, Z.: An Introduction to Formal Methods. John Wiley & Sons, Chichester (1994)MATHGoogle Scholar
  6. 6.
    Drossopoulou, S.: An Abstract Model of Java Dynamic Linking, Loading and Verification. In: Types in Compilation (September 2001)Google Scholar
  7. 7.
    Duggan, D.: Sharing in Typed Module Assembly Language. In: Preliminary Proceedings of the Third Workshop on Types in Compilation (TIC 2000). Carnegie Mellon, CMUCS- 00-161 (2000)Google Scholar
  8. 8.
    Jackson, D., Schechter, I., Shlyakhter, I.: Alcoa: the Alloy Constraint Analyzer, Limerick, Ireland, May 2000, pp. 730–733. ACM Press, New York (2000)Google Scholar
  9. 9.
    Eisenbach, S., Drossopoulou, S.: Manifestations of the Dynamic Linking Process in Java (June 2001), http://www-dse.doc.ic.ac.uk/projects/slurp/dynamic-link/linking.htm
  10. 10.
    Eisenbach, S., Sadler, C.: Ephemeral Java Source Code. In: IEEE Workshop on Future Trends in Distributed Systems (December 1999)Google Scholar
  11. 11.
    Eisenbach, S., Sadler, C.: Changing Java Programs. In: IEEE Conference in Software Maintenance (November 2001)Google Scholar
  12. 12.
    Eisenbach, S.: Alloy Model of .NET Evolution. Technical report (August 2003), http://www.doc.ic.ac.uk/~sue/alloymodel
  13. 13.
    Fisher, K., Reppy, J., Riecke, J.: A Calculus for Compiling and Linking Classes. In: ESOP Proceedings (March 2000)Google Scholar
  14. 14.
    Hicks, M., Weirich, S., Crary, K.: Safe and Flexible Dynamic Linking of Native Code. In: Harper, R. (ed.) TIC 2000. LNCS, vol. 2071, p. 147. Springer, Heidelberg (2000)CrossRefGoogle Scholar
  15. 15.
    Holzmann, G.: The Model Checker Spin. IEEE Transactions on Software Engineering 23(5) (May 1997)Google Scholar
  16. 16.
    Jackson, D.: Micromodels of Software: Lightweight Modelling and Analysis with Alloy. Technical report (February 2002), http://sdg.lcs.mit.edu/~dng/
  17. 17.
    Jurisic, V.: Deja-vu.NET: A Framework for Evolution of Component Based Systems (June 2002), http://www.doc.ic.ac.uk/~ajf/Teaching/Projects/DistProjects.html
  18. 18.
    Meijer, E., Szyperski, C.: Overcoming independent extensibility challenges. Communications of the ACM 45(10), 41–44 (2002)CrossRefGoogle Scholar
  19. 19.
    Mezini, M., Lieberherr, K.J.: Adaptive Plug-and-Play Components for Evolutionary Software Development. In: Proc. of OOPSLA, pp. 97–116 (1998)Google Scholar
  20. 20.
    Pietrek, M.: Avoiding DLL Hell: Introducing Application Metadata in the Microsoft .NET Framework. In: MSDN Magazine (October 2000), http://msdn.microsoft.com/
  21. 21.
    Pratschner, S.: Simplifying Deployment and Solving DLL Hell with the .NET Framework. In: MSDN Magazine (November 2001), http://msdn.microsoft.com/
  22. 22.
    Mens, K., Steyaert, P., Lucas, C., D’Hondt, T.: Reuse Contracts: Managing the Evolution of Reusable Assets. In: Proc. of OOPSLA (1996)Google Scholar
  23. 23.
    Sewell, P.: Modules, Abstract Types, and Distributed Versioning. In: Proc. of Principles of Programming Languages, January 2001. ACM Press, New York (2001)Google Scholar
  24. 24.
    Drossopouloum, S., Lagorio, G., Eisenbach, S.: Flexible Models for Dynamic Linking. In: Proc. of the European Symposium on Programming, March 2003. Springer, Heidelberg (2003)Google Scholar
  25. 25.
    Wragg, D., Drossopoulou, S., Eisenbach, S.: What is Java binary compatibility? In: Proc. of OOPSLA, vol. 33, pp. 341–358 (1998)Google Scholar
  26. 26.
    Eisenbach, S., Drossopoulou, S., Wragg, D.: A Fragment Calculus: Towards a Model of Separate Compilation, Linking and Binary Compatibility. In: Logic in Computer Science, pp. 147–156 (1999)Google Scholar
  27. 27.
    Eisenbach, S., Sadler, C., Shaikh, S.: Evolution of Distributed Java Programs. In: IFIP/ACM Working Conf on Component Deployment (June 2002)Google Scholar
  28. 28.
    Wells, J., Vestergaard, R.: Confluent Equational Reasoning for Linking with First- Class Primitive Modules. In: ESOP Proceedings (March 2000)Google Scholar

Copyright information

© IFIP International Federation for Information Processing 2003

Authors and Affiliations

  • Susan Eisenbach
    • 1
  • Vladimir Jurisic
    • 1
  • Chris Sadler
    • 2
  1. 1.Department of ComputingImperial CollegeLondonUK
  2. 2.School of Computing ScienceMiddlesex UniversityLondonUK

Personalised recommendations