Reduction of Program-generation Times by Transformation-sequence Optimization

Martin Kuhlemann, Andreas Lübcke, Gunter Saake

Abstract

Transforming source code is common today. Such transformation process may involve the execution of a number of program transformations on the source code. Overall, the transformation process can last long when individual program transformations last long and when high numbers of program transformations need to be executed. In this paper, we introduce and discuss techniques that can reduce the time transformation tools need to produce a program.

References

  1. Apel, S., Kästner, C., and Lengauer, C. (2009). FeatureHouse: Language-independent, automated software composition. In Proceedings of the International Conference on Software Engineering, pages 221-231. IEEE Computer Society.
  2. Apel, S., Rosenmüller, M., Leich, T., and Saake, G. (2005). FeatureC++: On the symbiosis of feature-oriented and aspect-oriented programming. In Proceedings of the Conference on Generative Programming and Component Engineering, pages 125-140. Springer Verlag.
  3. Batory, D. (2004). The road to Utopia: A future for generative programming. In Proceedings of the Seminar on Domain-Specific Program Generation, pages 211- 250. Springer Verlag.
  4. Batory, D. (2007). A modeling language for program design and synthesis. In Proceedings of the Lipari Summer School on Advances in Software Engineering, pages 39-58. Springer Verlag.
  5. Batory, D., Sarvela, J., and Rauschmayer, A. (2004). Scaling step-wise refinement. IEEE Transactions on Software Engineering, 30(6):355-371.
  6. Baxter, I. (1990). Transformational maintenance by reuse of design histories. PhD thesis, University of California at Irvine, USA.
  7. Cinnéide, M. O . and Nixon, P. (2000). Composite refactorings for Java programs. In Proceedings of the Workshop on Formal Techniques for Java Programs, pages 129-135.
  8. Czarnecki, K. and Eisenecker, U. (2000). Generative programming: Methods, tools, and applications. Addison-Wesley Longman Publishing Co., Inc.
  9. Dig, D. (2007). Automated upgrading of component-based applications. PhD thesis, University of Illinois at Urbana-Champaign, USA.
  10. Dig, D., Manzoor, K., Johnson, R., and Nguyen, T. (2008). Effective software merging in the presence of objectoriented refactorings. IEEE Transactions on Software Engineering, 34(3):321-335.
  11. Kiczales, G., Hilsdale, E., Hugunin, J., Kersten, M., Palm, J., and Griswold, W. (2001). An overview of AspectJ. In Proceedings of the European Conference on Object-Oriented Programming, pages 327-353. Springer Verlag.
  12. Kniesel, G. (2006). A logic foundation for program transformations. Technical Report IAI-TR-2006-1, University of Bonn, Germany.
  13. Kniesel, G. and Koch, H. (2004). Static composition of refactorings. Science of Computer Programming, 52(1-3):9-51.
  14. Kuhlemann, M., Batory, D., and Apel, S. (2009). Refactoring feature modules. In Proceedings of the International Conference on Software Reuse, pages 106-115. Springer Verlag.
  15. Kuhlemann, M., Liang, L., and Saake, G. (2010). Algebraic and cost-based optimization of refactoring sequences. In Proceedings of the Workshop on Model-Driven Product Line Engineering, pages 37- 48. CEUR-WS.org.
  16. Lynagh, I. (2006). An algebra of patches. [Available online: http://urchin.earth.li/~ian/conflictors/paper2006-10-30.pdf; accessed: July 16,2011].
  17. Mens, T., Kniesel, G., and Runge, O. (2006). Transformation dependency analysis - A comparison of two approaches. In Proceedings of Langages et Modèles à Objets, pages 167-184. Hermes Science Publishing.
  18. Mens, T., Taentzer, G., and Runge, O. (2007). Analysing refactoring dependencies using graph transformation. Software and Systems Modeling, 6(3):269-285.
  19. Roberts, D. (1999). Practical analysis for refactoring. PhD thesis, University of Illinois at Urbana-Champaign, USA.
  20. Schaefer, I., Bettini, L., Bono, V., Damiani, F., and Tanzarella, N. (2010). Delta-oriented programming of software product lines. In Proceedings of the Software Product Line Conference, pages 77-91. Springer Verlag.
  21. Stroustrup, B. (1991). The C++ programming language. Addison-Wesley Longman Publishing Co., Inc., 2nd edition.
  22. Whitfield, D. and Soffa, M. (1997). An approach for exploring code improving transformations. ACM Transactions on Programming Languages and Systems, 19(6):1053-1084.
  23. Wirth, N. (1971). Program development by stepwise refinement. Communications of the ACM, 14(4):221-227.
Download


Paper Citation


in Harvard Style

Kuhlemann M., Lübcke A. and Saake G. (2012). Reduction of Program-generation Times by Transformation-sequence Optimization . In Proceedings of the 7th International Conference on Evaluation of Novel Approaches to Software Engineering - Volume 1: ENASE, ISBN 978-989-8565-13-6, pages 182-186. DOI: 10.5220/0004093901820186


in Bibtex Style

@conference{enase12,
author={Martin Kuhlemann and Andreas Lübcke and Gunter Saake},
title={Reduction of Program-generation Times by Transformation-sequence Optimization},
booktitle={Proceedings of the 7th International Conference on Evaluation of Novel Approaches to Software Engineering - Volume 1: ENASE,},
year={2012},
pages={182-186},
publisher={SciTePress},
organization={INSTICC},
doi={10.5220/0004093901820186},
isbn={978-989-8565-13-6},
}


in EndNote Style

TY - CONF
JO - Proceedings of the 7th International Conference on Evaluation of Novel Approaches to Software Engineering - Volume 1: ENASE,
TI - Reduction of Program-generation Times by Transformation-sequence Optimization
SN - 978-989-8565-13-6
AU - Kuhlemann M.
AU - Lübcke A.
AU - Saake G.
PY - 2012
SP - 182
EP - 186
DO - 10.5220/0004093901820186