Skip to main content
SpringerLink
Log in

Round-trip engineering with the Two-Tier Programming Toolkit

  • Published:
Software Quality Journal Aims and scope Submit manuscript

Abstract

A major impediment to the long-term quality of large and complex programs is inconsistency between design and implementation. Conflicts between intent and execution are common because detecting them is laborious, error-prone, and poorly supported, and because the costs of continuously maintaining design documents outweigh immediate gains. A growing inconsistency between design and implementation results in software that is unpredictable and poorly understood. Round-trip engineering tools support an iterative process of detecting conflicts and resolving them by changing either the design or the implementation. We describe a Toolkit which supports a round-trip engineering of native Java programs without interfering with any existing practices, tools, or development environments, thereby posing a minimal barrier on adoption. The Toolkit includes a user-guided software visualization and design recovery tool, which generates Codecharts from source code. A “round-trip” process is possible because Codecharts visualizing source code can be edited to reflect the intended design, and the Verifier can detect conflicts between the intended and as-implemented design. We demonstrate each stage in this process, showing how the Toolkit effectively helps to close the gap between design and implementation, recreate design documentation, and maintaining consistency between intent and execution.

This is a preview of subscription content, log in via an institution to check access.

Access this article

Log in via an institution

Price excludes VAT (USA)
Tax calculation will be finalised during checkout.

Instant access to the full article PDF.

Institutional subscriptions

Fig. 1
Fig. 2
Fig. 3
Fig. 4
Fig. 5
Fig. 6
Fig. 7
Fig. 8
Fig. 9
Fig. 10
Fig. 11
Fig. 12

Similar content being viewed by others

