Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Modern Software Engineering

Modern Software Engineering

Doing What Works to Build Better Software Faster
Build software faster without betting on plans, process, or architecture that may be wrong.
by David Farley 2021 256 pages
4.16
1k+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Use empirical learning to build better software faster, not heavier process

Engineering is a way of working. Farley defines software engineering as applying scientific, evidence-based reasoning to practical software problems within economic limits. The goal is not to add paperwork or prove every line mathematically. It is to improve the odds of solving the right problem efficiently, then check whether the solution works in reality.

Software is design work. Unlike bridge building, software has almost no manufacturing cost: once it is written, producing another copy is largely automatic. The hard work is discovering what to build and designing it well. The Apollo flight software illustrates the stakes. Margaret Hamilton’s team tested recovery behavior so the computer could prioritize essential tasks during overload, helping the lunar landing continue despite alarms. Engineering means preparing for what cannot be predicted, not pretending uncertainty can be planned away.

Analysis

The key reframing is from production discipline to disciplined discovery. This connects software engineering to design science, where models are useful only insofar as experiments can challenge them. Software has an unusual advantage: its executable model is also the artifact being tested, so feedback can be unusually direct. The Apollo example also shows why engineering is broader than code quality. Design choices, testing, operational assumptions, and team practices all contribute to whether a system behaves safely. The approach is not a guarantee of success, however. Evidence can improve decisions without eliminating uncertainty, and economic constraints still determine how much investigation a team can afford.

Ship small changes because your first map of the problem will be wrong

Iteration buys learning. Iteration means repeating a process, using each result to adjust the next attempt. It works when a team cannot fully specify the destination in advance but can tell whether a step moves closer to it. This differs from a plan-first approach, which assumes the important questions can be answered before work begins.

Small bets limit damage. The book cites research suggesting that roughly two-thirds of tested product ideas at leading software companies produce no positive value. Small changes let teams discover this before investing heavily. They also reduce how long assumptions must remain true and how much work is lost if circumstances change. Continuous integration, frequent commits, and short development cycles apply the same logic at different scales: make a small move, inspect what happened, and use the result to choose the next move.

Analysis

Iteration is a practical form of managing uncertainty, not simply a calendar arrangement. It resembles Bayesian updating: a team begins with a provisional belief, gathers evidence, and revises its confidence. Small batches improve the quality of that update because fewer changes compete to explain a result. But iteration can become ritual if teams only divide work into short sprints while preserving long approval chains and fixed scope. The essential question is not how often a planning meeting occurs, but how quickly evidence can change the next decision.

Make feedback fast enough to correct mistakes before they spread

Feedback stabilizes action. Farley compares software development to balancing a broom on a hand. Calculating the perfect position in advance is fragile; sensing the tilt and making quick corrections is robust. Software teams face the same problem because requirements, designs, and operating conditions change while work is underway.

Short loops reduce correction costs. Feedback can come from a compiler, a focused test, a full integration build, or real users. Each answers a different question, and the earliest useful signal is often the cheapest to act on. In one example, a financial software team shortened a test build from nine and a half hours to a 12-minute early stage and a 40-minute full run. With quicker results, developers could address instability while the cause was still clear, instead of waiting overnight.

Analysis

The broom example captures a principle from control theory: a system exposed to disturbances can remain stable when it senses deviation and responds quickly. In software, latency between action and evidence is itself a risk factor because it allows assumptions and dependent changes to accumulate. Fast feedback does not mean testing everything at maximum intensity after every keystroke. It means matching the cost and depth of a check to the decision it informs, then escalating evaluation as the change affects more of the system.

Test explanations against evidence, not against what seems obvious

A plausible story is not proof. Empiricism means using observation and evidence to judge claims, rather than relying only on intuition or authority. Experimentation is the deliberate test of a hypothesis. The distinction matters: an experiment can be carefully run yet still answer the wrong question or ignore real-world conditions.

Check the facts before the fix. Farley recounts a team that blamed a messaging library after tests failed and CPU use spiked. A colleague had seen a similar symptom, making the explanation feel convincing. Reviewing what had actually changed showed the messaging code had been stable for a week. Logs revealed a new threading bug elsewhere. Another experiment compared parallel Scala code, which processed 400 copies of a book per second, with simpler Java code that processed 1,600. Measurement overturned the assumption that parallelism must be faster.

Analysis

