Customer Reviews

Software Architecture: Perspectives on an Emerging Discipline

5 star:		(2)
4 star:		(2)
3 star:		(2)
2 star:		(1)
1 star:		(1)

 

 

I was disappointed in that Sofware Architecture focused more on a few specific approaches to systems design than on an adaptive approach for creating architectures.

Although published in 1996, I found much of the material to be based on the past (e.g., a pipe and filter model, shared repository, etc.) moreso than on newer/emerging technologies, such as the role of component-based architectures.

I think this is a good text for a traditional summary of the SW industry and some solid practices, but it did not offer the foresight needed by "seasoned" professionals to earn a permanent spot on the bookshelf.

This is a book for these who begin to wonder what is the software architecture while they begin to design software, after going through the existing architecture styles, you will understand the bad thing and good thing about one particular style, and you will have the ability to frame your problem in term of these existing styles, if there is a solution existing, you will have a proved solution for your problem, provided you did a careful analysis on your problem. Again, software architecture is a engineering issue, you realy need practice to grasp it.

This book is very good for novice as well as experienced software professional. One can be easily acquinted with various techniques of Software achitecture for his/her project. It emphasizes all the techniques of S/A very well. I just took this book and went through, I found this book very good. Soon I will purchase this book. This is text book in Universities for post grduation course.

This is one of the first books which created the whole field of software architecture. This is a theoretic treatise on the fundamentals of software architecture. From that point of view, this book is timeless. However, if you are an industry practitioner with over 4 years of experience, and are looking for the cutting edge software architecture principles (with applications to J2EE, .NET, SAAS(APEX) etc), then this is definitely not the book for you.

This text is arguably the grandfather of many books that now address software architecture. And, as so sadly happens in the grandfather's generation, it shows some signs of senility.

The primary authors wrote and invited studies in a number of useful formats. After an introduction, the second chapter lays out a few basic styles of software architecture. The next two chapter examine case studies and common examples.

The next chapter (number 5) includes distinctive material: the notion of a design space with clear, orthogonal axes, and with a utility function that applies to each point in that space. They don't make the mistake of taking their quantitation too seriously. The numbers used in the analyses are openly acknowledged to have no physical meaning. Instead, the authors lay out the factors of a subjective analysis in a clear way, creating a rational framework for holding admittedly irrational discussions of "better" and "worse." I applaud this effort. Too many analyses apply no formal reasoning at all and too many mistake numbers for knowledge - this middle way is worth study and adaptation.

Discussion becomes increasingly concrete in the next chapters, not always with good effect. Formal reasoning about programs has been around since the 1970s, in my experience. It's never caught on for about the same reason that quantum mechanics never caught on in designing skyscrapers. Yes, it addresses all the basic phenomena. Even so, very few can wield it competently, and never at the scale of significant industrial constructions.

My most serious objections relate entirely to the book's age. It predates wide acceptance of the UML notations for reasoning about systems, so its many different box-and-arrow diagrams need to be learned from the ground up, separately for each diagram. Ch.7, "Linguistic Issues," has been overtaken by commercial languages like C# and Java, and was behind the cutting edge even when it was written. Static configuration and heterogeneity (p.158) are no longer the dealbreakers they were in the link-and-load world (though I admit that world still exists). Interface abstractions have moved way past dot-h files and into the development environment - ideas floating around the Ada world and elsewhere since the 1980s. Even their way-out-there discussion of "implicit invocation" (p.172) could credibly be subsumed under today's aspect oriented programming. And, because they skip the idioms of the Patterns community, the authors lack good ways to unify and contrast their studies of architectural basics.

I do not fault a book for being a product of its time, and this one is a remarkable product of a time gone by. I do evaluate a book according to its relevance to practitioners of the moment, and this book's moment has largely passed. It offers good service to people exploring basic issues in developing large systems, but says little to to poor slob meeting the next deadline, or the deadline after.

//wiredweird

This book is often cited as one of the seminal references on software architecture. The first chapter explains how software architecture fits into the developing field of software engineering. The second chapter illustrates common architectural styles such as pipes and filters, object-oriented organization, event-based invocation, layered systems, repositories, interpreters, process control, distributed process, main program/subroutine, blackboard, and state transition. Case studies are used to compare and contrast the selection of different architectural solutions. The case studies are key word in context, instrumentation software, mobile robotics, cruise control, three vignettes using mixed styles, and shared information systems. The final half of the book is focused on academic research such as quantified design space, formal models, formal specifications, Z notation, connector models, automated case tools, Wright Model of architectural description, and education of software architects.

I had very high hopes for this book, but they were all dashed. The first two chapters Introdution and Architectural Styles were a good overview of Software Architecture in general and some of the major architectural styles such as "pipe and filter" which is used in systems such as Microsoft SQL Server 7.0 DTS. Although it was great to read about the different styles, they were treated trivially--not in-depth. The rest of the book has very basic case studies that may be good for a Software Architecture 101 course in junior college--not Carnegie Mellon. I would have loved to have found some more "real world" case studies with UML (which this book does not address).

A great book on basic architectural patterns. The authors did a fine job of codifying the essence of architecture you have probably seen in practice (much like Gamma, et al did with design patterns. Great for telling your clueless boss what architecture is.