Location of Repository

A case for pattern-based software engineering

By Susan Kurian


Embedded software development is characterized by design issues involving time and\ud resource constraints. An application- specific user interface complicates the process of\ud developing such software using PC-based development environments. Reusing\ud established best-practices is a useful method of dealing with such complexities. Design\ud patterns are well-documented, time-tested solutions to classic design problems and\ud capture significant domain knowledge. This thesis is concerned with the use of one\ud such pattern collection suitable for building embedded systems with a time-triggered\ud architecture.\ud Traditionally, a practitioner wishing to incorporate design patterns into the software\ud being developed would read the documentation and apply the suggested solution\ud manually. More recently, code generators designed to automate the process of\ud converting a pattern solution to source code, have been developed. In either approach,\ud the example solution offered as part of the pattern documentation plays a key role in\ud obtaining source code from the design pattern documentation. However patterns\ud contain a lot of other information which can contribute to the evaluation and application\ud of the design pattern in a project.\ud The research described here suggests a framework for the use of patterns for developing\ud software. It recognises the fact that example implementations of patterns are well-used\ud entities. The research focuses on the use of the remaining information, particularly\ud pattern relationships available within the document, to support design space exploration\ud activities. This process is illustrated using a simple cruise control system.\ud In a bid to standardize the process of using design-specific information captured in the\ud pattern documentation, this thesis describes an approach to formalise the pattern\ud language. It suggests an approach based on the use of context-free grammars, to\ud represent the natural language information held in the pattern documentation. It\ud illustrates the use of the suggested approach using an elevator-based case study

Publisher: University of Leicester
Year: 2010
OAI identifier: oai:lra.le.ac.uk:2381/7886

