Agile software development. The best principles, patterns and practices - Robert C. Martin

Table of contents

Foreword (13)

Foreword (14)

About the authors (20)

PART I. AGILE SOFTWARE DEVELOPMENT (21)

Chapter 1 Agile practices (23)

• Agile Alliance (24)
  • Agile Alliance Manifesto (24)
• Principles (27)
• Conclusion (29)
• Bibliography (29)

Chapter 2 Overview of information on extreme programming (31)

• Extreme programming practices (31)
  • The client is a team member (32)
  • User stories (32)
  • Short cycles (32)
  • Acceptance tests (33)
  • Pair programming (33)
  • Test-driven programming (34)
  • Joint ownership (34)
  • Continuous integration (34)
  • Even pace (35)
  • Open workspace (35)
  • Planning game (35)
  • Simple design (36)
  • Refactorisation (37)
  • Metaphor (37)
• Conclusion (38)
• Bibliography (38)

Chapter 3 Planning (39)

• Initial exploration (40)
  • Prototyping, sharing and speed (40)
• Planning distribution versions (41)
• Iteration planning (41)
• Task planning (41)
  • Halfway point (42)
• Iteration course (42)
• Conclusion (43)
• Bibliography (43)

Chapter 4 Testing (45)

• Test-driven programming (45)
  • Example of a "test first" style project (46)
  • Insulation of the test (47)
  • Unexpected elimination of couplings (48)
• Acceptance tests (49)
  • Example of acceptance tests (50)
  • Architecture "by the way" (51)
• Conclusion (51)
• Bibliography (52)

Chapter 5 Refaction (53)

• Generating prime numbers - a simple example of refactorization (54)
  • Final review (59)
• Conclusion (62)
• Bibliography (63)

Chapter 6 Programming episode (65)

• Bowling (66)
• Conclusion (98)

PART II. AGILE PROJECT (101)

• Symptoms of bad design (101)
• Principles (101)
• Fragrances and principles (102)
• Bibliography (102)

Chapter 7. What is an agile project? (103)

• What's wrong with software? (103)
• Smells of the project - smell of perishable software (104)
  • What stimulates software to break down? (106)
  • Agile units do not allow software to break down (106)
• Copy Programme (106)
  • Example of a Copy program made according to agile methodology (109)
  • How did the agile developers know what to do? (110)
• Maintaining the project at its best (110)
• Conclusion (111)
• Bibliography (111)

Chapter 8 SRP - single liability principle (113)

• SRP - single responsibility principle (113)
  • What is responsibility? (115)
  • Separation of combined liability (115)
  • Durability (116)
• Conclusion (116)
• Bibliography (116)

Chapter 9 OCP - open-ended principle (117)

• OCP - open-ended principle (117)
• Description (118)
• The key is abstraction (118)
• Shape application (119)
  • Infringement of the principle of OCP (120)
  • Compliance with the OCP principle (121)
  • I admit it. I lied. (122)
  • Prediction and "natural" structure (122)
  • Placing "hooks" (123)
  • Use of abstraction to obtain a clear closure (124)
  • Application of the "data control" approach to achieve closures (125)
• Conclusion (126)
• Bibliography (126)

Chapter 10 LSP - substitution principle Liskov (127)

• LSP - substitution principle Liskov (127)
• Simple example of a breach of the LSP principle (128)
• Quadrants and rectangles - more subtle violation of the LSP rule (129)
  • A real problem (131)
  • The correctness is not congenital (132)
  • The IS-A relationship relates to behaviour (132)
  • Design by contract (132)
  • Specification of contracts in unit tests (133)
• A real example (133)
  • Motivation (133)
  • Problem (135)
  • Non-LSP (136)
  • LSP principle compliant solution (136)
• Secretion instead of inheritance (137)
• Heuristics and conventions (139)
  • Degenerate functions in derived classes (140)
  • Notification of exceptions from derived classes (140)
• Conclusion (140)
• Bibliography (140)

Chapter 11 DIP - the principle of reversion (141)

• DIP - reversal principle (141)
• Breakdown into layers (142)
  • Reversal of ownership (142)
  • Dependence on abstraction (143)
• Simple example (144)
  • Searching for needed abstractions (145)
• Example of the Furnace programme (146)
  • Dynamic and static polymorphism (147)
• Conclusion (148)
• Bibliography (148)

Chapter 12 PSI - Interface segregation principle (149)

• Interface littering (149)
• Separate clients means separate interfaces (150)
  • Power of customer influence on interfaces (151)
• ISP - interface segregation principle (151)
• Class and object interfaces (152)
  • Separation by delegation (152)
  • Separation by multiple inheritance (153)
• Example of an ATM user interface (153)
  • Polydes and monads (158)
• Conclusion (159)
• Bibliography (159)

PART III. CASE STUDY: PAYROLL SYSTEM (161)

