Curriculum
A Connected Route Through Kotlin
The Qeltraviox curriculum is organized as ten courses that move from foundational Kotlin concepts toward broader project structure, data flow, state coordination, and architectural planning. Each tier has its own subject focus while remaining connected to the ideas introduced earlier in the collection.
The learning route begins with syntax, values, conditions, functions, and collections. Later courses introduce classes, interfaces, data models, component boundaries, asynchronous operations, modular organization, and domain-focused structures.
Each course contains written explanations, annotated Kotlin examples, practical activities, project exercises, diagrams, and review sections. Learners can follow the collection in order or select a course that matches their current knowledge.
Course 1 — Free Capsule
Kotlin Foundations
Free Capsule introduces the building blocks used throughout the wider curriculum. Learners examine how Kotlin code is written, how values are stored, and how conditions influence program behaviour.
Main Subjects
- Code structure and formatting
- Variables and value types
- Arithmetic and comparison expressions
- Logical conditions
- Decision structures
- Functions and parameters
- Returned values
- Basic collections
- Repeated operations
- Introductory code review
Course Activity
Learners combine values, conditions, functions, and collections inside a compact Kotlin workflow.
Course 2 — Lattice Guide
Connecting Core Concepts
Lattice Guide develops the foundational material through broader work with reusable functions, structured collections, classes, and nullable values. The lessons show how separate language elements can support one readable code route.
Main Subjects
- Function responsibilities
- Parameters and local values
- Reusable logic
- Lists, sets, and maps
- Collection updates
- Filtering and sorting
- Classes and objects
- Properties and methods
- Constructors
- Nullable value handling
- Code organization
Course Activity
Learners create a record-management project with class-based entries, supporting functions, collection operations, and defined value checks.
Course 3 — Neon Framework
Building Focused Components
Neon Framework introduces project planning through data models, class relationships, collection processing, and reusable behaviour. Learners examine how broad code can be divided into smaller parts with clearly described duties.
Main Subjects
- Focused data models
- Immutable values
- Class composition
- Inheritance
- Shared behaviour
- Mapping and filtering
- Grouping and sorting
- Lambda expressions
- Higher-order functions
- Result states
- Input checks
- Component planning
Course Activity
Learners build an information manager containing data models, collection processors, validation rules, and focused supporting components.
Course 4 — Cipher Archive
Contracts and Component Boundaries
Cipher Archive explores how interfaces, abstract classes, generic structures, and defined states can guide communication between project components. The course also introduces structured refactoring activities.
Main Subjects
- Kotlin interfaces
- Shared behaviour contracts
- Abstract classes
- Component responsibilities
- Input and output routes
- Validation components
- Processing components
- Sealed state structures
- Generic classes
- Generic functions
- Dependency review
- Refactoring methods
Course Activity
Learners create a record-processing structure that moves information through models, validation, processing, and defined outcomes.
Course 5 — Drift Module
Coordinating Related Responsibilities
Drift Module examines delegation, extension functions, scoped operations, data conversion, and coordinated processing. Learners study how supporting components can work together without placing every responsibility inside one class.
Main Subjects
- Class delegation
- Delegated properties
- Extension functions
- Extension properties
- Scoped operations
- Nullable value workflows
- Model conversion
- Mapping functions
- Reusable validation rules
- Processing coordination
- Responsibility review
- Guided code restructuring
Course Activity
Learners create a course-record workflow with input models, mapping functions, validation components, processing rules, and prepared output.
Course 6 — Halo Blueprint
Mapping State and Events
Halo Blueprint introduces project state, event handling, layered responsibilities, dependency passing, and verification principles. Learners trace how an action moves through a handler and produces a defined state update.
Main Subjects
- Project state
- Temporary and stored values
- Event structures
- Event handlers
- State containers
- Layered responsibilities
- Constructor-based dependencies
- Interface relationships
- Validation outcomes
- Isolated function checks
- State diagrams
- Component documentation
Course Activity
Learners build a planning structure containing events, state holders, handlers, models, validation rules, and coordination components.
Course 7 — Echo Series
Asynchronous Kotlin Workflows
Echo Series explores asynchronous tasks, observable state, changing data streams, cancellation, and structured processing outcomes. Learners follow information as it moves through several coordinated operations.
Main Subjects
- Sequential operations
- Asynchronous operations
- Suspend functions
- Task scopes
- Cancellation handling
- Observable state
- Emitted values
- Data transformations
- Filtered updates
- Combined data routes
- Defined operation states
- Recovery and fallback rules
Course Activity
Learners create an activity-tracking workflow that loads records, processes updates, publishes changing state, and responds to interruptions.
Course 8 — Shift Series
Modules, Tasks, and Data Pipelines
Shift Series develops broader project organization through concurrency, modular boundaries, shared-state review, dependency flow, and staged data processing.
Main Subjects
- Concurrent operations
- Shared information
- Structured synchronization
- Controlled state changes
- Module boundaries
- Storage components
- Processing rules
- Data pipelines
- Dependency passing
- Interface contracts
- Isolated checks
- Connected scenario review
- Processing awareness
Course Activity
Learners build a modular record-processing engine with concurrent tasks, defined data stages, visible dependencies, and a written verification plan.
Course 9 — Quantum Series
Domain Models and Architectural Boundaries
Quantum Series focuses on domain concepts, value objects, state transitions, reusable abstractions, mapping boundaries, and project-wide consistency.
Main Subjects
- Domain entities
- Domain values
- Project rules
- Value objects
- Immutable models
- Validation inside focused types
- Architectural boundaries
- State transitions
- Allowed actions
- Generic contracts
- Type-safe wrappers
- Data mapping
- Dependency direction
- Architecture review
Course Activity
Learners create a reservation manager with domain models, value objects, state transitions, mapping components, and coordination services.
Course 10 — Vertex Series
Complete Kotlin Project Planning
Vertex Series brings together the full Qeltraviox curriculum through requirement analysis, architectural mapping, domain policies, concurrent operations, data boundaries, component checks, and decision records.
Main Subjects
- Requirement analysis
- Entities and actions
- Events and rules
- Component diagrams
- Dependency routes
- Domain policies
- Task coordination
- Cancellation routes
- Data conversion boundaries
- Verification scenarios
- State-transition checks
- Module documentation
- Architectural decision records
- Full project review
Course Activity
Learners plan and build a multi-module resource-management structure with documented requirements, domain models, state routes, asynchronous operations, data conversions, and component relationships.
How the Curriculum Is Organized
Each Qeltraviox course follows a consistent educational structure:
Topic Overview
Every module begins with a focused explanation of the subject and its role inside Kotlin development.
Annotated Examples
Code sections include supporting notes that describe values, functions, relationships, and data movement.
Practical Activities
Learners adjust examples, write focused code sections, review output, and compare different structural choices.
Connected Exercises
Earlier concepts return inside later activities, allowing learners to see how Kotlin topics develop across broader projects.
Project Work
Each tier includes a project that combines the primary subjects covered in the course.
Review Sections
Checklists and reflection questions help learners examine naming, responsibilities, data routes, state changes, and component relationships.
Choosing a Course Tier
Learners beginning their Kotlin study can start with Free Capsule and continue through the collection in order. Those who already understand foundational syntax may review the subject lists and begin with a tier suited to their current knowledge.
Earlier tiers focus on language foundations and code organization. Middle tiers examine component relationships, state, mapping, and asynchronous work. Later tiers focus on modules, domain structures, architectural boundaries, and full project planning.
The Qeltraviox curriculum is designed around connected learning. Each course introduces a distinct area of Kotlin while showing how it relates to the wider development process.