Abstract
Reuse between software systems is often not optimal. An important reason is that while at the functional level well-known modularization principles are applied for structuring functionality in modules, this is not the case at the build level for structuring files in directories. This leads to a situation where files are entangled in directory hierarchies and build processes, making it hard to extract functionality and to make functionality suitable for reuse. Consequently, software may not come available for reuse at all, or only in rather large chunks of functionality, which may lead to extra software dependencies.
In this paper we propose to improve this situation by applying component-based software engineering (CBSE) principles to the build level. We discuss how existing software systems break CBSE principles, we introduce the notion of build-level components, and we define rules for developing such components. To make our techniques feasible, we define a reengineering process for semi-automatically transforming existing software systems into build-level components. Our techniques are demonstrated in a case study where we decouple the source tree of Graphviz into 47 build-level components.
This research was sponsored by the Dutch National Research Organization (NWO), Jacquard project TraCE.
This is a preview of subscription content, log in via an institution to check access.
Access this chapter
Tax calculation will be finalised at checkout
Purchases are for personal use only
Preview
Unable to display preview. Download preview PDF.
References
den van Brand, M.G.J., van Deursen, A., Heering, J., de Jong, H.A., de Jonge, M., Kuipers, T., Klint, P., Moonen, L., Olivier, P.A., Scheerder, J., Vinju, J.J., Visser, E., Visser, J.: The ASF+SDF meta-environment: A component-based language development environment. In: Wilhelm, R. (ed.) CC 2001. LNCS, vol. 2027, pp. 365–370. Springer, Heidelberg (2001)
Chiricota, Y., Jourdan, F., Melano̧on, G.: Software components capture using graph clustering. In: Proceedings: IEEE 11th International Workshop on Program Comprehension (IWPC 2003), May 2003, pp. 217–226. IEEE Computer Society Press, Los Alamitos (2003)
Free Software Foundation. GNU Coding Standards (2004), http://www.gnu.org/prep/standards.html
Gansner, E., North, S.: An open graph visualization system and its applications to software engineering. Software – Practice and Experience 30(11), 1203–1233 (2000)
van der Hoek, Wolf, A.: Software release management for component-based software. Software – Practice and Experience 33(1), 77–98 (2003)
Holt, R., Godfrey, M., Dong, X.: The build / comprehend pipelines. In: Proceedings: Second ASERC Workshop on Software Architecture (Febuary 2003)
de Jonge, M.: The Linux kernel as flexible product-line architecture. Technical Report SENR0205, CWI (2002)
de Jonge, M.: Source tree composition. In: Gacek, C. (ed.) ICSR 2002. LNCS, vol. 2319, pp. 17–32. Springer, Heidelberg (2002)
de Jonge, M.: Package-based software development. In: Proceedings: 29th Euromicro Conference, September 2003, pp. 76–85. IEEE Computer Society Press, Los Alamitos (2003)
de Jonge, M.: To Reuse or To Be Reused: Techniques for Component Composition and Construction. PhD thesis, Faculty of Natural Sciences, Mathematics, and Computer Science, University of Amsterdam (January 2003)
Koschke, R., Eisenbarth, T.: A framework for experimental evaluation of clustering techniques. In: Proceedings: IEEE 8th International Workshop on Program Comprehension (IWPC’00), June 2000, pp. 201–210. IEEE Computer Society Press, Los Alamitos (2000)
Mackenzie, D., Elliston, B., Demaile, A.: Autoconf: creating automatic configuration scripts. Free Software Foundation (2002), Available at http://www.gnu.org/software/autoconf
Mackenzie, D., Tromey, T.: GNU Automake Manual. Free Software Foundation (2003), Available at http://www.gnu.org/software/automake
Miller, P.: Recursive make considered harmful. AUUGN 19(1), 14–25 (1998), http://aegis.sourceforge.net/auug97.pdf
van Ommering, R., van der Linden, F., Kramer, J., Magee, J.: The Koala component model for consumer electronics software. IEEE Computer 33(3), 78–85 (2000)
Parnas, D.L.: On the criteria to be used in decomposing systems into modules. Communications of the ACM 15(12), 1053–1058 (1972)
Szyperski, C.: Component Software: Beyond Object-Orientated Programming, 2nd edn (2002)
Tu, Q., Godfrey, M., Dong, X.: The build-time architectural view. In: Proceedings: IEEE International Conference on Software Maintenance (ICSM 2001), pp. 398–407. IEEE Computer Society Press, Los Alamitos (2001)
Author information
Authors and Affiliations
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2004 Springer-Verlag Berlin Heidelberg
About this paper
Cite this paper
de Jonge, M. (2004). Decoupling Source Trees into Build-Level Components. In: Bosch, J., Krueger, C. (eds) Software Reuse: Methods, Techniques, and Tools. ICSR 2004. Lecture Notes in Computer Science, vol 3107. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-540-27799-6_18
Download citation
DOI: https://doi.org/10.1007/978-3-540-27799-6_18
Publisher Name: Springer, Berlin, Heidelberg
Print ISBN: 978-3-540-22335-1
Online ISBN: 978-3-540-27799-6
eBook Packages: Springer Book Archive