goal of this course

• provide a common foundation in software engineering for students from various backgrounds
• provide a shared terminology to be able to work seamlessly with software developers
• introduce the fundamentals of modern software development methodologies and life cycle models
  • with focusing in details on Scrum and Kanban
• introduce requirements analysis and software modelling
  • both in theory and in practice
• provide an insight to code quality, code review, testing and automation

practise

• during the practical classes, the students explore and document the requirements of a software system
  • using user story mapping in accordance with the agile principles
• then, during the second half of the semester, they design its architecture
  • using the C4 model, which is a set of hierarchical diagrams describing the architecture of a software system
• the practical classes are workshops in which the students work in teams
  • under an instructor’s guidance, and can have immediate feedback on the project assignment

schedule

evaluation

tools

program vs. software

program is like a recipe

for i in range(1, 101):
    if i % 15 == 0:
        print("" + "FizzBuzz")
    elif i % 3 == 0:
        print("" + "Fizz")
    elif i % 5 == 0:
        print("" + "Buzz")
    else:
        print(i)

programming vs. software development

• does that mean a program is not
  • planned
  • documented
  • tested
  • verified?
• the main difference is the formality of the process
  • which correlates the complexity of the project

Software development is about translating a problem into a solution that a computer can understand and automatically resolve. Preferably in a secure and scalable way.

– Frederick Vanbrabant

software engineering in the age of AI LLM

• if your task was to improve project throughput, your first stop would be software development
• because that takes the most amount of time

software engineering in the age of AI LLM / 2

expectation: AI’s going to make it so much faster

Every software developer knows that you can’t make projects go faster just by typing faster. If that were the case we would all be taking typing lessons.

Frederick Vanbrabant

software is made between commits

coding agents generate code based on specification

which can get performing a requirement analysis

What software developers have been begging for since the beginning of the profession: Receiving a detailed outline of the problem and what the end result should look like.

Frederick Vanbrabant

from today, is software engineering dead?

software development is like building a house

• the software development is often compared to house building
  • which is more like a sequential process
• after the planning (including building permit, budget, etc.), the foundation is built first, then walls and the roof
  • these phases cannot be swapped
• after the construction is finished, the contractor leaves the site

software development not is like building a house

a software does not have to obey the laws of physics

• in software development you can start with the door of the second floor bathroom
• the size of a room can be changed during the construction – even several times

software development is like gardening

what is software rot?

dormant rot: the software in question is not changed, but as the environment evolves, it eventually becomes dysfunctional

Muni metro’s control software is still loaded from floppy disks (Harding, 2024)

active rot

• the software has undergone constant modifications but gradually loses its integrity
• the constant updates / bug fixing can lead to an evolution process,
  • which makes the program deviate from its original design,
  • even introducing newer bugs

software development is like gardening - cont.

how big are softwares?

software is often measured by the source lines of code

for i in range(10):
    print(i)

for i in 0..9 do
   puts i
end

# print numbers from 0 to 9
(0..9).each {|i| puts i}

how big are softwares?

software is often measured by the source lines of code

measurements made with tokei, the whole repo is counted

software growth

number of lines of code is increasing

why does software grow?

software growth – aircrafts

24 million lines of code – operational and support – needed for the F-35 to be fully operational; when the program started, the estimated number of lines of code required was closer to 15 million

– Robert N. Charette, F-35 Program Continues to Struggle with Software (Charette, 2012)

software growth – car industry

• 1981, GM was using microprocessor-based engine controls executing about 50 000 lines of code (Charette, 2009)
• even low-end cars now [2009] have 30 to 50 electronic control units (ECUs)
  • that means these cars “execute” tens of millions of lines of software code that control everything from your brakes to your radio volume (Charette, 2009)
• in a modern car [2023], you can expect to find 50 to over 100 ECUs (Walker, 2023)
• for hybrids, the amount of software required for engine control is almost double that of a standard car (Charette, 2009)

measuring code lines?

• in 1982, some managers of the Lisa team decided to track each developer’s weekly code output
  • developers had to report every Friday the number of LOC they wrote that week
• Bill Atkinson was working on optimizing Quickdraw’s region calculation at that time, and he had completely rewritten the region engine using a simpler, more general algorithm, which got almost six times faster
  • as a by-product, the rewrite saved about 2000 LOC
• that week’s output, in terms of lines, was -2000

Quickdraw: 2D graphics library

the more, the better?

if we wish to count lines of code, we should not regard them as “lines produced” but as “lines spent”

E. W. Dijkstra EWD 1036

keep it simple

Zawinski’s law of software envelopment

Every program attempts to expand until it can read mail. Those programs which cannot so expand are replaced by ones which can.

– Jamie Zawinski

• programs experience pressure to evolve into toolkits and application platforms
• often interpreted as a comment on software bloat

users only care about 20% of your application

• 80% of the users will only ever use about 20% of your application’s features
• but not enough to implement only 20%
• because each user uses a different 20%

Linux 5.8 – 800,000 new lines of code

• how is it manageable?
  • process
  • version control
• each change must do only one thing
  • proper documentation
• changes cannot break the software
  • rigorous and automated testing

version control

