- Paperback: 376 pages
- Publisher: Wiley; 1 edition (July 26, 2010)
- Language: English
- ISBN-10: 0470684208
- ISBN-13: 978-0470684207
- Product Dimensions: 7.4 x 0.7 x 9.2 inches
- Shipping Weight: 1.7 pounds (View shipping rates and policies)
- Average Customer Review: 19 customer reviews
- Amazon Best Sellers Rank: #362,236 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.
Lean Architecture: for Agile Software Development 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
"Children of Blood and Bone"
Tomi Adeyemi conjures a stunning world of dark magic and danger in her West African-inspired fantasy debut. Learn more
Frequently bought together
Customers who bought this item also bought
Customers who viewed this item also viewed
'...a book of advice that is broad, enabling, and concrete. (Lean Magazine, January 2010).
From the Back Cover
It's time for change - after 30 years, DCI has risen to complete the vision of object-oriented programming!
Aiming at no less than a paradigm shift, Lean Architecture uses a modern approach to software design, while embracing refreshing new insights of Lean and Agile. Giving a down-to-earth view of Agile requirements and the often-ignored relationship between requirements and architecture, this book goes beyond the fashionable idea of User Stories, and shows you how to employ Use Cases in a lightweight, incremental, Agile way. The authors detail the DCI (Data, Context and Interaction) architecture paradigm and show how DCI succeeds where object-oriented programming languages alone have failed to integrate software design with the end user's understanding of the overall business structure.
However, this is not a methodology book, but a book which focuses on code, with plenty of code examples. Topics covered include: Agile production, Stakeholder Engagement, Organizational issues, Scala/Python/Java implementation of the DCI account example, Qi4J and much more.
Renowned software architecture expert James Coplien and agile requirements expert Gertrud Bjørnvig share their expertise to give you concrete design advice that will help you:
- Create software that builds on your end-user mental models rather than design methodologies
- Write software that can directly be verified against behavioral requirements
- Organize - so that all your stakeholders support each other
- Support rapidly changing feature code in stable domain code to help embrace change
Lean Architecture casts a new light over important aspects of software development that have been marginalized or forgotten by the agile movement – it will help you find your own path.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
The things I liked are very readable font and very good paper quality. Too bad that besides few good insights I didn't find content and especially style of this book interesting. Maybe its just not my kind of book, but thats my opinion.
This is neither a beginner's "how to do it in ten easy lessons" nor is it a design method. It is a book written for the mature professional by two authors whose long experience has given them a deep understanding of what really matters in practical programming.
At a first glance, many methodologies appear as mere fads, but Coplien and Bjørnvig see through the fads and build on their real worth to create a thought-provoking and eminently practical book.
Three random jottings from my first reading:
* Architecture: "No matter how we care to define it, software architecture should support the enterprise value stream even to the extent that the source code itself should reflect the end user's mental model of the world."
* Lean secret: "...unite specialists together in one room: everybody, all together, from early on."
* Form and functionality: "System architecture should reflect the end user's mental model of the world. The model has two parts: The first part relates to the user's thought process when viewing the screen, and to what the system is: its form. The second part relates to what end users do - interacting with the system - and how the system should respond to user input. This is the system functionality. We work with users to elicit and develop these models and to capture them in code as early as possible."
The authors claim that an end user should have a picture in his head that enables him to see the commands that are meaningful in a given situation and to understand what they will do for him. This picture, Jim calls it the end user's mental model, it will be reflected into the actual code in well-built systems.
A few years ago, this reviewer introduced a new programming paradigm that he called Data, Context, and Interaction (DCI). The main feature of this paradigm is that it splits the code into two distinct parts. One part specifies system state; the other part specifies system behavior. Coplien and Bjørnvig use this paradigm to fill in the gap between architecture and code execution. To quote from the book:
* Key building blocks of object-oriented design: "Objects, which are end users' conceptualization of things in their business world; Classes, which provide simple, encapsulated access to the data that represents business information; Roles, which interact in a use case to achieve some business goal."
This book is a MUST read for all who want to understand the true nature of systems development.
A great practical description of how the use case evolves and translates directly into code, of how to reflect the end users mental model in code - making it much more readable for both programmers and domain experts. It goes into detail about how use case roles translates to Object Roles playing out their part of a use case algorithm and how they get injected into the domain objects to use their state. And we are presented with how the Context can set up the mapping of Roles to domain Objects in different flexible ways before firing off the trigger Interaction of the use case.
Apart from example code in C++ and Ruby through out the last chapters of the book, it also have a great appendix with coded DCI examples in Scala, Python, C#, Ruby and Squeak.
For anyone interested I can also recommend visiting the Google "object-composition" group where all the concepts are discussed and explored.