The Missing README

The Missing README

by Dmitriy Ryaboy
Released August 2021
Publisher(s): No Starch Press
ISBN: 9781718501836

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial

Book description

For new software engineers, knowing how to program is only half the battle. You'll quickly find that many of the skills and processes key to your success are not taught in any school or bootcamp. The Missing README fills in that gap -- a distillation of workplace lessons, best practices, and engineering fundamentals that the authors have taught rookie developers at top companies for more than a decade.

Early chapters explain what to expect when you begin your career at a company. The book's middle section expands your technical education, teaching you how to work with existing codebases, address and prevent technical debt, write production-grade software, manage dependencies, test effectively, do code reviews, safely deploy software, design evolvable architectures, and handle incidents when you're on-call. Additional chapters cover planning and interpersonal skills such as Agile planning, working effectively with your manager, and growing to senior levels and beyond.

You'll learn:

•How to use the legacy code change algorithm, and leave code cleaner than you found it

•How to write operable code with logging, metrics, configuration, and defensive programming

•How to write deterministic tests, submit code reviews, and give feedback on other people's code

•The technical design process, including experiments, problem definition, documentation, and collaboration

•What to do when you are on-call, and how to navigate production incidents

•Architectural techniques that make code change easier

•Agile development practices like sprint planning, stand-ups, and retrospectives

This is the book your tech lead wishes every new engineer would read before they start. By the end, you'll know what it takes to transition into the workplace -- from CS classes or bootcamps to professional software engineering.

