Skip to content

Software Engineering

This reference syllabus describes the MAGE software engineering curriculum as a semester-long course. It is based on ECE 30861 — Software Engineering at Purdue University.

See the Calendar for sequencing, Lectures for instructional materials, the Semester Project for project materials, and Assessment for project and oral-exam guidance.

Course description

Software engineering studies how to design, build, evaluate, operate, and evolve software systems.

The course covers:

  • software process and teamwork;
  • requirements and specification;
  • architecture and design;
  • implementation and representation;
  • validation and assurance;
  • deployment, operations, and security;
  • maintenance and evolution; and
  • professional judgment.

Students apply these ideas throughout a semester-long team project. Generative AI is used throughout the software engineering lifecycle.

Teaching goal

The course emphasizes engineering control and judgment: students learn not only software engineering practices, but how to understand and direct a complex software system, evaluate the evidence for its behavior, and decide which engineering practices and tradeoffs fit the system and why.

Topics are therefore organized around engineering problems, tradeoffs, and evidence rather than as a catalog of techniques. GenAI makes this emphasis especially important because substantial implementation work can be delegated while responsibility for the resulting system cannot.

MAGE provides one framework for reasoning about this shift. The course does not require adopting the MAGE framework.

Intended audience and prerequisites

This is a first course in software engineering for students who already have substantial programming and project experience.

The Purdue course assumes:

  • upper-level undergraduate standing;
  • substantial programming experience;
  • preparation in data structures and algorithms; and
  • prior experience completing nontrivial engineering projects.

It does not assume prior coursework in software engineering.

The semester project relies on this prior project experience. If you are reusing this course, account for this distinction: students with less project experience will need a smaller project or more implementation scaffolding.

Course learning outcomes

By the end of the course, students should be able to:

  1. Choose and justify a software process for a given engineering context.
  2. Develop and validate requirements and specifications.
  3. Design and justify a software architecture.
  4. Evaluate software using appropriate forms of evidence.
  5. Defend engineering decisions made during a team software project.

Course structure

The curriculum has three acts:

  • Act I — Foundations: process, teamwork, requirements, architecture, and design.
  • Act II — Building Systems & Governing Changes: implementation, agentic engineering, and assurance.
  • Act III — Software in the World: operations, security, maintenance, evolution, and professional judgment.

See the Calendar for one 16-week sequence.

Assessment

The course uses three forms of assessment:

  • Semester Project: sustained team application of the course material.
  • Oral Exams: individual explanation and defense of engineering decisions.
  • In-class Activities: formative practice with course concepts.

The oral exams complement the team project by assessing each student's individual command of the system and the engineering judgment behind it.

Reference grading scheme

The Purdue Fall 2026 offering used:

  • 75% — Semester Project
  • 15% — Oral Exams
  • 10% — Class engagement

These weights are an example, not a requirement of the curriculum.

Generative AI

Students use generative AI throughout the software engineering lifecycle.

Students remain responsible for:

  • the systems they submit;
  • the engineering decisions embodied in them; and
  • demonstrating sufficient command of those systems to explain, evaluate, and defend their engineering work.

Delegating work to an agent does not delegate responsibility.

Readings

Primary

  • James C. Davis, Model-Based Agentic Software Engineering, 2026.
  • Titus Winters, Tom Manshreck, and Hyrum Wright, Software Engineering at Google, 2020.

Additional references

  • Ian Sommerville, Software Engineering, 10th ed.
  • Frederick P. Brooks Jr., The Mythical Man-Month.
  • Erich Gamma et al., Design Patterns.
  • Steve McConnell, Code Complete, 2nd ed.

Individual lecture pages provide topic-specific readings.

Technology

Students need access to:

  • a modern software-development environment; and
  • a capable generative-AI system suitable for software engineering.

Specific tools and vendors are left to the course offering.

Materials