Browse Books

Reviewer: George Hacken

This is the definitive book on model-based engineering (MBE), as realized via the architecture analysis and design language (AADL). We experienced developers fancy ourselves as having "done" model-based engineering the proverbial "all our lives." This highly instructive book will disabuse us of that conceit, and will enlighten us on what has evolved into a very substantive system-level discipline in its own right: model-based engineering via the robust and extensible AADL. The target audience for the book includes advanced undergraduate and graduate students of computing science or software engineering. Experienced practitioners will find the book an opportunity to apply a force-multiplier to what they already know, and to exercise both static and dynamic (behavioral) architectural thinking and design, via 21st century tools. The authors state their goals in the preface: In the past, separate models have been created for various system components and for each of the different analyses [of system capabilities and operational quality attributes]. A systematic and less fragmented approach is an architecture-centric one ... that address[es] system-level issues and maintain[s] a self-consistent set of analytical views ... that retain their validity amidst architectural changes [throughout the life-cycle]. Though the AADL realization of MBE pervades both parts of the book, chapters 1 to 4 give substantial weight to the general principles of MBE, while chapters 5 to 15 treat AADL syntax and semantics in good detail. The appropriate and well-placed AADL code fragments throughout the text are ideal for learning by doing. The topics of the chapters include model-based software systems engineering; working with AADL; the basics of AADL modeling and analysis; applying AADL capabilities; defining AADL components; software components; execution platform components; composite and generic components; static and dynamic architecture; component interactions; system flows and software deployment; organizing AADL models; annotating models; extending the AADL language; and creating and validating models. The appendices provide an AADL syntax and property summary, and list additional resources and references. A major strength of this book is its clear definitions. For example, the authors define MBE as "designat[ing] engineering practices in which models are the central and indispensable artifacts throughout a product's lifecycle[,] encompassing concept, development, deployment, operation, and maintenance." Facets (or "dimensions") of analysis can include consistency of data, rate-monotonic scheduling, and state-machine and temporal-logic representations. But inconsistencies demand an architecture-centric model as the "single source to drive [these] different dimensions of analysis." Architecture-centricity is the key attribute of the AADL species of MBE. Section 1.2 is a good top-level comparison of AADL, Simulink, very-high-speed integrated circuit (VHSIC) hardware description language (VHDL), Modelica, unified modeling language (UML), and systems modeling language (SysML). As before, the book is clear about software components: they are threads, or processes, or data. Hardware abstractions are crisply enumerated as central processing units (CPUs), or memory, or buses, or devices. The syntax of AADL is, in my ungrammatical phrasing, "very Ada," and AADL's semantics include packages with public and private sections "in support of information hiding." This is information about, not criticism of, AADL's syntax for potential users. I also point out that there was a time in the 1980s when there were proponents of Ada itself as a design and specification language. I'll mention, but not elaborate on, another issue that AADL addresses, in my opinion quite successfully: the tension between unadulterated design thinking and "operational thinking," the latter having been "considered harmful" by the one and only E. W. Dijkstra, who continues to have my greatest respect. (My catchphrase for operational thinking is that it refers to a human "playing computer." AADL's dynamic modeling involves system behavior [operations], not that of the fetch-interpret-execute cycle of a CPU, which a high-level procedural language hardly hides.) The enumeration of AADL categories speaks clearly to our conceptual faculty in helping us to form clear, crisp categories: application software, for example, thread, process; platform, for example, processor, memory, bus; composite, that is, system; generic, or abstract (runtime-neutral). Software components are thread, process, data, and subprogram. The definitions of thread and process are the clearest I've encountered. The chapter on static and dynamic architecture in a sense tells the "whole story" of AADL: these modeling "views" (my word), as well as coarse and fine model granularity, are accommodated by AADL. Partially complete models are also analyzable, for issues such as resource budgets of processes. This is an important, perhaps defining, strength of MBE via AADL. The book seems to leave nothing out. For example, ports are declared in or out, queued or not, and as carrying events, data, or both. For example, roll, pitch, yaw can be dispatched together, or "aggregated." Connections can be immediate or delayed, and can be sampled or preemptive. I highly recommend this book. I believe that readers will find the time and effort spent on mastering MBE/AADL will be repaid handsomely by the acquired ability to design and validate "functional and nonfunctional [system] properties, such as behavior, performance, timing, safety, reliability, and security." More reviews about this item: Amazon Online Computing Reviews Service