Refactoring at Scale - Helion

ebook

Autor: Maude Lemaire
ISBN: 978-14-920-7548-6
stron: 246, Format: ebook
Data wydania: 2020-10-13
Księgarnia: Helion

Cena książki: 186,15 zł (poprzednio: 216,45 zł)
Oszczędzasz: 14% (-30,30 zł)

Osoby, które kupiły tę książkę, wybierały także »

Making significant changes to large, complex codebases is a daunting task--one that's nearly impossible to do successfully unless you have the right team, tools, and mindset. If your application is in need of a substantial overhaul and you're unsure how to go about implementing those changes in a sustainable way, then this book is for you.

Software engineer Maude Lemaire walks you through the entire refactoring process from start to finish. You'll learn from her experience driving performance and refactoring efforts at Slack during a period of critical growth, including two case studies illustrating the impact these techniques can have in the real world. This book will help you achieve a newfound ability to productively introduce important changes in your codebase.

Understand how code degrades and why some degradation is inevitable
Quantify and qualify the state of your codebase before refactoring
Draft a well-scoped execution plan with strategic milestones
Win support from engineering leadership
Build and coordinate a team best suited for the project
Communicate effectively inside and outside your team
Adopt best practices for successfully executing the refactor

Osoby które kupowały "Refactoring at Scale", wybierały także:

Windows Media Center. Domowe centrum rozrywki 66,67 zł, (8,00 zł -88%)
Ruby on Rails. Ćwiczenia 18,75 zł, (3,00 zł -84%)
DevOps w praktyce. Kurs video. Jenkins, Ansible, Terraform i Docker 190,00 zł, (39,90 zł -79%)
Przywództwo w świecie VUCA. Jak być skutecznym liderem w niepewnym środowisku 58,64 zł, (12,90 zł -78%)
Scrum. O zwinnym zarządzaniu projektami. Wydanie II rozszerzone 58,64 zł, (12,90 zł -78%)

Spis treści

Refactoring at Scale eBook -- spis treści

Preface
- Who Should Read This Book
- Why I Wrote This Book
- Navigating This Book
- Conventions Used in This Book
- Using Code Examples
- OReilly Online Learning
- How to Contact Us
- Acknowledgments
I. Introduction
1. Refactoring
- What Is Refactoring?
- What Is Refactoring at Scale?
- Why Should You Care About Refactoring?
- Benefits of Refactoring
  - Developer Productivity
  - Identifying Bugs
- Risks of Refactoring
  - Serious Regressions
  - Unearthing Dormant Bugs
  - Scope Creep
  - Unnecessary Complexity
- When to Refactor
  - Small Scope
  - Code Complexity Actively Hinders Development
  - Shift in Product Requirements
  - Performance
  - Using a New Technology
- When Not to Refactor
  - For Fun or Out of Boredom
  - Because You Happened to Be Passing By
  - To Making Code More Extendable
  - When You Dont Have Time
- Our First Refactoring Example
  - Simplifying Conditionals
  - Extracting Magic Numbers
  - Extracting Self-Contained Logic
2. How Code Degrades
- Why Understanding Code Degradation Matters
- Requirement Shifts
  - Scalability
  - Accessibility
  - Device Compatibility
  - Environmental Changes
  - External Dependencies
  - Unused Code
  - Changes in Product Requirements
- Tech Debt
  - Working Around Technology Choices
  - Persistent Lack of Organization
  - Moving Too Quickly
- Applying Our Knowledge
II. Planning
3. Measuring Our Starting State
- Why Is Measuring the Impact of a Refactor Difficult?
- Measuring Code Complexity
  - Halstead Metrics
  - Cyclomatic Complexity
  - NPath Complexity
  - Lines of Code
- Test Coverage Metrics
- Documentation
  - Formal Documentation
  - Informal Documentation
- Version Control
  - Commit Messages
  - Commits in Aggregate
- Reputation
- Building a Complete Picture
4. Drafting a Plan
- Defining Your End State
  - On the Road
  - At Work
- Mapping the Shortest Distance
  - On the Road
  - At Work
- Identifying Strategic Intermediate Milestones
  - On the Road
  - At Work
    - 1. Does this step feel attainable in a reasonable period?
    - 2. Is this step valuable on its own?
    - 3. If something comes up, could we stop at this step and pick it back up easily later?