Notes

  1. (Although the tools we implemented currently support only programs implemented in Java, analyzers of source code in other class-based programming languages can easily be integrated since no other component of the Toolkit interacts directly with the analyzer or with the source code. Proofs of concept for such analyzers have already been produced for C++, C#, and PHP5.

References

  • Alzahrani, A. A. H. (2015). Modelling and automated detection of design patterns using Codecharts with applications to security patterns (draft). Colchester, Essex: University of Essex.

    Google Scholar 

  • Alzahrani, A. A. H., Eden, A. H., & Yafi, M. Z. (2015). Conformance checking of single access point pattern in JAAS using Codecharts. In the world congress on information technology and computer applications. Tunisia: Hammamet.

    Google Scholar 

  • Anon. 2006. Java 3D, http://java3d.java.net/. Available at: http://java3d.java.net/.

  • Assmann, U. (2003). Automatic roundtrip engineering. Electronic Notes in Theoretical Computer Science, 82(5), 33–41.

    Article  Google Scholar 

  • Barringer, H. et al. (2004). Rule-based runtime verification. In B. Steffen & G. Levi, eds. Verification, Model Checking, and Abstract Interpretation. Lecture Notes in Computer Science. Springer Berlin / Heidelberg, pp. 277–306. Available at: http://www.springerlink.com/content/had48cpgyeu1lnnc/abstract/ [Accessed October 29, 2012].

  • Biggerstaff, T. J. (1989). Design recovery for maintenance and reuse. IEEE Computer, 22(7), 36–49.

    Article  Google Scholar 

  • Chen, F., & Roşu, G. (2007). Mop: an efficient and generic runtime verification framework. SIGPLAN Not., 42(10), 569–588.

    Article  Google Scholar 

  • Chikofsky, E. J., & Cross, J. H. (1990). Reverse engineering and design recovery: a taxonomy. IEEE Software, 7(1), 13–17.

    Article  Google Scholar 

  • Demeyer, S. et al. (1999). Why unified is not universal: UML shortcomings for coping with round-trip engineering. In Proc. 2nd Int’l Conf. on the Unified Modeling Language. Lecture Notes in Computer Science. pp. 630–645.

  • Eden, A. H., & Nicholson, J. (2011). Codecharts: roadmaps and blueprints for object-oriented programs. Hoboken: Wiley-Blackwell.

    Book  MATH  Google Scholar 

  • Eden, A. H., et al. (2013). Modeling and visualizing object-oriented programs with Codecharts. Formal Methods in System Design, 43(1), 1–28.

    Article  MathSciNet  MATH  Google Scholar 

  • Fischer, T. et al. (1999). Story diagrams: a new graph grammar language based on the unified modelling language and java. In Proc. Theory and Application of Graph Transformations–TAGT’98, LNCS 1764. Springer, pp. 296–309.

  • Gamma, E. Helm, R., Johnson, R., & Vlissides, J. (1995). Design patterns: elements of reusable object-oriented software. Reading: Addison Wesley Longman.

  • Gasparis, E. (2010) Design Navigation: recovering design charts from object-oriented programs. PhD Dissertation. School of Computer Science and Electronic Engineering, University of Essex.

  • Gasparis, E., Nicholson, J., et al. (2008a). Navigating through the design of object-oriented programs. In 15th Working Conf. on Reverse Engineering—WCRE. Antwerp, Belgium.

  • Gasparis, E., Eden, A.H., et al. (2008b). The Design Navigator: Charting Java Programs. In Tool Demonstrations, Proc. of 30th IEEE Int’l Conf. on Software Engineering—ICSE 2008. Leipzig: IEEE Computer Society Press.

  • Goldberg, M. & Wiener, G. (2010). Round-trip modeling using OPM/PL. In 2010 I.E. International Conference on Software Science, Technology and Engineering (SWSTE). IEEE, pp. 13–21.

  • Guéhéneuc, Y.-G. (2004) A reverse engineering tool for precise class diagrams. In CASCON ‘04. IBM Press, pp. 28–41. Available at: http://dl.acm.org/citation.cfm?id=1034914.1034917 [Accessed November 30, 2012].

  • Guttag, J. V., Horning, J. J., & Wing, J. (1982). Some notes on putting formal specifications to productive use. Science of Computer Programming, 2(1), 53–68.

    Article  MATH  Google Scholar 

  • Henriksson, A. & Larsson, H. (2003). A definition of round-trip engineering, University of Linköping.

  • Hettel, T., Lawley, M. & Raymond, K. (2008). Model Synchronisation: Definitions for Round-Trip Engineering. In A. Vallecillo, J. Gray, & A. Pierantonio, eds. Theory and Practice of Model Transformations. Lecture Notes in Computer Science. Springer Berlin Heidelberg, pp. 31–45.

  • Jackson, M. (2008). Automated software engineering: supporting understanding. Automated Software Engineering, 15(3–4), 275–281.

    Article  Google Scholar 

  • Kazman, R., & Carrière, S. J. (1999). Playing detective: reconstructing software architecture from available evidence. Automated Software Engineering, 6(2), 107–138.

    Article  Google Scholar 

  • Koschke, R. (2001). Software visualization for reverse engineering. In Lecture Notes In Computer Science. Revised Lectures on Software Visualization, International Seminar. pp. 138–150.

  • Mo, R. et al. (2015). Hotspot patterns: the formal definition and automatic detection of architecture smells. In 2015 12th Working IEEE/IFIP Conference on Software Architecture (WICSA). 2015 12th Working IEEE/IFIP Conference on Software Architecture (WICSA). pp. 51–60.

  • Müller, H. A. et al. (2000). Reverse engineering: a roadmap. In Proc. Conf. The Future of Software Engineering. Limerick, Ireland: ACM, pp. 47–60. Available at: http://portal.acm.org/citation.cfm?id=336512.336526&type=series [Accessed March 30, 2010].

  • Müller, H.A. & Klashinsky, K., 1988. Rigi—a system for programming-in-the-large. In Proc. 10th Int’l Conf. Software engineering. Singapore: IEEE Computer Society Press, pp. 80–86.

  • Nicholson, J. et al., 2014. Automated verification of design patterns: a case study. Science of Computer Programming, 80, Part B, pp.211–222.

  • Nicholson, J. (2011). On the theoretical foundations of LePUS3 and its application to object-oriented design verification. PhD Dissertation: School of Computer Science and Electronic Engineering, University of Essex.

    Google Scholar 

  • Nickel, U.A. et al. (2000) Roundtrip engineering with FUJABA (Extended Abstract). In 2nd Workshop on Software-Reengineering (WSR).

  • Paesschen, E. V., Meuter, W. D., & D’Hondt, M. (2005). SelfSync: A dynamic round-trip engineering environment. In L. Briand & C. Williams (Eds.), Model driven engineering languages and systems (pp. 633–647). Heidelberg: Lecture Notes in Computer Science. Springer Berlin.

    Chapter  Google Scholar 

  • Perry, D. E., & Wolf, A. L. (1992). Foundations for the study of software architecture. SIGSOFT Software Engineering Notes, 17(4), 40–52.

    Article  Google Scholar 

  • Quatrani, T. (1998). Visual modeling with rational Rose and UML. Boston: Addison-Wesley Longman Publishing Co., Inc..

    Google Scholar 

  • Ryoo, J., Laplante, P. & Kazman, R. (2012). Revising a security tactics hierarchy through decomposition, reclassification, and derivation. In Software Secutiry and Reliability. Washington, D.C.

  • Schmidt, D. C. (2006). Guest editor’s introduction: model-driven engineering. Computer, 39(2), 25–31.

    Article  Google Scholar 

  • Sendall, S. & Küster, J. (2004). Taming model round-trip engineering.

  • Shneiderman, B. (1996). The eyes have it: a task by data type taxonomy for information visualizations. In Proceedings of the 1996 I.E. Symposium on Visual Languages. VL ‘96. Washington, DC, USA: IEEE Computer Society, p. 336–. Available at: http://dl.acm.org/citation.cfm?id=832277.834354 [Accessed June 30, 2014].

  • Sipser, M. (1997). Introduction to the theory of computation. Boston: PWS Pub. Co..

    MATH  Google Scholar 

  • Wassermann, R. & Cheng, B. H. C. (2003). Security patterns. In Pattern Languages of Programs—PLoP 2003. Robert Allerton Park, MI.

  • Wing, J. M. (1990). A specifier’s introduction to formal methods. Computer, 23(9), 8–23.

    Article  Google Scholar 

  • Xiao, L. et al. (2016). Identifying and quantifying architectural debt. In Proceedings of the 38th International Conference on Software Engineering. ICSE ‘16. New York, NY, USA: ACM, pp. 488–498. Available at: http://doi.acm.org/10.1145/2884781.2884822 [Accessed May 23, 2016].

  • Yoder, J. & Barcalow, J. (2000). Architectural patterns for enabling application security. In B. Foote, N. Harrison, & H. Rohnert, eds. Pattern languages of program design 4. Addison-Wesley.

Download references

Acknowledgements

The authors wish to thank Raymond Turner for extending considerable support throughout this research; the Research Promotion Fund, the Knowledge Transfer Innovation Fund, University of Essex, and the EPSRC for funding various parts of this project. We also wish to thank Olumide Iyaniwura, Gu Bo, Maple Tao Liang, Dimitrious Fragkos, Omololu Ayodeji, Xu Yi, and Christina Maniati for their contributions to this research.

Author information

Authors and Affiliations

  1. Sapience.org, London, UK

    A.H. Eden

  2. Singularity Labs, Voudouri Street, 341 00, Chalkida, Evia, Greece

    E. Gasparis

  3. ZiNET Data Solutions, 25 Russell Street, Hastings, TN34 1QU, UK

    J. Nicholson

  4. Software Engineering Institute, Carnegie Mellon University, Fifth Avenue, Pittsburgh, PA, 15213-2612, USA

    R. Kazman

  5. University of Hawaii, Maile Way, Honolulu, HI, 96822, USA

    R. Kazman

Authors
  1. A.H. Eden
    View author publications

    You can also search for this author in PubMed Google Scholar

  2. E. Gasparis
    View author publications

    You can also search for this author in PubMed Google Scholar

  3. J. Nicholson
    View author publications

    You can also search for this author in PubMed Google Scholar

  4. R. Kazman
    View author publications

    You can also search for this author in PubMed Google Scholar

Corresponding author

Correspondence to A.H. Eden.

Additional information

Categories and Subject Descriptors (ACM)—D.2.10 Software Design, D.2.2 Design Tools and Techniques, D.1.5 Object-Oriented Programming, K.6.3 Software Maintenance

Rights and permissions

Reprints and permissions

About this article

Check for updates. Verify currency and authenticity via CrossMark

Cite this article

Eden, A., Gasparis, E., Nicholson, J. et al. Round-trip engineering with the Two-Tier Programming Toolkit. Software Qual J 26, 249–271 (2018). https://doi.org/10.1007/s11219-017-9363-9

Download citation

  • Published:

  • Issue Date:

  • DOI: https://doi.org/10.1007/s11219-017-9363-9

Keywords

Search

Navigation