Agile Technical Practices Distilled: A learning journey in technical practices and principles of software design
- Length: 442 pages
- Edition: 1
- Language: English
- Publisher: Packt Publishing
- Publication Date: 2019-06-28
- ISBN-10: 1838980849
- ISBN-13: 9781838980849
- Sales Rank: #2426852 (See Top 100 Books)
Delve deep into the various technical practices, principles, and values of Agile.
Key Features
- Discover the essence of Agile software development and the key principles of software design
- Explore the fundamental practices of Agile working, including test-driven development (TDD), refactoring, pair programming, and continuous integration
- Learn and apply the four elements of simple design
Book Description
The number of popular technical practices has grown exponentially in the last few years. Learning the common fundamental software development practices can help you become a better programmer. This book uses the term Agile as a wide umbrella and covers Agile principles and practices, as well as most methodologies associated with it.
You’ll begin by discovering how driver-navigator, chess clock, and other techniques used in the pair programming approach introduce discipline while writing code. You’ll then learn to safely change the design of your code using refactoring. While learning these techniques, you’ll also explore various best practices to write efficient tests. The concluding chapters of the book delve deep into the SOLID principles – the five design principles that you can use to make your software more understandable, flexible and maintainable.
By the end of the book, you will have discovered new ideas for improving your software design skills, the relationship within your team, and the way your business works.
What you will learn
- Learn the red, green, refactor cycle of classic TDD and practice the best habits such as the rule of 3, triangulation, object calisthenics, and more
- Refactor using parallel change and improve legacy code with characterization tests, approval tests, and Golden Master
- Use code smells as feedback to improve your design
- Learn the double cycle of ATDD and the outside-in mindset using mocks and stubs correctly in your tests
- Understand how Coupling, Cohesion, Connascence, SOLID principles, and code smells are all related
- Improve the understanding of your business domain using BDD and other principles for “doing the right thing, not only the thing right”
Who this book is for
This book is designed for software developers looking to improve their technical practices. Software coaches may also find it helpful as a teaching reference manual. This is not a beginner’s book on how to program. You must be comfortable with at least one programming language and must be able to write unit tests using any unit testing framework.
Table of Contents
- Pair Programming
- Classic TDD I – Test-Driven Development
- Classic TDD II
- Classic TDD III – Transformation Priority Premise
- Design I – Object Calisthenics
- Design II – Refactoring
- Design III – Code Smells
- Test Doubles
- Testing Legacy Code
- Design Patterns
- Cohesion and Coupling
- Solid Principles ++
- Design VII – Connascence
- The Four Elements of Simple Design
- Conclusion
- Outside-In Development
- Behavior-Driven Development
- Understand the Business
- The Story of Team C
- Conclusion
- The 12 Agile Principles
- PopcornFlow by Claudio Perrone
- EventStorming by Alberto Brandolini
- License: CyberDojo
- Sample Solutions
Cover FM Copyright Table of Contents Preface First Steps Chapter 1: Pair Programming What is Pair Programming? Roles Driver/Navigator Switch Techniques Chess Clock Ping Pong/Popcorn Breaks Pomodoro Katas When Should I Move to the Next Lesson? Resources Web Chapter 2: Classic TDD I – Test-Driven Development Classic TDD The Three Laws of TDD 1. You Are Not Allowed to Write Any More of a Unit Test That Is Sufficient to Fail, and Compilation Failures Are Failures 2. You Are Not Allowed to Write Any Production Code Unless It Is to Make a Failing Unit Test Pass 3. You Are Not Allowed to Write Any More Production Code That Is Sufficient to Pass the One Failing Unit Test Refactoring and the Rule of Three – Baby Steps Three Methods of Moving Forward in TDD From Red to Green Degrees of Freedom Naming Tests A Test Name Pattern Katas Fizz Buzz by cyber-dojo Fizz Buzz Kata Summary More Katas Leap Year by cyber-dojo Nth Fibonacci by cyber-dojo Great Habits Considerations when Writing a New Test Considerations When Making a Failing Test Pass Considerations After the Test Passes Classic TDD Flow Where are We in the Big Picture of Object-Oriented (OO) Software Design? When Should I Move to the Next Lesson? Resources Web Books Chapter 3: Classic TDD II Writing the Assertion First and Working Backward Organizing Your Test in Arrange, Act, and Assert Blocks Benefits of Organizing Tests in Arrange, Act, and Assert Blocks Unit Test Principles Katas Stats Calculator by cyber-dojo Anagrams by cyber-dojo Great Habits Considerations when Writing a New Test Considerations when Making a Failing Test Pass Considerations after the Test Passes Classic TDD Flow Where are we in the Big Picture of Object-Oriented (OO) Software Design? When Should I Move to the Next Lesson? Resources Web Books Chapter 4: Classic TDD III – Transformation Priority Premise Kata Roman Numerals by cyber-dojo TPP – Defining Obvious Implementation TPP Table The Transformations Transformation 1 – {} -> Nil Transformation 2 – Nil -> Constant Transformation 3 – Constant -> Constant+ Transformation 4 – Constant -> Scalar Transformation 5 – Statement -> Statements Transformation 6 – Unconditional -> Conditional Transformation 7 – Scalar -> Array Transformation 8 – Array -> Container Transformation 9 – Statement -> Tail Recursion Transformation 10 – If -> Loop Transformation 11 – Statement -> Recursion Transformation 12 – Expression -> Function Transformation 13 – Variable -> Mutation Example Using the TPP on the Fibonacci Sequence Katas Roman Numerals by cyber-dojo Prime Factors by cyber-dojo Boolean Calculator by Alessandro Di Gioia Great Habits Considerations when Writing a New Test Considerations when Making a Failing Test Pass Considerations after the Test Passes Classic TDD flow Where are We in the Big Picture of Object-Oriented (OO) Software Design? When Should I Move to the Next Lesson? Resources Web Chapter 5: Design 1 – Object Calisthenics It's the Design... Kata Tic-Tac-Toe Object Calisthenics – 10 Steps to Better Software Design Only One Level of Indentation per Method Don't Use the ELSE Keyword Wrap All Primitives and Strings First-Class Collections No Getters/Setters/Properties Wrap All Primitives and Strings One Dot per Line Don't Abbreviate Keep All Entities Small No Classes with More Than Two Instance Variables All Classes Must Have State Heuristics Katas Tic-Tac-Toe Game of Life Great Habits Considerations When Writing a New Test Considerations When Making a Failing Test Pass Considerations after the Test Passes Classic TDD flow Where Are We in the Big Picture of OO Software Design? When Should I Move on to the Next Lesson? Resources Web Walking Chapter 6: Design 2 – Refactoring When to Refactor (For Now) Main Refactors IDE Agility (Know Your Shortcuts) Kata Refactoring Golf Refactor 80-20 Rule Refactoring Guidelines Stay in the Green While Refactoring Commit as Often as Possible Refactor Readability before Design Change Design (Simple Changes) Kata Tennis Refactoring by Emily Bache Parallel Change (Or Expand, Migrate, and Contract) Expand Migrate Contract Kata Parallel Change Kata by Pawel Duda and Carlos Blé Great Habits Considerations When Writing a New Test Considerations When Making a Failing Test Pass Considerations after the Test Passes When Should I Move on to the Next Lesson? Resources Web Books Chapter 7: Design 3 – Code Smells Design Smells Code Smells Bloaters Couplers Object-Orientation Abusers Change Preventers Dispensables Highlighted Code Smells Code Smells Hierarchy Primitive Obsession Feature Envy Message Chains Object Calisthenics Preventing Code Smells When to Refactor (Extended for Code Smells) Refactor Code Smells Kata Smelly Tic-Tac-Toe Great Habits Considerations When Writing a New Test Considerations When Making a Failing Test Pass Considerations After the Test Passes Classic TDD Flow The Big Picture When Should I Move on to the Next Lesson? Resources Web Books Chapter 8: Test Doubles Principles Command-Query Separation Queries Commands Different Types of Test Doubles Dummy Objects Stubs Fake Objects Mocks Spies Test Doubles Guidelines Only Use Test Doubles for Classes That You Own Verify as Little as Possible in a Test Don't Use Test Doubles for Isolated Objects Don't Add Behavior in Test Doubles Only Use Test Doubles for Your Immediate Neighbors Too Many Test Doubles CQS Principle Trade-OffS Katas Character Copier by Urs Enzler Instrument Processor by Urs Enzler Great Habits Considerations When Writing a New Test Considerations When Making a Failing Test Pass Considerations after the Test Passes When Should I Move on to the Next Lesson? Resources Web Books Chapter 9: Testing Legacy Code Breaking Dependencies Using a Seam Using Inheritance to Decouple Production Code Characterization Tests Kata Characterization Tests on Gilded Rose Kata by Emily Bache Golden Master Feasibility Generate Input/Output (Golden Master) Assert Kata Golden Master on Gilded Rose Kata by Emily Bache Approval Tests by Llewellyn Falco Combination Tests Revisiting the Refactoring Guidelines Stay in the Green while Refactoring Kata Gilded Rose Refactoring Kata by Emily Bache Conclusions Guideline Questions Great Habits Considerations when Writing a New Test Considerations when Making a Failing Test Pass Considerations after the Test Passes When Should I Move to the Next Lesson? Resources Web Books Chapter 10: Design IV –Design Patterns Design Pattern Advantages Design Pattern Pitfalls A Quick Reference Catalogue Creational Design Patterns Behavioral Design Patterns Structural Design Patterns Revisiting the Refactoring Guidelines Refactoring Design Kata Refactoring Game of Life Kata to Patterns Great Habits Considerations When Writing a New Test Considerations When Making a Failing Test Pass Considerations After the Test Passes When Should I Move to the Next Lesson? Resources Web Books Running Chapter 11: Design V – Cohesion and Coupling Coupling Types of Coupling Interaction Coupling Law of Demeter Method Coupling Premises Inheritance Coupling Cohesion Other Indicators of Possible Low Cohesion in Design Types of Cohesion Class Cohesion Method Cohesion Katas Connecting Code Smells with Cohesion/Coupling Connecting Object Calisthenics with Code Smells and Cohesion/Coupling When to Refactor (Extended for Cohesion/Coupling) Classic TDD Flow The Big Picture When Should I Move to the Next Lesson? Resources Web Books Chapter 12: Design VI – Solid Principles ++ Single Responsibility Principle Open/Closed Principle Liskov Substitution Principle Interface Segregation Principle Dependency Inversion Principle Balanced Abstraction Principle Principle of Least Astonishment Kata Connecting Cohesion/Coupling and SOLID principles When to Refactor (Extended for SOLID Principles) Classic TDD Flow The Big Picture When Should I Move to the Next Lesson? Resources Web Books Chapter 13: Design VII – Connascence Definition Dimensions Degree Locality Strength Connascence of Name and Type (CoN and CoT) Connascence of Position Connascence of Value (CoV) Connascence of Meaning Connascence of Algorithm Connascence of Execution Order Connascence of Timing Connascence of Identity Connascence of Manual Task Classic TDD Flow The Big Picture When Should I Move to the Next Lesson? Resources Web Books Chapter 14: Design VIII –The Four Elementsof Simple Design What Are the Four Elements of Simple Design? What Does Each Element Mean? Passes Its Tests Minimizes Duplication Maximizes Clarity Has Fewer Elements Alternative Definitions of Simple Design Definition Definition Definition Definition Definition Definition Our Personal Definitions of Simple Design Pedro Marco Alessandro Kata Elevator Kata by Marco Consolaro Classic TDD Flow The Big Picture When Should I Move to the Next Lesson? Resources Web Books Chapter 15: Conclusion Cohesion and Coupling as Forces The 3 Cs of Design: From Cohesion and Coupling to Connascence Systems Entropy The Relevance of Systems Entropy Software Development as System Building Good Design as a Low-Entropy System The Big Picture Resources Web-based resources: Books: Flying Chapter 16: Outside-In Development The Classic TDD Approach Acceptance Tests Acceptance Test Styles Test Boundaries Double Loop TDD The Outside-In Approach An Outside-In Mindset Outside-In TDD: The London School Example The Direction of Dependencies Should I Use Classic TDD or Outside-In TDD? Kata Stock Portfolio Katacombs of Shoreditch by Marco Consolaro Part I PART II The Big Picture Great Habits Considerations When Writing a New Test Considerations When Making a Failing Test Pass Considerations After the Test Has Passed Resources Web-based resources: Books: Chapter 17: Behavior-Driven Development Poka-Yoke Mistakes versus Defects: Feedback Is the Cure (Again) Bugs and Communication User Stories Behavior-Driven Development The Structure of a Story Acceptance Criteria: It's All about the Examples From Criteria to Acceptance Tests Acceptance Tests Done Right Readable by Business Folks Feature Complete Fast Boundaries The Walking Skeleton Kata The Messy Delivery Office Requirements Resources Web-based resources Books Chapter 18: Understand the Business Knowledge versus Understanding Theory of Constraints Domain-Driven Design: What Domain? Beyond Requirements: Knowledge Crunching 5 Whys Impact Mapping PopcornFlow User Story Mapping EventStorming Business Model Canvas Value Streams and Domain Events Bounded Contexts and Communication Synchronous versus Asynchronous Command-Query Separation Business and DevOps The First Way The Second Way The Third Way Systems Thinking and Sociotechnical Organizations Resources Web-based resources Books Chapter 19: Story of Team C Terraforming Team Building The Backlog: Crunching Knowledge for Breakfast Cracking On From Forming to Performing Outside-In ATDD with Optional Unit Tests The Green Flag The Moral of the Story Chapter 20: Conclusion The Human Factor Team Play Bounded Rationality and Knowledge Sharing Resources Web Books Chapter 21: The 12 Agile Principles Chapter 22: PopcornFlow by Claudio Perrone The 7-Steps Decision Cycle The Principles Who Can Benefit from PopcornFlow Resources Web-based resources: Books: Chapter 23: EventStorming by Alberto Brandolini Silos and Value Streams The Importance of Learning The EventStorming Approach The Workshop: A Quick Overview Different Flavors of EventStorming Complex Systems and Proven Solutions Resources Web Books License: CyberDojo About CyberDojo Foundation Exercises Web Resources Sample Solutions Sample Solutions: FizzBuzz in Clojure Sample Solutions: Fibonacci Sequence in C++ Sample Solutions: Roman Numerals in C Sample Solutions: Tic-Tac-Toe in Swift (Partial Solution) Sample Solutions: Connecting Code Smells with Cohesion/Coupling Sample Solutions: Connecting Object Calisthenics with Code Smells and Cohesion/Coupling Sample Solutions: Connecting Cohesion/Coupling and SOLID Principles Feedback Personalized Coaching Individuals Organizations Feedback Please Index
Donate to keep this site alive
How to download source code?
1. Go to: https://github.com/PacktPublishing
2. In the Find a repository… box, search the book title: Agile Technical Practices Distilled: A learning journey in technical practices and principles of software design
, sometime you may not get the results, please search the main title.
3. Click the book title in the search results.
3. Click Code to download.
1. Disable the AdBlock plugin. Otherwise, you may not get any links.
2. Solve the CAPTCHA.
3. Click download link.
4. Lead to download server to download.