These episodes expose a familiar cognitive trap: people often interpret new evidence as confirmation of the first explanation that fits the story. A useful scientific habit is to distinguish observation from inference. A thread appears blocked is an observation; the messaging layer caused the failure is an inference. Keeping those categories separate makes it easier to seek disconfirming evidence. Still, experiments can mislead when their measurement setup is unrepresentative. Results need context, and a benchmark that isolates one task cannot automatically predict performance in a larger system.

Write tests first to reveal design problems while they are still cheap

Tests can shape design. Test-driven development, or TDD, means writing a small test for intended behavior before writing the production code, then making it pass and improving the design while keeping it passing. The test is both a check and a way to experience whether the code is easy to use.

Testability is a design signal. In Farley’s car example, a class creates its own petrol engine internally, leaving a test with no clean way to observe whether starting the car worked. Supplying the engine as a dependency allows a test to use a simple fake that records whether it started. That small change also makes the car easier to adapt to another engine. TDD does not automatically produce excellent design, but difficulty writing a focused test can reveal tangled responsibilities or hidden dependencies early.

Analysis

TDD makes an important shift in perspective: a test is not merely a net cast after construction, but a user’s first encounter with the interface being designed. That resembles usability testing at the level of code. The practice can encourage modularity because isolated behavior is easier to specify and observe. It is not a universal design oracle, though. A test can be easy to write and still encode the wrong behavior, or become brittle if it depends on implementation details. Its strongest value comes when tests describe meaningful behavior and developers treat friction as information rather than as a mandate to add abstractions blindly.

Separate responsibilities so each part can change without confusing the rest

Boundaries make complexity manageable. Modularity divides a system into parts that can be understood and changed with limited concern for neighboring parts. Cohesion keeps related responsibilities together. Separation of concerns helps establish those boundaries, while abstraction hides implementation details behind a simpler interface.

A small example shows the difference. A single function that reads a word file, sorts its contents, and writes a new file mixes the purpose of sorting with file-system details. Separating reading, sorting, and storing makes the sequence easier to understand and allows each responsibility to change independently. Domain-driven design can help locate meaningful boundaries by modeling the problem in its own language. For example, an order-management system and a billing system may use different definitions of an order, so treating them as separate contexts can prevent accidental dependencies.

Analysis

The design principles reinforce one another because they address the same practical question: what must a developer understand to make a safe change? A boundary is valuable when it hides details that are likely to change independently, not merely because a diagram looks cleaner. Domain language can help identify those seams, but it can also overstate the stability of business concepts. Real organizations change their definitions, and different teams may use the same word differently. A useful design preserves room to revise the model when actual work reveals that its boundaries are misplaced.

Choose coupling deliberately; microservices buy autonomy at a price

Coupling is unavoidable. Components must depend on one another to communicate, but tight dependencies make changes travel farther than intended. Farley describes two broad ways to manage this: keep a system integrated and invest in very fast shared testing, or make components independently deployable so teams can release without coordinating every change.

Microservices are an organizational trade. They are small, focused services aligned with a problem domain and designed for independent deployment. That independence can let teams work at different speeds, but it requires stable interfaces, careful failure handling, and more distributed-system machinery. The book also warns against applying DRY, or avoiding duplicated code, across independently deployed services when a shared library would force teams to release together. Reducing one kind of duplication can increase a more expensive kind of coupling.

Analysis

The choice between an integrated system and independently deployed services resembles a trade between centralized coordination and local autonomy. Neither is inherently superior. Distributed teams gain freedom only if interfaces absorb variation and failures; otherwise, coordination returns as production incidents. Conversely, a shared codebase can make broad changes safer when automated checks are genuinely fast. The useful unit of analysis is not the fashionable architecture label, but the costs a team actually faces: integration delay, operational complexity, and the time required to establish that a change is safe.

Keep future options open through refactoring, not speculative machinery

Design for change, not prophecy. Incremental design means evolving a system through small steps as understanding improves. It is not the same as building features for every imagined future. Refactoring changes the internal structure of code without changing its behavior, making later changes safer when new information arrives.

Real flexibility paid off. Farley describes a financial exchange whose separation of business logic from database concerns made replacing a commercial database with an open-source alternative a morning’s work. The team changed the storage implementation, fixed a couple of test failures, and released through its pipeline. By contrast, a large insurance company’s elaborate enterprise architecture existed mainly in documents and unusable code, while projects remained delayed. The practical distinction is whether an abstraction supports a current need and can be tested, not whether it promises universal future-proofing.

