We stand on the shoulders of giants. Let's build on their work.

“If I have seen further, it is by standing on ye shoulders of giants.” Isaac Newton, in a letter to Robert Hooke, 5 February 1675/76.

The practices of software engineering, named in the literature's own words, each backed by the books, papers and articles that name it. Say which ones you use.

28 practices
  1. Acceptance test

    A test of a specified acceptance criterion, written before the code from what the user should see, which the code must then pass.

    3 sources

  2. Approval testing

    A person approves an output once, and every later run must reproduce it until a new one is approved.

    named by ApprovalTests1 source

  3. Architectural fitness function

    An automated check that gives an objective verdict on one characteristic of the architecture, run like a test.

    1 source

  4. Characterization test

    A test records what the code does today, right or not, so that a change to it cannot go unseen.

    named by Michael Feathers2 sources

  5. Code generator (scaffolding)

    A command lays down the files of a new part of the code from a template, so they start in the shape the project expects.

    2 sources

  6. Code mode

    The agent writes a program that calls its tools, run in one step, rather than calling each tool itself and reading every result.

    named by Kenton Varda, Sunil Pai2 sources

  7. Codemod

    A program rewrites the code base mechanically, the same change at every place a pattern matches, instead of a person or an agent making each edit.

    named by Justin Rosenstein3 sources

  8. Contract test

    One suite of tests runs against both a fake and the real implementation, so the fake the other tests use is known to behave like the real one.

    named by J. B. Rainsberger2 sources

  9. Decision table testing

    Every combination of a finite set of conditions is listed with its expected outcome, and each row becomes a test.

    1 source

  10. Domain-driven design

    The code is shaped on a model of the business, written in the words its experts use, and kept apart from the technical concerns around it.

    named by Eric Evans2 sources

  11. Equivalence partitioning and boundary value analysis

    Inputs are split into classes the code should treat alike, and each class is tested once inside it and at each of its limits.

    3 sources

  12. Fuzzing

    A program is fed random or malformed input to find the inputs that make it crash or hang.

    named by Barton P. Miller, Lars Fredriksen, Bryan So1 source

  13. Golden master

    The output of a reference run is kept, and every later run is compared with it to catch any change in behaviour.

    1 source

  14. Hexagonal architecture (ports and adapters)

    The application talks to the outside only through ports, each served by an adapter, so its core depends on nothing outside it.

    named by Alistair Cockburn1 source

  15. Language server

    One server per language answers an editor or an agent about the code, its definitions, references and errors, through a common protocol.

    named by Microsoft2 sources

  16. Make illegal states unrepresentable

    Types are shaped so that a state the program must never reach cannot be written, and the compiler refuses it.

    named by Yaron Minsky1 source

  17. Metamorphic testing

    When the right output is unknown, two runs whose inputs are related are checked for outputs that relate the same way.

    named by Tsong Yueh Chen, S. C. Cheung, S. M. Yiu2 sources

  18. Model-View-ViewModel (MVVM)

    A view binds to a view model that holds its state and commands, so the interface's logic can be tested without the interface.

    named by John Gossman1 source

  19. Mutation testing

    Small faults are planted in the code, and a test suite that still passes on one of them has a gap to fill.

    1 source

  20. Parse, don't validate

    Input is checked once, at the boundary, into a type that keeps what was checked, so the rest of the program never meets an invalid value.

    named by Alexis King1 source

  21. Property-based testing

    Generated inputs are checked against a property that must always hold, and a failing input is shrunk to the smallest one that still fails.

    named by Koen Claessen, John Hughes1 source

  22. Ratchet

    The violations a code base already has are accepted and recorded, and the check fails on any new one, so the count can only go down.

    6 sources

  23. Separation of duties

    The one who does the work is not the one who checks it, because a measure the doer controls stops measuring.

    named by Jerome H. Saltzer, Michael D. Schroeder4 sources

  24. Smoke test

    A quick run of the main paths of the whole system, end to end, to see that it works at all before deeper testing.

    1 source

  25. Snapshot testing

    A test framework stores an output the first time a test runs and fails when a later run produces a different one.

    named by Meta1 source

  26. Stateful (model-based) testing

    Generated sequences of commands are run against the system and against a simple model of it, and the two must agree at every step.

    named by John Hughes2 sources

  27. Test sizes

    A test is small, medium or large by what it touches, one process, one machine or beyond, which decides its speed and its flakiness better than unit or integration.

    named by Simon Stewart2 sources

  28. Unit testing

    A test exercises a small part of the code, such as one function or class, fast enough to run on every change, with its collaborators real or replaced.

    1 source

A practice missing?Propose a practice
+ Propose a practice