Advanced SQL

Draft placeholder — add CTEs, window functions, query plans, partitions, and optimisation exercises.

Apache Airflow Orchestration

Draft placeholder — add DAGs, scheduling, retries, dependencies, and pipeline operations.

Apache Spark and Parallel Compute

Draft placeholder — add Spark DAGs, lazy evaluation, shuffles, and transformation optimisation.

API Reference Basics

An API reference explains how a service accepts requests, returns responses, and signals errors. Reading it well helps you use APIs correctly and avoid common integration issues.

Key sections to read

• Endpoint path and method: for example GET /items or POST /orders.
• Authentication: required credentials, token types, and scopes.
• Parameters: required and optional values, formats, and allowable ranges.
• Request body: schema, field names, nesting, and examples.
• Response format: success payload, status codes, error structure, and pagination.
• Rate limits and quotas: how often you can call the API and what happens when you exceed it.

Safe API usage

• Keep credentials on the server, not in browser or client-side code.
• Validate any user-supplied data before sending it to the API.
• Handle errors explicitly, including network failures and non-2xx responses.
• Read the API’s versions and deprecation policy before depending on it.

Guided steps

1. Pick one public API and open its reference documentation.
2. Find one endpoint and list its method, path, required parameters, and sample response.
3. Identify an error condition and note the expected status code.
4. Decide whether the request should be called from the browser or backend.

Recommended resources

• MDN: Overview of HTTP
• MDN: HTTP messages
• MDN: HTTP authentication

Application API Frameworks

Draft placeholder — add FastAPI, Spring Boot, Express, REST, GraphQL, and gRPC examples.

Application Containerisation

Draft placeholder — add Dockerfiles, Compose, multi-stage builds, and runtime isolation.

Asynchronous Message Queues

Draft placeholder — add Pub/Sub, delivery guarantees, and event-driven architecture guidance.

Business Intelligence

Draft placeholder — add BI tool concepts, dashboard design, and reporting workflows.

Caching and Query Performance

Draft placeholder — add Redis, cache strategies, connection pools, and query optimisation.

CI/CD Paradigms

Draft placeholder — add continuous integration, artifacts, deployment, and rollback workflows.

Command Line Mastery

Draft placeholder — expand this lesson with platform-specific command-line workflows and exercises.

Component Architecture

Draft placeholder — add React, Vue, Angular, component lifecycles, and composition patterns.

Computational Data Processing

Draft placeholder — add Pandas, NumPy, Jupyter, and repeatable data-processing exercises.

Computer Networking

Draft placeholder — add OSI, TCP/IP, DNS, HTTP/HTTPS, routing, and subnetting material.

Core Programming Paradigms

Draft placeholder — add programming paradigms, data structures, and algorithms content.

Data Engineering

Data engineering focuses on building and maintaining systems that collect, transform, and deliver data to analytics, reporting, and machine learning workflows. Reliable data engineering makes systems dependable and easier to scale.

Core responsibilities

• Ingest data: bring data from sources such as files, databases, APIs, or event streams.
• Transform data: clean, normalize, enrich, and structure raw data for downstream use.
• Load data: write the prepared data to a central store, warehouse, or application.
• Monitor pipelines: detect failures, slow jobs, and dataset drift.
• Ensure quality: validate schema, formats, completeness, and duplicate records.

Practical workflow

1. Define the business question and the data sources needed to answer it.
2. Extract the raw data into a safe staging area.
3. Apply deterministic transformation rules to create clean tables.
4. Load results into a destination that supports analytics or reporting.
5. Add checks for missing values, unexpected types, and duplicates.
6. Use version control and automated runs to make the pipeline repeatable.

Patterns to know

• Batch ETL: extract and transform data on a schedule, then load it.
• ELT: load raw data first and transform it later inside a warehouse.
• Data modeling: separate raw, staging, and curated layers.
• Schema evolution: handle changes in source data without breaking downstream users.

Practice milestone

Use an open dataset or sample data to build a basic pipeline.

• Extract data from a CSV, API, or local database.
• Transform it into a consistent table with clear column names.
• Load the result into a new file, table, or dataset.
• Add one validation step to catch invalid or missing values.

