Software Engineering

Process, methods, and tools for building reliable software systems.


foundation tier

Software Engineering addresses process, methods, and tools for building reliable software systems. It sits within Programming and Languages and inherits that area’s core questions about correctness, scale, and tractability. This page surveys the conceptual axes of the topic and points to the references that frame ongoing research and teaching. The intent is to be useful both as an entry point for newcomers and as an index for practitioners cross-checking their mental model against the field’s primary sources.

Work on software engineering can be organised around a few interlocking concerns: the formal objects under study, the algorithms or systems that compute over them, the resource trade-offs (time, memory, communication, statistical efficiency), and the empirical or theoretical guarantees that practitioners rely on. The sources cited below approach the topic from a mix of these angles.

Foundational references

Sommerville, Software Engineering (2015) is a standard reference for this material and is used both as a curriculum anchor and as a long-form survey of techniques.

Supporting and complementary work

Winters, Software Engineering at Google (2020) provides supporting material that complements the primary references — readers comparing approaches will find useful framings, alternative notations, or extensions there. Martin, Clean Code (2008) provides supporting material that complements the primary references — readers comparing approaches will find useful framings, alternative notations, or extensions there.

Open methodological questions in software engineering cluster around how to compose the techniques above under realistic constraints — scale, adversarial inputs, partial observability, and shifting workloads. The cited references give the precise statements, proofs, and empirical evaluations that this overview only sketches; downstream topic pages drill into specific subfields.

Prerequisites

Sources

  • textbook · primary · 2015
    Software Engineering
    sommerville-2015
  • textbook · supporting · 2020
    Software Engineering at Google
    winters-2020
  • textbook · supporting · 2008
    Clean Code
    martin-2008

In context

Where this topic sits in the prerequisite graph. Click any node to jump.

Open in full atlas →

Explore

  1. 01

    Software Architecture

    Architectural styles, patterns, and quality attributes.

  2. 02

    Design Patterns

    Reusable OO and functional design patterns.

  3. 03

    Software Testing

    Unit, integration, property-based, and end-to-end testing.

  4. 04

    Fuzz Testing

    Coverage-guided and grammar-based fuzzing.

  5. 05

    Static Analysis

    Lint-style and deep static analyzers for bugs and vulnerabilities.

  6. 06

    Dynamic Analysis

    Profilers, sanitizers, and runtime instrumentation.

  7. 07

    Empirical Software Engineering

    Data-driven studies of software development practices.

  8. 08

    Mining Software Repositories

    Extracting patterns from version histories and bug trackers.

  9. 09

    Version Control Systems

    Distributed VCS internals (Git, Mercurial) and branching models.

  10. 10

    Build Systems

    Incremental, hermetic, and distributed build systems (Make, Bazel, Nix).

  11. 11

    DevOps and CI/CD

    Continuous integration, delivery, and deployment pipelines.

  12. 12

    Site Reliability Engineering

    SLOs, error budgets, and production reliability practices.

  13. 13

    Observability

    Metrics, logs, traces, and distributed-systems observability.

  14. 14

    AI for Software Engineering

    Code completion, bug finding, and AI-assisted programming.

  15. 15

    Automated Program Repair

    Search-, constraint-, and learning-based patch generation.


Review this topic

This page was drafted by an agent and is waiting on expert review. Spotted a wrong prerequisite, a missing concept, a misattributed source, or a factual slip? Tell us — your review opens a tracked issue maintainers act on.