Suggested articles



  1. (2006). (in press b) “Restructuring a pattern language which supports time-triggered co-operative software architectures in resource-constrained embedded systems”. In:
  2. (2005). A ‘Hardware-in-the-Loop’ testbed representing the operation of a cruise-control system in a passenger car.
  3. (2003). A Component-Based Methodology for Embedded System Prototyping.
  4. (1980). A Hardware Redundancy Reconfiguration Scheme for Tolerating Multiple Module Failures.”
  5. (2007). A looming fault tolerance software crisis?”
  6. (1998). A Modified Least-Laxity-First Scheduling Algorithm for Real-Time Tasks.
  7. (2002). A Pattern Language: reviewed Harvard Design Magazine. WinterSpring
  8. (1977). A Pattern Language.
  9. (1997). A pattern-based application generator for building simulation.”
  10. (1999). A solution to the time jitter removal in deadline based scheduling of real-time applications”,
  11. (1991). Ada, an analyst and a metaphysician.”
  12. (1998). Addendum to the
  13. (2008). Ahaa --agile, hybrid assessment method for automotive, safety critical smes.
  14. (1993). AIRBUS A320/A330/A340 electrical flight controls - A family of fault-tolerant systems.” Fault-Tolerant Computing,
  15. (1994). An Architecture-Driven, BusinessSpecific, and Component-Based Approach to Software Engineering.
  16. (2001). An Embedded Software Primer”, Addison-Wesley /
  17. (1986). An experimental evaluation of the assumption of independence in multiversion programming.”
  18. (2007). An Improved LeastLaxity-First Scheduling Algorithm of Variable Time Slice for Periodic Tasks.
  19. (2002). An Introduction to Rapid System Prototyping.”
  20. (2005). An ObjectOriented Platform-based Design Process for Embedded Real-Time Systems.
  21. (1990). Analysis of Faults in an N-Version Software Experiment.”
  22. (1984). Another Impact of the Computer -
  23. (2006). Application of Design Patterns in the Maintenance of Software for Reliable Embedded Systems”.
  24. (2006). Applying patterns to build a lightweight middleware for embedded systems.
  25. (1985). Architecture's Unique Position Among the Disciplines : Puzzle-Making vs. Problem Solving.” The Architectural Student Journal.
  26. (2000). ARM System-on-Chip Architecture”,
  27. (1995). Attribute grammar paradigms—a high-level methodology in language implementation.”
  28. (2000). Automated refactoring to introduce design patterns.
  29. (1996). Automatic code generation from design patterns.”
  30. (2000). Automating the Development of PatternOriented Designs for Application Specific Software Systems.
  31. (2005). AutoMoDe - Model-Based Development of Automotive Software.
  32. (2006). Automotive electronics system, software, and local area network.
  33. (1988). Babbage and Aiken.”
  34. (2005). Building reliable embedded systems using Abstract Patterns, Patterns, and Pattern Implementation Examples In: Koelmans,
  35. (2005). Building reliable embedded systems using Abstract Patterns, Patterns, and Pattern Implementation Examples”. In: Koelmans,
  36. (2001). Bus Architectures for Safety-Critical Embedded Systems.
  37. (2008). Comparison between Redundancy Techniques for Real Time Applications.
  38. (1986). Compilers: principles, techniques, and tools,
  39. (2001). Consistent Design of Embedded Real-Time Systems with UML-RT.
  40. (1983). Contrasting Concepts of Harmony in Architecture: Debate between Christopher Alexander and Peter Eisenman.
  41. (2000). Cycle time reduction: concepts and case studies.”
  42. (2004). Defect Frequency and Design Patterns: An Empirical
  43. (2004). Design and test of a task guardian for use in TTCS embedded systems”. In: Koelmans,
  44. (2003). Design pattern automation.
  45. (2002). Design pattern modelling and instantiation using DPML.
  46. (2001). Design patterns in telecommunications system architecture. Design patterns in communications software,
  47. (1995). Design Patterns: Elements od Reusable Object-Oriented Software.
  48. (1995). Design patterns: Elements of reusable object-oriented software,
  49. (2004). Designing embedded systems using patterns: A case study”,
  50. (2006). Development and assessment of a CASE tool to support the design and implementation of time-triggered embedded systems
  51. (2000). Do Design Patterns Improve Communication? An Experiment with Pair Design.
  52. (2007). Evaluation of object-oriented design patterns
  53. (2004). Event-Triggered and Time-Triggered Control Paradigms, SpringerVerlag TELOS.
  54. (1991). Event-Triggered Versus Time-Triggered Real-Time Systems.
  55. (1994). Fast, Cheap Requirements: Prototype,
  56. (2007). Fault-tolerant time-triggered communication using CAN”,
  57. (2001). Faulttolerant telecommunication system patterns. Design patterns in communications software,
  58. (1995). Fixed priority pre-emptive scheduling: an historical perspective.” Real-Time Systems
  59. Flavio (2006). Early Embedded Software Design Space Exploration Using UML-Based Estimation.
  60. (1981). Formal Languages: Origins and Directions.”
  61. (2006). Formal Specification of Design Patterns and Their Instances.
  62. (1998). Formalizing design patterns.
  63. (1996). Forward: Importance of Software Prototyping.”
  64. (1983). From Napier to Lucas: The Use of Napier's Bones in Calculating Instruments.”
  65. (2007). From PIMs to PSMs.
  66. (1998). Fundamentals of implementing real-time control applications in distributed computer systems”,
  67. (2006). Guest Editor's Introduction:
  68. (1995). Hardware/software fault tolerance with multiple task modular redundancy.
  69. (1998). How to preserve the benefits of design patterns.
  70. (2007). hw79@le.ac.uk; M.Pont@le.ac.uk; sk183@le.ac.uk http://www.le.ac.uk/eg/embedded/
  71. (2001). Immediate Ceiling Priority Protocol (Burns,
  72. (1991). Implementing Design Diversity to Achieve Fault Tolerance.”
  73. (2004). Implementing low-cost TTCS systems using assembly language”.
  74. (2003). Integrating patterns into CASE tools. Practicing Ramamritham,
  75. (2006). M.Pont@le.ac.uk; sk183@le.ac.uk; rb169@le.ac.uk http://www.le.ac.uk/eg/embedded/ EuroPLoP
  76. (2007). Maintenance and evolution of resource-constrained embedded systems created using design patterns”,
  77. (2006). MDA-based approach for embedded software generation from a UML/MOF repository.
  78. (2003). Measuring and Improving Design Patterns Testability.
  79. (1998). Metadata and active object-models.
  80. (2003). Mining Design Patterns from C++ Source Code.
  81. (2005). Mining for pattern implementation examples”. In: Koelmans,
  82. (2009). Model Feedback Instruments Ltd, Teaching Solutions for Education and Industry” Retrieved 17-September-2009,
  83. (2003). Model Transformation: The Heart and
  84. (2001). Modeling software design diversity: a review.”
  85. (1964). Notes on the Synthesis of Form.
  86. (1992). OBSERV—a prototyping language and environment.”
  87. (1991). On satisfying timing constraints in hard-real-time systems.
  88. (1992). On the competitiveness of on-line real-time task scheduling.” RealTime Systems
  89. (1974). On the mathematical powers of the calculating engine Subsequently published
  90. (1992). Operational Prototyping: A New Development Approach.”
  91. (2003). Orion – A Component Based Software Engineering Environment."
  92. (1999). Pattern-based reverse-engineering of design components,
  93. (1996). Pattern-Oriented Software Architecture, A System of Patterns.
  94. (2001). Patterns for Time-Triggered Embedded Systems: Building Reliable Applications with the 8051
  95. (2001). Patterns for time-triggered embedded systems: Building reliable applications with the 8051 family of microcontrollers,
  96. (2001). Patterns for Time-Triggered Embedded Systems: Building Reliable Applications with the 8051 Family of Microcontrollers”, Addison-Wesley /
  97. (2008). Patterns which help to avoid conflicts over shared resources in time-triggered embedded systems which employ a pre-emptive scheduler.
  98. (2002). Pedagogical patterns: their place in the genre.
  99. (1986). Performance of real-time bus scheduling algorithms.
  100. (1998). Perl: Not Just for Web Programming.”
  101. Pont (2005a). Building reliable embedded systems using Abstract Patterns, Patterns, and Pattern Implementation Examples.
  102. Pont (2005b). Mining for Pattern Implementation Examples.
  103. (2000). Precise Specification of Design Patterns and Tool Support in Their Application.
  104. (2003). Precise Specification to Compound Patterns with ExLePUS.
  105. (2002). Priority Inheritance: The Real Story”,
  106. (1999). Programming Embedded Systems in
  107. (2000). Programming Perl,
  108. (1989). Prototyping a real-time embedded system in Smalltalk. Conference proceedings on Object-oriented programming systems, languages and applications.
  109. (1990). Prototyping revisited.
  110. (2004). Prototyping time-triggered embedded systems using PC hardware”.
  111. (1984). Prototyping vs. specifying: A multiproject experiment.
  112. (2003). Published by Universitätsverlag Konstanz.
  113. (2002). Rapid design space exploration of heterogeneous embedded systems using symbolic search and multi-granular simulation.
  114. (2005). Rapid Embedded System Testing Using Verification Patterns.”
  115. (2007). Rapid software development for reliable embedded systems using a pattern-based code generation tool”.
  116. (2006). Rapid software development for reliable embedded systems using a pattern-based code generation tool”. Paper presented at the Society of Automotive Engineers (SAE) World Congress,
  117. (2003). Rate-Monotonic Scheduling on Uniform Multiprocessors.”
  118. (1988). Real-Time Scheduling Theory and
  119. (1996). Recovery blocks and Algorithm-Based Fault tolerance.
  120. (2006). Reducing jitter in embedded systems employing a time-triggered software architecture and dynamic voltage scaling”
  121. (1995). Relationships Between Design Patterns.
  122. (1960). Report on the algorithmic language ALGOL 60.”
  123. (2005). Restructuring a pattern language for reliable embedded systems” ESL,
  124. (2005). Restructuring a pattern language for reliable embedded systems"
  125. (2006). Restructuring a pattern language which supports timetriggered co-operative software architectures in resource-constrained embedded systems”.
  126. (1973). Scheduling Algorithms for Multiprogramming in a Hard-Real-Time Environment.”
  127. (1998). Scheduling and Timing Analysis for Safety-Critical Systems.
  128. (1990). Scheduling Processes with Release Times, Deadlines, Precedence and Exclusion Relations,’’
  129. (2009). Selecting an appropriate scheduler for use with time-triggered embedded systems” In: Hvatum, Lise and Schummer, Till (eds.)
  130. (1992). Software architecture for hard real-time applications: cyclic executives vs. fixed priority executives.” Real-Time Systems
  131. (2003). Software development productivity and cycle time reduction.”
  132. (2000). Software engineering for real-time: a roadmap.
  133. (2000). Software Fault Tolerance: A Tutorial,
  134. (1985). Software Fault Tolerance: An Evaluation.”
  135. (2007). Software Reliability Engineering: A Roadmap.
  136. (1994). Software reuse experience at Hewlett-Packard.
  137. (2002). Software Reuse with Analysis Patterns.
  138. (1992). Software reuse.
  139. (1999). Specification-based prototyping for embedded systems.
  140. (2005). Spiral development of software-intensive systems of systems.
  141. (2000). Spiral Development: Experience, Principles and Refinements.
  143. (2006). Structure-preserving transformations in patterndriven groupware development.”
  144. (2003). Supporting the development of time-triggered co-operatively scheduled (TTCS) embedded software using design patterns”,
  145. (2006). Supporting the Maintenance and Evolution of Software for Embedded Systems Using Design Patterns and CASE Tools", Poster presentation at "Festival of Postgraduate Research"
  146. (2006). Supporting the Maintenance and Evolution of Software for Embedded Systems Using Design Patterns and CASE Tools", Poster presentation at at the Regional Poster Presentation Competition held at the (University of Warwick),
  147. (1975). System structure for software fault tolerance.
  148. (2007). Testing patterns for software transactional memory engines.
  149. (2003). The Big Bang Theory of IDEs.”
  150. (1988). The cyclic executive model and Ada.” Real-Time Systems Symposium:
  151. (1987). The design of the spring kernel,”
  152. (2007). The Embedded Prototyping System for Car Based on Object.
  153. (1993). The end of the line for static cyclic scheduling.”
  154. (2002). The impact of instruction pointer corruption on program flow: A computational modelling study.”
  155. (2002). The invention of the universal electronic computer--how the Electronic Computer Revolution began.”
  156. (2002). The Lost Prophet of Architecture. The Wilson Quarterly, Woodrow Wilson International Center for Scholars.
  157. (2007). The maintenance and evolution of resource-constrained embedded systems created using design patterns.”
  158. (1995). The Methodology of N-version Programming. Software Fault
  159. (1975). The Oregon Experiment.
  160. (2003). The Pragmatics of Model-Driven Development.”
  161. (1996). The pros and cons of adopting and applying design patterns in the real world.”
  162. (1989). The real-time operating system of
  163. (2004). The Rise of Modern Architecture in Postwar America: Class and Spatial Roots of Aesthetic Change. Annual meeting of the American Sociological Association. Hilton San Francisco & Renaissance Parc 55 Hotel,
  164. (1997). The Shannon sampling theorem: its various extensions and applications a tutorial review”,
  165. (1989). The Spring kernel: a new paradigm for realtime operating systems.”
  166. (1991). The static analysis of a safety-critical avionics control system”, in
  167. (1994). The Systematic Design of Large Real-Time Systems or Interface Simplicity. Revised Papers from a Workshop on Hardware and Software Architectures for Fault Tolerance,
  168. (1998). The Time-Triggered Model of Computation.
  169. (1979). The Timeless Way of Building.
  170. (2006). This Year's Model: Representing Modernism to the Post-war American Corporation “
  171. (2003). Time weaver: a software-through-models framework for embedded real-time systems.
  172. (2006). Time-Triggered vs. Event-Triggered: A matter of configuration?
  173. (1997). Tool Support for Object-Oriented Patterns.”
  174. (2008). Towards software process patterns: An empirical analysis of the behavior of student teams.”
  175. (1993). Towards target-level testing and debugging tools for embedded software.
  176. (2008). TTE Systems |Rapid development of reliable embedded systems.”
  177. (2004). Two Simple Patterns to Support the Development of Reliable Embedded Systems.
  178. (2005). UML 2 and SysML: An Approach to Deal with Complexity in SoC/NoC Design.
  179. (2003). UML Distilled: A Brief Guide to the Standard Object Modeling Language,
  180. United States,
  181. (1995). Using design patterns to develop reusable object-oriented communication software.” Commun.
  182. (1987). Using pattern languages for object-oriented programs.
  183. (2002). Using Role-Based Modeling Language (RBML) to Characterize Model Families.
  184. (2003). Using watchdog timers to improve the reliability of TTCS embedded systems, In
  185. (2003). Using watchdog timers to improve the reliability of TTCS embedded systems”,
  186. (1997). Welcome To The OMG's
  187. (2006). What Does It Mean To Be The First Computer?
  188. (1997). What really happened on Mars?” http://research.microsoft.com/~mbj/Mars_Pathfinder/Mars_Pathfinder.html Kalinsky,
  189. (1995). Why time-triggered architectures will succeed in large hard real-time systems.

To submit an update or takedown request for this paper, please submit an Update/Correction/Removal Request.