Course Series
Discover Programming – Adventure with Linus Lag 🎮
Learn Programming with Linus Lag and Gamification: Variables, Conditions, Loops, Functions, and more!

Didactic Concept
The course series enables a step-by-step introduction to fundamental programming concepts and promotes the development of central competencies such as algorithmic thinking, structuring of processes, and abstraction through functions and classes. Starting with variables and text output, conditions, loops, and functions are systematically introduced and expanded to more complex data structures such as lists and objects. The progression leads from simple program structures to object-oriented concepts and algorithmic solution strategies. Theory and application are continuously linked by practical problem-solving approaches such as navigation and labyrinth navigation.
For teachers, the series offers a structured introduction to central programming concepts with clear competency development. The modular structure supports flexible integration into existing lesson plans and provides transparency regarding the desired learning objectives.
Competency Development
- Development of basic programming competencies through variables, text output, and number processing
- Application of conditional statements using if-, elif- and else-structures
- Use of loops for repetition and structuring of program flows
- Structuring code through functions, parameters, and return values
- Modeling and processing data using lists, objects, and classes
Structure of the series

Programs and Variables
Introduction to Programming with Linus Lag
This module lays the foundation for understanding simple programs through the introduction of variables and text output. Learners connect initial calculations with outputs and develop a basic understanding of data processing as a basis for further program structures.

Conditional Statements
Learn if-queries with Leo and Linus in exciting programming adventures!
Building on variables, decision-making structures with if-, elif- and else-statements are introduced. Learners apply logical operators and nested conditions to control program flows.

Loops
Learn nested loops with Leo Loop!
This course extends decision-making logic by introducing repetition structures with while- and for-loops. Through nested loops, more complex workflows are modeled and automated.

Functions
Learn with Ruby and Bruno how to collect trash and clean up construction sites using functions and recursion!
Program structure is deepened by functions with parameters and return values. Additionally, recursion is introduced as a further concept for modeling recurring workflows.

Lists
Learn to create, fill and filter lists.
Working with multiple data values is introduced through lists and deepened by iteration and filtering. Learners structure and sort data as preparation for more complex data models.

Objects and OOP
Building on lists, object-oriented concepts are introduced. Classes, properties, methods, and inheritance enable a structured modeling of more complex program structures.

Algorithms
Finally, algorithmic solution strategies are applied to practical tasks. Learners combine previously worked out concepts to develop efficient programs.
For private customers, there is also a corresponding course offer to learn programming with Linus Lag Course offering to learn programming with Linus Lag .
Contents at a glance
Programs and Variables
| Content | Focus | Duration |
|---|---|---|
| On the way to the first school day | First steps with Linus | 5 min |
| Introduction to sag() | Combining variables and text | 5 min |
| Dialogs with sag() | Step-by-step programming of dialogs | 10 min |
| Calculating age | Calculate age using variable, str() function | 10 min |
| Determine passcode | Read numbers, add them up, and display the sum | 10 minutes |
Making decisions
| Content | Focus | Duration |
|---|---|---|
| Say the right answer with if | Basic if-questions without else | 10 minutes |
| Say the right answer with if else | Else instead of double if | 5 min -> @@ITEM_0001@@5 minutes |
| Simple if-check | Recognize danger before every step | 5 min -> @@ITEM_0001@@5 minutes |
| Do you recognize your guitar with elif | Multiple conditions with elif | 10 minutes |
| Rico's logic tour | Apply logical operators and, or, not | 15 min |
| Find your guitar with nested if else statements | Apply nested conditions | 10 min |
| The coffee slalom | If-questions with random values | 15 min |
| Find the oldest vases | Compare minimum year | 10 min |
Loops
| Content | Focus | Duration |
|---|---|---|
| An endless long corridor with while | Basic idea of the while-loop | 5 min |
| Collect packages with for-loop | For-loops with range | 5 min |
| Countdown with Range (Neo Nukes Countdown) | Countdown with range | 10 minutes |
| Loop Steps | Practicing Nested Loops | 5 minutes |
| Setting up a Love Letter with Loop Backwards | Applying Loops in the Labyrinth | 5 minutes |
Functions
| Content | Focus | Duration |
|---|---|---|
| The First Function (Leo's Dance) | Functions with Movements | 10 minutes |
| Functions with Parameters (The Bot Command) | Functions with Parameters | 10 minutes |
| Answer the Love Letter | Decipher and Send the Answer | 10 minutes |
| Functions with Return (The Calorie Check) | Functions with Return | 10 minutes |
| Follow Your Way – Recursively! | Introduction to Recursion | 15 minutes |
Lists
| Content | Focus | Duration |
|---|---|---|
| Create and Access (The Inventory) | Creating and Reading Lists | 5 minutes |
| Add and Iterate (The Finds) | Iterate with for-Loops | 10 minutes |
| Filtering (Picnic Control) | Filtering Lists with if | 10 minutes |
| Sort Listen (The Ball Challenge) | Sort Lists | 10 minutes |
Objects and OOP
| Content | Focus | Duration |
|---|---|---|
| Explore Objects | Read and Interact with Objects | 10 minutes |
| Custom Classes (The Mini-Linus) | Classes as Blueprints | 10 minutes |
| Classes and Properties (The Energy Barrier) | Initial Values with __init__ | 10 minutes |
| Methods with Parameters (Robot with Superpowers) | Methods with Parameters | 10 minutes |
| Inheritance (The RebelBot) | Apply Inheritance | 10 minutes |
Algorithms
| Content | Focus | Duration |
|---|---|---|
| Clear Spaces | Sort Pylons | 20 minutes |
| Efficiently Clear Spaces with Functions | Clean Up with Functions | 30 minutes |
| The Auto-Bot | Find Autonomous Reset Switch | 30 minutes |
The modular structure supports transparent progression and facilitates integration into existing lesson plans.
Request a demo access to try out the series in your own teaching context.