Lua Course

Lesson 1 • Variables and Data Types

Explains dynamic typing, nil, booleans, numbers, and strings. Students gain the ability to store and inspect values in any Lua program.

Lesson 2 • Lua Syntax and Code Structure

Introduces statement syntax, comments, and whitespace rules. Provides the grammatical foundation every subsequent script depends on.

Lesson 3 • Installing and Configuring Lua

Covers Lua runtime installation across major operating systems and editor setup. Connects to the chapter by enabling hands-on practice from the first lesson.

Lesson 4 • Basic Input and Output

Teaches print, io.write, and io.read for console interaction. Enables students to produce visible output and accept user input immediately.

Lesson 1 • Break, Goto, and Loop Control

Explains break to exit loops and goto for controlled jumps. Completes the control-flow toolkit with safe, intentional use patterns.

Lesson 2 • Numeric and Generic For Loops

Teaches numeric for with step control and generic for with iterators. Prepares students for table traversal covered in the next chapter.

Lesson 3 • Conditional Statements

Covers if, elseif, and else syntax with nested conditions. Directly enables branching logic required by every non-trivial program.

Lesson 1 • Recursive Functions

Covers direct and mutual recursion with base-case design. Builds problem-decomposition skills applied in algorithms and data structures.

Lesson 2 • Multiple Return Values and Varargs

Explains returning multiple values and using the ... vararg syntax. Unlocks flexible function signatures common in Lua idioms.

Lesson 3 • Local vs. Global Scope

Distinguishes local and global variable lifetimes and visibility rules. Prevents common scoping bugs that arise in larger scripts.

Lesson 4 • Defining and Calling Functions

Covers function declaration syntax, parameters, and return values. Establishes the primary abstraction mechanism used throughout the course.

Lesson 1 • Table Manipulation with table Library

Introduces table.insert, table.remove, table.sort, and table.concat. Equips students with standard library tools for common table operations.

Lesson 2 • Tables as Arrays

Explains integer-keyed sequences and the # length operator. Enables list-style data storage and sequential processing.

Lesson 3 • Table Creation and Access

Covers table constructor syntax and key-value access patterns. Provides the foundation for every data-modeling task in Lua.

Lesson 4 • Tables as Dictionaries

Covers string and mixed keys for map-style data storage. Connects to real-world use cases like configuration and record objects.

Lesson 1 • Replacing and Iterating Patterns

Teaches string.gsub for replacement and string.gmatch for iteration. Completes the pattern toolkit for full text transformation workflows.

Lesson 2 • String Formatting with string.format

Teaches format specifiers for numbers, strings, and padding. Enables precise output formatting required in logging and reporting.

Lesson 3 • String Library Essentials

Covers string.len, string.sub, string.upper, string.lower, and string.rep. Builds the baseline text-processing toolkit for all string tasks.

Lesson 4 • Finding and Matching Patterns

Covers string.find, string.match, and capture groups. Enables extraction of structured data from raw text inputs.

Lesson 1 • Building Classes with Prototypes

Implements class constructors and method dispatch via __index chains. Students create reusable object blueprints with shared methods.

Lesson 2 • Inheritance and Polymorphism

Extends prototype chains for single inheritance and method overriding. Completes the OOP model with subclass and super-call patterns.

Lesson 3 • Arithmetic and Comparison Metamethods

Covers __add, __sub, __mul, __eq, __lt, and __le metamethods. Enables custom types to participate in standard Lua expressions.

Lesson 4 • Index and Newindex Metamethods

Teaches __index for property lookup and __newindex for write interception. Enables default values, read-only tables, and proxy objects.

Lesson 1 • Debugging with the debug Library

Covers debug.traceback, debug.getinfo, and hook functions. Gives students tools to diagnose issues in complex, multi-module programs.

Lesson 2 • require and Package System

Explains require, package.path, and module caching behaviour. Teaches students to load and manage dependencies reliably.

Lesson 3 • Custom Errors and Error Objects

Teaches error() with levels and structured error table objects. Enables informative, machine-readable error reporting in libraries.

Lesson 4 • Error Handling with pcall and xpcall

Introduces pcall and xpcall for protected calls and error capture. Prevents unhandled errors from crashing production scripts.

Lesson 1 • Iterators Built with Coroutines

Builds stateful iterators using coroutine.wrap for clean syntax. Connects coroutine knowledge to practical generic-for usage.

Lesson 2 • Profiling and Performance Tuning

Applies timing, local caching, and table pre-allocation to reduce overhead. Students measure and improve script performance with concrete benchmarks.

Lesson 3 • Coroutines and Cooperative Multitasking

Introduces coroutine.create, resume, yield, and status. Enables cooperative scheduling and producer-consumer pipelines in Lua.

Lesson 4 • Memory Management and Garbage Collection

Covers the incremental GC, collectgarbage(), and weak tables. Teaches students to control memory usage in long-running applications.