Computer Science Advanced · Professor Erklärbär

15:40

Episode 2

Number Systems – Advanced

What you will learn

any base: value = digit · base^position, Horner's method as a shortcut
hexadecimal: 1 hex digit = 4 bits, 0x41 = 65, colour code #E08A4E = 224 / 138 / 78
octal and file permissions: chmod 755 = rwx r-x r-x
two's complement: −13 = 1111 0011, 7 − 13 = −6 with a single adder
range and overflow: 100 + 50 = −106, Pac-Man level 256, Ariane 5, the year 2038
floating point: 5.75 in IEEE 754 and why 0.1 + 0.2 = 0.30000000000000004
five exam traps where most points are lost

Watch on YouTube Watched

13:21

Episode 3

Huffman, UTF-8, Hamming

What you will learn

one bit = one yes/no question: guessing a number up to 100 in seven questions, entropy
UTF-8 in detail: lead bits, continuation bytes, ä = C3 A4 and the umlaut glitch
Huffman tree for ABRAKADABRA: 23 instead of 88 bits – and why you cannot shrink everything
JPEG, MP3/AAC and video: leaving out what we do not perceive
parity bit, EAN check digit at the checkout, IBAN
Hamming code (7,4): find and correct an error · Reed–Solomon in QR codes
five exam traps

Watch on YouTube Watched

13:16

Episode 4

Boolean Algebra & Logic Gates – Advanced

What you will learn

Boolean algebra: A·B, A + B, Ā – and why 1 + 1 = 1
laws of Boolean algebra, the second distributive law and De Morgan
majority circuit: truth table → minterms → DNF → simplified circuit (with a Karnaugh map)
NAND does it all: NOT, AND and OR from NAND – and the Apollo computer made of NOR
full adder, 4-bit adder (5 + 6) and subtraction with an XOR row (7 − 3)
sequential circuits: SR latch, debouncing, D flip-flop, registers and counters
five exam traps

Watch on YouTube Watched

12:54

Episode 5

Computer Architecture – Advanced

What you will learn

von Neumann architecture: five parts, program and data in the same memory
inside the CPU: ALU, accumulator, program counter, instruction register, status flags and control unit
three buses – and why 32 address lines reach only 4 GiB
fetch → decode → execute: a mini program cycle by cycle (7 + 5 = 12)
memory hierarchy: if a cache access took one second, a hard disk access would take four months
the bottleneck, Harvard, pipelining (400 vs 103 cycles), RISC and CISC, GPUs
five exam traps

Watch on YouTube Watched

14:35

Episode 6

Algorithms & Big O – Advanced

What you will learn

counting steps instead of measuring seconds: best, average and worst case
linear search O(n) versus binary search O(log n): 23 in three comparisons instead of six, a million in 20
selection, insertion and bubble sort – and why they are quadratic
recursion: base case, factorial, the call stack for 4! and the Towers of Hanoi
merge sort: O(n log n) instead of O(n²) – 2 · 10⁷ instead of 5 · 10¹¹ steps
Big O notation: growth curves and a table for n = 10, 1000 and one million
the travelling salesperson problem, P versus NP, approximations in navigation, chess
five exam traps

Watch on YouTube Watched

12:19

Episode 7

Compilers & Interpreters – Advanced

What you will learn

three language levels: total = a + b → LOAD, ADD, STORE → 1E 2F 3D
compilers (C, C++, Rust) versus interpreters · Python bytecode · Java with the JVM and JIT
the lexer: 17 characters become 5 tokens
grammar in EBNF and syntax trees: 2 + 3 · 4 = 14, (2 + 3) · 4 = 20, 8 − 2 − 3 = 3
reading Python bytecode with dis – and why Python computes 2 + 3 * 4 in advance
syntax versus semantics, logic and runtime errors
type systems: Java static, Python dynamic; Python strict, JavaScript lenient ("3" + 4)
imperative, declarative (SQL), object-oriented, functional
five exam traps

Watch on YouTube Watched

11:56

Episode 8

Automata & the Halting Problem – Advanced

What you will learn

state diagrams: a turnstile and a vending machine (€1.50, with change)
automata that check: is a binary number divisible by 3? 110 and 1001 step by step
regular expressions: [0-9]{4} for postcodes, ^ $ + * ? and a pattern for licence plates
why finite automata cannot check arbitrarily deep brackets – and how a stack helps
the Turing machine computes 1011 + 1 = 1100
the halting problem: the halt tester and the contrarian program
why there can be no perfect virus scanner
five exam traps

Watch on YouTube Watched

13:58

Episode 9

Data Structures – Advanced

What you will learn

arrays: address = start + index · size, access in O(1), insertion in O(n)
linked lists: nodes with pointers, re-linking two pointers
stacks: push, pop, peek · undo, the call stack, bracket matching (2 + [3 · 4]) · 5
queues: enqueue, dequeue, ring buffers, deque in Python
a binary search tree from 50, 30, 70, 20, 40, 60, 80 – searching for 45 in three comparisons
a hash table with ten buckets: Ben → 7, Anna and Nana → 2 (collision)
a cost table: which structure for what
five exam traps

Watch on YouTube Watched

11:50

Episode 10

Object-Oriented Programming – Advanced

What you will learn

designing a BankAccount class: owner, balance, deposit(), withdraw()
encapsulation: withdraw(150) is refused, withdraw(30) → €70 · Python _balance and @property, Java private
inheritance: Character → Knight, Archer, Mage · super().__init__()
polymorphism: for c in party: c.attack() – three different attacks
duck typing in Python
abstract classes with ABC and @abstractmethod · interfaces in Java
UML class diagrams: − private, + public, triangle, diamonds, multiplicities
five exam traps

