AI curriculum
Course outline for Programming Language Concepts for AI Engineers
Learn how programs represent data, organize behavior, and execute. Compare procedural, object-oriented, and functional approaches using the same small task. Explore types, scope, references, memory lifetime, errors, and shared-state concurrency through runnable examples. Connect these ideas to readable, testable programs before considering generated code.
Programming Language Concepts for AI Engineers Course Objectives
- Explain source execution, types, scope, references, and runtime errors.
- Design collaborating objects with encapsulated state and explicit interfaces.
- Use pure functions, immutable data, and function composition.
- Compare paradigms and reproduce a simple shared-state concurrency failure.
Pre-requisites
- Write programs with variables, functions, expressions, collections, and control flow.
- Run a small program and follow a simple execution trace.
- No object-oriented, functional, compiler, or AI knowledge is assumed.
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.
Readiness checks
- Write programs with variables, functions, expressions, collections, and control flow.
- Run a small program and follow a simple execution trace.
- No object-oriented, functional, compiler, or AI knowledge is assumed.
Can write programs with variables, functions, expressions, collections, and control flow and follow a simple execution trace; no paradigm, compiler, or AI knowledge is assumed.
Find your place in the learning mapLab Setup
Delivery requirements: the following environment, materials, access, and exercise timing must be prepared and verified before delivery. This outline does not certify that a lab package is ready.
A code editor, a selected language runtime supporting object-oriented and functional examples, a test runner, and a controlled concurrency harness. Use prepared small programs; no compiler installation, AI account, or production service is needed. Environment and exercise files need verification before delivery.
Detailed Course Outline
Module 1: How a program runs (2 hours)
- Source text and evaluation: Source text, tokens, syntax trees, and evaluation order.
- Compilation and interpretation: Compare compilation, interpretation, and the responsibilities of a runtime system.
- Values and types: Distinguish values, types, static checks, and validation at runtime.
- Scope and memory: Trace scope, references, aliasing, lifetime, and memory management in programs.
- Errors and failures: Use errors, exceptions, and explicit failure handling in small programs.
Practical outcome: Predict short programs and explain syntax, type, and runtime failures.
Module 2: Objects, interfaces, and responsibilities (2 hours)
- Procedural decomposition: Procedural decomposition and the limits of shared mutable data.
- Classes and encapsulation: Use classes, objects, constructors, methods, and encapsulation in a small task.
- Object interfaces: Define public interfaces and explain collaboration between objects through behavior.
- Composition and inheritance: Compare composition, inheritance, and substitutable implementations for the same task.
- Cohesion and coupling: Improve cohesion and coupling through a small, behavior-preserving refactoring.
Practical outcome: Implement collaborating objects and test their public behavior.
Module 3: Functions, composition, and explicit effects (2 hours)
- Pure functions: Use pure functions and immutable inputs to avoid hidden mutation.
- Higher-order functions: Use functions as values and pass them to higher-order functions.
- Collection transformations: Compare mapping, filtering, reducing, and function composition on small collections.
- Calculations and effects: Separate calculations from input/output effects to make behavior easier to test.
- Comparing functional and object designs: Functional and object-oriented solutions to the same task.
Practical outcome: Implement a functional alternative and compare state and testability.
Module 4: Choosing a design and managing shared state (2 hours)
- Choosing a paradigm: Choose procedural, object-oriented, functional, or mixed designs for a small task.
- Strategy and simpler functions: A strategy example compared with simpler function-based code.
- Interface contracts: Specify interface inputs, outputs, errors, and compatibility for collaborating code.
- Concurrent interleavings: Reproduce concurrent tasks, controlled interleavings, and a shared-state lost update.
- Shared-state corrections: Compare synchronization with isolated-state alternatives when correcting a concurrency failure.
- Reviewing generated code: Brief transfer: reviewing generated code using the same language concepts.
Practical outcome: Justify a small design and reproduce and correct one controlled race.
Practical exercise
- Implement the core of a small order-pricing task with objects and then pure functions. Change one rule and compare the impact on both versions. Predict an aliasing example before running it. Reproduce a lost update under a controlled interleaving, apply one correction, and check the result. Explain the types, interfaces, state, and effects in the resulting code.
What you will produce
Implement a small task with objects and pure functions, explain its execution, and correct a controlled shared-state race.
How the work is checked
- Short-program predictions distinguish scope, aliasing, and error categories.
- Objects expose useful behavior without allowing uncontrolled state changes.
- Functional calculations avoid hidden mutation and external effects.
- The design comparison identifies trade-offs rather than a universally best paradigm.
- The concurrency correction is supported by actual runs and an explanation.
Eight guided hours, including demonstrations, practice, feedback, and questions. Breaks and pre-course setup are outside the total. This is an introductory programming and software-design foundation, not mastery of every paradigm. Parsing is introductory. Compiler construction, advanced ownership systems, API service implementation, microservices, and distributed architecture are outside scope. Software delivery practices belong in Software Engineering Foundations for AI Engineers. Environments and exercise files need verification before delivery.
When another approach is better
- Use an introductory programming course first if variables, functions, collections, and control flow are unfamiliar.
- Use compiler, API, or distributed-systems training for implementation depth beyond this small-program course.
How we train
Contact us for full course details, including duration, delivery options and lab requirements.
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 goalsRelated Courses
These courses list this course as preparation.