Analysis

This is a useful correction to two opposite instincts: freezing a design early and building elaborate flexibility before its value is known. Refactoring keeps adaptation available without requiring developers to forecast every future requirement. In economics, this resembles preserving an option: a modest present investment buys the right, but not the obligation, to make a later change. That option has a cost, so not every boundary deserves a layer of indirection. The strongest case for abstraction is a real source of change or an actual testing obstacle, not a vague claim that something might be useful someday.

Measure delivery stability and throughput, not activity theater

Useful measures guide decisions. Farley highlights two dimensions from the DORA research: stability, reflected in how often changes cause failures and how quickly service is restored, and throughput, reflected in lead time and deployment frequency. These measures do not show whether a team chose the right product idea, but they help assess whether it can deliver working changes reliably and efficiently.

Metrics should test a change. Lines of code, velocity, and test coverage can reward activity without showing value. One organization tied bonuses to an 80 percent coverage target, then discovered that more than a quarter of its tests contained no assertions. Farley also cites evidence that change approval boards did not improve stability while slowing delivery. The practical approach is to record a baseline, change one part of the process, and check whether meaningful outcomes improve.

Analysis

Measurement is most useful as a feedback instrument, not a verdict on individual worth. The distinction between a proxy and an outcome matters: deployment speed can indicate learning capacity, but it cannot prove that users benefit from what is shipped. Stability and throughput are valuable partly because they expose trade-offs that conventional activity counts conceal. They remain imperfect, correlational indicators, so teams should pair them with evidence of product impact and avoid turning targets into incentives that invite gaming. A metric earns trust by improving a decision, not by looking precise.

Scale autonomous teams by reducing coordination, not adding headcount

Organizations are information systems too. A team’s ability to work depends on how much information it must exchange with other teams before acting. As software grows, organizational dependencies can become as constraining as dependencies in code. Research discussed in the book associates stronger delivery performance with small teams that can make decisions without repeatedly seeking outside permission.

Choose structure after purpose. Farley presents a business-first sequence: determine the goal, choose an architecture that can support it, select a workable process, and then organize teams accordingly. This reverses the common habit of letting existing departments dictate the product and system design. A microservice structure can support independent teams, but only when the software is genuinely independent enough to test and deploy separately. More teams do not automatically mean more progress if their work must constantly be synchronized.

Analysis

The organizational argument follows the same logic as modular software: autonomy depends on well-chosen boundaries and limited cross-boundary obligations. This resonates with research on cognitive load and coordination, where each additional communication path consumes attention that could otherwise go toward problem-solving. Yet autonomy is not a synonym for isolation. Teams still need shared goals, compatible interfaces, and mechanisms for resolving conflicts that cross boundaries. The design challenge is to make routine decisions local while keeping system-wide consequences visible, rather than replacing hierarchy with disconnected fiefdoms.

Analysis

Farley’s central contribution is not a new development ritual but a way to judge rituals, architectures, and tools. Software work is treated as disciplined learning under uncertainty. That perspective links two often separated concerns: the speed at which a team learns and the structure that lets it change what it has learned. Short feedback loops are useful only when the system is observable; modularity is useful partly because it makes experiments narrower and results easier to interpret. Testability, deployability, and controlled environments therefore function as design pressures, not merely operational conveniences.

The framework is strongest when it rejects false choices. Quality need not be sacrificed for speed if defects are found early and changes remain small. Craft and creativity are not enemies of engineering; evidence and measurement give skilled people a better way to direct them. Nor does the book claim that one architecture fits every context. Its treatment of microservices, abstraction, and coupling emphasizes costs, though its preference for test-first development and rapid delivery is forceful enough that readers should distinguish durable principles from favored practices.

A useful critical boundary is that technical throughput is not product success. Fast, stable delivery proves that a team can change software reliably, not that it is solving a valuable problem. The book recognizes this distinction, but organizations can still mistake operational indicators for customer outcomes. Another risk is metric substitution: once a measure becomes a target, teams may optimize the number rather than the system it was meant to represent. The soundest application is therefore a layered one. Use engineering measures to evaluate delivery capability, user evidence to judge product value, and local experiments to test changes in process. The result is not certainty. It is a more reliable way to find and correct error before it becomes expensive.