• Remaining specification of the payroll system (162)
• Exercise (162)
• Use case 1: adding a new employee (162)
• Case of use No. 2: removal of a worker (163)
• Case of use 3: delivery of the work card (163)
• Case of use no. 4: delivery of sales report (163)
• Case of use No 5: provision of information on the fee for a trade union (164)
• Case of use 6: change of employee data (164)
• Use case no. 7: payroll generation per day (164)

Chapter 13 Design templates Command and Active Object (165)

• Simple instructions (166)
• Transactions (167)
  • Physical and temporal code division (168)
  • Temporary code division (168)
• Undo method (169)
• Active facility (169)
• Conclusion (173)
• Bibliography (173)

Chapter 14 Template method and Strategy: succession and delegation (175)

• Template method (176)
  • Misuse of the template (178)
  • Bubble sorting (179)
• Strategy (181)
  • Sorting again (183)
• Conclusion (185)
• Bibliography (185)

Chapter 15 Design Patterns Facade and Mediator (187)

• Facade (187)
• Mediator (188)
• Conclusion (190)
• Bibliography (190)

Chapter 16 Singleton and Monostate design models (191)

• Singleton (192)
  • Benefits of using the Singleton standard (193)
  • Costs of using the Singleton template (193)
  • Singleton Design Pattern in Practice (193)
• Monostate (194)
  • Benefits of using the Monostate standard (196)
  • Costs of using the Monostate template (196)
  • Monostate Design Pattern in Practice (196)
• Conclusion (200)
• Bibliography (200)

Chapter 17 Null Object design template (201)

• Conclusion (204)
• Bibliography (204)

Chapter 18. Case study: payroll system. First iteration (205)

• Introduction (205)
  • Specification (206)
• Analysis by use cases (206)
• Adding staff (207)
• Dismissal of employees (208)
• Delivery of the work card (209)
• Provision of sales reports (209)
• Provision of information on the fee payable to the trade union (210)
• Change in employee data (210)
• Payments (212)

• Reflection: what have we learned? (214)
• Searching for needed abstractions (214)
  • Abstract from the schedule (214)
  • Payment methods (215)
  • Membership of trade unions (216)
• Application (216)
• Bibliography (216)

Chapter 19. Case study: payroll system. Implementation (217)

• Adding staff (218)
  • Payroll system database (219)
  • Template application Template method for adding employees (220)
• Dismissal of staff (223)
  • Global variables (225)
• Work cards, sales reports and premiums (225)
• Change in employee data (231)
  • Reclassification (235)
  • What did I smoke? (240)
• Payment execution (244)
  • Do we want developers to make business decisions? (246)
  • Implementation of payments to employees with fixed salaries (246)
  • Execution of payments for hourly employees (248)
  • Settlement periods: project problem (251)
• Main programme (257)
• Database (257)
• Summary of the payroll system project (258)
  • History (259)
  • Resources (259)
• Bibliography (259)

PART IV. BREAKDOWN OF THE PAYROLL SYSTEM INTO BUNDLES (261)

Chapter 20 Package design rules (263)

• Designing with packages? (263)
• Grain size: principles of package consistency (264)
  • Principle of equivalence of multiple code use and distribution (REP) (264)
  • The Reusable Collective Reusable Collection Rule (CRP) (265)
  • Collective closing (CCP) rule (266)
  • Summary of the subject of package coherence (266)
• Stability: coupling rules for packages (267)
  • Acyclical Dependency Principle (ADP) (267)
  • Weekly compilations (267)
  • Eliminating dependency cycles (268)
  • Effects of the existence of cycles in the graph of dependencies between packages (269)
  • Cycle interruption (270)
  • Deviations (270)
• Up-to-Down Project (271)
• The principle of stable dependency (SDP) (272)
  • Stability (272)
  • Stability metrics (273)
  • Not all packages need to be stable (274)
  • Where should the implementation of a high-level project be located? (276)
• Stable abstractions principle (SAP) (276)
  • Measurement of abstraction (276)
  • Main thrust (277)
  • Distance from main line (278)
• Conclusion (280)

Chapter 21 Factory design template (281)

• Cycle of dependencies (283)
• Exchangeable factories (284)
• Using the Factory Standard to create test sets (284)
• The importance of using factories (286)
• Conclusion (287)
• Bibliography (287)

Chapter 22. Case study: payroll system (part 2.) (289)

• Package structure and notation (290)
• Application of the collective closure rule (CCP) (291)
• Application of the principle of equivalence of multiple code use and distribution (REP) (292)
• Couplings and airtightness (294)
• Metrics (296)
• Application of indicators to payroll application (297)
  • Factories of facilities (300)
  • Facility Factory for TransactionImplementation (300)
  • Factory initiation (301)
  • Rebuilding the boundaries of cohesion (301)
• Final package structure (302)
• Conclusion (304)
• Bibliography (304)

PART V. CASE STUDY: WEATHER STATION (305)

Chapter 23 Composite design template (307)

