Patterns in the machine: a software engineering guide to embedded development
1: Introduction -- 2: Core Concepts -- 3: Design Theory For Embedded Programming -- 4: Persistent Storage Example -- 5: Software Architecture -- 6: Unit Testing -- 7: Functional Simulator -- 8: Continuous Integration -- 9: The Data model architecture -- 10: Finite State Machines -- 11: Documentation...
Gespeichert in:
| Hauptverfasser: | , |
|---|---|
| Format: | Buch |
| Sprache: | English |
| Veröffentlicht: |
New York
Apress
[2021]
|
| Schlagworte: | |
| Online-Zugang: | Inhaltsverzeichnis |
| Zusammenfassung: | 1: Introduction -- 2: Core Concepts -- 3: Design Theory For Embedded Programming -- 4: Persistent Storage Example -- 5: Software Architecture -- 6: Unit Testing -- 7: Functional Simulator -- 8: Continuous Integration -- 9: The Data model architecture -- 10: Finite State Machines -- 11: Documentation -- 12: File Organization and Naming -- 13: More About Late Bindings -- 14: Initialization and the main pattern -- 15: More Best Practices -- 16: PIM Thermostat Example -- 17: The Tao of Development -- Appendix A: Terminology -- Appendix B: State Machines Notation -- Appendix C: A UML cheat sheet -- Appendix D: Why C++ -- Appendix E: About Package Management with outcast -- Appendix F: Requirements vs. Design Statements Discover how to apply software engineering patterns to develop more robust firmware faster than traditional embedded development approaches. In the authors' experience, traditional embedded software projects tend towards monolithic applications that are optimized for their target hardware platforms. This leads to software that is fragile in terms of extensibility and difficult to test without fully integrated software and hardware. Patterns in the Machine focuses on creating loosely coupled implementations that embrace both change and testability. This book illustrates how implementing continuous integration, automated unit testing, platform-independent code, and other best practices that are not typically implemented in the embedded systems world is not just feasible but also practical for today's embedded projects. After reading this book, you will have a better idea of how to structure your embedded software projects. You will recognize that while writing unit tests, creating simulators, and implementing continuous integration requires time and effort up front, you will be amply rewarded at the end of the project in terms of quality, adaptability, and maintainability of your code. You will: Incorporate automated unit testing into an embedded project ; Design and build functional simulators for an embedded project ; Write production-quality software when hardware is not available ; Use the Data Model architectural pattern to create a highly decoupled design and implementation ; Understand the importance of defining the software architecture before implementation starts and how to do it ; Discover why documentation is essential for an embedded project Use finite state machines in embedded projects |
| Beschreibung: | Includes index |
| Beschreibung: | XIX, 293 Seiten Illustrationen 26 cm |
| ISBN: | 1484264398 9781484264393 |
Internformat
MARC
| LEADER | 00000nam a2200000 c 4500 | ||
|---|---|---|---|
| 001 | BV047954071 | ||
| 003 | DE-604 | ||
| 005 | 20220429 | ||
| 007 | t | ||
| 008 | 220425s2021 xxua||| |||| 00||| eng d | ||
| 020 | |a 1484264398 |9 1-4842-6439-8 | ||
| 020 | |a 9781484264393 |9 978-1-4842-6439-3 | ||
| 035 | |a (OCoLC)1314900338 | ||
| 035 | |a (DE-599)KXP1761726749 | ||
| 040 | |a DE-604 |b ger |e rda | ||
| 041 | 0 | |a eng | |
| 044 | |a xxu |c XD-US | ||
| 049 | |a DE-739 | ||
| 050 | 0 | |a QA76.75-.765 | |
| 082 | 0 | |a 005.1 | |
| 084 | |a ST 153 |0 (DE-625)143597: |2 rvk | ||
| 100 | 1 | |a Taylor, John T. |e Verfasser |0 (DE-588)1227954743 |4 aut | |
| 245 | 1 | 0 | |a Patterns in the machine |b a software engineering guide to embedded development |c John T. Taylor, Wayne T. Taylor |
| 264 | 1 | |a New York |b Apress |c [2021] | |
| 300 | |a XIX, 293 Seiten |b Illustrationen |c 26 cm | ||
| 336 | |b txt |2 rdacontent | ||
| 337 | |b n |2 rdamedia | ||
| 338 | |b nc |2 rdacarrier | ||
| 500 | |a Includes index | ||
| 520 | 3 | |a 1: Introduction -- 2: Core Concepts -- 3: Design Theory For Embedded Programming -- 4: Persistent Storage Example -- 5: Software Architecture -- 6: Unit Testing -- 7: Functional Simulator -- 8: Continuous Integration -- 9: The Data model architecture -- 10: Finite State Machines -- 11: Documentation -- 12: File Organization and Naming -- 13: More About Late Bindings -- 14: Initialization and the main pattern -- 15: More Best Practices -- 16: PIM Thermostat Example -- 17: The Tao of Development -- Appendix A: Terminology -- Appendix B: State Machines Notation -- Appendix C: A UML cheat sheet -- Appendix D: Why C++ -- Appendix E: About Package Management with outcast -- Appendix F: Requirements vs. Design Statements | |
| 520 | 3 | |a Discover how to apply software engineering patterns to develop more robust firmware faster than traditional embedded development approaches. In the authors' experience, traditional embedded software projects tend towards monolithic applications that are optimized for their target hardware platforms. This leads to software that is fragile in terms of extensibility and difficult to test without fully integrated software and hardware. Patterns in the Machine focuses on creating loosely coupled implementations that embrace both change and testability. This book illustrates how implementing continuous integration, automated unit testing, platform-independent code, and other best practices that are not typically implemented in the embedded systems world is not just feasible but also practical for today's embedded projects. After reading this book, you will have a better idea of how to structure your embedded software projects. You will recognize that while writing unit tests, creating simulators, and implementing continuous integration requires time and effort up front, you will be amply rewarded at the end of the project in terms of quality, adaptability, and maintainability of your code. You will: Incorporate automated unit testing into an embedded project ; Design and build functional simulators for an embedded project ; Write production-quality software when hardware is not available ; Use the Data Model architectural pattern to create a highly decoupled design and implementation ; Understand the importance of defining the software architecture before implementation starts and how to do it ; Discover why documentation is essential for an embedded project Use finite state machines in embedded projects | |
| 650 | 0 | 7 | |a Integrierte Software |0 (DE-588)4120497-9 |2 gnd |9 rswk-swf |
| 650 | 0 | 7 | |a Software Engineering |0 (DE-588)4116521-4 |2 gnd |9 rswk-swf |
| 653 | 0 | |a Computer software / Development | |
| 653 | 0 | |a Software engineering | |
| 653 | 0 | |a Electronic circuits | |
| 653 | 0 | |a Computer input-output equipment | |
| 653 | 0 | |a Computer input-output equipment | |
| 653 | 0 | |a Computer software | |
| 653 | 0 | |a Electronic circuits | |
| 653 | 0 | |a Software engineering | |
| 689 | 0 | 0 | |a Integrierte Software |0 (DE-588)4120497-9 |D s |
| 689 | 0 | 1 | |a Software Engineering |0 (DE-588)4116521-4 |D s |
| 689 | 0 | |5 DE-604 | |
| 700 | 1 | |a Taylor, Wayne T. |e Verfasser |0 (DE-588)1227954867 |4 aut | |
| 776 | 0 | |z 9781484264409 |c oBook | |
| 856 | 4 | 2 | |m Digitalisierung UB Passau - ADAM Catalogue Enrichment |q application/pdf |u http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=033335386&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA |3 Inhaltsverzeichnis |
| 999 | |a oai:aleph.bib-bvb.de:BVB01-033335386 | ||
Datensatz im Suchindex
| _version_ | 1804183638942679040 |
|---|---|
| adam_text | Table of Contents About the Authors................................................................................................................xiii About the TechnicalReviewer.............................................................................................xv Acknowledgments..............................................................................................................xvii Preface................... Chapter 1: Introduction......................... xix 1 Patterns in the Machine.................................................................................................................. 3 What Is Software Engineering?.......................................................................................................4 Software Engineering Best Practices..............................................................................................5 What PIM Is Not............................................................................................................................... 7 What You’ll Need to Know............................................................................................................... 8 Chapter 2: Core Concepts.............................................. 9 Software Architecture..................................................................................................................... 9 Automated Unit Testing................................................................................................................. 10 Functional
Simulator..................................................................................................................... 12 Continuous Integration.................................................................................................................. 13 Data Model.....................................................................................................................................16 Finite State Machines................................................................................................................... 20 Documentation.............................................................................................................................. 22 Chapter 3: Design Theory for Embedded Programming...............................................25 SOLID.............................................................................................................................................26 Single Responsibility Principle................................................................................................27 Open-Closed Principle............................................................................................................. 28 Liskov Substitution Principle...................................................................................................33
TABLE OF CONTENTS TABLE OF CONTENTS Interface Segregation Principle............................................................................................... 34 Functional Simulator............................................................................................................... 77 Dependency Inversion Principle..............................................................................................36 File Organization...................................................................................................................... 78 Binding Time................................................................................................................................. 38 Localization and Internationalization...................................................................................... 79 Source Time Binding................................................................................................................ 39 Conventions............................................................................................................................. 79 Compile Time Binding.............................................................................................................. 40 Unit Test Strategy.................................................................................................................... 80 Link Time Binding.................................................................................................................... 41 Build
System........................................................................................................................... 80 A SOLID Conclusion................................................................................................................. 42 Creating “Real” Architecture Documents..................................................................................... 82 Chapter 4: Persistent Storage Detailed Design Example..............................................43 Chapter 6: Unit Testing......... ............................................ 83 Persistent Storage Example.......................................................................................................... 43 What Is a Unit Test?....................................................................................................................... 84 Software Requirements........................................................................................................... 43 Source Directories and Unit Tests............................................................................................86 High-Level Design................................................................................................................... 44 Manual Unit Tests.................................................................................................................... 87 A Monolithic Detailed Design...................................................................................................45 Automated Unit
Tests............................................................................................................... 88 A PIM-Informed Detailed Design.............................................................................................46 Code Coverage Metrics............................................................................................................89 Benefits of the PIM Design...................................................................................................... 49 About Testing Frameworks...........................................................................................................91 Expanded Layering.................................................................................................................. 50 Continuous Integration..................................................................................................................92 Example PIM Thermostat Application............................................................................................53 Tips for Unit Testing...................................................................................................................... 93 High-Level Design................................................................................................................... 54 Minimize Dependencies..........................................................................................................93 Detailed Design....................................................................................................................... 56 Use
Abstract Interfaces...........................................................................................................93 The PIM Dilemma.......................................................................................................................... 62 Use the Data Model Pattern.....................................................................................................94 Chapter 5: Software Architecture.................. 63 About the Software Architect........................................................................................................ 63 About Software Architecture Documents......................................................................................64 Major Sub-systems................................................................................................................. 66 Test Early................................................................................................................................. 94 Develop and Test Incrementally...............................................................................................94 The Dark Side of Unit Testing........................................................................................................95 Unit Testing vs. Integration Testing vs. System Testing................................................................ 96 Major Interface Semantics...................................................................................................... 68 Chapter 7: Functional
Simulator....................................................................................... 97 Threading and Processor Model..............................................................................................70 Operating System Abstraction Layer.............................................................................................99 Communications Mechanisms................................................................................................ 70 Hardware Abstraction Layer..........................................................................................................99 Memory Strategy or Rules....................................................................................................... 71 Main Pattern................................................................................................................................. 99 Performance Requirements and Constraints.......................................................................... 72 Simulated Time........................................................................................................................... 101 Hardware Interfaces................................................................................................................ 73 How to Implement Simulated Time.......................................................................................101 Operating System.................................................................................................................... 76 Third-Party
Software............................................................................................................... 76 VI vii
TABLE OF CONTENTS TABLE OF CONTENTS Platform Boundaries................................................................................................................................102 Chapter 11: Documentation.............................................................................................153 Mocked Simulation.............................................................................................................................103 Documenting Header Files........................................................................... Simulated Devices..............................................................................................................................103 Document First, Then Implement.......................................................................................................... 158 Emulated Devices...............................................................................................................................103 Documenting Your Development Process............................................................................................159 Simulated Use Cases...............................................................................................................................104 A Simulated LCD................................................................................................................................. 104 154 Document Your Software Architecture and Design......................................................................... 161 Document Your Team’s Best
Practices................................................................................................. 162 An Algorithm with Simulated Time..................................................................................................104 Chapter 12: File Organization and Naming...................... 163 A Model Simulator with Simulated Time....................................................................................... 105 Organizing Files by Namespace............................................................................................................ 163 A Communication Channel............................................................................................................... 105 Organizing External Packages...............................................................................................................167 The Functional Simulator for the Thermostat Example..................................................................... 106 Naming....................................................................................................................................................... 169 Chapter 8: Continuous Integration.................... 107 Naming Recommendations for C++...............................................................................................170 Implementing Continuous Integration...................................................................................................108 Naming Recommendations for
C.....................................................................................................171 Continuous Integration and PIM.............................................................................................................109 Chapter 13: More About Late Binding............................................................................ 175 About the Build Machine......................................................................................................................... 110 LHeader...................................................................................................................................................... 175 Maximizing Build Machine Performance....................................................................................... 111 Implementation Example.................................................................................................................. 177 About Software Configuration Management....................................................................................... 112 LConfig............................................................................................... 181 Implementing Branching Strategies............................................................................................... 113 About Formal Builds........................ 114 About the Build Automation Tool............................................................................................................114 About Build Scripts...................... 116 Chapter 14: Initialization and the Main
Pattern.......................... 183 Staged Initialization.................................................................................................................................186 About Open/Close with Inter-thread Communication............................................. 190 Main Pattern............................................................................................................................................. 191 Chapter 9: The Data Model Architecture.................................................... ............. 119 Additional Model Point Features............................................................................................................126 Main Minor..........................................................................................................................................192 Main Major..........................................................................................................................................196 Model Points vs. Global Variables......................................................................................................... 133 Chapter 15: More Best Practices.................................................................................... 201 Chapter 10: Finite State Machines...................... 137 Example of a Thermostat FSM............................................................................................................... 138 State
Tables................................................................................................................................................141 Design vs. Implementation.....................................................................................................................142 Code Generation Is a Good Thing.......................................................................................................... 145 Tips, Hints, and Suggestions.................................................................................................................. 148 viii Avoid Dynamic Memory Allocation........................................................................................................201 Documenting Header Files..................................................................................................................... 203 Interfaces and More Interfaces............................................................................................................. 206 Compile Time Binding........................................................................................................................206 Link Time Binding.............................................................................................................................. 209 C++ Pure Virtual and Virtual Constructs........................................................................................ 213 ix
TABLE OF CONTENTS TABLE OF CONTENTS Data Model................................................................................................................................................ 214 Build System............................................................................................................................................. 216 Chapter 16: PIM Thermostat Example................................................................... 219 Appendix B: State Machine Notation............................................................................. 269 Appendix C: A UML Cheat Sheet..................................................................................... 273 Appendix D: Why C++..................... 275 Features and Requirements................................................................................................................... 219 Appendix E: About Package Management with Outcast............................................ 279 Target Hardware....................................................................................................................................... 221 Outcast....................................................................................................................................................... 230 Installation and Setup............................................................... ............................................................ 223 Outcast Model.................................................................................................. 281 Linux
Setup..........................................................................................................................................224 Windows Setup...................................................................................................................................224 Building............................. 227 Building on Linux with the GCC Compiler...................................................................................... 228 Building on Windows with the Visual Studio Compiler............................................................... 229 Build Directory Naming Conventions..............................................................................................231 PIM Thermostat Application Usage................................................................................................. 234 About NQBP............................................ 240 Installing NQBP................................................................................................................................... 241 NQBP Usage.........................................................................................................................................242 NQBP Build Model.............................................................................................................................. 242 NQBP Object Files vs. Libraries.......................................................................................................242 NQBP Build
Variants........................................................................................................................... 244 NQBP Build Scripts............................................................................................................................ 244 Selecting What to Build with NQBP................................................................................................ 245 NQBP Extras....................................................................................................................................... 247 Colony.core................................................................................................................................................ 249 Colony.Apps............................................................................................................................................... 253 Colony,Arduino..........................................................................................................................................253 RÄTT............................................................................................................................................................254 Chapter 17: The Tao of Development............... 255 John’s Rules of Development.................................................................................................................255 Wayne’s Rules of Development............................................................................................................. 261 Appendix A: Terminology................... X 265
Appendix F: Requirements vs. Design Statements......................................................285 Index................................................... .........289
|
| adam_txt |
Table of Contents About the Authors.xiii About the TechnicalReviewer.xv Acknowledgments.xvii Preface. Chapter 1: Introduction. xix 1 Patterns in the Machine. 3 What Is Software Engineering?.4 Software Engineering Best Practices.5 What PIM Is Not. 7 What You’ll Need to Know. 8 Chapter 2: Core Concepts. 9 Software Architecture. 9 Automated Unit Testing. 10 Functional
Simulator. 12 Continuous Integration. 13 Data Model.16 Finite State Machines. 20 Documentation. 22 Chapter 3: Design Theory for Embedded Programming.25 SOLID.26 Single Responsibility Principle.27 Open-Closed Principle. 28 Liskov Substitution Principle.33
TABLE OF CONTENTS TABLE OF CONTENTS Interface Segregation Principle. 34 Functional Simulator. 77 Dependency Inversion Principle.36 File Organization. 78 Binding Time. 38 Localization and Internationalization. 79 Source Time Binding. 39 Conventions. 79 Compile Time Binding. 40 Unit Test Strategy. 80 Link Time Binding. 41 Build
System. 80 A SOLID Conclusion. 42 Creating “Real” Architecture Documents. 82 Chapter 4: Persistent Storage Detailed Design Example.43 Chapter 6: Unit Testing. . 83 Persistent Storage Example. 43 What Is a Unit Test?. 84 Software Requirements. 43 Source Directories and Unit Tests.86 High-Level Design. 44 Manual Unit Tests. 87 A Monolithic Detailed Design.45 Automated Unit
Tests. 88 A PIM-Informed Detailed Design.46 Code Coverage Metrics.89 Benefits of the PIM Design. 49 About Testing Frameworks.91 Expanded Layering. 50 Continuous Integration.92 Example PIM Thermostat Application.53 Tips for Unit Testing. 93 High-Level Design. 54 Minimize Dependencies.93 Detailed Design. 56 Use
Abstract Interfaces.93 The PIM Dilemma. 62 Use the Data Model Pattern.94 Chapter 5: Software Architecture. 63 About the Software Architect. 63 About Software Architecture Documents.64 Major Sub-systems. 66 Test Early. 94 Develop and Test Incrementally.94 The Dark Side of Unit Testing.95 Unit Testing vs. Integration Testing vs. System Testing. 96 Major Interface Semantics. 68 Chapter 7: Functional
Simulator. 97 Threading and Processor Model.70 Operating System Abstraction Layer.99 Communications Mechanisms. 70 Hardware Abstraction Layer.99 Memory Strategy or Rules. 71 Main Pattern. 99 Performance Requirements and Constraints. 72 Simulated Time. 101 Hardware Interfaces. 73 How to Implement Simulated Time.101 Operating System. 76 Third-Party
Software. 76 VI vii
TABLE OF CONTENTS TABLE OF CONTENTS Platform Boundaries.102 Chapter 11: Documentation.153 Mocked Simulation.103 Documenting Header Files. Simulated Devices.103 Document First, Then Implement. 158 Emulated Devices.103 Documenting Your Development Process.159 Simulated Use Cases.104 A Simulated LCD. 104 154 Document Your Software Architecture and Design. 161 Document Your Team’s Best
Practices. 162 An Algorithm with Simulated Time.104 Chapter 12: File Organization and Naming. 163 A Model Simulator with Simulated Time. 105 Organizing Files by Namespace. 163 A Communication Channel. 105 Organizing External Packages.167 The Functional Simulator for the Thermostat Example. 106 Naming. 169 Chapter 8: Continuous Integration. 107 Naming Recommendations for C++.170 Implementing Continuous Integration.108 Naming Recommendations for
C.171 Continuous Integration and PIM.109 Chapter 13: More About Late Binding. 175 About the Build Machine. 110 LHeader. 175 Maximizing Build Machine Performance. 111 Implementation Example. 177 About Software Configuration Management. 112 LConfig. 181 Implementing Branching Strategies. 113 About Formal Builds. 114 About the Build Automation Tool.114 About Build Scripts. 116 Chapter 14: Initialization and the Main
Pattern. 183 Staged Initialization.186 About Open/Close with Inter-thread Communication. 190 Main Pattern. 191 Chapter 9: The Data Model Architecture. . 119 Additional Model Point Features.126 Main Minor.192 Main Major.196 Model Points vs. Global Variables. 133 Chapter 15: More Best Practices. 201 Chapter 10: Finite State Machines. 137 Example of a Thermostat FSM. 138 State
Tables.141 Design vs. Implementation.142 Code Generation Is a Good Thing. 145 Tips, Hints, and Suggestions. 148 viii Avoid Dynamic Memory Allocation.201 Documenting Header Files. 203 Interfaces and More Interfaces. 206 Compile Time Binding.206 Link Time Binding. 209 C++ Pure Virtual and Virtual Constructs. 213 ix
TABLE OF CONTENTS TABLE OF CONTENTS Data Model. 214 Build System. 216 Chapter 16: PIM Thermostat Example. 219 Appendix B: State Machine Notation. 269 Appendix C: A UML Cheat Sheet. 273 Appendix D: Why C++. 275 Features and Requirements. 219 Appendix E: About Package Management with Outcast. 279 Target Hardware. 221 Outcast. 230 Installation and Setup. . 223 Outcast Model. 281 Linux
Setup.224 Windows Setup.224 Building. 227 Building on Linux with the GCC Compiler. 228 Building on Windows with the Visual Studio Compiler. 229 Build Directory Naming Conventions.231 PIM Thermostat Application Usage. 234 About NQBP. 240 Installing NQBP. 241 NQBP Usage.242 NQBP Build Model. 242 NQBP Object Files vs. Libraries.242 NQBP Build
Variants. 244 NQBP Build Scripts. 244 Selecting What to Build with NQBP. 245 NQBP Extras. 247 Colony.core. 249 Colony.Apps. 253 Colony,Arduino.253 RÄTT.254 Chapter 17: The Tao of Development. 255 John’s Rules of Development.255 Wayne’s Rules of Development. 261 Appendix A: Terminology. X 265
Appendix F: Requirements vs. Design Statements.285 Index. .289 |
| any_adam_object | 1 |
| any_adam_object_boolean | 1 |
| author | Taylor, John T. Taylor, Wayne T. |
| author_GND | (DE-588)1227954743 (DE-588)1227954867 |
| author_facet | Taylor, John T. Taylor, Wayne T. |
| author_role | aut aut |
| author_sort | Taylor, John T. |
| author_variant | j t t jt jtt w t t wt wtt |
| building | Verbundindex |
| bvnumber | BV047954071 |
| callnumber-first | Q - Science |
| callnumber-label | QA76 |
| callnumber-raw | QA76.75-.765 |
| callnumber-search | QA76.75-.765 |
| callnumber-sort | QA 276.75 3765 |
| callnumber-subject | QA - Mathematics |
| classification_rvk | ST 153 |
| ctrlnum | (OCoLC)1314900338 (DE-599)KXP1761726749 |
| dewey-full | 005.1 |
| dewey-hundreds | 000 - Computer science, information, general works |
| dewey-ones | 005 - Computer programming, programs, data, security |
| dewey-raw | 005.1 |
| dewey-search | 005.1 |
| dewey-sort | 15.1 |
| dewey-tens | 000 - Computer science, information, general works |
| discipline | Informatik |
| discipline_str_mv | Informatik |
| format | Book |
| fullrecord | <?xml version="1.0" encoding="UTF-8"?><collection xmlns="http://www.loc.gov/MARC21/slim"><record><leader>04470nam a2200541 c 4500</leader><controlfield tag="001">BV047954071</controlfield><controlfield tag="003">DE-604</controlfield><controlfield tag="005">20220429 </controlfield><controlfield tag="007">t</controlfield><controlfield tag="008">220425s2021 xxua||| |||| 00||| eng d</controlfield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">1484264398</subfield><subfield code="9">1-4842-6439-8</subfield></datafield><datafield tag="020" ind1=" " ind2=" "><subfield code="a">9781484264393</subfield><subfield code="9">978-1-4842-6439-3</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(OCoLC)1314900338</subfield></datafield><datafield tag="035" ind1=" " ind2=" "><subfield code="a">(DE-599)KXP1761726749</subfield></datafield><datafield tag="040" ind1=" " ind2=" "><subfield code="a">DE-604</subfield><subfield code="b">ger</subfield><subfield code="e">rda</subfield></datafield><datafield tag="041" ind1="0" ind2=" "><subfield code="a">eng</subfield></datafield><datafield tag="044" ind1=" " ind2=" "><subfield code="a">xxu</subfield><subfield code="c">XD-US</subfield></datafield><datafield tag="049" ind1=" " ind2=" "><subfield code="a">DE-739</subfield></datafield><datafield tag="050" ind1=" " ind2="0"><subfield code="a">QA76.75-.765</subfield></datafield><datafield tag="082" ind1="0" ind2=" "><subfield code="a">005.1</subfield></datafield><datafield tag="084" ind1=" " ind2=" "><subfield code="a">ST 153</subfield><subfield code="0">(DE-625)143597:</subfield><subfield code="2">rvk</subfield></datafield><datafield tag="100" ind1="1" ind2=" "><subfield code="a">Taylor, John T.</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)1227954743</subfield><subfield code="4">aut</subfield></datafield><datafield tag="245" ind1="1" ind2="0"><subfield code="a">Patterns in the machine</subfield><subfield code="b">a software engineering guide to embedded development</subfield><subfield code="c">John T. Taylor, Wayne T. Taylor</subfield></datafield><datafield tag="264" ind1=" " ind2="1"><subfield code="a">New York</subfield><subfield code="b">Apress</subfield><subfield code="c">[2021]</subfield></datafield><datafield tag="300" ind1=" " ind2=" "><subfield code="a">XIX, 293 Seiten</subfield><subfield code="b">Illustrationen</subfield><subfield code="c">26 cm</subfield></datafield><datafield tag="336" ind1=" " ind2=" "><subfield code="b">txt</subfield><subfield code="2">rdacontent</subfield></datafield><datafield tag="337" ind1=" " ind2=" "><subfield code="b">n</subfield><subfield code="2">rdamedia</subfield></datafield><datafield tag="338" ind1=" " ind2=" "><subfield code="b">nc</subfield><subfield code="2">rdacarrier</subfield></datafield><datafield tag="500" ind1=" " ind2=" "><subfield code="a">Includes index</subfield></datafield><datafield tag="520" ind1="3" ind2=" "><subfield code="a">1: Introduction -- 2: Core Concepts -- 3: Design Theory For Embedded Programming -- 4: Persistent Storage Example -- 5: Software Architecture -- 6: Unit Testing -- 7: Functional Simulator -- 8: Continuous Integration -- 9: The Data model architecture -- 10: Finite State Machines -- 11: Documentation -- 12: File Organization and Naming -- 13: More About Late Bindings -- 14: Initialization and the main pattern -- 15: More Best Practices -- 16: PIM Thermostat Example -- 17: The Tao of Development -- Appendix A: Terminology -- Appendix B: State Machines Notation -- Appendix C: A UML cheat sheet -- Appendix D: Why C++ -- Appendix E: About Package Management with outcast -- Appendix F: Requirements vs. Design Statements</subfield></datafield><datafield tag="520" ind1="3" ind2=" "><subfield code="a">Discover how to apply software engineering patterns to develop more robust firmware faster than traditional embedded development approaches. In the authors' experience, traditional embedded software projects tend towards monolithic applications that are optimized for their target hardware platforms. This leads to software that is fragile in terms of extensibility and difficult to test without fully integrated software and hardware. Patterns in the Machine focuses on creating loosely coupled implementations that embrace both change and testability. This book illustrates how implementing continuous integration, automated unit testing, platform-independent code, and other best practices that are not typically implemented in the embedded systems world is not just feasible but also practical for today's embedded projects. After reading this book, you will have a better idea of how to structure your embedded software projects. You will recognize that while writing unit tests, creating simulators, and implementing continuous integration requires time and effort up front, you will be amply rewarded at the end of the project in terms of quality, adaptability, and maintainability of your code. You will: Incorporate automated unit testing into an embedded project ; Design and build functional simulators for an embedded project ; Write production-quality software when hardware is not available ; Use the Data Model architectural pattern to create a highly decoupled design and implementation ; Understand the importance of defining the software architecture before implementation starts and how to do it ; Discover why documentation is essential for an embedded project Use finite state machines in embedded projects</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Integrierte Software</subfield><subfield code="0">(DE-588)4120497-9</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="650" ind1="0" ind2="7"><subfield code="a">Software Engineering</subfield><subfield code="0">(DE-588)4116521-4</subfield><subfield code="2">gnd</subfield><subfield code="9">rswk-swf</subfield></datafield><datafield tag="653" ind1=" " ind2="0"><subfield code="a">Computer software / Development</subfield></datafield><datafield tag="653" ind1=" " ind2="0"><subfield code="a">Software engineering</subfield></datafield><datafield tag="653" ind1=" " ind2="0"><subfield code="a">Electronic circuits</subfield></datafield><datafield tag="653" ind1=" " ind2="0"><subfield code="a">Computer input-output equipment</subfield></datafield><datafield tag="653" ind1=" " ind2="0"><subfield code="a">Computer input-output equipment</subfield></datafield><datafield tag="653" ind1=" " ind2="0"><subfield code="a">Computer software</subfield></datafield><datafield tag="653" ind1=" " ind2="0"><subfield code="a">Electronic circuits</subfield></datafield><datafield tag="653" ind1=" " ind2="0"><subfield code="a">Software engineering</subfield></datafield><datafield tag="689" ind1="0" ind2="0"><subfield code="a">Integrierte Software</subfield><subfield code="0">(DE-588)4120497-9</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2="1"><subfield code="a">Software Engineering</subfield><subfield code="0">(DE-588)4116521-4</subfield><subfield code="D">s</subfield></datafield><datafield tag="689" ind1="0" ind2=" "><subfield code="5">DE-604</subfield></datafield><datafield tag="700" ind1="1" ind2=" "><subfield code="a">Taylor, Wayne T.</subfield><subfield code="e">Verfasser</subfield><subfield code="0">(DE-588)1227954867</subfield><subfield code="4">aut</subfield></datafield><datafield tag="776" ind1="0" ind2=" "><subfield code="z">9781484264409</subfield><subfield code="c">oBook</subfield></datafield><datafield tag="856" ind1="4" ind2="2"><subfield code="m">Digitalisierung UB Passau - ADAM Catalogue Enrichment</subfield><subfield code="q">application/pdf</subfield><subfield code="u">http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=033335386&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA</subfield><subfield code="3">Inhaltsverzeichnis</subfield></datafield><datafield tag="999" ind1=" " ind2=" "><subfield code="a">oai:aleph.bib-bvb.de:BVB01-033335386</subfield></datafield></record></collection> |
| id | DE-604.BV047954071 |
| illustrated | Illustrated |
| index_date | 2024-07-03T19:38:17Z |
| indexdate | 2024-07-10T09:26:38Z |
| institution | BVB |
| isbn | 1484264398 9781484264393 |
| language | English |
| oai_aleph_id | oai:aleph.bib-bvb.de:BVB01-033335386 |
| oclc_num | 1314900338 |
| open_access_boolean | |
| owner | DE-739 |
| owner_facet | DE-739 |
| physical | XIX, 293 Seiten Illustrationen 26 cm |
| publishDate | 2021 |
| publishDateSearch | 2021 |
| publishDateSort | 2021 |
| publisher | Apress |
| record_format | marc |
| spelling | Taylor, John T. Verfasser (DE-588)1227954743 aut Patterns in the machine a software engineering guide to embedded development John T. Taylor, Wayne T. Taylor New York Apress [2021] XIX, 293 Seiten Illustrationen 26 cm txt rdacontent n rdamedia nc rdacarrier Includes index 1: Introduction -- 2: Core Concepts -- 3: Design Theory For Embedded Programming -- 4: Persistent Storage Example -- 5: Software Architecture -- 6: Unit Testing -- 7: Functional Simulator -- 8: Continuous Integration -- 9: The Data model architecture -- 10: Finite State Machines -- 11: Documentation -- 12: File Organization and Naming -- 13: More About Late Bindings -- 14: Initialization and the main pattern -- 15: More Best Practices -- 16: PIM Thermostat Example -- 17: The Tao of Development -- Appendix A: Terminology -- Appendix B: State Machines Notation -- Appendix C: A UML cheat sheet -- Appendix D: Why C++ -- Appendix E: About Package Management with outcast -- Appendix F: Requirements vs. Design Statements Discover how to apply software engineering patterns to develop more robust firmware faster than traditional embedded development approaches. In the authors' experience, traditional embedded software projects tend towards monolithic applications that are optimized for their target hardware platforms. This leads to software that is fragile in terms of extensibility and difficult to test without fully integrated software and hardware. Patterns in the Machine focuses on creating loosely coupled implementations that embrace both change and testability. This book illustrates how implementing continuous integration, automated unit testing, platform-independent code, and other best practices that are not typically implemented in the embedded systems world is not just feasible but also practical for today's embedded projects. After reading this book, you will have a better idea of how to structure your embedded software projects. You will recognize that while writing unit tests, creating simulators, and implementing continuous integration requires time and effort up front, you will be amply rewarded at the end of the project in terms of quality, adaptability, and maintainability of your code. You will: Incorporate automated unit testing into an embedded project ; Design and build functional simulators for an embedded project ; Write production-quality software when hardware is not available ; Use the Data Model architectural pattern to create a highly decoupled design and implementation ; Understand the importance of defining the software architecture before implementation starts and how to do it ; Discover why documentation is essential for an embedded project Use finite state machines in embedded projects Integrierte Software (DE-588)4120497-9 gnd rswk-swf Software Engineering (DE-588)4116521-4 gnd rswk-swf Computer software / Development Software engineering Electronic circuits Computer input-output equipment Computer software Integrierte Software (DE-588)4120497-9 s Software Engineering (DE-588)4116521-4 s DE-604 Taylor, Wayne T. Verfasser (DE-588)1227954867 aut 9781484264409 oBook Digitalisierung UB Passau - ADAM Catalogue Enrichment application/pdf http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=033335386&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA Inhaltsverzeichnis |
| spellingShingle | Taylor, John T. Taylor, Wayne T. Patterns in the machine a software engineering guide to embedded development Integrierte Software (DE-588)4120497-9 gnd Software Engineering (DE-588)4116521-4 gnd |
| subject_GND | (DE-588)4120497-9 (DE-588)4116521-4 |
| title | Patterns in the machine a software engineering guide to embedded development |
| title_auth | Patterns in the machine a software engineering guide to embedded development |
| title_exact_search | Patterns in the machine a software engineering guide to embedded development |
| title_exact_search_txtP | Patterns in the machine a software engineering guide to embedded development |
| title_full | Patterns in the machine a software engineering guide to embedded development John T. Taylor, Wayne T. Taylor |
| title_fullStr | Patterns in the machine a software engineering guide to embedded development John T. Taylor, Wayne T. Taylor |
| title_full_unstemmed | Patterns in the machine a software engineering guide to embedded development John T. Taylor, Wayne T. Taylor |
| title_short | Patterns in the machine |
| title_sort | patterns in the machine a software engineering guide to embedded development |
| title_sub | a software engineering guide to embedded development |
| topic | Integrierte Software (DE-588)4120497-9 gnd Software Engineering (DE-588)4116521-4 gnd |
| topic_facet | Integrierte Software Software Engineering |
| url | http://bvbr.bib-bvb.de:8991/F?func=service&doc_library=BVB01&local_base=BVB01&doc_number=033335386&sequence=000001&line_number=0001&func_code=DB_RECORDS&service_type=MEDIA |
| work_keys_str_mv | AT taylorjohnt patternsinthemachineasoftwareengineeringguidetoembeddeddevelopment AT taylorwaynet patternsinthemachineasoftwareengineeringguidetoembeddeddevelopment |