Springer Nature is making SARS-CoV-2 and COVID-19 research free. View research | View latest news | Sign up for updates

Model-based engineering for change-tolerant systems

  • 140 Accesses

  • 3 Citations


Developing and evolving today’s systems are often stymied by the sheer size and complexity of the capabilities being developed and integrated. At one end of the spectrum, we have sophisticated agent-based software with hundreds of thousands of collaborating nodes. These require modeling abstractions relevant to their complex workflow tasks as well as predictable transforms and mappings for the requisite elaborations and refinements that must be accomplished in composing these systems. At the other end of the spectrum, we have ever-increasing capabilities of reconfigurable hardware devices such as field-programmable gate arrays to support the emerging adaptability and flexibility needs of these systems. From a model-based engineering perspective, these challenges are very similar; both must move their abstraction and reuse levels up to meet growing productivity and quality objectives. Model-based engineering and software system variants such as the model-driven architecture (MDA) are increasingly being applied to systems development as the engineering community recognizes the benefits of managing complexity, separating key concerns, and automating transformations from high-level abstract requirements down through the implementation. However, there are challenges when it comes to establishing the correct boundaries for change-tolerant parts of the system. Capabilities engineering (CE) is a promising approach for defining long-lived components of a system to ensure some sense of change tolerance. For innovative initiatives such as the National Aeronautics and Space Administration (NASA)’s autonomous nanotechology swarms (ANTS), the development and subsequent evolution of such systems are of considerable importance as their missions involve complex, collaborative behaviors across distributed, reconfigurable satellites. In this paper, we investigate the intersection of these two technologies as they support the development of complex, change-tolerant systems. We present an effective approach for bounding computationally independent models so that, as they transition to the architecture, capabilities-based groupings of components are relevant to the change-tolerant properties that must convey in the design solution space. The model-based engineering approach is validated via a fully functional prototype and verified by generating nontrivial multiagent systems and reusing components in subsequent systems. We build off of this research completed on the collaborative agent architecture, discuss the CE approach for the transition to architecture, and then examine how this will be applied in the reconfigurable computing community with the new National Science Foundation Center for High-Performance Reconfigurable Computing. Based on this work and extrapolating from similar efforts, the model-based approach shows promise to reduce the complexities of software evolution and increase productivity—particularly as the model libraries are populated with canonical components.

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


  1. 1.

    Pellerin D and Thibault S (2005) Practical FPGA programming in C. Prentice Hall, Englewood Cliffs

  2. 2.

    Esam E et al (2007) Comparative analysis of high level programming for reconfigurable computers: methodology and empirical study. In: Proceedings of SPL2007 (Southern Programming Logic). IEEE Press

  3. 3.

    Sterling T (2004). Productivity metrics and models for high performance computing. Int J High Perform Comput Appl 18(4): 433–440

  4. 4.

    Special technology area review on Field Programmable Gate Arrays (2005) (FPGAs). In: DOD Advisory Group on Electron Devices ARL-SR-147. Department of Defense, Army Research Laboratory

  5. 5.

    Lehman MM (1998). The future of software—managing evolution. IEEE Softw 15(1): 40–44

  6. 6.

    George B, Bohner SA, Díaz RP (2004) Software information leaks: a complexity perspective. In: Ninth international conference on engineering of complex computer systems. IEEE Computer Society

  7. 7.

    Bohner S et al (2007) Model-based evolution of collaborative agent-based systems. J Braz Comput Soc (to appear in December)

  8. 8.

    Brown A (2004) An introduction to model driven architecture, Part I: MDA and today’s systems. developerWorks (cited 17 March 2006); available from: http://www-128.ibm.com/developerworks/rational/library/3100.html

  9. 9.

    Bohner S, Gracanin, Denis, George, Boby, Singh, Lally, He, Nannan (2005) Active methods project report and CMDA system documentation. Virginia Tech Department of Computer Science, p 77

  10. 10.

    Ravichandar R, Arthur JD, Bohner SA (2007) Capabilities engineering: constructing change-tolerant systems. In: Fortieth annual international conference on system sciences (HICSS-40). The Big Island, Hawaii

  11. 11.

    Ravichandar R, Arthur JD, Broadwater RP (2007) Reconciling synthesis and decomposition: a composite approach to capability identification. In: 14th Annual IEEE international conference and workshop on the engineering of computer based systems

  12. 12.

    Bohner SA (2007). Software technologies in an era of change tolerant systems. IEEE Comput 40(6): 100–102

  13. 13.

    Gracanin D, Bohner S, Hinchey M (2004) Towards a model-driven architecture for autonomic systems. In: 11th IEEE international conference and workshop on the engineering of computer-based systems (ECBS-04). Brno, Czech Republic

  14. 14.

    Object Management Group (2006) Model Driven Architecture (MDA). http://www.omg.org/md. Object Management Group, Inc

  15. 15.

    Frakes W, Prieto-Díaz R, Fox C (1998) DARE: Domain analysis and reuse environment. Ann Softw Eng, vol 5, Baltzer Science Publishers, pp 125–141

  16. 16.

    Lehman MM (1996) Laws of software evolution revisited. In: 5th European workshop on software process technology (EWSPT). LNCS, Springer, Nancy, France

  17. 17.

    Bell TE, Thayer TA (1976) Software requirements: are they really a problem? In: 2nd International conference on software engineering (ICSE-76)

  18. 18.

    Lutz RR (1993) Analyzing software requirements errors in safety-critical, embedded systems. In: First international symposium on requirements engineering (RE’93). San Diego, California

  19. 19.

    Charette RN (2005). Why software fails. IEEE Spectr 42(9): 42–49

  20. 20.

    Haney FM (1972) Module connection analysis—a tool for scheduling software debugging activities. In: Joint computer conference

  21. 21.

    Russell S, Norvig P (2003) Artificial intelligence: a modern approach, 2nd edn. Pearson Education, Inc, Upper Saddle River

  22. 22.

    Dogac A, Cingil I (2004) Agent technology. B2B e-Commerce technology: frameworks, standards and emerging issues. Addison–Wesley, Reading

  23. 23.

    Grasshopper 2, Agent platform, IKV++ Technologies AG (2004). http://www.grasshopper.de

  24. 24.

    Agent oriented software, The Agent Oriented Software Group (2004). http://www.agent-software.com

  25. 25.

    Cognitive agent architecture (Cougaar), Cougaar Open Source Project (2004). http://www.cougaar.com

  26. 26.

    Java agent development framework (JADE), JADE Board (2004). http://www.jade.tilab.com

  27. 27.

    The foundation for intelligent physical agents (fipa), FIPA Secretariat (2004). http://www.fipa.org/resources/livesystems.html

  28. 28.

    Cougaar architecture document (2004) Version for Cougaar 11. 4. 2004, BBN Technologies: Technical report, p 74. http://www.cougaar.org/

  29. 29.

    Cougaar Developer’s Guide (2004) Version for Cougaar 11. 4. 2004, BBN Technologies Technical report, p 74. http://www.cougaar.org/

  30. 30.

    Hinchey M, Sterritt R and Rouff C (2007). Swarms and swarm intelligence. IEEE Comput 40(4): 111–113

  31. 31.

    Bohner S, George B, Gracanin D, Hinchey M (2005) Formalism challenges of the Cougaar model driven architecture. Lecture notes in computer science, Springer, Heidelberg. GmbH (selected and expanded from formal approaches to agent-based systems—FAABS III)

  32. 32.

    Gracanin D, Singh HL, Bohner S, Hinchey M (2005) Model-driven architecture for agent-based systems. Lecture notes in computer science, Springer, Heidelberg. GmbH (selected and expanded from formal approaches to agent-based systems—FAABS III)

  33. 33.

    George B, Singh H, Bohner S, Gracanin D (2004) Requirements capture for Cougaar model-driven architecture system. In: IEEE/NASA software engineering conference/workshop (SEW-29). Greenbelt, MD

  34. 34.

    Gracanin D, Singh H, Hinchey M, Eltoweissy M, Bohner S (2005) CSP agent modeling framework for Cougaar agent-based architecture. In: Proceedings of the 12th annual IEEE international conference and workshop on the engineering of computer based systems (ECBS 2005). Greenbelt, MD

  35. 35.

    Eclipse main Website (2005) (Last accessed on 6 July 2005). http://www.eclipse.org/

  36. 36.

    ANTLR Parser Generator (2005) (Last accessed on 6 July 2005). http://www.antlr.org/

  37. 37.

    Goguen JA, Linde C (1993) Techniques for requirements elicitation. In: International symposium on requirements engineering. Los Alamitos, California

  38. 38.

    Bieman JM and Ott LM (1994). Measuring functional cohesion. IEEE Trans Softw Eng 20: 644–657

  39. 39.

    Yourdon E and Constantine L (1979). Structured design. Prentice-Hall, Englewood Cliffs

  40. 40.

    Heylighen F (1989) Self-organization, emergence and the architecture of complexity. In: 1st European conference on system science, AFCET. Paris, France

  41. 41.

    Boehm BW (1989). Software risk management. IEEE Computer Society Press, New York

  42. 42.

    Stevens SS (1946). On the theory of scales of measurement. Science 103: 677–680

  43. 43.

    Briand L, Emam KE and Morasco S (1996). On the application of measurement theory in software engineering. Empir Softw Eng 1(1): 61–88

  44. 44.

    Velleman PF and Wilkinson L (1993). Nominal, ordinal, interval and ratio typologies are misleading. Am Stat 47(1): 65–72

  45. 45.

    Page-Jones M (1980). The practical guide to structured systems design. Yourdon, New York

  46. 46.

    Stevens WP, Myers GJ and Constantine LL (1974). Structured design. IBM Syst J 13(2): 115–139

  47. 47.

    Ravichandar R (2007) Capabilities engineering (research support document), in computer science. Virginia Tech, Blackburg, Virginia, p 111

  48. 48.

    Ravichandar R, Arthur JD, Pérez-Quiñones MA (2007) Capabilities: a step towards easing the giant leap in pre-requirement specification traceability. In: International symposium on grand challenges in traceability (GCT ‘07). Lexington, Kentucky

  49. 49.

    Qin S et al (2006). From statecharts to Verilog: a formal approach to hardware/software co-specification. J Innov Syst Softw Eng 2(1): 17–38

  50. 50.

    Vinh PC and Bowen JP (2005). Continuity aspects of embedded reconfigurable computing. J Innov Syst Softw Eng 1(1): 41–53

  51. 51.

    Broy M (2007). Model-driven architecture-centric engineering of (embedded) software intensive systems: modeling theories and architectural milestones. J Innov Syst Softw Eng 3(1): 75–102

  52. 52.

    Arnout K and Meyer B (2006). Pattern componentization: the factory example. J Innov Syst Softw Eng 2(2): 65–79

Download references

Author information

Correspondence to Shawn Bohner.

Rights and permissions

Reprints and Permissions

About this article

Cite this article

Bohner, S., Ravichandar, R. & Arthur, J. Model-based engineering for change-tolerant systems. Innovations Syst Softw Eng 3, 237–257 (2007). https://doi.org/10.1007/s11334-007-0038-8

Download citation


  • Change tolerance
  • Model-based engineering
  • Capabilities engineering
  • Complex systems
  • Agent-based systems
  • Model-driven architecture
  • Reconfigurable computing