Software engineering

(the disciplined process of designing, building, and maintaining reliable software)

What is software engineering?

Software engineering is the disciplined process of designing, building, testing, and maintaining software — not just writing code that works once, but building it in a way that stays correct, understandable, and fixable as it grows and changes over time.

The stages of building software

Most software passes through similar stages: gathering requirements (what should this software actually do?), design (how will it be structured?), implementation (writing the code), testing (checking it actually works), deployment (releasing it for real use), and maintenance (fixing problems and adding improvements afterward — often the longest stage of a piece of software's life).

Why testing matters: a concrete example

Imagine a shopping cart function that calculates a total price, but the programmer only ever tried it with items that all cost the same price. It might work perfectly in that one case, while silently producing the wrong total the first time two differently-priced items are combined. A unit test — a small, automated check that runs the function with specific inputs and verifies the output is exactly correct — catches this kind of mistake before it ever reaches a real customer, and catches it again automatically if a future code change accidentally breaks it.

Version control: tracking every change

Version control systems record every change made to a project's code over time, who made it, and why. This matters for two direct, concrete reasons: if a change turns out to be a mistake, it can be undone precisely, without losing any other work; and when multiple people work on the same project, version control can combine their separate changes together, and flag it clearly if two people happened to change the exact same part of the code in conflicting ways.

Why software engineering matters

Code that merely "works" once is very different from code that keeps working correctly as new features are added, as more people use it, and as new programmers who didn't write the original version have to understand and modify it. Software engineering is the set of practices — testing, careful design, version control — that make that ongoing reliability possible, rather than leaving it to chance.