Software Engineering UKSoftware Engineering UK
Software Engineering: The Case for and Against
Software Engineering UK

Software Engineering: The Case for and Against

Omar EvansWords by Omar Evans

It is possible to adopt every visible sign of engineering practice and still watch the same class of defect return within a few releases; the common explanation is that discipline slipped, but the more accurate one is that no one ever wrote down a statement the team could check and no one was accountable for the cost of a mistake. That gap is where the debate about software engineering actually exists.

Software engineering is used in two ways. It is a discipline: a set of obligations that make a changing system safe to build and safe to hand over. It also shows a job title, a salary band, a course label and a badge on a job advert. The discipline earns its case. The title often does not. This page separates the two, because most disputes about software engineering are really disputes about which one the speaker means.

The assertion that makes engineering different from programming

Start with the principle. Engineering is the practice of making a checkable assertion about a thing that does not exist yet, attaching an owner to that assertion, and accepting the cost when evidence contradicts it. A programmer can write code that works on their machine and call the job done. An engineer has to state what working means under conditions the author will not control.

Michigan Technological University defines software engineering as the branch of computer science that deals with the design, development, testing and maintenance of software applications, where engineers apply engineering principles and knowledge of programming languages to build solutions for end users (Michigan Technological University). The definition is plain, but the order matters. Design, testing and maintenance are not later stages added to coding. They are the parts that make the assertion checkable.

The University of Edinburgh's programme page makes the same point through its list of system requirements: reliability, maintainability, usability and cost-effectiveness, with practical application as computer systems grow in size and complexity (University of Edinburgh). Those are engineering words because each one can be argued about before the system exists. A maintainability assertion says a stranger can change the system with the evidence available. A cost-effectiveness assertion says the chosen design is worth its operating burden. If the team cannot state the goal, it is not doing software engineering, whatever its job titles say.

Why the discipline earns its keep

Software engineering shifts uncertainty into the open while the cost of an error is still low. A team that states its assertions early can test them against evidence, reject a direction before it becomes a sunk cost, and leave a record for the developer who inherits the system. That is not bureaucracy. It is the difference between a system that can be changed and a system that can only be defended.

Salford's course page draws a useful distinction: software engineers focus on the larger picture, including system design, architecture and overall software quality, while software developers are more focused on specific code implementation and functionality (University of Salford). That is not a rigid division of labour, because good developers do design work and good engineers write code. The value is in the direction of attention. Engineering asks what happens to the system when the current author is gone, the traffic pattern changes, or the dependency is no longer maintained.

External accreditation is the institutional version of the same idea. Southampton says its software engineering degree is accredited by the Institution of Engineering and Technology and the British Computer Society, with the accreditation meeting part or all of the academic requirement for professional registration (University of Southampton). That matters because it gives an employer and a graduate a shared reference point beyond the label on a CV. It is also a warning: accreditation can become a gate, and a gate is not the same thing as a discipline.

Where the title outruns the practice

The case against software engineering is not a case against rigour. It is a case against the way the term is sold. Prospects notes that job titles in this industry are not standardised, and that a software engineer may be called a programmer, engineer, developer or something named after a language (Prospects). Once a title can mean almost anything, it stops carrying an obligation. A company can advertise for a software engineer and ask for exactly the code production it would have asked from a developer, without any of the checkable assertions, ownership or reversal ways that engineering implies.

The entry routes make the same point from another direction. The Complete University Guide reports that a degree is no longer the only way into software engineering, mentioning apprenticeships, bootcamps, self-teaching with a portfolio and employer-led training alongside traditional degrees (The Complete University Guide). That openness is good for the field. It also means the word engineer cannot be used as a proxy for a shared body of practice. The practice has to be demonstrated in the work, not inferred from the hiring process.

This has been seen in review rooms. A team presents a delivery plan with every ceremony in place: The stand-up, the sprint duration, the ticket hierarchy, and the definition of ready are the tools used to organise work. Then someone asks what promise the release makes about the system under load, who owns the answer if the promise fails, and how the change is reversed. The room goes quiet. The process was never the engineering. It was the scheduling around the engineering, and the engineering part had not been written down.

The cost of copying the form and skipping the assertion

The most common failure is not a lack of technical skill. It is substitution. A team substitutes a toolchain for a statement, a ceremony for an owner, or a title for a standard. The substitution feels productive because it produces artefacts. There are dashboards, documents and meetings. Not one of the documents states what the system must do under conditions no one has seen yet, and not one of them specifies the individual who will accept the cost if the system does not do it.

This is why the case against software engineering often sounds like a case against process. People are not rejecting engineering. They are rejecting the paperwork that arrived without the obligations. The test is simple enough to apply in a single review. If the team cannot point to a requirement, an owner and a way to undo changes, then the engineering is absent regardless of how many artefacts surround it.

Four checks that turn the label back into a discipline

The principle becomes practical when a team can run these checks without waiting for a new methodology.

  1. Write the statement about the system, not the task. The assertion should specify behaviour under stated conditions and identify the evidence that would prove it false. The statement that the checkout remains available during the peak window is an assertion. "Finish the checkout tickets" is a task list.

  2. Name the owner who can accept the cost. The owner is not the individual who writes the code by default. The owner is the individual with the authority to change the design, delay the release or accept the risk. If no one has that authority, the assertion is only a wish.

  3. Define the reversal before the change ships. A release without a way back is not an engineering decision. It is a bet with the system as collateral. The reversal can be a rollback, a feature flag, a data migration plan or a manual fallback, but it has to be written and tested.

  4. Place the assertion where the next engineer will find it. The record has to survive the author, the sprint and the reorganisation. A short configuration record beside the change is enough if it includes the request, the owner and the reversal.

claim: checkout stays available through the agreed peak window
owner: payments-platform-lead
evidence: production traffic replay plus load test result
reversal: disable new pricing path and restore previous queue depth
review_date: next architecture review

That record is not a project plan. It is the smallest unit of software engineering: an assertion another individual can verify, an owner who can be called, and a reversal that limits the cost of an error.

What the case leaves standing

The case for software engineering is the case for making claims explicit before the system makes them for you. The case against is the case against a title that promises engineering and delivers a job description. Both can be true at once. The discipline is worth adopting because it reduces the hidden work of maintenance and gives a team a way to argue about risk without pretending that risk is absent. The title is worth distrusting because it is cheap to grant and hard to verify.

The practical answer is not to abolish the term or to defend it as a status symbol. It is to ask a narrower question in every review: What assertion is this change making, who owns the consequence, and how do we reverse it? A team that can answer those questions is doing software engineering. A team that cannot is using the name. The difference will show up long after the job advert has been forgotten.

Sources

The usual questions

What is the difference between software engineering and programming?

Programming focuses on writing code that works. Engineering involves making checkable claims about how a system will behave under conditions the author does not control.

Why is software engineering useful for teams?

It identifies uncertainties while the cost of being wrong is low. This allows teams to reject poor directions before they become sunk costs.

Are software engineering job titles standardised?

No, job titles are not standardised. A software engineer might be called a programmer, developer, or named after a specific language.