Useful open resources

• Apache Airflow Documentation
• dbt Getting Started
• Apache Spark Quick Start
• PostgreSQL Tutorial

Data Exploration

Draft placeholder — add exploratory analysis workflows and practical exercises.

Data Ingestion

Draft placeholder — add batch, API, database, and streaming ingestion patterns.

Data Modeling

Draft placeholder — add ER diagrams, schema design, normalization, and indexing guidance.

Data Privacy Regulations

Draft placeholder — add GDPR, HIPAA, regional requirements, and data-governance practices.

Data Science Foundations

Data science uses data to answer questions and support decisions. The most important work is understanding the data and communicating findings clearly.

Core workflow

1. Define the question so it can be answered with data.
2. Inspect the data to understand structure, sources, and quality.
3. Clean and prepare the data before analysis.
4. Explore patterns with summaries and charts.
5. Choose metrics that align with the problem.
6. Share results with clear conclusions and limitations.

Key concepts

• DataFrame: a table of rows and columns used in pandas.
• descriptive statistics: mean, median, mode, counts, and ranges.
• missing values: identify, explain, and decide whether to fill or exclude them.
• grouping: summarize data by categories.
• joins: combine datasets with a common key.

Guided steps

• Load a CSV and inspect the first rows with head().
• Check column types, rename unclear labels, and document each field.
• Find missing or invalid values and decide how to handle them.
• Create one chart that supports a clear story.
• Write a short conclusion that notes one limitation.

Open-source guides

• pandas Getting started
• pandas Intro tutorials
• Kaggle Learn Data Cleaning
• scikit-learn User Guide

Data Visualization

Draft placeholder — add chart selection, storytelling, accessibility, and dashboard exercises.

Data Warehousing

Draft placeholder — add warehouse layers, dimensional modeling, and cost considerations.

Python Decorators & Metaprogramming

Learn how higher-order functions and @decorator syntax modify function behaviors at runtime.

Deep Learning Architectures

Explore deep convolutional architectures, residual networks, and transformer attention mechanisms.

Distributed Data Computing

Draft placeholder — add partitioning, parallel processing, and distributed-compute concepts.

Distributed Storage Systems

Draft placeholder — add object storage, partition pruning, replication, and storage trade-offs.

Enterprise Distributed System Design

Draft placeholder — add idempotency, circuit breakers, microservices, and event-driven patterns.

ETL and ELT Workflows

Draft placeholder — add transformation patterns, orchestration, and data-quality checks.

Feature Engineering

Draft placeholder — add feature creation, transformation, selection, and leakage prevention.

Global Application State Management

Draft placeholder — add Redux Toolkit, Pinia, server state, caches, and async data flows.

Identity and Access Architecture

Draft placeholder — add least privilege, RBAC, OAuth2, JWT, and secret-management practices.

Infrastructure as Code

Draft placeholder — add Terraform, state, modules, drift detection, and environment workflows.

Introduction to AI

An overview of artificial intelligence history, symbolic reasoning, and modern machine intelligence.

JavaScript Variables

Variables store values that your program can use later. JavaScript supports let, const, and var for declaring variables, with different scoping and reassignment rules.

Learning objectives

• Know when to use const and let.
• Use descriptive variable names.
• Assign values and update variables safely.

Example

const name = 'Ada';
let score = 10;
score = 11;
console.log(`${name} scored ${score}`);

Guided practice

1. Create a let variable for your favorite food and print it.
2. Create a const value for your name and try reassigning it to observe the error.
3. Use a template literal to combine text with variable values.

Common mistakes

• Reassigning a const variable.
• Using unclear names like x or data.
• Declaring with var when let or const is clearer.

Self-check

1. Which keyword should you use when a value should not change?
2. What happens when you reassign a const variable?
3. Why are descriptive names helpful?

References

• MDN: JavaScript Guide
• MDN: let
• MDN: const

Kubernetes Orchestration

Draft placeholder — add workloads, scaling, ingress, services, and declarative networking.

Large Language Models (LLMs)

