- Paperback: 696 pages
- Publisher: Wiley; 1 edition (September 24, 2004)
- Language: English
- ISBN-10: 0471202843
- ISBN-13: 978-0471202844
- Product Dimensions: 7.4 x 1.4 x 9.2 inches
- Shipping Weight: 2.2 pounds
- Average Customer Review: 15 customer reviews
- Amazon Best Sellers Rank: #2,552,320 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Software Factories: Assembling Applications with Patterns, Models, Frameworks, and Tools 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
From the Back Cover
"Software Factories does a wonderful job integrating modeling with patterns, frameworks, and agile development. The authors provide a compelling look at how a new generation of tools will make this a reality. A must read for software architects and developers."
John Crupi, Sun Distinguished Engineer, and coauthor, Core J2EE Patterns
Many of the challenges currently facing software developers are symptoms of problems with software development practices. Software Factories solves these problems by integrating critical innovations that have been proven over the last ten years but have not yet been brought together.
A team of industry experts led by Jack Greenfield explains that a Software Factory is a configuration of languages, patterns, frameworks, and tools that can be used to rapidly and cost-effectively produce an open-ended set of unique variants of a standard product.
Their ground-breaking methodology promises to industrialize software development, first by automating software development within individual organizations, and then by connecting these processes across organizational boundaries to form supply chains that distribute cost and risk. Featuring an example introduced in the first chapter and revisited throughout the book, the authors explain such topics as:
- Chronic problems that object orientation has not been able to overcome, and critical innovations that solve them
- How models can become first class software development artifacts, not just documentation
- How software product lines can be used to consistently achieve commercially significant levels of reuse
- How patterns, frameworks, tools, and other reusable assets can be used to scale up agile development methods
- How orchestration and other adaptive mechanisms can be used to enable development by assembly
About the Author
JACK GREENFIELD (Redmond, WA) is an Architect for Visual Studio Team System. He is an author, frequent speaker, and key contributor to component, model, and pattern technologies at Microsoft.
KEITH SHORT (Redmond, WA) is an Architect for Visual Studio Team System. He is responsible for strategy and architecture for enterprise tools at Microsoft.
STEVE COOK (Canterbury, UK) is an Architect for Visual Studio Team System. He was formerly an IBM Distinguished Engineer and a major contributor to UML and UML2.
STUART KENT (Bishop’s Stortford, UK) is a Program Manager for Visual Studio Team System. He focuses on modeling technology and is an internationally recognized authority on UML.
Author interviews, book reviews, editors picks, and more. Read it now
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
Since the material is strongly consolidated, one would re-read the books several times each time finding something new to perceive. Authors are great guys - I would eagerly read any other book of their authorship.
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.
But..this book is too Microsoft biased. As written by a MSFT emplyee this is kind of expected but the fact is that the guy makes everything to say C#/.Net is the future of Java. This includes saying that JIT compilation was first introduced by .Net, that JavaBeans are a convention that are evolved in C# by delegates and properties and lots of other tries to make people believe that .Net is an evolution of the Java platform. I think this really compromises the book and would be much, much better if it just used C# and forgot all comparisson.
I'd suggest that people intersted in MDA, DSL and new trends read this book but just skip all the Java bashing.
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 discussing Families of Languages, Systematic Reuse, Software Product Lines, Platform-Based Abstractions, Components and Services, Mappings and Transformations, and Generating Implementations. Incredibly well done and I cannot do these chapters justice in this short review.
Chapter 16 demonstrates a concrete example of a Software Factory using all of the concepts, techniques and best practices described previously in the book. Jack and Keith "show how the methodology can be implemented now, that it can be widely used to complement and eventually replace existing practices, and that it can help move the software industry toward maturity." This chapter alone is worth the price of the book.
Finally, a section on Frequently Asked Questions compares Software Factory approach to what we know about software development, before Software Factories. This puts into great perspective the differences between Software Factories and the current state of the art, which is commonly referred to as custom "one-off" software development.
I cannot recommend this book highly enough. As someone who came from the R&D electronics world 20 years ago where I (and the rest of the electronics industry) routinely used product line engineering development practices, I thought when I joined the software world 15 years ago this approach would be the norm. How naïve was I. This book should not only be required reading for anyone practicing software development, but also mandatory reading in every Computer Science program. Then maybe we will see the industrialization of software development become common practice as it currently is in other industrialized engineering disciplines.