• Example: composite commands (308)
• Multiple or no multiple (309)

Chapter 24 Observer - evolution of code to pattern (311)

• Digital clock (311)
• Conclusion (326)
  • Use of diagrams in this chapter (327)
• Design standard Observer (327)
  • Management of object-oriented design rules for the design template Observer (328)
• Bibliography (329)

Chapter 25 Design patterns Abstract server and bridge (331)

• Design standard Abstract server (332)
  • Who owns the interface? (333)
• Design standard Adapter (333)
  • Design standard Adapter in class form (334)
  • The modem problem. Adapters and LSP principle (334)
• Bridge design template (338)
• Conclusion (339)
• Bibliography (340)

Chapter 26 Design Patterns Plenipotentiary and Stairs to Heaven - management of external APIs (341)

• Design specimen Proxy (342)
  • Implementation of the design template Plenipotentiary in the shopping basket application (345)
  • Summary of the project template message Plenipotentiary (356)
  • Support for databases, middleware and external APIs (357)
• Stairs to heaven (359)
  • Example of use of the staircase to the sky (360)
• Conclusion (365)
• Other design patterns that can be used with databases (365)
• Conclusion (366)
• Bibliography (366)

Chapter 27. Case study: weather station (367)

• Cloud Company (367)
  • WMS-LC software (369)
  • Language selection (369)
• Nimbus-LC system software design (369)
  • 24-hour history and fixation (382)
  • Implementation of HiLo algorithms (384)
• Conclusion (391)
• Bibliography (391)
• Overview of requirements for Nimbus-LC software (391)
  • Performance requirements (391)
  • 24-hour history (392)
  • User configuration (392)
  • Administrative requirements (392)
• Cases of use of Nimbus-LC system (393)
  • Actors (393)
  • Cases of use (393)
  • History of measurements (393)
  • Configuration (393)
  • Administration (393)
• Publication plan for Nimbus-LC distribution versions (394)
• Introduction (394)
• Edition I (394)
• Hazards (394)
• Project outputs (395)
• Edition II (395)
• Implemented use cases (395)
• Hazards (395)
• Project outputs (395)
• Edition III (396)
• Implemented use cases (396)
• Hazards (396)
• Project outputs (396)

PART VI. CASE STUDY: ETS (397)

Chapter 28 Visitator design template (399)

• Design Pattern Family Visitor (400)
• Visitor (400)
  • Design standard The visitor works like a matrix (403)
• Design standard Acyclical visitor (403)
  • Design standard The visitor works like a rare matrix (407)
  • Use of the Visitor Design Pattern in Report Generators (407)
  • Other applications of the design template Visitor (412)
• Design standard Decorator (413)
  • Many decorators (416)
• Design standard Object of extension (418)
• Conclusion (426)
  • Reminder (426)
• Bibliography (426)

Chapter 29 Design standard State (427)

• Overview of Finite State Automation information (427)
• Implementation techniques (429)
  • Nested Switch/Case instructions (429)
  • Interpretation of transition table (432)
• Design standard State (433)
  • SMC - compiler of state machine (436)
• When should you use state machines? (439)
  • High-level GUI service strategies (439)
  • GUI interaction controllers (440)
  • Distributed processing (441)
• Conclusion (441)
• Listings (441)
  • Implementation of Turnstile.java class using transition table interpretation (441)
  • Turnstile.java class generated by SMC compiler and other auxiliary files (443)
• Bibliography (447)

Chapter 30 ETS Framework (449)

• Introduction (449)
  • Review of project information (449)
  • Early 1993 to 1994 (451)
  • Framework? (451)
• Framework (452)
  • The 1994 team (452)
  • Term (452)
  • Strategy (452)
  • Results (453)
• Project framework (454)
  • Common requirements for assessment applications (454)
  • Draft assessment framework (456)
• Template case Template method (459)
  • Write a loop once (460)
  • Common requirements for the passing application (463)
  • Draft framework for passing (463)
  • Task Manager Architecture (469)
• Conclusion (472)
• Bibliography (472)

Appendix A. UML notation. Part I: Example CGI (473)

• Course registration system: problem description (474)
  • Actors (475)
  • Cases of use (475)
  • Domain model (478)
  • Architecture (482)
  • Abstract classes and interfaces in sequence diagrams (492)
• Summary (494)
• Bibliography (494)

Appendix B. UML notation. Part II: STATMUX (495)

• Definition of the statistical multiplexer (495)
  • Software environment (496)
  • Real time limits (496)
  • Procedures for handling entry interruptions (497)
  • Output interruption handling procedures (501)
  • Communication protocols (502)
• Conclusion (512)
• Bibliography (512)

Appendix C. Satire on two companies (513)

• Rufus! Inc. Project Kickoff (513)
• Rupert Industries Project Alpha (513)

Appendix D. Source code is a project (525)

• What is software design? (525)

Scorch (535)