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

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)

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 / 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 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

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 [4]

software development is like gardening - cont.

how big are softwares?

software is often measured by the source lines of code

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 [6]

software growth – car industry

• 1981, GM was using microprocessor-based engine controls executing about 50 000 lines of code [8]
• 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 [8]
• in a modern car [2023], you can expect to find 50 to over 100 ECUs [9]
• for hybrids, the amount of software required for engine control is almost double that of a standard car [8]

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%

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.

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

from Michael Bykovski’s essay [15]

• 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 [16]
• 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

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 [19]

software development is more like gardening

software growth