Data Types Course

Lesson 1 • What Data Types Represent

Defines data types as contracts between values and operations. Establishes vocabulary used throughout the course.

Lesson 2 • Why Type Systems Exist

Explains the safety and efficiency motivations behind type systems. Connects type discipline to fewer runtime errors.

Lesson 3 • Strong vs. Weak Typing

Distinguishes strict type enforcement from permissive coercion. Clarifies common misconceptions about type strength.

Lesson 4 • Primitive vs. Composite Types

Contrasts atomic primitive types with structured composite types. Prepares students to categorise any type they encounter.

Lesson 1 • Numeric Type Promotion and Coercion

Describes automatic widening and narrowing conversions between numeric types. Students predict coercion outcomes in mixed-type expressions.

Lesson 2 • Integer Types and Ranges

Covers signed and unsigned integers across common bit widths. Students calculate value ranges from bit width formulas.

Lesson 3 • Choosing the Right Numeric Type

Applies selection criteria based on range, precision, and performance needs. Reinforces all numeric concepts through decision exercises.

Lesson 4 • Floating-Point Representation

Explains IEEE 754 binary representation of real numbers. Students identify precision loss and rounding artefacts.

Lesson 1 • Truthy and Falsy Values

Explains how non-Boolean values are coerced to Boolean in dynamic languages. Students avoid common truthiness bugs.

Lesson 2 • Null and Undefined as Special Values

Examines null and undefined as distinct absence-of-value markers. Students apply null-safety patterns to prevent null-reference errors.

Lesson 3 • Character Encoding Basics

Introduces ASCII and Unicode as the basis for character types. Students map characters to code points and byte sequences.

Lesson 4 • The Character Type in Practice

Covers how languages represent a single character and its operations. Bridges character types to string construction.

Lesson 1 • String Validation and Normalisation

Applies regex and Unicode normalisation to validate and clean input strings. Connects to data quality and security requirements.

Lesson 2 • String Formatting and Interpolation

Teaches format strings, template literals, and interpolation syntax. Students produce readable, injection-safe formatted output.

Lesson 3 • String Internals and Memory Layout

Reveals how strings are stored in memory as sequences of characters. Connects internal layout to performance implications.

Lesson 4 • Core String Operations

Covers slicing, searching, replacing, and splitting strings. Builds the manipulation toolkit used in all subsequent text work.

Lesson 1 • Dynamic Lists and Resizable Arrays

Explains how dynamic lists grow by reallocating backing arrays. Students understand amortised cost and capacity management.

Lesson 2 • Choosing the Right Collection Type

Applies selection criteria based on ordering, uniqueness, and access patterns. Synthesises all collection types through comparative exercises.

Lesson 3 • Sets: Unique Element Collections

Introduces sets as unordered collections with uniqueness guarantees. Students apply set operations to deduplication and membership testing.

Lesson 4 • Arrays: Fixed-Size Sequences

Covers contiguous memory arrays, indexing, and bounds checking. Establishes arrays as the baseline for all collection types.

Lesson 5 • Maps and Key-Value Stores

Covers hash maps and tree maps as associative data structures. Students implement lookup, insertion, and iteration patterns.

Lesson 1 • Designing for Type Safety

Applies type-safe design patterns to prevent conversion errors by construction. Reinforces safety principles across all previously studied types.

Lesson 2 • Type Errors and Debugging

Catalogues common type errors and their root causes. Students use error messages and stack traces to locate and fix type bugs.

Lesson 3 • Explicit Casting Techniques

Covers safe and unsafe casting syntax across paradigms. Students apply the least-privilege casting principle to minimise data loss.

Lesson 4 • Type Guards and Runtime Checks

Introduces runtime type inspection to validate types before use. Connects type guards to defensive programming patterns.

Lesson 1 • Type Aliases and Newtype Wrappers

Distinguishes transparent aliases from opaque newtype wrappers. Students improve code clarity and prevent unit-confusion bugs.

Lesson 2 • Enumerations and Named Constants

Defines enums as closed sets of named values. Students replace magic numbers and strings with type-safe enumerations.

Lesson 3 • Recursive and Recursive-Variant Types

Models self-referential structures such as trees and linked lists. Connects recursive types to data structure implementation.

Lesson 4 • Union and Sum Types

Introduces types that hold one of several alternative types at runtime. Students use exhaustive pattern matching to handle all variants safely.

Lesson 1 • Type Inference and Annotation

Explains how compilers deduce types automatically and when explicit annotations are required. Students balance inference convenience with annotation clarity.

Lesson 2 • Types in API and Schema Design

Applies type thinking to API contracts, serialisation schemas, and data interchange formats. Students design APIs that communicate intent through types.

Lesson 3 • Evaluating Type Systems Across Languages

Compares type systems of several mainstream languages using consistent criteria. Students select the right language type system for a given project context.

Lesson 4 • Generics and Parametric Types

Introduces type parameters that enable reusable, type-safe abstractions. Students write generic functions and containers without sacrificing safety.