Summary in 30 Seconds
Software development is design under uncertainty, so teams learn by making small changes and checking the results. Short feedback loops catch defects while their causes are still clear: one team cut an early test run from nine and a half hours to 12 minutes. Writing tests before code can expose tangled design, while modular boundaries make changes safer. Measure delivery reliability and speed, not activity proxies. Independent teams need software boundaries that let them test and release separately.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.16 out of 5
Average of 1k+ ratings from Goodreads and Amazon.

Modern Software Engineering receives mixed reviews. Many praise its comprehensive overview of software engineering principles, emphasizing empiricism, complexity management, and continuous delivery. Readers appreciate the focus on fundamental concepts rather than specific technologies. However, some criticize the book for being repetitive, lacking concrete examples, and overly promoting Test-Driven Development. While experienced engineers may find little new information, beginners and those seeking a refresher on core principles generally find value in the book's content, despite its verbose writing style.

Your rating:
4.52
319 ratings
Want to read the full book?

Glossary

Empiricism

Evidence-led judgment

A way of deciding based on observations and evidence rather than intuition, authority, or assumptions alone. In software engineering, empiricism keeps experiments grounded in the conditions and outcomes that matter in practice. It also requires skepticism about the interpretation of evidence, since a real observation can still be explained by the wrong hypothesis.

Continuous delivery

Software kept deployable

An approach to software development in which changes are built, tested, and prepared so that the system can be released safely whenever the organization chooses. It relies on frequent small changes, automated evaluation, and reliable deployment. Its purpose is not simply to automate releases, but to support a steady flow of changes and timely feedback.

Test-driven development

Tests guide implementation

A development practice in which a developer first writes a test describing intended behavior, runs it to confirm that it fails for the expected reason, then writes code to make it pass and refactors while keeping the test passing. Farley emphasizes that this sequence provides rapid behavior checks and feedback about the design and testability of the code.

Deployment pipeline

Automated release evaluation

An automated process that evaluates changes from source-code commit through the checks needed to establish that a software unit is ready for deployment. Its scope should match an independently deployable unit. If further integration tests or approvals are still required to determine safety, the pipeline has not yet provided a definitive deployability result.

Ports & Adapters

Interfaces isolate dependencies

An architectural pattern that separates a system’s core behavior from external technologies through explicit interfaces, called ports, and translating components, called adapters. The core code depends on the interface rather than a specific database, service, or device. This makes components easier to test and allows external implementations to change with less impact on core logic.

Bounded context

A domain language boundary

A defined part of a system in which a set of domain concepts and terms has a consistent meaning. Different parts of an organization may use the same word differently, such as an order in billing versus order management. Treating those areas as distinct contexts can guide modular design and reduce misleading dependencies.

Essential and accidental complexity

Problem complexity versus overhead

Essential complexity is the difficulty inherent in solving the problem itself, such as calculating a balance or matching orders. Accidental complexity comes from the technical means used to solve it, such as persistence, display, or communication details. Separating them helps keep core behavior understandable while still handling necessary technical constraints.

Stability and throughput

Delivery quality and flow

Two dimensions used in DORA research to assess software delivery performance. Stability concerns the effects of changes on production and the time needed to recover from failures. Throughput concerns how quickly and how often changes reach production. They help evaluate delivery capability, but do not establish whether the product choices themselves create customer value.

Mechanical sympathy

Design informed by hardware

A performance-oriented approach that considers how software interacts with the underlying hardware. In the book’s financial-exchange example, developers measured the effects of memory access and concurrency rather than trusting general assumptions about speed. The aim is to shape code around the behavior of the machine when performance requirements make those details important.

FAQ

What's Modern Software Engineering about?

  • Engineering Principles: The book emphasizes applying engineering principles to software development, advocating for a scientific and empirical approach to problem-solving.
  • Complexity Management: It discusses managing complexity in software systems and optimizing for learning through iterative processes and feedback.
  • Practical Techniques: David Farley provides practical techniques and tools to improve software quality and delivery speed.

Why should I read Modern Software Engineering?

  • Improve Practices: The book offers insights into building better software faster by applying proven engineering techniques.
  • Real-World Applications: Farley draws from his extensive experience, providing real-world examples that illustrate the effectiveness of the concepts discussed.
  • Continuous Improvement: It serves as a guide for teams looking to adopt continuous delivery and improve their software development processes.