- Choosing a Rollout Strategy
  - Dark Mode/Light Mode
  - Smart DNAs Rollout
- Cleaning Up Artifacts
- Referencing Metrics in Your Plan
  - Interpolating Goal Metrics to Intermediate Milestones
  - Distinct Milestone Metrics
- Estimating
- Sharing Your Plan with Other Teams
  - Transparency
  - Perspective
- Refined Plan
5. Getting Buy-In
- Why Your Manager Is Not Onboard
  - Managers Arent Coding
  - Managers Are Evaluated Differently
  - Managers See the Risk
  - Managers Need to Coordinate
- Strategies for Making a Compelling Argument
  - Using Conversational Devices
    - Compliment their thought process
    - Present the counter-argument
  - Building an Alignment Sandwich
    - Rallying your teammates
    - Skip-level
    - Departments
    - Tapping into influential engineers
  - Relying on Evidence
  - Playing Hardball
    - Stop doing unrewarded maintenance work
    - Giving an ultimatum
- Buy-In Shapes the Refactor
6. Building the Right Team
- Identifying Different Kinds of Experts
- Matchmaking
  - Experts of Many Trades
  - Revisiting Active Contributors
  - Biases in Our Expert List
- Types of Refactoring Teams
  - Owners
    - Option 1: One team migrates all tests
    - Option 2: Teams update their own tests
    - Striking a balance
  - Proposed Approach
  - Cleanup Crews
- The Pitch
  - Metrics
  - Generosity
  - Opportunity
  - Bartering
  - Repeat
- A Few Outcomes
  - Realistic Scenario
  - Worst-Case Scenario
- Fostering Strong Teams
III. Execution
7. Communication
- Within Your Team
  - Stand-Ups
  - Weekly Syncs
  - Retrospectives
- Outside Your Team
  - When Kicking Off the Project
    - Choosing a single source of truth
    - Setting expectations
  - During Project Execution
    - Progress announcements
    - Execution plan
    - Seeking feeback from senior engineers
- Always Iterate
8. Strategies for Execution
- Team Building
  - Pair Programming
  - Keeping Everyone Motivated
    - Motivating individuals
    - Motivating teams
- Keeping a Tally
  - Intermediate Metric Measurements
  - Unearthed Bugs
  - Clean-Up Items
  - Out-of-Scope Items
- Programming Productively
  - Prototyping
  - Keep Things Small
  - Test, Test, Test
  - Asking the Stupid Question
- Conclusion
9. Making the Refactor Stick
- Fostering Adoption
- Education
  - Active Education
    - Workshops
    - Office hours
    - Engineering gatherings
  - Passive Education
- Reinforcement
  - Progressive Linting
  - Code Analysis Tools
  - Gates Versus Guardrails
- Integrating Improvement into the Culture
IV. Case Studies
10. Case Study: Redundant Database Schemas
- Slack 101
- Slack Architecture 101
- Scalability Problems
  - Booting Up the Slack Client
  - File Visibility
  - Mentions
- Consolidating the Tables
  - Gathering the Scattered Queries
  - Developing a Migration Strategy
  - Quantifying Our Progress
  - Attempting to Keep the Team Motivated
  - Communicating Our Progress
- Tidying Up
- Lessons Learned
  - Develop a Well-Defined, Well-Communicated Plan
- Understand the Codes History
  - Ensure Adequate Test Coverage
  - Keep Your Team Motivated
  - Focus on Strategic Milestones
  - Identify and Rely on Meaningful Metrics
- Takeaways
11. Case Study: Migrating to a New Database
- Workspace-Sharded Data
- Migrating channels_members to Vitess
  - Sharding Scheme
  - Developing a New Schema
    - User-sharded membership table
    - Channel-sharded table schema
- Detangling JOINs
- A Difficult Rollout
  - Backfill Mode
  - Dark Mode
    - Performance
    - Data discrepancies
  - Light Mode
  - Sunset Mode
- Tidying Up
- Lessons Learned
  - Set Realistic Estimates
  - Source the Teammates You Need
  - Plan Scope Carefully
  - Choose a Single Place for Project Communication
  - Design a Thoughtful Rollout Plan
- Takeaways
Index