Watch on YouTube Watched

16:04

Episode 11

Networking & Internet Protocols – Advanced

What you will learn

encapsulation: HTTP in TCP in IP in Ethernet – like letter, envelope, parcel and truck
MAC address, switch and ARP: “Who has 192.168.1.1?”
subnets: /24, /26 and /28 – network address = address AND mask
Dijkstra step by step: A–C–B–D–E with 10 ms
TCP handshake SYN, SYN-ACK, ACK · UDP for games and video calls
ports 80, 443, 53, 22 and sockets
DNS hierarchy and caching · HTTP 200, 301, 404, 500
NAT, port forwarding and IPv6 with 128 bits
https://www.example.com: DNS → TCP → TLS → GET
five exam traps

Watch on YouTube Watched

15:00

Episode 12

Databases & SQL – Advanced

What you will learn

relation, tuple, attribute, candidate key, domain
ER model: 1 : n with a foreign key, n : m with a junction table
SELECT … FROM … WHERE … ORDER BY, LIKE '%Potter%', BETWEEN, IN
COUNT, MIN, AVG, GROUP BY – and why HAVING instead of WHERE
INNER JOIN, LEFT JOIN and the cross product (9 × 6 = 54)
loans per book row by row – including zero
INSERT, UPDATE, DELETE – and DELETE without WHERE
transactions with COMMIT and ROLLBACK, ACID
anomalies and 1st, 2nd, 3rd normal form on the loan list
five exam traps

Watch on YouTube Watched

15:29

Episode 13

Cryptography – Advanced

What you will learn

confidentiality, integrity, availability, authenticity
Vigenère with KEY and frequency analysis
XOR: 0101 ⊕ 1100 = 1001 and back · one-time pad · AES with 2¹²⁸ keys
Diffie-Hellman with colours and with p = 23, g = 5 → secret 2
RSA with n = 55: 7 → 13 → 7
SHA-256 and the avalanche effect
passwords with salt, bcrypt and Argon2
digital signatures and signed updates
TLS handshake, certificates, Signal protocol, man in the middle
SQL injection and prepared statements · post-quantum cryptography
five exam traps

Watch on YouTube Watched

14:52

Episode 14

AI & Machine Learning – Advanced

What you will learn

three kinds of learning: labels, groups, rewards (Go, 2016)
apples and pears in feature space · k nearest neighbours with k = 3
splitting data: 70 % training, 15 % validation, 15 % test
the perceptron: AND gate with weights 1 and 1, bias −1.5 · the learning rule step by step
XOR is not linearly separable – and is solved anyway with OR, NAND and AND
gradient descent: F(w) = (w − 3)², w = 0 → 0.6 → 1.08 → … · learning rate too big, too small
spotting overfitting and stopping early
a spam filter with 1000 mails: accuracy 96 %, precision 75 %, recall 90 %
CNNs, transformers, tokens and attention
bias, explainability, copyright, deepfakes and the EU AI Act
five exam traps

Watch on YouTube Watched

14:03

Episode 15

Expression Calculator – Advanced

What you will learn

a compiler-style architecture: lexer → parser → evaluator · class diagram
the lexer as a finite automaton: “3,5” and “3.5”, operators, parentheses, signs
postfix (RPN): 3 4 2 1 − × + without parentheses – evaluated with a stack
shunting yard (Dijkstra, 1961) token by token for 3 + 4 × (2 − 1)
left associativity: 8 − 2 − 3 = 3 · powers are right associative: 2 ^ 3 ^ 2 = 512
recursive descent: expression, term, factor – the call tree for (3 + 4) × 2
custom exceptions, decimal instead of float – and why eval() is off limits
unit tests with unittest: 10 cases, 3 of them error cases
five exam traps

Watch on YouTube Watched

13:17

Episode 16

Database App with SQL – Advanced

What you will learn

requirements → an ER model with six entities, third normal form
PRIMARY KEY, FOREIGN KEY, NOT NULL, UNIQUE, CHECK – and PRAGMA foreign_keys = ON
overdue loans, top 5, never borrowed (LEFT JOIN), a subquery with NOT IN
the Python app with sqlite3 and a LibraryRepository class
SQL injection on our own practice project – and why placeholders protect you
passwords with salt and scrypt, roles for teachers and students
EXPLAIN QUERY PLAN: SCAN versus SEARCH USING INDEX – about 13× faster in our test
transactions: COMMIT, ROLLBACK, all or nothing
“people who borrowed this also borrowed …” with a self-join
five exam traps

Watch on YouTube Watched

15:31

Episode 17

Build Your Own CPU – Advanced

What you will learn

the blueprint: bus, registers, ALU, memory, program counter, instruction register, clock
the ALU: 8 full adders, a row of XOR gates and two's complement – 4 − 1 with the same circuit
the instruction set: 1 byte = 4-bit opcode + 4-bit address · LDA 14 = 0x1E · JZ 8 = 0x78
the control unit: micro-steps T0 to T4, control signals in a ROM, a state machine
the program: 3 · 4 without a multiply instruction, as a loop in 11 bytes
cycle by cycle: the first round with a glowing bus, then fast-forward to 12
5 · 7: change just two bytes → 35 = 0x23
limits and real CPUs: 64 bit, caches, pipelines, ARM, RISC-V, FPGA
five exam traps

Watch on YouTube Watched