AI curriculum

Course outline for Programming Language Concepts for AI Engineers

A model-generated expression or tool request can be syntactically valid yet have the wrong types or meaning. Trace a tiny expression language from parsing to checked execution. Use supplied agent-plan and parallel-tool traces to connect language semantics, memory, and concurrency to AI engineering without executing unrestricted generated code.

Technology: Software Engineering Foundations
Duration: 4 hours
Modules: 2 · 2 hours each
Level: Level 1

About Programming Language Concepts for AI Engineers

Programming Language Concepts for AI Engineers Course Objectives

Trace supplied generated expressions through tokens, syntax, type checks, and execution.
Distinguish compilation, interpretation, and runtime responsibilities.
Reject malformed JSON and incompatible tool-argument types before execution.
Explain why syntax and type validity do not establish intent or permission.
Compare memory lifetime and aliasing; identify a parallel-tool lost update and cancellation boundary.
Compare paradigms and distinguish interpreting a bounded plan from running arbitrary generated code.

Pre-requisites

Experience writing programs in one language.
Familiarity with functions and data structures.
Comfort reading simple expression trees and execution traces; introductory examples are supplied.

Before this course

Complete the required courses or bring equivalent experience. Recommended courses add useful depth; they are not enrolment gates.

No prerequisite course is required. The entry skills above still apply.

Recommended preparation

Software Engineering Foundations for AI Engineers

Can program with functions and data structures; general design practice helps but is not a compiler-course gate.

Find your place in the learning map

Lab Setup

Computer with a code editor, a familiar language runtime, and a test runner.
Supplied parser/evaluator scaffold, synthetic generated expressions and JSON tool arguments, and deterministic concurrency/cancellation traces.
Use harmless local expressions and mock tools; no live model, arbitrary generated-code execution, or compiler implementation is required.

Detailed Course Outline

Module 1: From generated text to checked execution (2 hours)

Compilation and interpretation: Compare source translation with interpreting bounded generated expressions; distinguish an agent-plan interpreter from unrestricted execution of model-generated code.
Parsing: Use tokens, grammar, and syntax trees to inspect generated expressions and JSON tool arguments; valid syntax alone does not establish correct meaning.
Type systems: Check expression operands and generated tool arguments against explicit types; distinguish static guarantees from runtime validation, business rules, and permissions.
Runtime systems: Trace evaluation order, runtime errors, and effects in a bounded evaluator; identify which execution responsibilities remain after generated text passes validation.

Practical outcome: Extend a supplied expression evaluator with a type check; inspect generated JSON tool arguments and distinguish syntax, type, runtime, and business-rule failures.

Module 2: Understand agent execution semantics (2 hours)

Memory models: Stack and heap lifetimes, aliasing, ownership, and garbage collection; distinguish memory management from visibility across concurrent execution.
Concurrency: Trace parallel mock tool calls, shared-state races, and cancellation; distinguish stopping pending work from undoing an effect that already committed.
Programming language paradigms: Compare imperative tool sequences, object-based session state, and functional plan transformations; make dependencies and effects explicit rather than relying on natural-language instructions.

Practical outcome: Trace memory lifetime and aliasing, expose a parallel-tool lost update, inspect cancellation before and after an effect, and annotate a typed three-stage agent plan.

Practical exercise

Produce a tiny evaluator with a documented grammar, type rules, and an execution trace using supplied model-output fixtures.
Evaluate a valid expression; reject malformed syntax and mismatched types, and identify a type-valid tool request that still needs business-rule and permission checks.
Run at least six fixtures, including deterministic parallel-update and cancellation traces; record which effects have already occurred when cancellation arrives.
Compare interpreting a bounded agent plan with running arbitrary generated code; distinguish dependencies, permitted transitions, and explicit effects.

What you will produce

Check generated expressions and tool arguments while distinguishing language validity, execution effects, and application permission.

How the work is checked

The evaluator distinguishes syntax, type, and runtime failure categories.
Valid expressions execute and type-invalid expressions fail before evaluation.
Memory and concurrency traces identify aliasing and a lost update accurately.
The agent-plan annotation distinguishes dependencies, transitions, effects, and cancellation limits; type validity is not treated as authorization.

Four hours with a supplied parser and mock agent artifacts. Implement only the type check and evaluator extension; memory, parallel-tool, and cancellation examples use guided traces. The typed plan is not a second interpreter project. No AI prerequisite, live model, unrestricted generated code, or sandbox guarantee is required.

When another approach is better

Do not build a new language when a validated data format and existing runtime meet the need.
Do not treat natural-language plans as statically typed programs without explicit syntax, rules, and execution semantics.

How we train

Ask about exercises, instructor feedback and the prior knowledge you need. Tool-specific courses marked provisional may become modules in a broader course.

Discuss your learning goals