Large language models generate text by learning patterns from massive datasets. They can assist with summarization, translation, classification, code generation, and explanation tasks.

Key concepts

• Token: a unit of text processed by the model.
• Context window: the amount of text the model can use as input.
• Prompt: instructions and examples given to the model.
• Inference: the process of generating output.
• Evaluation: comparing outputs to representative examples.

How to learn it

1. Start with a narrow task and a clear desired output.
2. Write prompts that specify format, examples, and constraints.
3. Test multiple inputs and inspect errors.
4. Add a human review step for important or factual results.

Reliability rules

• Always verify important outputs independently.
• Do not use an LLM as a sole source of truth.
• Avoid sending sensitive or private data without consent.
• Keep prompts and model versions traceable.

Open-source guides

• Hugging Face Transformers documentation
• Hugging Face LLM course
• EleutherAI GPT-NeoX documentation

LLM Integration Guide

Build LLM features with a narrow use case, predictable behavior, and server-side protections. A good integration separates user input, provider instructions, and output validation.

Recommended flow

1. Browser sends a validated request to your server.
2. Server authenticates the user and checks allowances.
3. Server sends the prompt to the provider with a secret API key.
4. Server validates the provider response and returns a safe result.

Responsible patterns

• Never expose API keys in browser or client code.
• Limit allowed tasks and reject unsupported requests.
• Validate structured responses before using them in the app.
• Log only the data needed for diagnostics and avoid storing private input.
• Provide a fallback path when the model is uncertain.

Practice milestone

Design one feature such as code explanation, summarization, or question answering. Document:

• input validation rules,
• provider call flow,
• response validation checks,
• privacy/security considerations.

Open-source resources

• OpenAI API quickstart
• OpenAI best practices
• Hugging Face inference guidelines

Machine Learning Foundations

Master the core concepts of supervised learning, unsupervised learning, and model optimization.

Machine Learning Foundations

Machine learning teaches a computer to make predictions from data. A strong foundation begins with a clear problem, clean data, and reliable evaluation.

Core concepts

• Feature: an input used to make a prediction.
• Label: the answer the model should learn.
• Training set: examples used to fit the model.
• Validation/test set: separate data used to measure performance.
• Overfitting: when a model learns noise instead of general patterns.

Learning sequence

1. Define a measurable goal and success metric.
2. Prepare a dataset and split it into training and test examples.
3. Train a simple model first.
4. Evaluate with metrics that match the task.
5. Inspect errors and document limitations.

Practice milestone

Use an open dataset to train a simple model. Compare it to a baseline, identify failure cases, and write a summary of one strength and one limitation.

Open-source resources

• scikit-learn Getting started
• scikit-learn User Guide
• Google Machine Learning Crash Course

Metrics and Analytical Reporting

Draft placeholder — add KPI design, metric definitions, reporting cadence, and stakeholder communication.

MLOps and Model Deployment

Draft placeholder — add packaging, deployment, monitoring, and model lifecycle practices.

Model Evaluation

Draft placeholder — add validation strategies, metrics, error analysis, and model comparison.

Monitoring and Observability

Draft placeholder — add logging, metrics, traces, dashboards, and alert design guidance.

Monoliths and Microservices

Draft placeholder — add monolith, microservice, API contract, and decoupling trade-offs.

Neural Networks

Learn how artificial neural networks process features, apply activation functions, and compute backpropagation gradients.

Python Programming Guide

Comprehensive Python reference covering syntax, data structures, functional paradigms, and modules.

Python Learning Path

Python is a popular language for automation, web apps, data work, and machine learning. Learn it by solving small problems and building reusable code.

What to learn first

1. Values and variables ? store and reuse numbers, text, and booleans.
2. Control flow ? make decisions with if and repeat work with loops.
3. Functions ? name reusable steps, accept inputs, and return results.
4. Data structures ? use lists, dictionaries, tuples, and sets.
5. Files and errors ? read and write files, and handle exceptions.
6. Modules and packages ? import standard tools, create a virtual environment, and install packages safely.

Guided practice

