Robotrek - Programming & Robotics Instructor

Curriculum Designer & Instructor

2019 – 2021 Robotrek Balakovo, Russia

Overview

Taught programming and robotics at Robotrek — a franchised network of 100+ coding schools across Russia. Over two years, I designed and delivered four distinct course tracks for children and teenagers aged 6–17, each with original curricula and teaching materials developed from scratch. In my second year, I also helped management expand the school’s course offerings.

Each course track was designed for a specific age group and skill level, with its own lesson structure, progression system, and learning goals. I ran multiple groups simultaneously, adapting my teaching approach to different ages and learning speeds.

Course Tracks

Platforms & Tools: LEGO Mindstorms, Arduino, Scratch 3, Java, Swing, Processing, GIMP, Audacity, PixelArt Online tools

Self-built: SKENGINE (custom 2D Java game engine), FlyShip (demo space shooter game), 26-lesson Java course, 20-lesson Arduino course, Scratch Game Design course

Teaching Practices: Curriculum design, lesson planning, age-appropriate pedagogy, hands-on project-based learning, student motivation systems, competition facilitation, progress assessment

Teaching

Ages 6–9 — Construction & Logic Foundations HUNA-MRT

  • Designed and taught an introductory robotics course using Korean educational construction kits (similar to LEGO WeDo), focused on spatial thinking and basic programming logic
  • Structured each 80-minute class around a themed model: 15 minutes of topic introduction and presentation, 60 minutes of hands-on building with interactive instructions, followed by group games and competitions
  • Implemented a collectible card reward system to sustain motivation — students earned cards for good behavior, performance, and winning mini-games, exchangeable for prizes
  • Adapted teaching pace and complexity to individual students within group sessions

Ages 9–12 — Arduino based Construction (Blockly) HUNA-MRT

  • Delivered Arduino-based robotics course using visual Blockly programming, covering sensors, variables, loops, conditional logic, and functions
  • Each class had its own theme and physical robot model, giving students a concrete, tangible goal every session
  • Organized in-class competitions and games to reinforce concepts and keep engagement high across the full 80-minute session
  • Helped students debug both hardware assembly and programming logic, developing the ability to explain technical concepts clearly to young learners

Ages 9–12 — LEGO Mindstorms

  • Ran a parallel Mindstorms track for the same age group, combining more advanced mechanical construction with programmable logic
  • Designed lesson sequences that gradually introduced more complex builds and behaviors, maintaining a consistent theme-per-class format
  • Balanced structured instruction with open exploration time, allowing students to experiment beyond the base model

Curriculum Design

Ages 12–17 — DIY Robots: Arduino Course for Teens (self-designed course)

  • Designed and taught a 20-lesson Arduino programming course (~3–5 months) built around the Keyestudio KS0192 4WD Bluetooth Multi-functional Car, targeting high-school students with no prior experience
  • Students wrote real Arduino C++ from lesson one — no block-based tools. Each lesson followed a consistent rhythm: new concept → standalone sketch → exercise building on previous code
  • Structured the course in five phases:
    • Foundations (lessons 1–4): Arduino IDE, digital I/O, conditionals with IR sensor, Serial Monitor
    • Sensors & actuators (5–9): ultrasonic rangefinder, IR remote, servo motors and PWM, Bluetooth (HC-06) with Android companion app, I2C LCD display
    • Algorithms (10–11): loops, user-defined functions, and a radar project pairing an ultrasonic sensor on a servo with a Processing visualization on PC
    • Robotics (12–19): chassis assembly, motor driver control, IR remote driving, Bluetooth driving, line following, ultrasonic obstacle avoidance
    • Capstone (20): fully autonomous “4-in-1” SmartBot — line follower, obstacle avoider, IR-controlled, and Bluetooth-controlled, with push-button mode selector and live LCD status
  • Students walked away with a working autonomous robot and hands-on experience reading datasheets, wiring sensors, integrating libraries, and shipping embedded sketches

Ages 9–12 — Scratch Game Design (self-designed course)

  • Designed and taught an original game development course in Scratch, built around real game studio roles rather than programming alone
  • Structured each project to include four roles: Programmer (logic and mechanics), Artist (pixel art in GIMP and online tools), Level Designer (building levels from created assets), and Audio Designer (sound effects in Audacity)
  • Introduced students to real game industry concepts — mechanics, art styles, professional roles — using examples from well-known games
  • Developed a clear learning progression: early classes built games together step by step; mid-course students received project briefs and worked semi-independently; final project was fully open-ended — students formed their own teams, chose their roles, and built original games
  • Every 2–3 classes produced a complete new game, maintaining a high sense of achievement and momentum throughout the course

Ages 13–17 — Java Game Development (self-designed course)

  • Designed a 13-lesson Java programming course from the ground up, taking students from zero to building GUI desktop applications and an introductory Arduino sketch
  • Course arc: variables and types → loops and user input → arrays → OOP and classes → Swing GUI (calculator, chatbot, dialogs) → C and Arduino introduction
  • Oriented the entire curriculum around game development to keep the material relevant and motivating for the age group; kept groups small (up to 10 students) to provide individual attention
  • Authored all lesson plans, exercises, and reference materials independently — published on GitHub

SKENGINE — Custom 2D Java Game Engine

  • Built SKENGINE from scratch without third-party libraries, inspired by Unity’s component system, specifically as an educational framework for the course
  • Key features: component-based GameObject architecture, fixed-timestep game loop, software pixel renderer with alpha blending, scene management, collision detection, 2D animation system, asset pipeline, and audio — all using only native Java APIs
  • Designed to be simple enough for beginners to understand internals, yet capable enough to produce interactive results from early lessons, lowering the barrier to learning OOP concepts

FlyShip — Space Shooter Demo Game

  • Developed FlyShip on top of SKENGINE as a live coding demonstration — students built the game step-by-step following instructor-led sessions
  • Covered core game dev concepts hands-on: directional movement with trigonometry, energy and weapon systems, enemy AI with sensor-based detection and orbital movement, solar system with orbiting planets, collision response, and animation — all built incrementally as teaching material

Impact

  • Designed 3 original course tracks from scratch covering ages 6–17, each with full lesson plans, exercises, and teaching materials authored independently
  • Built SKENGINE — a custom 2D Java game engine from scratch using only native Java APIs — and FlyShip, a complete demo game built on top of it, both used as live teaching material
  • Arduino course curriculum took complete beginners from blinking an LED to building a fully autonomous multi-mode robot over 20 lessons
  • Introduced a game studio role-based structure to the Scratch curriculum, giving students exposure to programming, pixel art, level design, and audio production in a single course
  • Contributed to curriculum expansion in second year, helping the school grow its course offerings
  • Supervised student teams at regional robotics competitions and off-site events