Software Engineering
From evidence and folklore to object-oriented and functional design, test-driven development, refactoring, legacy code, reliability, performance and work with coding agents, software engineering as told through the free samples of the Leanpub books about it.
Created from the free samples of 13 Leanpub books and the descriptions and tables of contents of 18 more, with every source cited.
Software engineering is the discipline of building software that has to be relied on and kept: not the writing of a program, but the practices by which programs are designed, checked, changed over years and delivered by teams. This article surveys that ground from above. The narrower subjects it passes through, among them software architecture, software testing and test automation, agile methods, continuous delivery, version control and the individual programming languages, have fuller articles of their own, and what is said here is meant as a map of how they fit together.
The books on this shelf are notably argumentative about the discipline's foundations. One examines the facts that every practitioner is supposed to know, such as the tenfold difference between programmers or the rising cost of fixing a defect late, and finds that many are anecdotes passed from hand to hand until they hardened into research.[1] Another holds, against common resignation, that code without defects is achievable and costs less than code with them.[5] A third treats the code that teams inherit and resent as something made by people doing their best with what they knew, to be understood before it is judged.[2]
The article moves from what the discipline knows and how, to design, to the technical practices of testing first and refactoring, to legacy code and maintenance, performance and tools, and finally requirements, teams and coding agents. Its sources are the free samples of thirteen books and the descriptions and tables of contents of eighteen more, listed at the end, and every claim that rests on a source is cited to it.
Where to start
For the technical practices, Test-Driven Development: Extensive Tutorial (2024) is a free tutorial on test-driven development,[10] Agile Technical Practices Distilled (2019) is a path through the practices arranged by three coaches,[17] and The Software Developers’ Guidebook (2025) collects short guides to current practice.[18]
For design, The Object Oriented Way (2025) explains object-oriented programming without depending on a language,[16] and Composing Software (2024), the most widely sold of the core books, presents design as composition.[15] Readers who want to check what they have been told should read The Leprechauns of Software Engineering (2017),[1] and those who want the reasoning skills beneath design and testing have Logic for Programmers.[6]
Most working programmers spend their time in code that already exists, and for them there are The Legacy Code Programmer's Toolbox (2022) and Idea Flow (2019).[2][3] Those whose work now includes directing coding agents can begin with The Sovereign Engineer or, for the specification of what is to be built, Writing Use Cases for AI.[24][23]
History
The term dates from a conference of 1968, called in response to what its organisers named a crisis: software delivered late, over budget and unreliable. The decades that followed produced structured programming, the hiding of information behind interfaces, and processes that planned a project in phases from requirements to maintenance. Object orientation became the dominant style of design in the 1980s and 1990s. At the end of the 1990s a group of practitioners reacted against heavy process with iterative methods and a set of technical practices, writing tests first, refactoring, working in pairs and integrating continuously, and in the 2010s the automation of delivery extended the same thinking to operations. The current change is the arrival of language models that write code.
Several books here are commentaries on that history. The Leprechauns of Software Engineering counts the crisis itself among the received truths that deserve scrutiny, along with the curve that shows the cost of a change rising with time.[1] Writing Use Cases for AI looks back over forty years of one technique for stating what a system must do, all of which assumed that the reader of a specification was a person.[23] Test-Driven Development: Extensive Tutorial says of itself that it is not original at all, and presents what others invented, with a list of the people from whom its author learned.[10] And Idea Flow describes a cycle that its author saw in one team after another: a new project begun with the best intentions, years later a meeting to decide whether to rewrite it, and then a new project begun with the same intentions.[3]
What the discipline knows
The Leprechauns of Software Engineering compares the profession to a game in which a message is whispered from person to person until it is unrecognisable. The claims in question began as reasonable hypotheses; the trouble is that they have become fixed as facts supposedly established by research while remaining anecdotal. The book invents a parody, a sentence asserting with six scholarly references that defects are caused by leprechauns, and then lists the ways in which real chains of citation mislead without any dishonesty: the papers cited are not empirical, or support a weaker claim, or merely cite others, or are so old, long or obscure that nobody checks them, or represent one side of a dispute. Such beliefs work even when unstated. A manager seeking exceptional programmers at great expense is relying on the tenfold difference, and an advocate of testing early on the cost curve. To question them is unpopular, the author found, and is taken as support for some equally silly opposite; very few people can imagine doubting that productivity is a measurable thing at all. The book sorts such beliefs into those that have become tacit, those repeated as folklore and those formally asserted, and treats each kind differently.[1]
Other books argue from experience. Extreme Reliability draws on a career spent partly in safety-critical work and sets out its position as a table of recommendations, of which the first are that quality is not a luxury because good code costs less, and that there should be no tolerance of defects; its chapter on testing has a section on why testing does not find them. Others in the same table say that failure is not an option, that code is for reading, that a first version should be planned for discarding, and that someone who can program in only one language cannot really program.[5] Code Is for Humans locates the causes of faulty code and failed projects in the limits of human cognition and proposes an engineering that allows for them.[21] The adjacent Humans vs Computers (2017) collects true stories of people harmed by software's assumptions, written by a developer who hopes colleagues will find more empathy for those who suffer from their mistakes, since it is always people who pay in the end. Its subjects include people whom computers could not see and a default password with remarkable consequences, and its last part turns the stories into checklists.[9]
Design
The Object Oriented Way begins from its author's question of a decade ago, why object-oriented programming has so many rules, and offers mental models for reasoning about complexity and choosing abstractions, building from plain imperative code to the injection of dependencies, the preference for composition over inheritance, the patterns and the principle that one object may stand in for another.[16] Composing Software starts from a single proposition, that all design is composition, the breaking of a complex problem into smaller ones and the putting together of their solutions, and teaches the composition of functions and of objects in JavaScript, from functions without side effects and data that is not modified to the more abstract structures of functional programming, ending with rules of style and a chapter that treats the need for imitation objects in tests as a sign of a fault in design.[15] PHP Brilliance is for senior developers in one language and is expressly not about programming with an assistant; its concern is to strengthen design ability at a time when more hours go to reviewing generated code than to writing. Its preface describes the reader it wants as a good developer who wishes to acquire an almost uncanny ability to foresee the situations in which faults will arise and to avoid them, and concedes that seniority means very different things in different organisations.[11]
Two books come from the functional tradition. Algebra-Driven Design (2023) designs an interface by first writing the laws it must satisfy and deriving tests and implementations from them,[7] and Functional Design and Architecture (Early Edition, 2020) (2020) treats the design of whole applications, taking complexity as the main problem developers face.[8] Logic for Programmers supplies the tool common to all of them, teaching the logic of conditions, sets and quantifiers in a programmer's notation and applying it to tests, databases and requirements.[6]
Above the level of code lies architecture, which has its own article; three adjacent books show its range. Get Your Hands Dirty on Clean Architecture (2nd edition) (2023) implements one style in a web application,[26] Hands-on Domain-driven Design - by example (2020) explains design driven by the business domain through a case study of lending,[27] and arc42 by Example (2023) documents real systems with a standard template.[28] Residues: Time, Change, and Uncertainty in Software Architecture. (2024) introduces a newer theory of architecture.[29]
Testing first and refactoring
The practices that the agile movement attached to programming are taught in several ways. Test-Driven Development: Extensive Tutorial is a long open tutorial with examples in one language. Its first part keeps to the basic philosophy and practice of writing a test before the code, on examples that exercise the methods of a single object, and leaves to a second part the harder case of systems in which many objects collaborate.[10] Agile Technical Practices Distilled arranges what three coaches, with half a century of experience among them, had been teaching into a single sequence: working in pairs and the classic form of test-driven development, then refactoring and the recognition of code that needs it, then design patterns, coupling and the principles of object-oriented design, and finally development driven from the outside and from an understanding of the business.[17] The Software Developers’ Guidebook, which ranges from the setting up of a project and the writing of user stories to testing, architecture and a developer's habits, is drawn from a series of practical guides by an author known for work on continuous delivery, whose adjacent Continuous Delivery Pipelines (2025) is on the automated path from a change to a release.[18][25] Maintainable React (2025) teaches the same practices by refactoring examples in one front-end library step by step.[19]
Technical Agile Coaching with the Samman method (2023) is about how such practices are spread. Its method has two parts. In a daily learning hour a coach uses exercises to teach a technique; in the example the technique is the rule that no production code is written without a failing test that requires it, which the group tries on a small problem and then discusses, several having found that they wrote the code first by mistake. In ensemble sessions a whole team works together on its real code with the coach, so that everyone experiences the practice there. A coach divides the week among several teams, and the foundation of the method, the book says, is good relationships with the people concerned.[4]
Legacy code and maintenance
The foreword to The Legacy Code Programmer's Toolbox observes that legacy code is as much about the people who surround it as about the code. The usual response to it is the instinct to fight or to flee: the question of what the code needs gives way to the question of how to spend as little time in it as possible. The remedy is to recognise that the code was not written arbitrarily or with malice but by people working with incomplete knowledge and the tools of their time, that there are no winners in a game of blame, and that because no two inheritances are alike what is needed is a set of tools and not a single cure. Outside software, the foreword notes, a legacy is a gift from the past, and the book sets out to reclaim the word. Its chapters cover the attitude to take, techniques for reading unfamiliar code, the sharing of knowledge within a team, the quick finding of faults and the shortening of long functions.[2]
Idea Flow begins with its author's worst release, a new version of the control software for a factory that shut down every machine in it, twice, from a fault that took months to find. The lesson drawn is about why nothing was done while the trouble accumulated. Work on features is visible, to be seen, used and sold; confusion, misunderstanding and mistakes are indirect and hard to measure, so decisions follow the benefits that can be seen, and developers who ask for time to repair things cannot make the cost felt. From outside, the author says, a project in this state looks like a car driven without a steering wheel: its course is set by ideals at the start, the accelerator is pressed, and when it hits the wall a new car is built. The book treats technical debt as a symptom of those habits of decision and proposes to make the friction visible, so that a case can be put to management with data.[3]
Tools carry part of the load. Rector - The Power of Automated Refactoring (2025) is a guide to a program that rewrites code by rule, used to move projects across many versions of a language, to enforce a standard of practice and to shorten the review of changes,[13] and SurviveJS - Maintenance (2021) gathers the practices of maintaining applications and published packages in JavaScript: the handling of dependencies, automatic checking and formatting, types, tests, automated releases, documentation and planning for a project's future.[20]
Performance and tools
High-Performance Java Persistence (2024) is a study of one performance problem, the access of an application to its database, from the management of connections through batched updates and the size of fetches to the control of concurrency. Its sample chapter, on sending many statements to the database at once, is a reminder of how empirical the subject is: each database driver behaves differently, some ignore a batch altogether unless it is written in a particular form, and the book measures the effect of each setting and of reordering the statements.[12] Getting to Know IntelliJ IDEA (2024) is a guide to a development environment, in tutorials and in questions and answers,[22] and Practical Python for Production under Pressure (2025) describes the building of tools and pipelines for film and games, where, as its description puts it, everything is always urgent and always broken and the developer's position resembles that of a pit crew. The nearer a tool is to the people who use it daily, its author writes, the more speed is preferred to stability, and the result is a debt of hurried code; the book is mostly on theory and ways of working, for developers with some experience.[14]
Requirements, teams and coding agents
Writing Use Cases for AI argues that a specification now has three readers, the people who want the system, the engineers and an agent that turns the text directly into code and tests, and shows how to write for all of them, with a template, a worked example, the slicing of a use case into deliverable parts, tests, and requests for change in systems that already exist.[23] The Sovereign Engineer offers a framework in six levels for working with such tools, beginning from the observation in its description that the fast teams have become faster and the broken teams more broken; its practices are those the rest of this shelf would recognise, verification, tests written first and explicit specifications, and its last level is the direction of several agents at once.[24]
The human side of the work has its own articles on agile methods and leadership; two adjacent books stand for it here. Getting Value out of Agile Retrospectives (2016) is a collection of exercises for the meeting in which a team reviews how it works, with chapters on why teams hold such meetings and what they are worth to a business,[30] and How To Be A Tech Lead (2019) is a short guide to the role between programming and management.[31]
Sources
Every source is a Leanpub book. The note after each says which part of it was read; where no sample was available, only the public description and table of contents were used.
- 1.The Leprechauns of Software Engineering, Laurent Bossavit: How folklore turns into fact and what to do about it Free sample: the opening chapter, on how anecdote becomes accepted fact. 2017. Free sample: PDF · EPUB
- 2.The Legacy Code Programmer's Toolbox, Jonathan Boccara: Practical skills for software professionals working with legacy code Free sample: the foreword and the acknowledgements. 2022. Free sample: PDF · EPUB
- 4.Technical Agile Coaching with the Samman method, Emily Bache Free sample: the introduction, with a worked example of the method. 2023. Free sample: PDF · EPUB
- 5.Extreme Reliability, Jules May: Programming like your life depends on it Free sample: the contents, the table of recommendations and the acknowledgements. 2026. Free sample: PDF
- 6.Logic for Programmers, Hillel Wayne Free sample: the introduction, on why the book exists and its conventions. 2026. Free sample: PDF
- 7.Algebra-Driven Design, Sandy Maguire: Elegant Solutions from Simple Building Blocks Free sample: the contents and the foreword. 2023. Free sample: PDF
- 8.Functional Design and Architecture (Early Edition, 2020), Alexander Granin: Building real programs in static functional languages: application architectures, design patterns, best practices and approaches Free sample: the first chapter, on software design and complexity. 2020. Free sample: PDF · EPUB
- 9.Humans vs Computers, Gojko Adzic: Wrong assumptions, computer bugs, and people caught in between Free sample: the introduction. 2017. Free sample: PDF · EPUB
- 10.Test-Driven Development: Extensive Tutorial, Grzegorz Gałęzowski Free sample: the front matter and the opening of part one. 2024. Free sample: PDF · EPUB
- 11.PHP Brilliance, Thunder Raven-Stoker: Stepping up from Senior in the age of Agentic AI Free sample: the preface, on whom the book is for. 2026. Free sample: PDF · EPUB
- 12.High-Performance Java Persistence, Vlad Mihalcea: Get the most out of your persistence layer Free sample: part of a chapter on batched updates. 2024. Free sample: PDF · EPUB
- 13.Rector - The Power of Automated Refactoring, Matthias Noback, Tomas Votruba The free sample was not used: from the description and table of contents. 2025. Free sample: PDF · EPUB
- 14.Practical Python for Production under Pressure, Alex Telford: Managing the insanity that is developing pipelines alongside a production at full speed Free sample: the introduction and the opening of a section on code debt; most sections are withheld. 2025. Free sample: PDF · EPUB
- 15.Composing Software, Eric Elliott: An Exploration of Functional Programming and Object Composition in JavaScript No sample: from the description and table of contents. 2024.
- 16.The Object Oriented Way, Christopher Okhravi (PhD) No sample: from the description and table of contents. 2025.
- 17.Agile Technical Practices Distilled, Pedro Moreira Santos, Marco Consolaro, Alessandro Di Gioia: A Journey Toward Mastering Software Design No sample: from the description and table of contents. 2019.
- 18.The Software Developers’ Guidebook, David Farley, Bernard McCarty (Editor): A Collection of Modern Engineering Practices No sample: from the description and table of contents. 2025.
- 19.Maintainable React, Juntao Qiu: Test-Driven Development, Refactoring and Clean Code. No sample: from the description and table of contents. 2025.
- 20.SurviveJS - Maintenance, Juho Vepsäläinen, Artem Sapegin: Streamline JavaScript Workflow No sample: from the description and table of contents. 2021.
- 21.Code Is for Humans, Zohar Jackson: A Guide to Human-Centric Software Engineering No sample: from the description. 2026.
- 22.Getting to Know IntelliJ IDEA, Trisha Gee, Helen Scott: Get up to speed on IntelliJ IDEA's New UI No sample: from the description and table of contents. 2024.
- 23.Writing Use Cases for AI, Simon Martinelli: How to write use cases for stakeholders, engineers, and AI agents No sample: from the description and table of contents. 2026.
- 24.The Sovereign Engineer, Russ Miles: AI Literacy for Software Professionals No sample: from the description and table of contents. 2026.
- 25.Continuous Delivery Pipelines, Dave Farley: How to Build Better Software Faster No sample: from the description and table of contents. 2025.
- 26.Get Your Hands Dirty on Clean Architecture (2nd edition), Tom Hombergs: A Hands-on Guide to Creating Clean Web Applications with Code Examples in Java No sample: from the description and table of contents. 2023.
- 27.Hands-on Domain-driven Design - by example, Michael Plöd: Domain-driven Design practically explained with a massive case study No sample: from the description and table of contents. 2020.
- 28.arc42 by Example, Gernot Starke, Michael Simons, Stefan Zörner, Ralf D. Müller, Hendrik Lösch: Software Architecture Documentation in Practice No sample text (the download failed): from the description and table of contents. 2023. Free sample: PDF · EPUB
- 29.Residues: Time, Change, and Uncertainty in Software Architecture., Barry M O’Reilly No sample: from the description. 2024.
- 30.Getting Value out of Agile Retrospectives, Ben Linders, Luis Gonçalves: A Toolbox of Retrospective Exercises The free sample was not used: from the description and table of contents. 2016. Free sample: PDF · EPUB
- 31.How To Be A Tech Lead, Michael Rice: A practical guide for new and experienced tech leads to increase their confidence, effectiveness, and impact No sample: from the description and table of contents. 2019.
Further reading
Other widely read books in the library on neighbouring ground, not cited above; most belong to the narrower subjects.
- Mastering Software Development in R, Roger D. Peng, Sean Kross, Brooke Anderson Building tools for data science in R, from a sequence of courses. 2017. Free sample: PDF · EPUB
- How to Tango with Django 1.9/1.10/1.11, Leif Azzopardi, David Maxwell: A beginners guide to Python/Django A student's guide to building a web application in a Python framework. 2018. Free sample: PDF · EPUB
- Go, from the beginning, Chris Noring: from o to hero A beginner's walk through the Go language. 2022.
- GitOps, Florian Beetz, Anja Kammer, Dr. Simon Harrer: Cloud-native Continuous Deployment A short introduction to deployment driven from a repository. 2021.
- The Agile Coaching DNA, Manoel Pimentel Concepts, techniques and stories for coaches of agile teams. 2019.
- Jetpack Compose internals, Jorge Castillo How one interface toolkit for mobile applications works inside. 2022.
- Web Hacking 101, Peter Yaworski: How to Make Money Hacking Ethically Common web vulnerabilities explained through published reports. 2018. Free sample: PDF · EPUB
- Learn Bash the Hard Way, Ian Miell: Master Bash Using The Only Method That Works A hands-on course in a command shell. 2019. Free sample: PDF · EPUB
- Machine Learning Engineering, Andriy Burkov Building machine learning systems from scoping to deployment. 2020. Free sample: PDF
- Why We Still Suck At Resilience, Adrian Hornsby: Organizational Dynamics Why practices meant to make systems resilient so often fail to. 2026. Free sample: PDF · EPUB