• version control (a.k.a. revision control) is system for recording and managing changes made in files
• commonly used to manage source code
  • however, it can be used to tracking changes to any kind of files
• people often employ their own version control system, without realising it

why you should use version control (for everything)

benefits of version control systems

• generate backups
• separates experiments from the working version
  • branching, deployment strategies (much later in the course)
• keep history and track changes
  • traceability
• foster collaboration and contribution
  • team work

The current level of software complexity is not manageable without allowing many people to work on the same code base, and the separation of the development versions from the production one.

complexity

if you want to deliver product fast, and the developer time is expensive, reuse components

is it possible to decrease the dependency stack?

is it possible to decrease the dependency stack?

dependencies for transposing a spreadsheet

import pandas as pd


def transpose_with_pandas(path: str) -> pd.DataFrame:
    df = pd.read_excel(path)
    return df.transpose()

8 dependencies: numpy, pandas, python-dateutil, pytz, six, tzdata, et-xmlfile, openpyxl

dependencies for transposing a spreadsheet / 2

import numpy as np
from openpyxl import load_workbook


def transpose_without_pandas(path: str) -> np.ndarray:
    wb = load_workbook(filename=path, read_only=True)
    arr = np.array(
        [[cell for cell in row] for row in wb.active.iter_rows(values_only=True)]
    )
    return np.transpose(arr)

3 dependencies: numpy, et-xmlfile, openpyxl

dependencies for transposing a spreadsheet / 3

from openpyxl import load_workbook


def transpose_without_numpy(path: str) -> list:
    wb = load_workbook(filename=path, read_only=True)
    sheet = wb["Sheet1"]

    mx = []
    for row in sheet.iter_rows(values_only=True):
        mx.append(list(row))

    # https://stackoverflow.com/a/6473724/4737417
    return list(map(list, zip(*mx)))

2 dependencies: et-xmlfile, openpyxl

dependencies are used only to open an XLSX spreadsheet, the transposition is achieved only using the standard library

not trivial to understand the list(map(list, zip(*mx))),
read the explanation at Stack Overflow

why don’t you reimplement it (from scratch)?

trade-off between

• implementation speed (or ease of coding) and the number of dependencies
• reading/understanding the code and the number of dependencies

how much code a developer write

reimplementation costs

recalculating reimplementation costs

• with Opus 4.5 and enabling Agent Teams, the average net lines added by Claude per commit is 1,000 lines of code per commit
• which is ~2 magnitudes higher than what a human programmer writes per day

practically decreasing

complexity classes

source: (Bykovski, 2020)

complexity classes

from Michael Bykovski’s essay (Bykovski, 2020)

• in a simple system, we know the knowns, everything is predictable, it’s easy to understand the system
• in a complicated system, we know the knowns and unknowns
  • it requires analysis to know the unknowns, but the system is measurable
  • it is the province of engineers, surgeons, intelligence analysts, lawyers, and other experts (Wikipedia contributors, 2025a)
• in a complex system, the knowns are unknown to us, but we are aware of our uncertainty
• a chaotic system is a system of unknown unknowns

project complexity – Cynefin framework

• Cynefin framework is a conceptual framework used to aid decision-making
  • cynefin (/kəˈnɛvɪn/ kuh-NEV-in) is a Welsh word for ‘habitat’
  • created by Dave Snowden
• defines five decision-making contexts or “domains”
  • clear (aka simple)
  • complicated
  • complex
  • chaotic
  • confusion (or disorder)
• you can read more on Wikipedia

project complexity

what is software architecture?

“Architecture” is a term that lots of people try to define, with little agreement. There are two common elements: One is the highest-level breakdown of a system into its parts; the other, decisions that are hard to change.

– Martin Fowler - Patterns of Enterprise Application Architecture

In most successful software projects, the expert developers working on that project have a shared understanding of the system design. This shared understanding is called ‘architecture’. This understanding includes how the system is divided into components and how the components interact through interfaces. These components are usually composed of smaller components, but the architecture only includes the components and interfaces that are understood by all the developers.

Ralph Johnson, XP mailing list

All architecture is design but not all design is architecture. Architecture represents the significant design decisions that shape a system, where significant is measured by cost of change.

– Grady Booch

so, architecture

# Title

## Status

What is the status, such as proposed, accepted,
rejected, deprecated, superseded, etc.?

## Context

What is the issue that we're seeing that is
motivating this decision or change?

## Decision

What is the change that we're proposing and/or doing?

## Consequences

What becomes easier or more difficult to do
because of this change?

what are these decisions?

design is compromise

Compromise is neither good nor bad, it’s something we do every day. It’s decision making. Prioritizing. Deciding that one thing is more important than another. It’s finding the right balance between two competing desires.

Which compromises you make   — that’s what matters. Choosing the right compromises is what defines good design.

– Steph Ango

constructing a software design

There are two ways of constructing a software design:

One way is to make it so simple that there are obviously no deficiencies and the other way is to make it so complicated that there are no obvious deficiencies.

The first method is far more difficult.

– C.A.R. Hoare (Hoare, 2007)

summary: software engineering often compared to house building

software development is more like gardening

software growth

references