Advertisement

Barriers to Modularity - An Empirical Study to Assess the Potential for Modularisation of Java Programs

  • Jens Dietrich
  • Catherine McCartin
  • Ewan Tempero
  • Syed M. Ali Shah
Part of the Lecture Notes in Computer Science book series (LNCS, volume 6093)

Abstract

To deal with the challenges when building large and complex systems modularisation techniques such as component-based software engineering and aspect-oriented programming have been developed. In the Java space these include dependency injection frameworks and dynamic component models such as OSGi. The question arises as to how easy it will be to transform existing systems to take advantage of these new techniques. Anecdotal evidence from industry suggests that the presence of certain patterns presents barriers to refactoring of monolithic systems into a modular architecture. In this paper, we present such a set of patterns and analyse a large set of open-source systems for occurrences of these patterns. We use a novel, scalable static analyser that we have developed for this purpose.

The key findings of this paper are that almost all programs investigated have a significant number of these patterns, implying that modularising will be therefore difficult and expensive.

Keywords

Design Pattern Dependency Graph Pattern Instance Path Constraint Service Implementation 
These keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Preview

Unable to display preview. Download preview PDF.

Unable to display preview. Download preview PDF.

References

  1. 1.
    The eclipse project, http://www.eclipse.org/
  2. 2.
    Java specification requests, http://jcp.org/en/jsr/overview
  3. 3.
    JDepend dependency analyser, http://clarkware.com/software/JDepend.html
  4. 4.
    OSGiTM- the dynamic module system for java, http://www.osgi.org/
  5. 5.
  6. 6.
    Spring dynamic modules for OSGiTMservice platforms, http://www.springsource.org/osgi
  7. 7.
    Mvel expression language (2009), http://mvel.codehaus.org/
  8. 8.
    Baxter, G., Frean, M., Noble, J., Rickerby, M., Smith, H., Visser, M., Melton, H., Tempero, E.: Understanding the shape of Java software. In: Proceedings OOPSLA 2006, pp. 397–412 (October 2006)Google Scholar
  9. 9.
    Beyer, D., Noack, A., Lewerentz, C.: Efficient relational calculation for software analysis. IEEE Transactions on Software Engineering (TSE) 31(2), 137–149 (2005)CrossRefGoogle Scholar
  10. 10.
    Chidamber, S.R., Kemerer, C.F.: A metrics suite for object oriented design. IEEE Trans. Softw. Eng. 20(6), 476–493 (1994)CrossRefGoogle Scholar
  11. 11.
    Copeland, T.: PMD Applied. Centennial Books (2005)Google Scholar
  12. 12.
    Dietrich, J., Yakovlev, V., McCartin, C., Jenson, G., Duchrow, M.: Cluster analysis of java dependency graphs. In: SoftVis 2008, pp. 91–94 (2008)Google Scholar
  13. 13.
    Fowler, M.: Refactoring: Improving the Design of Existing Code. Addison-Wesley, Boston (1999)Google Scholar
  14. 14.
    Fowler, M.: Inversion of control containers and the dependency injection pattern (2004), http://martinfowler.com/articles/injection.html
  15. 15.
    Gamma, E., Helm, R., Johnson, R., Vlissides, J.: Design patterns: elements of reusable object-oriented software. Addison-Wesley, Boston (1995)Google Scholar
  16. 16.
    Garcia, J., Popescu, D., Edwards, G., Medvidovic, N.: Identifying architectural bad smells, pp. 255–258. IEEE Computer Society, Los Alamitos (2009)Google Scholar
  17. 17.
    Gil, J.Y., Maman, I.: Micro patterns in Java code. In: Proceedings OOPSLA 2005, pp. 97–116. ACM Press, New York (2005)CrossRefGoogle Scholar
  18. 18.
    Girvan, M., Newman, M.E.: Community structure in social and biological networks. Proc. Natl. Acad. Sci. USA 99(12), 7821–7826 (2002)zbMATHCrossRefMathSciNetGoogle Scholar
  19. 19.
    He, H., Singh, A.K.: Graphs-at-a-time: Query language and access methods for graph databases. In: Proceedings SIGMOD 2008, pp. 405–418 (2008)Google Scholar
  20. 20.
    Hovemeyer, D., Pugh, W.: Finding bugs is easy. In: Proceedings OOPSLA 2004, pp. 132–136. ACM, New York (2004)CrossRefGoogle Scholar
  21. 21.
    Humble, C.: IBM, BEA and JBoss adopting OSGi, http://www.infoq.com/news/2008/02/osgi_jee
  22. 22.
    Jagadish, H.V., Lakshmanan, L.V.S., Srivastava, D., Thompson, K.: Tax: A tree algebra for xml. In: Ghelli, G., Grahne, G. (eds.) DBPL 2001. LNCS, vol. 2397, pp. 149–164. Springer, Heidelberg (2002)CrossRefGoogle Scholar
  23. 23.
    Koenig, A.: Patterns and antipatterns. JOOP 8(1), 46–48 (1995)Google Scholar
  24. 24.
    Lippert, M., Roock, S.: Refactoring in Large Software Projects: Performing Complex Restructurings Successfully. Wiley, Chichester (2006)Google Scholar
  25. 25.
    Melton, H., Tempero, E.: An empirical study of cycles among classes in Java. Empirical Software Engineering 12(4), 389–415 (2007)CrossRefGoogle Scholar
  26. 26.
    Müller, H., Orgun, M., Tilley, S., Uhl, J.: A reverse-engineering approach to subsystem structure identification. Journal of Software Maintenance: Research and Practice 5, 181–204 (1993)CrossRefGoogle Scholar
  27. 27.
    Muschevici, R., Potanin, A., Tempero, E., Noble, J.: Multiple dispatch in practice. In: Proceedings OOPSLA 2008, October 2008, pp. 563–582 (2008)Google Scholar
  28. 28.
    Nord, R.L., Tomayko, J.E.: Software architecture-centric methods and agile development. IEEE Software 23(2), 47–53 (2006)CrossRefGoogle Scholar
  29. 29.
    O’Madadhain, J., Fisher, D., White, S., Boey, Y.-B.: The jung (java universal network/graph) framework. Technical Report UCI-ICS 03-17, University of California, Irvine (2003)Google Scholar
  30. 30.
    Prud’hommeaux, E., Seaborne, A.: SPARQL Query Language for RDF. Technical report, W3C (2006)Google Scholar
  31. 31.
    Qualitas Research Group. Qualitas corpus version 20080312. The University of Auckland (March 2008), http://www.cs.auckland.ac.nz/~ewan/corpus
  32. 32.
    Sangal, N., Jordan, E., Sinha, V., Jackson, D.: Using dependency models to manage software architecture. In: Proceedings OOPSLA 2005, pp. 164–165. ACM, New York (2005)CrossRefGoogle Scholar
  33. 33.
    Schwanke, R.W.: An intelligent tool for re-engineering software modularity. In: Proceedings ICSE 1991, pp. 83–92 (1991)Google Scholar
  34. 34.
    Singer, J., Brown, G., Lujan, M., Pocock, A., Yiapanis, P.: Fundamental nano-patterns to characterize and classify java methods. In: Proceedings LDTA 2009 (2009)Google Scholar
  35. 35.
    Taibi, T. (ed.): Design Patterns Formalization Techniques. Idea Group Inc., Hershey (2007)Google Scholar
  36. 36.
    Tempero, E.: An empirical study of unused design decisions in open-source Java software. In: Proceedings APSEC 2008, December 2008, pp. 33–40 (2008)Google Scholar
  37. 37.
    Tempero, E., Noble, J., Melton, H.: How do java programs use inheritance? an empirical study of inheritance in java software. In: Vitek, J. (ed.) ECOOP 2008. LNCS, vol. 5142, pp. 667–691. Springer, Heidelberg (2008)CrossRefGoogle Scholar
  38. 38.
    Tessier, J.: Dependency finder, http://depfind.sourceforge.net/

Copyright information

© Springer-Verlag Berlin Heidelberg 2010

Authors and Affiliations

  • Jens Dietrich
    • 1
  • Catherine McCartin
    • 1
  • Ewan Tempero
    • 2
  • Syed M. Ali Shah
    • 1
  1. 1.School of Engineering and Advanced TechnologyMassey UniversityPalmerston NorthNew Zealand
  2. 2.Department of Computer ScienceUniversity of AucklandAucklandNew Zealand

Personalised recommendations