What are the key takeaways of Modern Software Engineering?

  • Iterative Learning: The importance of working iteratively is highlighted, allowing teams to learn and adapt quickly based on feedback.
  • Managing Complexity: Concepts like modularity, cohesion, and separation of concerns are essential for managing software complexity.
  • Empirical Approach: The book advocates for evidence-based decision-making in software engineering.

What is the definition of software engineering according to Modern Software Engineering?

  • Empirical Approach: Farley defines it as "the application of an empirical, scientific approach to finding efficient, economic solutions to practical problems in software."
  • Focus on Learning: The definition underscores the need for continuous learning and effective complexity management.
  • Beyond Coding: It emphasizes that software engineering involves a structured approach to problem-solving, not just writing code.

How does Modern Software Engineering define feedback?

  • Essential for Learning: Feedback is described as "the transmission of evaluative or corrective information," crucial for learning.
  • Improves Decision-Making: Effective feedback allows teams to make informed decisions, enhancing work quality.
  • Multiple Levels: The book emphasizes feedback at various levels, including coding, integration, and product design.

What is the significance of modularity in Modern Software Engineering?

  • Managing Complexity: Modularity helps manage complexity by allowing system components to be separated and recombined.
  • Independent Development: It facilitates independent work on separate modules, enhancing collaboration and speeding up development.
  • Improves Code Quality: A modular approach encourages separation of concerns, reducing the risk of changes affecting unrelated parts.

What are the five techniques for optimizing learning mentioned in Modern Software Engineering?

  • Iteration: Emphasizes iterative processes to refine and improve software continuously.
  • Feedback: Highlights the importance of gathering feedback to inform decisions and guide development.
  • Incrementalism: Advocates for building systems in small, manageable increments to deliver value progressively.
  • Experimentation: Encourages experimenting with new ideas to discover what works best.
  • Empiricism: Stresses validating ideas based on real-world evidence.

What is continuous delivery, and why is it important according to Modern Software Engineering?

  • Deployment Pipeline: Continuous delivery involves a deployment pipeline that automates testing and deployment, keeping software always releasable.
  • Faster Feedback: It allows rapid feedback on changes, enabling quick issue identification and resolution.
  • Agile Alignment: Supports agile methodologies, allowing incremental feature delivery and effective user feedback response.

How does Modern Software Engineering suggest managing complexity?

  • Use of Abstraction: Advocates for using abstraction to hide unnecessary details, reducing complexity.
  • Separation of Concerns: Encourages separating system aspects to create more maintainable and understandable code.
  • Iterative Development: Emphasizes making small, frequent changes to better manage complexity over time.

What is the role of testability in software design according to Modern Software Engineering?

  • Design for Testability: Code should be designed to be easily testable, leading to better architecture and quality.
  • Feedback Mechanism: Testability provides feedback to identify design flaws early, allowing iterative improvements.
  • Encourages Good Practices: Focus on testability encourages modular design and separation of concerns, leading to maintainable code.

What are some common pitfalls in software engineering discussed in Modern Software Engineering?

  • Over-Engineering: Warns against over-engineering solutions, which can lead to unnecessary complexity.
  • Ignoring Testability: Failing to design for testability can result in tightly coupled, hard-to-maintain code.
  • Neglecting Feedback Loops: Highlights the importance of fast feedback loops, cautioning against delayed testing and validation.

What are some best practices for achieving high-quality software as per Modern Software Engineering?

  • Focus on Testability: Prioritize designing software that is easy to test for better quality and maintainability.
  • Embrace Continuous Delivery: Implement practices to ensure software is always in a releasable state, facilitating rapid feedback.
  • Iterate and Improve: Adopt an iterative approach, allowing continuous learning and improvement based on feedback.

About the Author

David Farley is a renowned software engineer, author, and educator. He is best known for his contributions to continuous delivery practices and his work on software engineering principles. Farley has authored multiple books on software development, including "Continuous Delivery" and "Modern Software Engineering." He shares his expertise through various media, including a popular YouTube channel focused on continuous delivery and software engineering topics. Farley's background as a practitioner informs his teaching and writing, which emphasize empirical approaches, modularity, and test-driven development. His work has influenced many in the software industry, promoting more efficient and effective development practices.

Download PDF

To save this Modern Software Engineering summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.43 MB     Pages: 21

Download EPUB

To read this Modern Software Engineering summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.45 MB     Pages: 26
Want to read the full book?
Follow
Listen8 mins
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...