Skip to content
wannacode

Software engineering: Python

The course is the same for all four languages, and the code here is in Python. Every module says which lessons of the language you need before it.

Module 0

Welcome

1 lesson · what the course teaches and what you need to know

  1. Welcome

Module 1

Design patterns

14 lessons · Strategy, Observer, Builder, State…

  1. Why patterns
  2. Strategy
  3. Observer
  4. Factory Method and Simple Factory
  5. Builder
  6. Singleton and Dependency Injection
  7. Adapter and Facade
  8. Decorator
  9. Composite
  10. Command
  11. State
  12. Template Method and Iterator
  13. Repository
  14. The shop: which pattern where

Module 2

Clean code and refactoring

8 lessons · names, functions, smells, small steps

  1. Names in code
  2. Functions: one job, few parameters, no hidden side effects
  3. Comments that lie and comments that help
  4. Code smells: long method, large class, duplication, primitives instead of types, long if chains
  5. Tests as a safety net
  6. Refactoring in small steps
  7. SOLID without dogma
  8. Exercise: a messy class, cleaned up step by step

Algorithms and complexity

Module 3

Complexity

5 lessons · Big-O, time and memory, measuring

  1. Time complexity: counting steps
  2. Big-O: how the work grows
  3. Best, average and worst case
  4. Space complexity
  5. Amortized complexity

Module 4

Searching

3 lessons · linear and binary search

  1. Linear search
  2. Binary search
  3. Binary search on the answer

Module 5

Sorting

6 lessons · insertion, merge, quick, heap, counting

  1. Insertion sort and selection sort
  2. Merge sort and "divide and conquer"
  3. Quick sort and the bad pivot
  4. Heap and heap sort
  5. Counting sort and radix sort
  6. Stable sorting and the built-in sort

Module 6

Recursion

4 lessons · the call stack, divide and conquer

  1. The call stack from the inside
  2. From recursion to a loop
  3. Fast exponentiation
  4. Divide and conquer and the recursion tree

Module 7

Data structures

8 lessons · array, list, hash table, trees, heap

  1. The dynamic array from the inside
  2. Linked list
  3. Stack and queue
  4. Hash table
  5. Binary search tree
  6. Priority queue
  7. Trie
  8. Union-find

Module 8

Graphs

6 lessons · BFS, DFS, Dijkstra, dependencies

  1. Graph: adjacency list and matrix
  2. BFS: the fewest stops
  3. DFS: islands and cycles
  4. Topological sorting
  5. Dijkstra
  6. Minimum spanning tree

Module 9

Dynamic programming

5 lessons · memoisation, tables, knapsack

  1. Overlapping subproblems
  2. The coin change problem
  3. The knapsack problem
  4. The longest common subsequence and diff
  5. How to recognise a DP task

Module 10

Greedy algorithms

2 lessons · when they work and when they fail

  1. Greedy algorithms and when they work
  2. When a greedy algorithm fails

Module 11

Problem-solving techniques

4 lessons · two pointers, sliding window, prefix sums

  1. Two pointers
  2. Sliding window
  3. Prefix sums
  4. A hash table as a counter

Module 12

Project: city navigation

1 lesson · the map as a graph, BFS, Dijkstra

  1. City navigation

Module 13

Concurrency and race conditions

9 lessons · locks, deadlock, async

  1. Why threads
  2. Race condition
  3. Locking
  4. Atomic operations and immutable objects
  5. Deadlock
  6. Producer and consumer
  7. A pool of threads and tasks
  8. async is not a thread
  9. Testing concurrent code

Module 14

Security for developers

9 lessons · untrusted input, passwords, sessions, tokens, secrets

  1. Untrusted input
  2. Injections: when data becomes a command
  3. XSS: someone else’s script in your page
  4. Passwords
  5. Sessions, cookies and CSRF
  6. JWT and its traps
  7. Secrets in code and in git
  8. Dependencies: other people’s code that yours runs
  9. Cryptography you don't write yourself

Module 15

Software architecture

9 lessons · layers, modules, events, APIs, caching, scaling

  1. Layers
  2. Hexagonal and clean architecture
  3. Monolith, modular monolith, services
  4. Events and queues
  5. Transactional outbox
  6. API design: contract, versions, retried requests
  7. Caching
  8. Scaling
  9. ADR: architecture decision records

Module 16

The architect at work

9 lessons · NFRs, trade-offs, integration, migrations, review

  1. Non-functional requirements you can measure
  2. Trade-offs
  3. When the neighbour is slow: timeout, retry, circuit breaker
  4. A transaction across services (saga)
  5. Integrating old and foreign systems
  6. Changing a live system (strangler fig, expand–contract)
  7. Architecture review
  8. The enterprise landscape and capabilities
  9. Your first architecture task

Practice

Tasks

Every task from the lessons in one place, by module.

Made by Ivo Gergov as part of Evo Tech's campaign for accessible programming education ·