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