Skip to content
Tutorials Center
My learning

Topics

Lesson 1 of 50 ยท What Software Engineering Is

What Is Software Engineering?

Learn what software engineering is, how it differs from programming, why projects fail, where the field came from and what roles make up a software team.

Anyone can write a program that works on their own laptop today. Software engineering is the discipline of building software that keeps working for other people, for years, while the team, the requirements and the technology all change. It is programming plus everything around programming: agreeing on what to build, designing it so it can be changed, checking that it works, delivering it, and looking after it afterwards.

A common short definition is "the application of systematic, disciplined, measurable approaches to the development, operation and maintenance of software". The words that matter are systematic (you do not rely on heroics), measurable (you can tell whether you are doing well) and maintenance (the work continues after the first release). This course walks through those ideas one at a time, starting with this lesson.

Software engineering cannot run on this page as a product, so the diagrams and checklists are text. The runnable examples are small JavaScript stand-ins: plain scoring code that makes an idea concrete. They are models for learning, not real project tools.

Programming versus engineering

Programming answers the question "how do I make the computer do this?" Engineering also asks "should we build this, what happens when it changes, who will maintain it, and how will we know it is good enough?"

Programming and engineering

Programming Writing code that solves a problem.
Engineering Building and keeping a solution for many people.

Engineering includes programming. It is not a replacement for it.

1 / 2

Think of a bridge. A person can lay planks across a stream in an afternoon. A bridge for thousands of cars needs surveys, loads calculations, inspections and a maintenance plan. Software has no physical weight, but it has the same pattern: the bigger the system and the more people depend on it, the more the surrounding discipline matters. Typical differences:

  • Size and lifetime. Programs written by one person for a weekend are discarded. Products live for ten years and are changed by dozens of people, most of whom never met the original author.
  • Teams. Code is read far more often than it is written, and several people edit it. Conventions, reviews and documentation replace "ask the person who wrote it".
  • Change. Requirements move. Engineering assumes change and designs for it; see design principles later in the course.
  • Consequences. Software controls payments, medical devices and aircraft. Errors cost money, privacy and sometimes lives.

A short history: the software crisis

In the 1960s computers became powerful enough that people tried to build very large programs, such as operating systems and airline reservation systems. Many projects ran late, cost far more than planned, did not do what users needed, or were too buggy to trust. In 1968 a NATO conference in Garmisch, Germany, used the phrase software crisis for this situation, and the term "software engineering" was popularized there on purpose: the aim was to bring the habits of engineering to a craft that had grown too fast.

The decades since produced a long list of responses: structured programming, object-oriented design, formal process models such as waterfall, iterative methods, and later agile practices. None of them ended project failures, but together they made the field far more predictable. A useful lesson from history is that there is no single fix: each idea works well in some contexts and badly in others, which is why choosing a process is a skill of its own.

Why projects fail

Studies of failed software projects keep finding the same few causes, and almost none of them are "the programmers could not code":

  1. Unclear or changing requirements. The team builds the wrong thing, or builds the right thing for last year's problem.
  2. Unrealistic estimates and schedules. A deadline is chosen first and the scope is squeezed into it.
  3. Poor communication. Customers, developers and testers hold different pictures of the product.
  4. Unmanaged risk. Known dangers (a new technology, a key person leaving) are never discussed until they hurt.
  5. Weak quality practices. Bugs are found at the end, when fixing them is most expensive.
  6. Scope creep. Features keep arriving with no matching change in time or budget.

Each cause maps to a part of this course: requirements, estimation, team practice, risk management and testing. Failure is rarely a single event; it is usually a chain of small unaddressed problems.

What "good" means

Working code is the minimum. Good software also has the qualities that users and maintainers care about: it is correct, reliable, secure, fast enough, easy to use and easy to change. These often pull against one another, and engineering means choosing deliberately. The next lesson, Qualities of Good Software, covers them in depth. For now, try a tiny model of the idea: score a project on a few qualities and see how its weakest area limits it.

JS Score a project against quality attributes

Press Run (or Ctrl + Enter) to see the console output here.

No output.

The weighted average hides one thing the "weakest quality" column shows: a single very low score, such as security of 2, can sink a product that looks fine on average. That is why engineers check each quality separately.

Roles on a software team

Titles differ between companies, but most teams cover the same responsibilities. One person may hold several roles, especially in small teams.

  • Product owner or product manager decides what is worth building and in what order.
  • Business analyst or requirements engineer gathers and writes down needs.
  • Architect shapes the overall structure and the big technical decisions.
  • Developer designs, writes and reviews the code.
  • Tester or QA engineer plans checks, finds defects and measures quality.
  • DevOps or site reliability engineer automates delivery and keeps the system running.
  • Designer (UX/UI) shapes how the product feels to use.
  • Project or delivery manager tracks schedule, risk and communication.

The next TryIt turns that list into a small data model. It shows how a feature passes through several roles, and why handoffs are a typical place for misunderstandings.

JS A feature passing through roles

Press Run (or Ctrl + Enter) to see the console output here.

No output.

Modern teams try to reduce handoffs by working together in small cross-functional groups; you will see how in Agile principles and later chapters. The roles still exist; the walls between them become thinner.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. Which statement best separates software engineering from programming?

    Programming is one activity inside software engineering, which also covers agreeing on what to build and keeping the product working over time.
  2. 2. What was the 'software crisis' of the 1960s?

    As systems grew, many projects overran budgets and schedules or delivered unreliable products, which led to the call for an engineering approach.
  3. 3. Which is the most common cause of project failure according to the lesson?

    Failures are usually about people, planning and requirements rather than raw coding skill.
  4. 4. Why does the quality-scoring example report the weakest quality as well as the average?

    An average can hide a critical weakness, so engineers look at each quality separately.

Summary

  • Software engineering is the systematic, measurable building, delivery and maintenance of software, not just coding.
  • The software crisis of the 1960s motivated the field; later process models and practices improved predictability but never removed risk.
  • Most failures come from requirements, estimates, communication, risk and quality, not from coding ability.
  • Good software balances qualities such as correctness, security and maintainability; the weakest one often decides success.
  • Teams share responsibilities across roles such as product owner, developer, tester and DevOps, and every handoff needs clear communication.

Next: Qualities of Good Software.