Software Factories: Assembling Applications with Patterns, Models, Frameworks, and Tools

by Steve Cook, Stuart Kent, Jack Greenfield, et al.

Book Overview

The architects of the Software Factories method provide a detailed look at this faster, less expensive, and more reliable approach to application development. Software Factories significantly increase the level of automation in application development at medium to large companies, applying the time tested pattern of using visual languages to enable rapid assembly and configuration of framework based components.Unlike other approaches to Model Driven...

• Format: Paperback
• Language: English
• ISBN: 0471202843
• ISBN13: 9780471202844
• Release Date: September 2004
• Publisher: John Wiley & Sons
• Length: 666 Pages
• Weight: 2.30 lbs.
• Dimensions: 1.5" x 7.4" x 9.4"

Customer Reviews

Exceptional reasoning on software construction

Wow! I bought this book a long time ago and it lived on my "bibliophile" stack of bought but unread gems. It's a stunning book if you seek to understand the decomposition of complexity in modern software applications and the complex deployment architectures they work in. My only concern is the book is not an engineering book - there are no mathematical models of scale and performance for distributed decompositions. It has a excellent description of aspect oriented programming which I learned from. The authors could also benefit if they discovered the ideas in Carliss Baldwin's superlative "Design Rules" book and brought those ideas into their own discussion of the software construction domain. This is a WONDERFUL book for enterprise architects.

Factories are the future

This book provided insightful coverage of what I think is a fascinating topic. THe author organizes the material in a logical manner making it easy to transition from one topic to another. I would have liked more illustrations, but what was supplied was enough for me to understand everything. Very recommended!

detailed breakdown of product line engineering

This is an awesome book for an overview of the software development industry practices. It includes a detailed breakdown of product line engineering, as well as a ton of other great information. VSTS 2005 missed the mark on Software Architecting Tools, and only includes System Architecting tools. With my own MSDN subscription I opted for the Developer version instead of the Architect version because of this. Microsoft is banking on the Software Architecture Tools of Domain Specific Languages (DSL) instead of UML and Software Factories (which Product Line Engineering is the heart of). This is great except for the fact that to use it properly is going to cause a huge learning curve. Not so much with just DSL, but in applying the industry standards that exist in the architecture world to this new way of architecting. It is going to be hard to move software factories into most development communities. It will be great for engineering firms that take 3 to 5 years between releases, but in the type of environment that needs to consider time to market, software factories are going to be difficult to sell. If you get this book, I suggest not getting to carried away with the software factory part of it. Software Factory information only takes up about 20% of the book. The rest is great material.

The "state of the art" in software engineering

This book in my mind represents the state of the art in software engineering today. The book is based upon the concept of building families of similar, but distinct products, which have been around for years in other engineering disciplines such as civil, mechanical and electronics engineering. These concepts promote the systematic reuse of like components and factored out variable components for customization in order to produce products that were similar but yet each one being unique. This is commonly known as mass customization, something that is very new to the software world, but "old hat" for other industrialized engineering industries. I know Software Factories is an overloaded term, but consider this definition: "a factory is a highly organized production facility that produces members of a product line using standardized parts, tools and production processes." The "factory" term is common in the industrialized engineering world, but extremely uncommon in our un-industrialized software development world. Jack and Keith initially introduce us to dealing with complexity and change, which are the two fundamental problems in designing and constructing quality software of any size. Anyone that has read the Standish Group's CHAOS report understands our incredibly poor track record in dealing with these fundamental problems, regardless of programming languages, platforms or methodologies used. The following chapter on Paradigm Shift assists the reader in understanding these problems as well as the critical innovations that solves these problems. Software Factories goes on to explain their concept of what is a Software Factory within the context of economies of scale and scope. This is the most critical point of the book to understand, "Economies of scale arise in production, while economies of scope arise in development. Economies of scale arise when multiple identical instances of a single design are produced collectively. Economies of scope arise when multiple similar but distinct designs and prototypes are produced collectively rather than individually." This fundamental concept is absolutely key in understanding the how Software Factories pave the road to the industrialization of software. The authors could have spent more time on this subject at it is the most confusing concept for any software or non-software person to understand and represents the barrier to understanding that software development is no different than any other traditional engineering development process. The next 3 chapters delve into Models and Patterns, Programming with Models and Language Anatomy and how these approaches raise the level of abstraction so that models can be used as first class development artifacts. Essentially how Domain Specific Languages (as opposed to general purpose languages) converges the gap between requirements (problem input) and executables (the solution). The following 7 chapters cover in detail the concepts above by discu

Scholarly and sophisticated

The authors present a massive and sophisticated approach to understanding and integrating patterns, models and frameworks into a project. The tone is scholarly, with many references to important previous papers and texts. The book is targeted at developers and senior programmers. Much of it deals with the different levels of abstraction, and how you move between these. So that if you have designed a project using patterns, then this is a high level structure. The book offers aid in migrating this into a framework, which might be considered a reification of the patterns. An extensive survey is also given of various design/modelling tools that are available. These might be open source, proprietary or of the academic research type. One easy thing you can do with this book is to use its analysis of these tools. This is doable without having to wade through most of the rest of the book. The book will not be an easy read to some. A lot of material is covered and a considerable amount is fairly abstract. Without significant prior experience in design and coding, you may miss the full meanings and appreciation of much of the text. It makes a typical computer book look trivial.