Files
ProcessControl/Schedule.md
T

7.4 KiB
Raw Blame History

SIN.04028 – Course Schedule

Autumn Semester 2026

This is a hands-on course.

We will learn about distributed systems, Event-Driven Architectures, and Sensor–Actuator Networks by building things, experimenting, breaking things, repairing them, and trying again.

At the beginning, we will work through several examples together. Later, you will increasingly have to find your own solutions.

Our short-term goal is rather simple:

Make the cars race – and win.

There is, however, a somewhat more serious goal behind all this:

Learn how autonomous and distributed systems can be designed — and understand what makes an architecture truly Event-Driven.

Do not expect us to tell you everything in advance.

Sometimes the important part of an exercise will be realizing that you are missing something.


Before the course

Please make sure that you have:

  • a working installation of Java 26 or Java 27;
  • access to a terminal / command line;
  • preferably a relatively simple programming environment;
  • and some curiosity.

We deliberately want to work relatively close to the underlying technologies.

Working with LLMs

You may use LLMs.

But the exercises in this course are intentionally small enough that the main objective is not generating code. The objective is to make sure that the important concepts end up in your brain.

Using an LLM to figure out the syntax of a library, an API call, or a particular implementation detail is perfectly reasonable.

But afterwards, you should still be able to explain what your system is doing and why.

And please ask us questions — including questions that arose while talking to an LLM.


Weekly Schedule

Date Mission What we will do
15 Sep 2026 Getting Ready What does it actually mean to control another process? What changes if that process is somewhere else? We introduce the course, distributed systems, different architectural ideas, and our main architectural theme: Event-Driven Architecture. Then we begin with something harmless: ROT13.
22 Sep 2026 Fighting to the Metal We take ROT13 further than anyone reasonably should. Processes become separated, communication becomes external, and suddenly architecture starts to matter. We will explore the difference between telling another component what to do and reacting to what has happened.
29 Sep 2026 Something Faster Files work. But perhaps there are better ways of exchanging very small pieces of information. We introduce MQTT, Publish/Subscribe, clients, brokers, topics, YAML/JSON and MQTT Explorer. Then we revisit an old problem with a new communication mechanism. Groups will be formed.
06 Oct 2026 Now You Do It Build your own small distributed system. Technology is not the important part. Architecture is. Your system must be Event-Driven, and you must be able to convince us that it really is. Continue developing your system. Simplify it. Break it. Repair it. Explain it. We will inspect your architecture and may ask inconvenient questions.
13 Oct 2026 Graded Exercise I Present your first system and report. We will look at architecture, simplicity, understanding, explicability, and scientific/technical writing. A working system is useful. Understanding why it works is more important.
20 Oct 2026 Disco Time A new system appears. It has wheels. First challenge: communicate with it. Second challenge: make something visible happen. You will encounter a separate network, an unfamiliar API, messages, commands and a small vehicle that may or may not listen to you.
27 Oct 2026 Make It Yours The vehicle can do more than one thing. Build an Event-Driven interface that lets a user interact with it. The technology and design of the interface are up to you. We care about both architecture and user experience.
03 Nov 2026 RaceTrack I – Humans There is now a track. Your job is to drive the vehicle around it using your own remote-control interface. Functionality matters. Usability matters too. There may even be a small competition. If you notice that the vehicle or track can do more than we explicitly asked for, feel free to investigate.
10 Nov 2026 RaceTrack II – No Humans Same track. Different problem. The human driver disappears. Your vehicle now has to race autonomously. At some point you may discover that simply telling the car to “go fast” is not quite sufficient.
17 Nov 2026 RaceTrack III – That Was Too Easy A new track. Different geometry. Different opportunities. A solution that was optimal last week may suddenly no longer be optimal. There might even be ways of travelling through the track that are considerably faster than others. The interesting question is: how would your system know?
24 Nov 2026 Concourse / Gymnasium Race. Test. Compare. Debug. Improve. It is your autonomous vehicle vs human controlled vehicles. (We will design the track together in advance!)
01 Dec 2026 RaceTrack IV – The Track Knows Things Until now, you have mostly concentrated on the vehicle. Perhaps that is not the only interesting source of information. We introduce another piece of the puzzle and see what new Event-Driven behaviours become possible. What you do with that information is up to you.
24/7 ;-) Build Something Good Open development session. Integrate everything you have learned. Experiment. Simplify. Optimize. Add ideas that we did not ask for. Most importantly, make sure that your entire group understands the resulting system.
15 Dec 2026 Finale Show us what you managed to build. Race it. Demonstrate it. Explain it. Defend the architecture. Surprise us if you can. It should be a little difficult — but hopefully also fun.

Assessment

The final course grade consists of:

Assessment Weight
Individual graded exercise 30%
Group graded exercise / final presentation 30%
Final written examination 40%
Total 100%

For practical work, producing something that works is only one part of the exercise.

You should also be able to:

  • explain your architecture;
  • distinguish Event-Driven from Command-Driven interaction;
  • keep unnecessary complexity out of your solution;
  • justify your technical decisions;
  • understand the technologies you use;
  • and explain your work clearly.

What if your group is faster?

Good.

Different groups will progress at different speeds.

If your group finishes an exercise early, do not assume that you have to stop. There are always more difficult things one can try.

You may encounter additional features, modified tracks, new constraints, or completely unnecessary challenges.

And if you ask:

“Could we also…?”

there is a significant chance that our answer will be:

“Interesting. Try it.”

There is only one catch:

If you claim it can be done, we may ask you to demonstrate it.


One Last Warning

The schedule above tells you roughly what problem we will attack each week.

It deliberately does not tell you every tool, trick, event, feature or architectural possibility that you may encounter along the way.

Discovering that you need something is sometimes part of the exercise.

Build it. Test it. Question it. Understand it. Explain it.