Table of contents

  1. Title Page
  2. Copyright
  3. Dedication
  4. About the Authors
  5. Acknowledgments
  6. Preface
  7. Chapter 1: The Journey Ahead
    1. Your Destination
    2. A Map for Your Journey
      1. Peak Newb
      2. Ramp-Up River
      3. Cape Contributor
      4. Operations Ocean
      5. Competence Cove
    3. Onward!
  8. Chapter 2: Getting to Conscious Competence
    1. Learning to Learn
      1. Front-Load Your Learning
      2. Learn by Doing
      3. Experiment with Code
      4. Read
      5. Watch Presentations
      6. Attend Meetups and Conferences (Sparingly)
      7. Shadow and Pair with Experienced Engineers
      8. Experiment with Side Projects
    2. Asking Questions
      1. Do Your Research
      2. Timebox
      3. Show Your Work
      4. Don’t Interrupt
      5. Prefer Multicast, Asynchronous Communication
      6. Batch Your Synchronous Requests
    3. Overcoming Growth Obstacles
      1. Impostor Syndrome
      2. The Dunning–Kruger Effect
    4. Do’s and Don’ts
    5. Level Up
  9. Chapter 3: Working with Code
    1. Software Entropy
    2. Technical Debt
      1. Addressing Technical Debt
    3. Changing Code
      1. Use the Legacy Code Change Algorithm
      2. Leave Code Cleaner Than You Found It
      3. Make Incremental Changes
      4. Be Pragmatic About Refactoring
      5. Use an IDE
      6. Use Version Control System Best Practices
    4. Avoiding Pitfalls
      1. Use Boring Technology
      2. Don’t Go Rogue
      3. Don’t Fork Without Committing Upstream
      4. Resist the Temptation to Rewrite
    5. Do’s and Don’ts
    6. Level Up
  10. Chapter 4: Writing Operable Code
    1. Defensive Programming
      1. Avoid Null Values
      2. Make Variables Immutable
      3. Use Type Hinting and Static Type Checking
      4. Validate Inputs
      5. Use Exceptions
      6. Be Precise with Exceptions
      7. Throw Exceptions Early, Catch Exceptions Late
      8. Retry Intelligently
      9. Write Idempotent Systems
      10. Clean Up Resources
    2. Logging
      1. Use Log Levels
      2. Keep Logs Atomic
      3. Keep Logs Fast
      4. Don’t Log Sensitive Data
    3. Metrics
      1. Use Standard Metrics Libraries
      2. Measure Everything
    4. Traces
    5. Configuration
      1. Don’t Get Creative with Configuration
      2. Log and Validate All Configuration
      3. Provide Defaults
      4. Group Related Configuration
      5. Treat Configuration as Code
      6. Keep Configuration Files Clean
      7. Don’t Edit Deployed Configuration
    6. Tools
    7. Do’s and Don’ts
    8. Level Up
  11. Chapter 5: Managing Dependencies
    1. Dependency Management Basics
      1. Semantic Versioning
      2. Transitive Dependencies
    2. Dependency Hell
    3. Avoiding Dependency Hell
      1. Isolate Dependencies
      2. Deliberately Add Dependencies
      3. Pin Versions
      4. Scope Dependencies Narrowly
      5. Protect Yourself from Circular Dependencies
    4. Do’s and Don’ts
    5. Level Up
  12. Chapter 6: Testing
    1. The Many Uses of Tests
    2. Types of Tests
    3. Test Tools
      1. Mocking Libraries
      2. Test Frameworks
      3. Code Quality Tools
    4. Writing Your Own Tests
      1. Write Clean Tests
      2. Don’t Overdo Testing
    5. Determinism in Tests
      1. Seed Random Number Generators
      2. Don’t Call Remote Systems in Unit Tests
      3. Inject Clocks
      4. Avoid Sleeps and Timeouts
      5. Close Network Sockets and File Handles
      6. Bind to Port Zero
      7. Generate Unique File and Database Paths
      8. Isolate and Clean Up Leftover Test State
      9. Don’t Depend on Test Order
    6. Do’s and Don’ts
    7. Level Up
  13. Chapter 7: Code Reviews
    1. Why Review Code?
    2. Getting Your Code Reviewed
      1. Prepare Your Review
      2. De-risk with Draft Reviews
      3. Don’t Submit Reviews to Trigger Tests
      4. Walk Through Large Code Changes
      5. Don’t Get Attached
      6. Practice Empathy, but Don’t Tolerate Rudeness
      7. Be Proactive
    3. Reviewing Code
      1. Triage Review Requests
      2. Block Off Time for Reviews
      3. Understand the Change
      4. Give Comprehensive Feedback
      5. Acknowledge the Good Stuff
      6. Distinguish Between Issues, Suggestions, and Nitpicks
      7. Don’t Rubber-Stamp Reviews
      8. Don’t Limit Yourself to Web-Based Review Tools
      9. Don’t Forget to Review Tests
      10. Drive to a Conclusion
    4. Do’s and Don’ts
    5. Level Up
  14. Chapter 8: Delivering Software
    1. Software Delivery Phases
    2. Branching Strategies
    3. Build Phase
      1. Version Packages
      2. Package Different Resources Separately
    4. Release Phase
      1. Don’t Throw Releases Over the Fence
      2. Publish Packages to a Release Repository
      3. Keep Releases Immutable
      4. Release Frequently
      5. Be Transparent About Release Schedules
      6. Publish Changelogs and Release Notes
    5. Deployment Phase
      1. Automate Deployments
      2. Make Deployments Atomic
      3. Deploy Applications Independently
    6. Rollout Phase
      1. Monitor Rollouts
      2. Ramp Up with Feature Flags
      3. Protect Code with Circuit Breakers
      4. Ramp Service Versions in Parallel
      5. Launch in Dark Mode
    7. Do’s and Don’ts
    8. Level Up
  15. Chapter 9: Going On-Call
    1. How On-Call Works
    2. Important On-Call Skills
      1. Make Yourself Available
      2. Pay Attention
      3. Prioritize Work
      4. Communicate Clearly
      5. Track Your Work
    3. Handling Incidents
      1. Triage
      2. Coordination
      3. Mitigation
      4. Resolution
      5. Follow-Up
    4. Providing Support
    5. Don’t Be a Hero
    6. Do’s and Don’ts
    7. Level Up
  16. Chapter 10: Technical Design Process
    1. The Technical Design Process Cone
    2. Thinking About Design
      1. Define the Problem
      2. Do Your Research
      3. Conduct Experiments
      4. Give It Time
    3. Writing Design Documents
      1. Document Consequential Changes
      2. Know Why You’re Writing
      3. Learn to Write
      4. Keep Design Documents Up-to-Date
    4. Using a Design Document Template
      1. Current State and Context
      2. Motivation for Change
      3. Requirements
      4. Potential Solutions
      5. Proposed Solution
      6. Design and Architecture
      7. Test Plan
      8. Rollout Plan
      9. Unresolved Questions
      10. Appendix
    5. Collaborating on Design
      1. Understand Your Team’s Design Review Process
      2. Don’t Surprise People
      3. Brainstorm with Design Discussions
      4. Contribute to Design
    6. Do’s and Don’ts
    7. Level Up
  17. Chapter 11: Creating Evolvable Architectures
    1. Understanding Complexity
    2. Design for Evolvability
      1. You Ain’t Gonna Need It
      2. Principle of Least Astonishment
      3. Encapsulate Domain Knowledge
    3. Evolvable APIs
      1. Keep APIs Small
      2. Expose Well-Defined Service APIs
      3. Keep API Changes Compatible
      4. Version APIs
    4. Evolvable Data
      1. Isolate Databases
      2. Use Schemas
      3. Automate Schema Migrations
      4. Maintain Schema Compatibility
    5. Do’s and Don’ts
    6. Level Up
  18. Chapter 12: Agile Planning
    1. The Agile Manifesto
    2. Agile Planning Frameworks
    3. Scrum
      1. User Stories
      2. Tasks
      3. Story Points
      4. Backlog Triage
      5. Sprint Planning
    4. Stand-ups
    5. Reviews
    6. Retrospectives
    7. Roadmaps
    8. Do’s and Don’ts
    9. Level Up
  19. Chapter 13: Working with Managers
    1. What Managers Do
    2. Communication, Goals, and Growth Processes
      1. 1:1s
      2. PPPs
      3. OKRs
      4. Performance Reviews
    3. Managing Up
      1. Get Feedback
      2. Give Feedback
      3. Discuss Your Goals
      4. Take Action When Things Aren’t Working
    4. Do’s and Don’ts
    5. Level Up
  20. Chapter 14: Navigating Your Career
    1. To Senior and Beyond
    2. Career Advice
      1. Be T-Shaped
      2. Participate in Engineering Programs
      3. Steer Your Promotion
      4. Change Jobs Carefully
      5. Pace Yourself
    3. Closing Thoughts
  21. Index

Product information

  • Title: The Missing README
  • Author(s): Dmitriy Ryaboy
  • Release date: August 2021
  • Publisher(s): No Starch Press
  • ISBN: 9781718501836