• Build a small CLI app such as a task list, grade calculator, or text summarizer.
• Use functions to keep logic reusable.
• Read a file, handle a missing file error, and print a meaningful message.
• Create a project environment and install one package with pip.

Common beginner issues

• mixing tabs and spaces for indentation.
• naming files after standard modules like random.py or json.py.
• using variables before defining them.
• installing packages globally instead of inside a virtual environment.

Helpful guides

• The Python Tutorial
• Python standard library
• Python venv tutorial

Real-Time Event Streaming

Draft placeholder — add Kafka, consumer groups, partitions, delivery semantics, and windows.

Secure Coding Practices

Draft placeholder — add OWASP guidance, input validation, authentication, and secure development practices.

Self-Paced Learning Library

Welcome to the AITutor reference library and self-paced wiki guides. Browse topic categories to explore concepts step-by-step.

Single-Page Build Optimisation

Draft placeholder — add Vite, Webpack, SSR, bundle sizing, and Core Web Vitals guidance.

Small Language Models (SLMs)

Small language models are compact models designed to operate with less memory, cost, and latency than very large models. They are a good fit for narrower tasks and constrained environments.

When to choose a smaller model

• the task is narrow and predictable.
• low latency or lower cost is essential.
• on-device or privacy-sensitive deployment is required.
• a larger model adds little additional value.

How to evaluate them

1. Set a clear task and acceptable quality level.
2. Test the same inputs against multiple models.
3. Measure correctness, formatting reliability, latency, and memory use.
4. Read the model card for licensing, supported languages, and limitations.
5. Keep a fallback or human review for uncertain cases.

Practice milestone

Run a compact model on a simple text classification or summarization task. Record the prompt, model version, latency, and at least five failure cases. Compare results to a larger model if available.

Useful resources

• Hugging Face Transformers quick tour
• SmolLM3 documentation
• Hugging Face model cards guide

SQL for Data Work

Draft placeholder — add SQL querying, joins, aggregations, and performance exercises.

Statistical Analysis

Draft placeholder — add descriptive statistics, probability, inference, and experiment design.

System Design

Draft placeholder — add monolith, microservice, event-driven, and scalability design material.

Testing Frameworks

Draft placeholder — add test strategy, test types, tooling, and resilient test examples.

Interactive Tutor Workspace

Welcome to the AI Tutor interactive goal-based learning workspace. Select a learning goal or dive straight into any of the modules in the sidebar.

Variables and Data Types in Python

Understand dynamic typing, primitive data types (int, float, str, bool), and sequence types.

Version Control with Git

Draft placeholder — add Git workflows, branching conventions, and collaboration exercises.

Web Accessibility

Draft placeholder — add semantic HTML, keyboard support, ARIA, contrast, and testing practices.

Web Foundations

A strong foundation for web development includes HTML structure, CSS visual styling, and JavaScript interaction.

Learning sequence

1. HTML — create headings, paragraphs, lists, links, and forms.
2. CSS — add color, spacing, layout, and typography.
3. JavaScript — build interactivity, validate input, and update content.

Guided practice

• Build one simple page with a title, section, and list.
• Add CSS to style the page background, headings, and buttons.
• Add JavaScript to change text or show a message when a button is clicked.

Open-source guides

• MDN HTML basics
• MDN CSS basics
• MDN JavaScript first steps

What is an API?

An API (Application Programming Interface) is a structured way for software to communicate with other software. It defines how requests are made and how responses are returned.

Basic idea

• A client sends a request to a server.
• The server performs work or returns data.
• Responses include a status code, headers, and a body.

Common API styles

• REST APIs: use HTTP methods like GET, POST, PUT, and DELETE.
• GraphQL APIs: ask for exactly the fields you need in one request.
• Webhooks: send data from one service to another when events happen.

Why APIs matter

APIs let developers build on other systems without knowing internal details. They separate interface from implementation and make software easier to combine.

Practice milestone

Find one public API and identify:

• the request method and path,
• required parameters,
• sample success response,
• one error response,
• whether it should be called from browser code or the backend.

Useful resources

• MDN: Overview of HTTP
• MDN: HTTP messages