Curriculum

Detailed Course Breakdown

1. Free Kit — First C# Contact

Course focus: first contact with C#, basic code shape, variables, data types, conditions, and simple methods.
Good for: learners who are just starting with C# and want to understand what basic code looks like.

Modules:

1. First Look at C# — the shape of C# code and the basic parts of an example.
2. Variables and Data Types — variables, values, and simple data types.
3. Conditions in Code — basic conditional structures and different program paths.
4. Simple Methods — the role of methods in dividing code into understandable parts.
5. Practice Notes — short exercises for reviewing basic topics.
6. Reading Code Calmly — careful reading of small code fragments.
7. Common Beginner Mistakes — frequent starting mistakes and careful checking habits.
8. Next Study Steps — topics to study after the introductory block.

---

2. Vertex Pack — Code Flow Basics

Course focus: the connection between variables, conditions, loops, logical checks, and methods.
Good for: learners who have already seen basic C# code and want to better understand command order.

Modules:

1. Code Flow Basics — how a program is read from top to bottom and why command order matters.
2. Working with Values — creating, changing, and using values in examples.
3. Boolean Logic — logical values, comparisons, and simple checks.
4. If and Else Practice — building conditions for different scenarios.
5. Loops Without Confusion — repeating actions with basic loops.
6. Method Building — methods with parameters and returned results.
7. Small Task Workshop — combining several topics in one task.
8. Code Review Notes — reviewing your own code and finding places to improve.

---

3. Luma Course — Classes and Objects

Course focus: classes, objects, properties, constructors, and methods inside classes.
Good for: learners who want to move from simple commands to object-based C# code.

Modules:

1. Class as a Blueprint — a class as a description for future objects.
2. Creating Objects — creating objects and working with their data.
3. Properties in Practice — properties for storing and reading information.
4. Methods Inside Classes — object behavior through methods.
5. Constructors Explained — starting values and object creation.
6. Object Interaction — interaction between several objects in a study example.
7. Small Model Practice — creating simple models for tasks.
8. Structure Review — reviewing classes, names, and roles in code.

---

4. Nexus Guide — Connected Code Parts

Course focus: connecting classes, lists, methods, conditions, search, filtering, and checks.
Good for: learners who already understand classes and objects and want to work with connected scenarios.

Modules:

1. Connecting Code Parts — links between classes, methods, and conditions.
2. Working with Lists — creating lists, adding items, and reading data.
3. Object Collections — storing objects in collections.
4. Search and Filter Logic — searching and selecting data by conditions.
5. Data Checks — checking values before processing.
6. Scenario Methods — methods for separate actions within one scenario.
7. Mini Project Structure — a small example with models, lists, and checks.
8. Refined Reading Practice — careful code reading and finding repetition.

---

5. Path Library — Data Models and Collections

Course focus: data models, collections, search, sorting, grouping, updating, and method roles.
Good for: learners who want wider practice with data sets in C#.

Modules:

1. Data Model Basics — describing models through classes and properties.
2. Collection Patterns — working with lists and element groups.
3. Search by Rules — finding records by values and conditions.
4. Sorting and Grouping — ordering and grouping data.
5. Update Logic — changing data inside objects.
6. Method Responsibility — dividing code by method roles.
7. Data Scenario Practice — examples with several models and collections.
8. Structure Notes — reviewing structure and reducing repetition.

---

6. Prime Collection — Multi-Part Scenarios

Course focus: larger study scenarios with several models, lists, checks, methods, and processing blocks.
Good for: learners who have already worked with classes, methods, and collections and want to study larger examples.

Modules:

1. Multi-Part Code Structure — dividing a larger example into parts.
2. Connected Data Models — several data models in one scenario.
3. Collection Workflows — working with several lists.
4. Input and Validation Logic — checking values before processing.
5. Search, Sort, and Select — search, sorting, and data selection.
6. Method Layers — methods with separate roles.
7. Scenario Assembly Practice — assembling a scenario from several parts.
8. Code Cleanup Notes — reviewing an example and organizing code.

---

7. Origin Module — Structure Planning

Course focus: planning a C# task, separating models, checks, processing, and reusable code parts.
Good for: learners who want to plan larger C# scenarios before writing code.

Modules:

1. Structure Planning — dividing a task into parts before writing code.
2. Model Separation — separating data models from logic.
3. Validation Blocks — separate blocks for value checks.
4. Service Methods — grouping methods by actions.
5. Flow Mapping — describing the action order inside a scenario.
6. Reusable Code Parts — code parts for reuse in study tasks.
7. Larger Scenario Practice — a larger example with several connected blocks.
8. Structure Review Session — finding mixed roles and reviewing code shape.

---

8. Layer Module — Logical Layers

Course focus: logical code layers: models, checks, processing, helper methods, result preparation, and review.
Good for: learners who want to divide C# scenarios into parts with separate roles.

Modules:

1. Layered Thinking — understanding a scenario as a set of layers.
2. Model Layer — the data model layer.
3. Check Layer — the layer for value and rule checks.
4. Processing Layer — the data processing layer.
5. Helper Methods — helper methods for small repeated tasks.
6. Result Preparation — preparing data for further use.
7. Layer Refactoring Practice — dividing a mixed example into parts.
8. Layer Review Notes — checking the role of each layer.

---

9. Echo Module — Repetition and Reuse

Course focus: repeated fragments, moving logic into methods, shared checks, helper blocks, and loop review.
Good for: learners who work with longer examples and want to reduce duplication in code.

Modules:

1. Repetition Signals — finding repeated lines and similar actions.
2. Method Extraction — moving repeated logic into methods.
3. Shared Checks — shared checks for several scenarios.
4. Helper Logic — helper methods for small actions.
5. Naming for Reuse — names that explain the role of reusable parts.
6. Refined Loops and Conditions — reviewing loops and conditions.
7. Rebuild Practice — rewriting a longer example with less duplication.
8. Echo Review Notes — checking whether the structure became easier to read.

---

10. Shift Module — Review and Refinement

Course focus: reviewing a finished C# example, names, long methods, action order, role separation, and version comparison.
Good for: learners who already write larger study examples and want to refine them more carefully.

Modules:

1. Review Mindset — a calm approach to code review.
2. Naming Review — evaluating variable, method, and class names.
3. Long Method Split — dividing long methods into smaller parts.
4. Flow Cleanup — reviewing the order of actions.
5. Role Separation Check — checking whether different roles are mixed.
6. Before and After Practice — comparing two versions of one example.
7. Rewrite with Purpose — rewriting fragments with a specific learning goal.
8. Final Study Scenario — a full review of a study example.