BSc Computer Science & Engineering: construire les bases derrière l’IA, la cyber et les systèmes numériques modernes.

Networks were introduced as shared infrastructure connecting users, devices and applications. The class examined campus and wide-area design, including access, distribution and core layers, redundant links, switching and routing. Internet Protocol (IP) addresses, subnet masks and default gateways connected addressing decisions with the path a packet takes. Protocol layering explained how data is packaged and unpackaged during transmission, while reliable transport was compared with approaches suited to real-time traffic. Students built small computer, switch and router topologies in Packet Tracer, assigned addresses, tested connectivity with ping and inspected interfaces and learned hardware-address tables.

Students revised subnet calculations: usable host counts, block sizes, subnet masks and binary operations for finding network addresses. Configuration checks and ping tests helped establish whether hosts shared a subnet or needed a gateway. Internet Protocol version 6 (IPv6) introduced compressed addresses, address types, automatic configuration and coexistence with IPv4. Virtual local area networks (VLANs) then connected logical separation with access ports, tagged trunk links and routing between networks. Spanning Tree Protocol explained how redundant switches can avoid loops. A practical task asked students to build a virtual local area network (VLAN) and trunking topology with redundant switches and consider its protective settings.

The session covered multilayer (Layer 3) switches and their use for inter-VLAN routing, replacing a router-on-a-stick design with switch virtual interfaces (SVIs). Students built a Packet Tracer topology using VLANs, access ports, trunk links, EtherChannel, spanning tree configuration and VTP VLAN propagation. The class practised IPv4 subnetting, including usable host ranges, broadcast addresses, default gateways and /26 and /30 networks. Routing concepts were introduced through routing tables, directly connected and static routes, return routes, loopback interfaces, administrative distance, metrics, longest-prefix matching, floating static routes and default routes. The session also distinguished campus networks from WANs and introduced routing protocols, autonomous systems and the differing roles of internal and external routing.

The session covered configuring OSPF on routers, including network statements, wildcard masks, areas, router IDs, passive interfaces and default-route propagation. Students examined OSPF neighbour adjacencies, routing tables, link-state databases, equal-cost load balancing and troubleshooting commands for common configuration faults. A practical lab required building an OSPF topology, injecting a static default route, testing connectivity and observing rerouting after a link failure. The session then introduced network services including Dynamic Host Configuration Protocol (DHCP) and relay agents, Domain Name System (DNS), network address translation (NAT) and PAT, NTP, Syslog, SNMP and quality of service. Students also reviewed relevant verification commands and began configuring DHCP, NAT overload and NTP in a further lab setup.

A support session explained the assessed network lab, covering VLANs, trunk links, addressing and routing between networks. The brief included connectivity to an internet service provider, loop prevention and verification of blocked links. Address allocation, address translation, encrypted remote administration, port security and access control lists added service and security requirements. Students were advised to verify each configuration stage through diagnostic commands, routing tables, ping tests and captured evidence. A question-and-answer activity revisited subnetting, switching, IPv6 neighbour discovery, routing and automation. These were lab requirements and revision activities, rather than a record of every configuration having been completed.

The session introduced data engineering on AWS, focusing on the five Vs of data: value, veracity, volume, velocity and variety. It explained data pipelines, including extract, transform and load (ETL) and extract, load and transform (ELT) approaches, structured and unstructured data, and the choice between batch and streaming processing. AWS ingestion services were covered, including AppFlow for software-as-a-service data, DataSync for file transfers, and Data Exchange for third-party data. The class examined AWS Glue for data catalogues, crawlers, ETL jobs, schema management, data quality and handling sensitive information. Streaming tools including Kinesis Data Firehose, Kinesis Data Streams, managed Apache Flink and Kafka services were compared, alongside data lakes, data warehouses, Lake Formation, Athena, Redshift and OpenSearch.

Disaster recovery planning connected acceptable data loss and recovery delay with storage, computing, databases and networks. Backups, snapshots and cross-region replication were compared, including why replication alone does not protect against corruption. The class reviewed storage migration, lifecycle management and shared file services, then considered machine recovery, automatic scaling, load balancing and regional failover. Managed database recovery and repeatable infrastructure deployment added further recovery options. A guided hybrid-storage lab covered configuring storage, moving files to Amazon Simple Storage Service (S3) and replicating data into another region, connecting architectural choices with the mechanics of protecting and moving data.

The session completed the disaster recovery module by reviewing recovery point objectives (RPOs), recovery time objectives (RTOs), and the relationship between disaster recovery and business continuity planning. It covered AWS services and approaches for resilience, including S3 replication, Storage Gateway, Amazon Machine Images, snapshots, CloudFormation infrastructure as code, Route 53 health checks and failover. Four disaster recovery patterns were compared: backup and restore, pilot light, warm standby, and multi-site active-active, with emphasis on their cost, recovery speed and suitable use cases. Students worked through knowledge-check and exam-style questions on selecting the appropriate recovery pattern and AWS service for different scenarios. The session also introduced the certification exam structure, exam guide and practice-question resources.

Certification preparation used a modular study guide and short quizzes to identify topics needing further revision. The material revisited computing, storage, networking, databases and security, alongside name resolution, logging, resilience, performance and cost. Students were shown how quiz results could guide their study rather than treating every topic as equally familiar. Additional resources included hands-on AWS practice environments, an architecture project and configurable practice tests. The session concerned ways to prepare and assess understanding; the source does not establish completion of the project or an eventual certification result.

The session reviewed commonly misunderstood AWS concepts in preparation for an assessment. It covered service-level agreements, Elastic Compute Cloud (EC2) Auto Scaling, S3 durability, encryption and access logs, virtual private cloud (VPC) networking, network address translation (NAT) gateways, VPC peering, security groups and availability zones. It also compared relational databases with DynamoDB, explained Identity and Access Management (IAM) permissions and roles, and distinguished CloudWatch, CloudTrail and AWS Config for monitoring and auditing. Further topics included messaging with SNS and SQS, CloudFormation, caching, VPC flow logs, cost-allocation tags, SSL offloading, and gateway versus interface VPC endpoints. Practice-question answers were used to reinforce how to select appropriate AWS services for performance, security, scalability and cost management.

The session introduced the AWS Cloud Architecting course, its learning resources, guided labs, challenge labs and preparation for the AWS Certified Solutions Architect – Associate examination. It explained how a café business case will be developed from a static website into a secure, scalable online ordering system with databases, automation and monitoring. The class reviewed cloud architecture roles, including IT professionals, developers, DevOps practitioners and cloud architects, alongside development, test and production environments and CI/CD pipelines. Key cloud concepts included high availability, scalability, reliability, virtual machines, cloud service origins and the distinction between on-premises infrastructure and cloud services. The AWS Well-Architected Framework was presented through its six pillars: operational excellence, security, reliability, performance efficiency, cost optimisation and sustainability, including the use of assessment and recommendation tools.

The session covered AWS Identity and Access Management (IAM) security, including resource-based and identity-based policies, ARN structure, principals, policy statements, conditions and the precedence of explicit denies over allows. Examples were used to distinguish permissions on Simple Storage Service (S3) buckets from permissions on objects within buckets, and to interpret IAM and Elastic Compute Cloud (EC2) policy conditions such as IP ranges and permitted instance types. Students completed a lab exploring IAM users, groups, managed policies and inline policies, then tested the different S3 and EC2 permissions granted through group membership. The class also reviewed security best practice: create individual IAM users, assign permissions through groups, use temporary role credentials where appropriate, apply least privilege, and avoid using the root user for routine administration.

The session completed an Amazon S3 lab for hosting a static website and granting public read access through a bucket policy. It covered S3 versioning to recover from accidental overwrites or deletions, and showed how uploading an updated Hypertext Markup Language (HTML) file creates a new object version. Lifecycle rules were configured to move non-current versions to Standard-IA after 30 days and delete them after 365 days to manage storage costs. Cross-Region Replication was set up with a destination bucket and IAM role, demonstrating replication of new objects and the effect of not replicating delete markers. The class related these choices to security, cost optimisation, resilience and disaster recovery in the AWS Well-Architected Framework, then practised an exam-style question on protecting S3 files from accidental deletion.

The session continued the AWS EC2 compute module by comparing storage options, with particular focus on Amazon Elastic File System (EFS) for shared Linux file storage and Amazon FSx for Windows workloads. It explained EFS mount targets, multi-AZ availability, network file system access on port 2049, security groups, performance monitoring through CloudWatch, and the trade-offs of the One Zone storage class. Students completed a lab creating an EFS file system, configuring access, mounting it on an EC2 instance and observing throughput metrics. The class then covered EC2 user data scripts, instance metadata, and the use of base, silver and golden AMIs to balance build time, boot time and configuration consistency. It also introduced placement groups and reviewed EC2 pricing models, including on-demand, reserved, Savings Plans and Spot Instances.

The session completed a lab on duplicating a dynamic café website hosted on Amazon EC2 by creating an Amazon Machine Image (AMI), copying it to another AWS Region, and launching a new instance from it. It covered configuring instance roles, security groups, virtual private cloud (VPC) networking, public IP access and regional Secrets Manager secrets so that the replicated application could access its database. The class explained that an AMI creates a point-in-time copy, so the copied database is not synchronised with the original, and introduced Amazon Relational Database Service (RDS) as the next step for managed databases. It also reviewed EC2 best practice through the Well-Architected Framework, including security, right-sizing, managed services, AMI use, user data and pricing models. Learners completed knowledge-check questions on AMIs, storage, instance types, metadata, user data, EFS, FSx and Savings Plans.

The session reviewed relational and non-relational database choices in AWS, focusing on Amazon RDS, Aurora and DynamoDB. It covered RDS architecture, database engines, private subnet deployment, replicas, serverless capacity, RDS Proxy, backups, encryption and security controls. DynamoDB data modelling was explained through items, attributes, partition and sort keys, secondary indexes, consistency, global tables and monitoring. The class also compared purpose-built databases for analytics, documents, wide-column data, in-memory workloads, graphs, time series and immutable ledgers, and introduced AWS Database Migration Service for homogeneous and heterogeneous migrations. Students then began a lab to migrate a café application database from an EC2 instance to Amazon RDS.

The session introduced Amazon VPCs as logically isolated virtual networks within AWS Regions, covering Classless Inter-Domain Routing (CIDR) address ranges, Availability Zones, subnets and route tables. It explained how public and private subnets use Internet Gateways, network address translation (NAT) Gateways and Elastic IP addresses to control internet connectivity, with examples of suitable placement for databases, batch-processing workloads, web applications and NAT components. The class compared security groups and network ACLs, including their resource or subnet scope, allow/deny behaviour, and stateful or stateless handling of return traffic, alongside AWS Network Firewall and bastion hosts. It also covered VPC endpoints for privately accessing AWS managed services, distinguishing interface endpoints, gateway endpoints and Gateway Load Balancer endpoints. A console demonstration showed the creation of a VPC, subnets, routing, an Internet Gateway, a NAT Gateway and security groups, before students began a guided VPC configuration lab.

The session reviewed VPC networking, including security groups and network ACLs, public and private subnets, NAT gateways, bastion hosts, VPC endpoints and flow logs. It introduced Transit Gateway as a hub-and-spoke method for connecting many VPCs, compared it with one-to-one VPC peering, and explained routing requirements and non-overlapping address ranges. A practical activity created and accepted a VPC peering connection, added routes between two VPCs, connected an application server to a MySQL database, and inspected VPC Flow Logs in CloudWatch. The session also covered site-to-site VPNs, Direct Connect, Global Accelerator, redundant connections, and choosing connectivity options according to security, performance, availability and cost requirements. Knowledge-check questions were used to practise selecting suitable AWS networking solutions.

The session covered AWS security and access management, including attribute-based access control using resource tags and identity federation with IAM Identity Centre, STS and identity brokers. It explained Amazon Cognito user pools for authentication and identity pools for granting temporary AWS credentials, using a lab scenario involving controlled access to a DynamoDB table. Multi-account governance was reviewed through AWS Organisations, organisational units, service control policies, permission boundaries and Control Tower. The class also examined encryption of data at rest, comparing symmetric and asymmetric encryption, envelope encryption, server-side and client-side encryption, and AWS Key Management Service integration with S3 and EBS. Finally, it introduced security services including AWS WAF, Macie, Inspector, Detective, Security Hub and CloudTrail.

The session reviewed Elastic Load Balancing, including listeners, target groups, health checks and the use of multiple Availability Zones to remove single points of failure. It compared Application, Network and Gateway Load Balancers by their network layers, routing capabilities and security uses. The class then introduced Domain Name System (DNS) resolution and Amazon Route 53, covering domain registration, hosted zones, DNS records, caching and authoritative name servers. Route 53 routing policies were explained, including simple, weighted, latency, failover, geolocation, geoproximity, multivalue and IP-based routing, alongside health checks and failover notifications. A lab was introduced to make a café application more scalable and highly available using a load balancer, Auto Scaling and resources distributed across two Availability Zones.

The session covered infrastructure as code using AWS CloudFormation, including YAML template structure, resources, stack creation and validation. A practical lab automated the deployment of a static website in an Amazon S3 bucket, including website hosting configuration, outputs and public access settings. It then introduced Git and AWS CodeCommit for version control, and AWS CodePipeline for automatically deploying CloudFormation changes to create networking resources and an EC2-hosted café application. The class also examined CloudFormation parameters, outputs and conditions, including using conditions to distinguish production and development environments. Finally, it introduced caching with CloudFront for static edge caching and ElastiCache for in-memory database caching, including cache expiry, cache hits and misses, lazy loading, write-through caching, Redis and Memcached.

The session reviewed microservices and serverless architecture, explaining how AWS services can separate application functions so that they can be deployed, changed and scaled independently. It covered AWS Lambda, including execution limits, pricing, permissions, VPC access, layers, triggers, and synchronous, asynchronous and streaming invocation models. Container-based microservices were compared with Lambda, with Amazon ECS, AWS Fargate, EKS, task definitions, services, load balancing and container registries explained through an ECS deployment example. The class also examined Step Functions for orchestrating workflows, error handling, branching and long-running processes, and application programming interface (API) Gateway for exposing and securing Hypertext Transfer Protocol (HTTP), Representational State Transfer (REST) and WebSocket APIs. A design activity applied these services to shopping-cart, payment and delivery workflows, followed by introduction to a lab creating scheduled café order reports using EventBridge, Lambda and SNS.

The session introduced Windows Server administration in hybrid on-premises and Azure environments, with a focus on Active Directory Domain Services (AD DS). It explained AD DS logical and physical components, including forests, domains, organisational units, users, groups, computer accounts, service accounts, domain controllers and the Global Catalogue. Students learnt about deploying and maintaining domain controllers, FSMO roles, functional levels, replication, backup and recovery, and recommended practices for deploying domain controllers in Azure. The class also covered Group Policy Objects, their scope, processing order, inheritance, default policies, storage and administrative templates. Practical activities demonstrated enabling Hyper-V, creating a local Windows Server virtual machine, installing AD DS through PowerShell and Server Manager, and preparing an Azure virtual machine while considering resource costs and security requirements.

The session covered secure Windows Server administration, including security principals, least privilege, delegated permissions, restricted groups, User Account Control, privileged access workstations and jump servers. It introduced administration tools such as Windows Admin Center, Server Manager, Remote Server Administration Tools and PowerShell, including remoting, Secure Shell (SSH) support and the second-hop authentication issue. Post-installation configuration was reviewed, covering server naming, static IP addressing, Domain Name System (DNS), updates, roles, monitoring, Server Core configuration and unattended answer files. Students then began a practical activity using Hyper-V to create Windows Server virtual machines, configure networking, and install and promote Active Directory domain controllers.

The session introduced a six-day simulated client engagement focused on building and managing a hybrid Windows Server environment. It reviewed Active Directory Domain Services, including domains, forests, organisational units, domain controllers, replication, DNS and Group Policy processing. Students were instructed to create a Hyper-V virtual switch and Windows Server domain controller, configure organisational units, users, groups, a baseline Group Policy Object and Windows Admin Centre, while documenting evidence in a runbook. The class also covered least-privilege administration, Just Enough Administration, Azure Arc, remote server management and preparation for hybrid identity. Finally, it taught Windows containers and Kubernetes, including container isolation, Docker commands, networking, images, orchestration and Azure Arc-enabled Kubernetes.

The session covered Azure hybrid networking, including VNets, subnets, network interfaces, address planning, network security groups, Azure Firewall, VPN gateways, ExpressRoute and Virtual WAN. It explained Azure DNS, private DNS zones, hybrid DNS forwarding, split-horizon DNS and a structured approach to diagnosing name-resolution problems. Learners also reviewed Azure VM IP addressing, routing, static and dynamic private addresses, public IP exposure, Bastion and IPv6 dual-stack design. The class then covered Windows Server storage technologies, including file systems, File Server Resource Manager, SMB security, Volume Shadow Copy Service, Storage Spaces, Storage Spaces Direct and data deduplication. A practical activity was introduced to configure PowerShell remoting, onboard a server to Azure, create Azure networking resources, deploy a VM with Bastion, and document evidence in a runbook.

The session covered Windows Server security, including least-privilege user rights, Group Policy security settings, fine-grained password policies, Protected Users, authentication policies and Credential Guard. It examined server hardening through OS Config, Windows LAPS, privileged access workstations, domain controller protection, security baselines and SMB encryption. Update management was discussed using WSUS and Azure Update Manager, including testing, deployment rings, maintenance schedules, reporting and hybrid management through Azure Arc. Azure network and virtual machine security covered network security groups, application security groups, Azure Firewall, host firewalls, Defender for Cloud and Microsoft Sentinel. Learners then worked on or completed labs involving virtual machine connectivity, Windows Admin Centre, file shares, quotas, data deduplication and Azure File Sync.

The session covered disaster recovery for Windows Server hybrid environments, distinguishing Hyper-V Replica, Azure Site Recovery and Azure Backup according to their different purposes. It explained replication prerequisites, authentication, replication intervals, extended replication, failover types, and the difference between recovery time objectives and recovery point objectives. Azure Site Recovery was presented as a service for orchestrated, dependency-aware disaster recovery, including isolated test failovers, failback and re-protection. Azure Backup covered Recovery Services vaults, the Microsoft Azure Recovery Services agent, backup policies, snapshots, file-level recovery, VM restoration options and backup-cost considerations. Students were then directed to use lab time or complete practice tests to identify areas needing revision.

The session covered planning and carrying out Windows Server migrations, including lift-and-shift strategies, Azure Migrate assessments, replication, test migrations and cutover. It compared server upgrade approaches and explained Storage Migration Service for file-server inventory, data transfer and identity cutover. It also covered containerising supported ASP.NET applications for Azure App Service, including version requirements and the distinction between updating and upgrading. Monitoring and troubleshooting topics included performance and resource monitoring, event logs, auditing, Hyper-V resource metering, capacity forecasting and centralised event collection. Active Directory topics included object and database recovery, SYSVOL recovery, replication troubleshooting, FSMO roles, and hybrid identity synchronisation with Microsoft Entra Connect.

The session reviewed key AZ-800 and AZ-801 Windows Server hybrid administration topics through recap diagrams and exam-style questions. It covered Active Directory Domain Services, domain controllers, FSMO roles, Group Policy processing, replication, trusts, Microsoft Entra integration and managed domain services. It also reviewed secure administration, remote management tools, PowerShell Just Enough Administration, Azure Arc, Hyper-V, containers, Kubernetes, VM deployment and configuration automation. Further topics included Dynamic Host Configuration Protocol (DHCP), DNS, IP address management, VPN and hybrid networking, file and storage services, data replication, Azure Files, security hardening and update management. Learners were encouraged to use key terms, command names, process orders and elimination techniques to answer certification questions.

The session introduced Linux user management, including root, application and standard user accounts, and the use of UID and GID values to identify them. Students used commands such as id, sudo -i, cat /etc/passwd, top and ls -l to inspect accounts, processes and file permissions. The class explained that system and application accounts support controlled access to resources, while interactive accounts use a shell such as /bin/bash. It covered file ownership and the owner, group and other permission categories, with read, write and execute permissions illustrated through /etc/passwd and /etc/shadow. Password storage was discussed in terms of hashes in the shadow file, and students practised changing their own password with passwd before comparing the passwd command with the /etc/passwd file.

Linux permissions were reviewed in symbolic and octal notation, connecting read, write and execute settings with chmod commands. Extended permission bits and the sticky bit introduced further access behaviour. The class distinguished permissions on resources from privileges or capabilities, using system administration examples. Regular expressions and shell wildcard patterns were introduced as different pattern-matching tools. Exercises examined filename selection and patterns such as numerical endings or address formats. Students were asked to explain chmod commands in plain language and construct symbolic and octal commands that gave users only the access required.

The session covered Bash arrays, including defining arrays, accessing indexed elements, retrieving all elements and counting them. It explained how to pass command-line parameters to scripts using positional parameters such as $1 and $2, so that scripts can work with different paths and values without being edited. Conditional logic in Bash was introduced through if, elif and case statements, logical operators, pattern matching and the need for precise spacing and variable syntax. The class also used the test command and conditional expressions to check file types, file existence and permissions, including read, write, execute, SUID, SGID and sticky-bit permissions. Students began an exercise to create a directory and files, set SUID and SGID permissions, verify them and remove the created directory.

Loops were used to process files and directories before the class introduced while conditions, user input, break and continue. Shell functions separated tasks and accepted arguments, with attention to the difference between returning from a function and exiting the script. Directory traversal connected file-type checks and absolute paths with recursion through nested folders. The Linux manual and command help supported independent investigation, while stat exposed attributes such as ownership, size, permissions and access time. An exercise asked students to list a directory’s files and report selected attributes for each, bringing iteration and inspection together.

The session reviewed shell automation through an earlier exercise that gathered file and directory attributes, then introduced basic Linux networking concepts. It covered IPv4 addresses, Classless Inter-Domain Routing (CIDR) notation and netmasks, network and host portions of addresses, routing tables, gateways and interfaces, alongside commands such as systemctl, ip, route, ping, traceroute, whois and netcat. The class then moved to Windows automation with PowerShell, including PowerShell ISE, cmdlets using verb–noun naming, PowerShell script files with the .ps1 extension, and execution policies. It also introduced PowerShell’s object-based approach, using Get-Help, Get-Command, Get-Member and Get-Item to inspect commands, files, properties and methods. Students were asked to identify the PowerShell command for listing network adapters by searching available commands.

The session covered PowerShell file management, including copying files, reading file contents, retrieving line counts and specific lines, and writing or replacing text with Add-Content and Set-Content. Students practised extending a script to check whether files exist, retrieve file properties and write results to a text file. The class introduced string comparison operators, Windows environment variables, automatic variables, conditional Switch statements, loops and functions, including passing script arguments through $args. It also covered accessing and checking Windows services with Get-Service and foreach loops. Error handling was taught using try/catch, ErrorAction and ErrorActionPreference, with exercises to produce clear, specific error messages.

The session reviewed PowerShell automation for retrieving file and folder permissions with Get-Acl, including recursive directory structures, indentation and saving results to a text file. It then introduced local Windows user accounts and groups, using Get-LocalUser to view accounts and inspect properties such as enabled status and SID. Students learnt to create a local user with New-LocalUser, using Read-Host and secure strings to avoid hard-coding passwords in scripts. They practised creating a user in a virtual machine, adding it to the Users group with Add-LocalGroupMember, restarting if needed, and testing whether they could log in with the new account.

A PowerShell brief brought together users, groups and file permissions through a hospital scenario. Students were asked to model role-based access control for doctors, nurses, administrators and IT staff, granting access according to each role’s needs. Scripts were to validate structured input, create accounts and resources, assign group membership, apply permissions and remove created items when needed. The brief also required restrictions on administrative tools, tests of those restrictions and screenshot evidence. The expected group submission comprised scripts and a report; this session records the assignment and its requirements, not a completed hospital deployment.

The session introduced Java as a compiled, portable, object-oriented language that runs through the Java Virtual Machine, with comparisons to C++ and an explanation of automatic memory management through the garbage collector. Students installed or checked the Java Development Kit, verified the Java and Java compiler commands, then created, compiled and ran a basic Hello World program from the terminal. The class covered the structure of a Java program, including classes, the main method, console output, semicolons and code blocks. It then introduced typed variables, basic arithmetic and modulo operations, user input using Scanner, conditional structures with if/else and switch, and while loops. Students completed short programming exercises involving personal information variables and calculations on two decimal inputs.

The session reviewed core Java concepts, including variables, methods, arrays, strings, object references and the difference between passing primitive values and object references to methods. Through live coding, students observed that modifying an object inside a method changes the original object, whereas modifying a primitive parameter affects only a copy. The class then introduced classes, attributes, methods, object instantiation and arrays of objects, using student records as an example. Students completed and reviewed an exercise creating a Colour class with red, green and blue (RGB) attributes, collecting values through user input and displaying them with loops. The session also introduced object-oriented programming, encapsulation, private and public access, and getters and setters as ways to validate and control changes to object state.

The session reviewed Java object-oriented programming, including classes, encapsulation, constructors, inheritance and polymorphism through animal-based examples. Students completed and corrected an exercise in which instrument subclasses overrode a shared play method, while also considering when inherited default behaviour should be retained or overridden. The class introduced Jakarta EE as a platform for enterprise full-stack web applications, comparing it with standard Java and Spring Boot, and discussing scalability, structured architecture, Representational State Transfer (REST) APIs, databases and authentication. Students installed and configured IntelliJ IDEA, Postman and a local TomEE server, then created and ran a Jakarta EE web application project. The session concluded with an introduction to servlets as Java classes that handle Hypertext Transfer Protocol (HTTP) requests and responses.

The session reviewed Jakarta EE web development using Java servlets, including servlet classes, URL mappings and handling HTTP GET, POST, PUT and DELETE requests. It covered retrieving request parameters, testing endpoints with Postman, servlet lifecycle methods such as init and destroy, response formats, redirects versus forwards, and user session management. Students completed and corrected a practical exercise building a simple login system with an Hypertext Markup Language (HTML) form, credential checks, session creation, protected dashboard access, error handling and logout through session invalidation. The correction also explained comparing Java strings with equals, parsing values such as booleans, and retrieving typed session attributes.

The session reviewed JavaServer Pages (JSP) as the presentation layer for Java web applications, emphasising the separation of user-interface code from servlet-based logic. It covered JSP syntax including scriptlets, expressions, declarations, implicit objects, standard actions, and Expression Language, particularly its readable access to parameters and scoped attributes with null-safe behaviour. Students refactored a form-validation exercise so that validation and message construction took place in the servlet, while the JSP displayed only a prepared message and style. The Model–View–Controller pattern was then introduced, with Java classes as models, JSP pages as views, and servlets as controllers; students began organising these components into separate model, view and controller packages.

The class revisited form handling, request parameters, validation and forwarding to success or error pages. The Model–View–Controller pattern separated Java models, servlet controllers and page views, with restricted view locations preventing direct access. Java Persistence application programming interface (API) (JPA) then introduced object-relational mapping: connecting Java objects with stored database records. Entities, entity managers, configuration and Hibernate explained the persistence layer. A practical setup activity configured Docker and MySQL, connected the database through the development environment, tested table creation with Structured Query Language (SQL) and added the Maven dependencies needed by the application.

The session reviewed Java Persistence API (JPA) as an object-relational mapping approach, using Hibernate to connect Java objects to a MySQL database. It covered turning a Java class into an entity through annotations, including table mapping, primary keys, auto-incremented identifiers and column settings. Students practised using the EntityManager for create, read, update and delete (CRUD) operations: persist, find, custom queries for retrieving all records, merge and safe removal after checking that a record exists. The class then implemented a data-access object (DAO) layer through an interface and implementation class, and integrated it into an Model–View–Controller (MVC) application using a servlet to retrieve student data and forward it to a JSP page for display.

The session introduced REST APIs as a way of separating back-end data services from front-end presentation, allowing different clients such as web and mobile applications to consume the same data. It covered REST principles including client-server separation, stateless requests, uniform resource paths, resources and collections, and the use of HTTP methods for CRUD operations. The class also reviewed common HTTP response status codes and explained serialisation of Java objects into JavaScript Object Notation (JSON) or XML. Students configured JAX-RS using Jersey and Maven dependencies, created an application base path, and built and tested simple GET endpoints returning plain text and JSON.

A support session introduced a library-management project combining a web interface with a service interface. Books and borrowings were to become linked persistence entities, supported by database tables, queries, transactions and data-access objects. The brief required creation, retrieval, updates and deletion for books and loans. The web interface was to use servlet controllers, server-side validation and page templates; service endpoints were to return structured data and appropriate response codes. Students were advised to build incrementally and verify behaviour through test scenarios. These were the project’s design and implementation requirements, rather than evidence that the complete application had been delivered.

The session introduced C++ as a compiled, performance-oriented language derived from C, with uses in embedded systems, robotics, games, critical software and finance. Students set up or accessed C++ compilation tools, then created and ran basic “Hello World” programs. The class covered program structure, libraries, the main function, console input and output, variables and common data types, arithmetic operators and user input. Students completed short exercises using variables, calculations and displayed results, before learning conditional statements with if, else if and else, switch statements, and while, do-while and for loops.

The session reviewed conditional statements, functions, and the difference between passing arguments by value and by reference, including exercises to calculate an average and swap two variables. It also revisited arrays, indexing from zero, and using for loops to input and display array contents. Character strings were introduced using the modern string type, contrasted with older C-style character arrays and their null terminator. Pointers were explained as variables that store memory addresses, with practice in reading and modifying pointed-to values and passing pointers to functions. Structures were then introduced to group related attributes, and arrays of structures were used in an exercise to enter and display red, green and blue (RGB) colour values.

The session reviewed core C++ object-oriented programming, including classes, attributes, methods, object instantiation, encapsulation, constructors, copy constructors and destructors. Students completed and corrected an exercise creating a Car class with private attributes, getters and setters, several constructors, a destructor, a display method, and a collection of objects processed with an array and a for loop. The lesson then introduced inheritance through parent and child classes, showing how specialised classes inherit attributes and methods while adding their own behaviour. It also covered protected access for members needed by derived classes, and polymorphism using virtual methods and method overriding to give inherited methods different behaviours.

The session covered automatic and dynamic memory allocation in C++, including pointers, the use of new and delete, and dynamically allocated arrays. It introduced function templates, allowing the same function to work with different data types. The Standard Template Library was explored through vectors, maps and sets, including adding, removing, finding and counting elements. Practical exercises involved creating a telephone directory with a map, checking whether contacts exist, and performing union, intersection and difference operations on sets. File input and output streams were also briefly introduced.

A support session explained a small library-management project applying object-oriented programming. Students were asked to create a Book class with borrowing, returning, display and storage behaviour, then specialise it through an Ebook subclass. A Library class would use vectors to manage physical and digital books, with functions for adding, searching and saving items. The brief required an interactive console menu and persistence to a text file. It clarified that downloading an ebook was a console simulation, not a real transfer, and encouraged Git-based version control. The session records project guidance rather than completed implementations.

Software engineering was introduced through design, implementation, testing, deployment, maintenance and evolution. The class distinguished algorithms and data structures from the act of writing code, and discussed architectural choices for which no single solution is correct. Compilation stages connected syntax checks and code representation with machine instructions and platform dependencies. Java’s bytecode, virtual machine and just-in-time compilation illustrated portability and performance questions. The .NET ecosystem was then introduced as a multi-language environment, including C#, Visual Basic .NET, F# and PowerShell. Plans to use Visual Studio connected these ideas with the development environment for subsequent work.

Visual Studio Live Share introduced collaborative access to a project, including read-only and editable participation. Constructors, getters and setters were explored through objects whose data becomes available at different stages. Method and constructor overloading showed how one name can support different parameter sets. A geometric path-finding exercise used points, lines, segments and a polyline to connect object modelling with Euclidean distance. Discussion compared local and global optimisation, computational complexity, parallel processing and heuristics. The class also considered .NET development conventions, including namespaces, top-level statements, code documentation and inherited methods for representing objects as text.

The session reviewed object-oriented and functional programming paradigms, and compared explicit, implicit, strong and weak typing in several languages. It explained C# type inference with var, the object nature of basic types in C#, and contrasts with C++, Java and Python. The class explored parameter passing by value and by reference through a swap function, using debugging tools to observe local copies, references and call stacks. It then related parameter passing to stack memory, pointers, dynamic memory allocation, the heap, input/output data of unknown size, and automatic versus manual memory management.

The session compared arrays and linked lists as fundamental collection structures, explaining fixed versus dynamic size, contiguous storage, and the implications for other collections such as dictionaries, tuples, stacks and sets in .NET. It examined algorithmic complexity, including worst-case and amortised time, using stack growth and internal array resizing as examples. Generic types and immutable collections were introduced, alongside the memory and performance trade-offs of immutable values such as strings. The class also covered cryptographically secure random-number generation for password creation, distinguishing it from ordinary pseudo-random generators and considering entropy sources. A password-generator project was presented, involving parallel processing, a protected .NET web service, authentication, logging and database access.

A support session introduced persistence through Entity Framework, which maps .NET objects to relational database tables. Database contexts, drivers and connection configuration led into a SQLite example demonstrating creation, retrieval, updates and deletion through Language Integrated Query (LINQ). Package installation with NuGet was discussed alongside the risks of putting credentials or encryption keys in source code. External configuration, controlled network access and certificates provided alternative approaches to consider. The session also attempted a simple ASP.NET front end for the password-generator project; the record supports describing the demonstration attempt, not a completed web application.

The session introduced relational databases, explaining how tabular data is organised into rows and columns and how tables are linked through primary and foreign keys. It contrasted relational and non-relational data models, using document and key-value structures to show why highly variable data may create sparse tables. The class explained client-server database architecture, including database servers, clients, web interfaces, back-end code, SQL queries, connection details and access permissions. It also compared proprietary and open-source database systems, and outlined the course case-study approach and SQL-based assessment.

The session covered restoring a SQL Server database from a backup file, including verifying the backup and using the database interface to inspect tables. It reviewed relational tables, primary and foreign keys, schemas, and the use of schemas for functional organisation and access permissions. Students wrote basic SQL queries using SELECT, FROM, USE and COUNT, and discussed why row counts should be checked before using SELECT * on an unfamiliar or very large table. The class also examined database collation, including case and accent sensitivity, and explored customer data to identify data-quality inconsistencies and infer how customer and billing identifiers were structured.

Self-joins compared product prices, including a query for non-USB products priced at least as highly as a USB product. Text filters, wildcard placement and case conversion affected which rows matched; DISTINCT addressed repeated results from multiple comparisons. An entity–relationship diagram then connected customers, orders and invoices through their keys. The class explored orders without invoices using an outer join with missing-value filtering and alternative subqueries. These examples led into invoice structure: identifiers, dates, line items, quantities, prices and totals. The queries were examined in their data context, without asserting that every alternative behaves identically for all missing values.

The session reviewed database normalisation, covering first, second, third and Boyce-Codd normal forms, functional dependencies, atomic values, composite keys and the risks of duplicated or dependent non-key data. Examples from a sample database were used to identify non-atomic JavaScript Object Notation (JSON)-style fields and third-normal-form breaches that could create inconsistent customer and invoice information. The class then restored and explored a second SQL Server database, checked table keys and case-sensitive collation, and used the graphical interface to add and edit a city column. Finally, it practised GROUP BY, COUNT and HAVING, then developed two approaches for finding customers who had bought every product, including a division query using nested NOT EXISTS conditions.

The session introduced the SQL lab workflow using SQL Server Management Studio and the Wide World Importers database, including restoring the specified database version and checking that the environment was working. It explained how SQL data wrangling supports business intelligence by preparing enterprise data before analysis, reporting and visualisation. Students reviewed data profiling, including inspecting tables and columns, counting rows, identifying primary and foreign keys, and checking for duplicate records. The class also covered table grain and how joins can change the level of detail and create incorrect totals, followed by exercises on profiling tables and writing brief comments to explain each query’s purpose and findings.

The session introduced a simplified teaching schema built from invoice, invoice-line and stock data to make the database easier to query. Students checked that their SQL environment and database connection were working, then used a cheat sheet and guided examples to practise SELECT, TOP and ORDER BY queries. They applied filters to quantities and customer names, linking these operations to possible business questions. The class also began joining tables to create an invoice-line-level dataset, with emphasis on identifying the correct grain and checking row counts before and after joins to detect duplication or incorrect joins. Students were asked to annotate and save their SQL files clearly for later reuse in a mini-project.

The class reviewed row grain, keys and relationships before revisiting joins, filtering, grouping and row-count checks. Repeated invoice identifiers were expected when each row represented a line item; removing them indiscriminately would lose information. Database inspection then investigated returns and their effect on revenue measures. Returns were not stored as negative invoice lines in the inspected data. A proposed returns table introduced constraints on quantities, invoice-line references and reasons. Students were asked to consider the necessary fields and business rules, then work through a SQL template based on the demonstration.

The session reviewed how to check that an SQL environment and source data are working correctly before analysis. It covered views, aliases, data granularity, joins, common table expressions and casting numeric values to decimal formats for financial calculations. Students practised building an invoice-line fact dataset, calculating net, tax and gross amounts, and carrying out sanity checks to ensure joins and calculations were reliable. The class then used GROUP BY, HAVING and WHERE to create business KPIs, including top customers and invoices by gross sales in the dataset. It also introduced the reuse and adaptation of reports through stored procedures and adjustable parameters.

The class introduced the main aims of cryptography: confidentiality, integrity and authentication, and compared steganography with cryptography for protecting information. It examined substitution and transposition ciphers, frequency analysis, historical mechanical encryption, and the distinction between symmetric and asymmetric cryptography. Public and private keys, certificates, man-in-the-middle attacks, hybrid encryption and digital authentication were explained, along with the potential impact of quantum computing. Students were then introduced to Python using Anaconda and Spyder, covering variables, functions, indentation, conditions, loops, numerical types, tuples and fraction-manipulation exercises. The session began practical work on the Caesar cipher, using character codes and modular arithmetic to shift letters.

The class reviewed natural and integer numbers, divisibility, and the use of strictly decreasing non-negative integer quantities to prove that loops and recursive functions terminate. Examples in Python illustrated repeated integer division and recursive digit summation, with discussion of loop and recursion variants. It introduced prime numbers, prime factorisation, testing primality up to the square root, and why naïve primality testing is impractical for cryptographic-sized numbers. The Sieve of Eratosthenes was explained and implemented in Python using Boolean lists and list comprehensions. The session also covered proofs concerning infinitely many primes and arbitrarily long sequences of composite numbers, followed by calculating greatest common divisors and least common multiples from prime factorisations.

The session continued the study of modular arithmetic, reviewing congruence and its compatibility with addition, multiplication and powers. Exercises used simplified powers to calculate remainders and prove divisibility, including showing that a sum of powers is divisible by 13. Divisibility tests for 2, 3, 5, 9 and 11 were derived from the decimal expansion of a number and the residues of 10 modulo each divisor. Modular equations were converted into linear Diophantine equations, with solvability determined using greatest common divisors and solutions expressed as congruence classes. The class also introduced the residue rings Z/nZ through addition and multiplication tables, additive opposites and multiplicative inverses.

The class reviewed the Miller–Rabin probabilistic primality test, including how repeated tests reduce the probability of error. Large probable primes were used to construct Rivest–Shamir–Adleman (RSA) keys, encode messages numerically and perform modular encryption and decryption. Discussion linked security with the difficulty of factorising large products and considered quantum computing as a potential threat. Symmetric cryptography introduced a comparison between protecting a key and encrypting message data. Shannon’s confusion and diffusion principles then connected with exclusive-or operations and substitution–permutation networks, explored through small Python implementations rather than production cryptographic systems.

The class introduced the aims of Practical and Business English, with a focus on speaking, listening, reading, writing, professional communication and confidence in international workplaces. Students discussed their previous learning and identified personal goals, including technical vocabulary, professional writing, presentations, debates and workplace small talk. An AI conversation tool was demonstrated as a possible way to practise spoken English independently. Students completed a speaking activity in which they either explained technical computing concepts in layman’s terms or argued for a position on technology-related topics, receiving feedback on clarity, pronunciation and grammar. The session also began a discussion of generational differences and how they may affect attitudes to work and technology.

The class explored small talk and business networking, focusing on ways to begin, maintain and end conversations at professional events. Students discussed how asking context-specific questions, showing genuine interest, pausing, paraphrasing and using phrases such as ‘tell me more’ can make spontaneous conversations easier. They watched and analysed a business communication video, then began an individual written response activity about its advice, including the ‘what, so what, now what’ structure and the ‘white flag’ method for ending a conversation. Students also delivered and discussed article presentations on health technology, fitness-app communities and programming-language design, with feedback on clear, concise slide design and vocabulary explanation.

The session practised the present perfect continuous for actions that began in the past and are still continuing, using forms such as ‘I have been studying’ and ‘What have you been doing lately?’. Students compared this tense with the simple past and practised giving personal examples. The class explored small talk in social and business settings, including role-plays for meeting classmates, attending parties and speaking at technology conferences. It covered active listening, open questions, paraphrasing, validation, concise responses and building rapport with clients, colleagues and business contacts. Students also identified overly personal, dismissive or potentially offensive topics to avoid in small talk.

The class practised the present perfect and present perfect continuous to ask about duration, comparing forms such as ‘How long have you worked?’ and ‘How long have you been working?’. Students translated and completed example questions about work, study, living, waiting, sport and software use, then completed a grammar and vocabulary quiz. Vocabulary included the meaning and use of ‘bloated’. The class discussed articles about AI-generated art, considering its value compared with human-made art, copyright, ownership, ethics, environmental impact and the adoption of new technology in different cultures. Students then worked in groups to create slides responding to discussion questions using ideas from the articles and their own opinions.

The class explored how generative AI tools can be used to create marketing materials for a small business. Students used Sora to produce flyers or videos advertising an English activity for children, then evaluated prompts, image size, language choice, target audiences and the professional quality of the results. The group discussed benefits such as speed, accessibility and reduced marketing costs, alongside limitations including repetitive designs, errors, glitches, misleading imagery and possible effects on marketing jobs. Business vocabulary and concepts included advertisements, word of mouth, target customers, expenses, net income, entrepreneurship, competitive advantage, hard skills and soft skills. Students also prepared arguments for a later debate on whether AI-generated art can be considered art alongside human creativity.

The class practised making recommendations and discussing French-language songs and films, with attention to explaining meanings and translating song lyrics. It reviewed the grammar pattern ‘interested in’ followed by an -ing form, as well as the difference between ‘will’ and ‘be going to’ for predictions and definite plans. Students wrote and corrected example sentences using conference-related vocabulary, including keynote, networking, panel discussion, exhibitor and Q&A session. They then completed and presented research on suitable data science conferences, discussing themes, speakers, costs, locations, registration, networking opportunities and relevance to professional goals. The session also developed conversational questioning skills for discussing conference recommendations.

The class developed professional elevator pitches for internship and apprenticeship applications. Students reflected on their skills, qualifications, interests and career goals, and discussed how data science can be applied in sectors such as sports technology, healthcare and IT support. The session covered the structure of a pitch: introducing oneself, presenting relevant strengths and technical evidence, stating a target role, and using an appropriate call to action. Students drafted and delivered their pitches, then received feedback on concision, strong vocabulary, sentence variety, specificity, certifications and adapting applications to employers.

The session contrasted hard, technical skills with soft skills such as communication, teamwork, reliability, empathy, conflict resolution and staying calm in difficult situations. Students discussed how customer service affects client satisfaction and practised ways of addressing poor service or unhelpful behaviour respectfully. Cultural differences in communication, including language expectations and attitudes towards smiling, were considered in relation to international workplaces. Students delivered and discussed presentations on applications of artificial intelligence and data science in football, medical imaging, supply-chain optimisation and drug discovery, including benefits, limitations, bias, privacy and human responsibility.

The session began with a quiz on previously studied business idioms. The class then examined ten management styles, including autocratic, democratic, laissez-faire, bureaucratic, servant, coaching, charismatic, transactional, transformational and situational leadership. Learners discussed the advantages and disadvantages of each style, considering issues such as decision-making, employee autonomy, feedback, motivation, competition, flexibility and team relationships. They identified management styles from written descriptions and practised related vocabulary such as charisma, incentives, feedback and relaying information. Students were assigned to produce at least two pros and two cons for each management style, using a specified business article and other credible sources if needed.

The class reviewed ten specified management styles, their advantages and disadvantages, and their relevance to future workplaces. Students compared preferred and least preferred styles, particularly democratic, coaching, autocratic and laissez-faire approaches, considering collaboration, decision-making, feedback, independence, motivation and productivity. The class also discussed whether leaders reflect on their own management style and whether deadlines and limited pressure can support performance. Students began preparing an individual or pair presentation analysing the leadership style of a real business leader, using credible sources and relevant business vocabulary.

Students presented job advertisements they had chosen and explained the role, their reasons for choosing it, its responsibilities, and the technical and soft skills required. The class practised speaking naturally rather than reading, with feedback on using ‘keep up with’ and ‘interested in’. Discussion covered career planning, apprenticeships and internships, researching employers, networking, preparing for interviews, and developing skills through further study and practice. Students also compared programming and machine learning, considered communication in international teams, and explored the meanings of ‘imposter syndrome’ and ‘conflict of interest’.

The class reviewed how to assess credible sources for presentations, including checking authors’ expertise, institutional affiliation, publication type and supporting evidence. Students discussed study planning, time management and using reliable educational resources to strengthen their understanding of difficult subjects. They practised answering interview questions about skills to improve, with a focus on giving professional, constructive answers and using vocabulary such as “overcome”. Students delivered presentations on communication, discipline, public speaking and stress management, receiving feedback on source evaluation, practical improvement plans, clear speech and effective slide design.

The session introduced the purpose of accounting as a standardised system for recording, classifying and communicating an organisation’s financial information to internal and external stakeholders. It explained the French accounting framework, including the Plan comptable général, the principle of a faithful representation, historical cost, prudence, entity separation and accounting periods. Students distinguished the balance sheet, profit and loss account and notes, and learned to classify assets, liabilities, equity, stock, receivables, cash and debts. Worked examples were used to prepare simplified balance sheets and profit and loss accounts, calculate profit, track cash movements and receivables, and value unsold stock at purchase cost.

The session introduced the French chart of accounts, including the main account classes for balance-sheet items, expenses and income. It explained double-entry bookkeeping: every transaction has matching debit and credit entries, with assets, liabilities, expenses and income increasing or decreasing on different sides. Students practised recording capital contributions, loans, purchases, sales, supplier debts, customer receivables, cash movements and staff costs in journal entries. They then used these entries to prepare an income statement and opening and closing balance sheets, distinguishing investment activities from financing activities. The session also introduced depreciation as an annual expense reflecting the use of fixed assets.

The session completed an accounting exercise by preparing journal entries, calculating the income statement and producing the balance sheet for year N+1. It covered the treatment of capital, loans, loan instalments split between principal and interest, purchases, sales, wages, taxes, supplier debts, receivables, stock movements and reversing opening stock entries. Students practised applying debit and credit rules to assets, liabilities, expenses and income, including depreciation of vehicles and buildings. A further practice case was introduced to consolidate the full sequence from entries to profit or loss and the balance sheet.

The session practised preparing income statements and balance sheets from accounting entries, including stock adjustments, loan repayments, supplier and customer settlements, depreciation and cash movements. It then introduced fixed assets, distinguishing them from expenses according to their useful life, value, purpose and the business activity concerned. The class covered tangible, intangible and financial fixed assets, value added tax (VAT) on asset purchases, lease arrangements, subsequent repair costs and asset disposals. It also explained depreciation, impairment, residual value, straight-line depreciation, time apportionment and depreciation based on units of production, followed by balance-sheet exercises.

Management accounting was introduced as a way to analyse costs and performance within an organisation, alongside statutory financial accounting. Product pricing, stock valuation, forecasts and break-even calculations connected costs with operational decisions. The class distinguished full, partial and marginal costs; actual and predetermined costs; and direct, indirect, fixed and variable expenses. Cost centres and production stages provided ways to organise allocations. Discussion also considered which expenses enter a costing calculation and which adjustments it requires. A bakery exercise asked students to classify direct and indirect costs and calculate full and partial costs.

The session reviewed the full-cost method, including its benefits, limitations and the risks of arbitrary allocation of shared costs. It introduced rational allocation of fixed overheads, using the ratio of actual to normal activity to smooth unit costs and identify the cost of underactivity. Students completed worked examples comparing unit costs under the full-cost and rational fixed-overhead methods. The class then introduced partial-cost methods, especially variable costing, contribution margins, specific costs and the treatment of fixed and indirect costs. It also covered cost-volume-profit analysis, including contribution margin, break-even turnover, break-even sales volumes and graphical interpretation of the break-even point.

The class reviewed a cost-accounting exercise on full cost, contribution margin, the contribution margin rate, break-even point and safety margin. Calculations were carried out for break-even turnover, sales quantity and number of days, with checks using fixed and variable costs. The session also covered the operating leverage ratio and how changes in turnover affect profit. It then introduced budgetary control, including budget forecasts, pre-established and standard costs, and criticisms and limitations of using standards. Finally, it explained how to identify and interpret variances between budgeted and actual costs, activities, production, sales and margins.

The session prepared students for the assessment through worked accounting exercises. Students distinguished direct costs from indirect costs using a bakery production example, then calculated contribution margin, contribution margin ratio, break-even turnover, break-even quantity and break-even point in days, including checks for the reasonableness of results. The class also examined full costing for several business activities, allocating indirect costs using activity drivers and turnover-based allocation keys, accounting for changes in stock, and reconciling activity results with the overall operating result. The next stages of the exercise were introduced: variable costing and rational allocation of fixed overheads based on actual and normal activity levels.

The session distinguished weather, as short-term atmospheric conditions, from climate, as long-term patterns and averages, and introduced meteorology as the study of atmospheric phenomena. Students compared weather and climate data from different locations, using online tools to examine temperatures, rainfall, forecasts and historical records. The class discussed meteorological events such as storms, hurricanes, floods, sandstorms, fog and hail, including how warmer oceans can intensify tropical cyclones. It introduced the interacting components of the climate system: the atmosphere, oceans, biosphere, cryosphere and lithosphere, with emphasis on carbon emissions, ocean warming, acidification, ice melt and sea-level rise. The session also covered unequal solar heating across latitudes, heat transfer through radiation, conduction and convection, and the oceans’ role in storing and redistributing heat.

The oceans were examined as stores of heat and carbon and as part of the water cycle. Wind-driven surface currents were distinguished from deep circulation associated with temperature, salinity and density. The Gulf Stream, ocean gyres and the Coriolis effect connected circulation with regional climate. The class then considered carbon sources and sinks, fossil-fuel emissions, warming and sea-level rise. Ocean acidification linked changing water chemistry with carbonate availability and risks to shell-forming organisms and coral reefs. Fisheries, food security and tourism illustrated how changes in marine systems can also affect human activity.

Energy production was examined through greenhouse gases and their environmental effects. Carbon dioxide, methane and nitrous oxide were compared by source, warming effect and atmospheric lifetime. Discussion connected emissions with climate impacts and unequal historical responsibility. Hydroelectricity illustrated both the benefits of renewable generation and its environmental and social costs, including altered rivers, habitat loss, methane emissions and displacement. A lifecycle comparison then considered construction and disposal alongside operation. Wind and solar were presented as having substantially lower carbon emissions than fossil-fuel generation, while still requiring attention to their material and environmental impacts.

The session examined how climate change affects ecosystems, biodiversity and human societies through rising temperatures, altered rainfall, droughts, wildfires, floods, storms, sea-level rise and ocean acidification. It explained how species shift their geographical ranges towards cooler latitudes, higher elevations or deeper waters, reshuffling ecosystems and sometimes enabling pests, diseases or invasive species to spread. The class considered the effects on water supplies, agriculture, food security, coral reefs and other ecosystem services such as pollination, soil processes and climate regulation. It also discussed biodiversity loss, the vulnerability of apex predators, cascading effects in food webs, and the importance of conservation, ecosystem restoration, renewable energy, sustainable consumption and citizen science.

The session introduced the course’s focus on multivariable calculus, linear algebra and the analysis of data sets. It reviewed one-variable differentiation rules and used a quadratic function to construct a variation table and identify its minimum. Functions of two variables were then represented as surfaces, illustrating how cross terms can create more complex shapes and why changing coordinate directions can reveal useful structure. Partial derivatives, critical points, second derivatives, the gradient and the Hessian were introduced, with exercises on calculating them. The session ended by introducing vectors as column arrays and explaining their role in efficient computation and data analysis.

Worked examples connected dot products with orthogonality and the Euclidean norm. Bilinearity and symmetry were contrasted with the norm’s triangle inequality and its response to scaling. Normalising vectors to unit length introduced a way to handle differences in numerical scale. The class then examined linear independence, dependence and bases: a basis provides unique coordinates, while a change of basis changes those coordinates rather than the vector itself. Orthogonal and orthonormal bases simplified coordinate calculations and connected the algebra with data-analysis methods, including principal component analysis and linear regression.

The class derived the inverse of a 2×2 matrix and showed that it exists precisely when its determinant is non-zero. It introduced determinants as a test for invertibility and for whether column vectors are linearly independent, with applications to removing redundant variables from data sets. Students practised expanding 3×3 determinants along a chosen row or column, using minors and alternating signs, and learned that choosing zeros reduces the amount of calculation. The inverse of a 3×3 matrix was constructed from the cofactor matrix, its transpose, and the reciprocal of the determinant. The session also considered the rapidly increasing computational cost of recursive determinant calculations and noted that numerical methods are used for large matrices.

The session reviewed the diagonalisation of a 2×2 matrix by finding eigenvalues from the characteristic equation and then calculating corresponding eigenvectors. It showed how to normalise orthogonal eigenvectors, construct an orthogonal change-of-basis matrix, and use its transpose as its inverse to obtain a diagonal matrix. The practical advantages of diagonal matrices were explained through simpler multiplication, inversion and powers of matrices, including the potential for independent parallel calculations. A second example introduced complex eigenvalues, leading to the definition of complex numbers, their arithmetic, conjugates, moduli and geometric representation in the complex plane. The class also considered how complex-number calculations and type conversions are handled in R.

The session practised partial differentiation of functions of two variables, including mixed second derivatives and the fact that the order of differentiation does not affect the result in the examples considered. It then covered matrix operations: checking whether products and sums are defined, calculating matrix products, and finding an inverse using determinants, cofactors and transposition. Students also calculated traces and determinants of matrices, choosing efficient rows or columns for cofactor expansion. Finally, the class found eigenvalues and unit eigenvectors, formed an orthogonal change-of-basis matrix, and used it to diagonalise a matrix.

The session introduced preparation for the AZ-500 Azure Security Engineer certification, including its four learning paths: identity and access, networking, compute/storage/database security, and security operations using Microsoft Defender for Cloud and Microsoft Sentinel. It explained the Microsoft Cloud Security Benchmark, particularly identity management and privileged access, alongside the principle of least privilege. The class covered Microsoft Entra ID, including tenants, directories, licences, identities, principals, users, groups, managed identities, service principals, federation and role scopes. Students then began a practical lab on role-based access control, creating and managing users and groups and assigning roles within an Azure environment.

The session reviewed Microsoft Entra ID identity and access management, including licensing, users and groups, external identities, Identity Protection, hybrid identity synchronisation and authentication methods. It covered passwordless authentication, password protection for on-premises Active Directory, and the planning and lifecycle management required for security keys. Students examined single sign-on methods and a SAML-based integration example, including application gallery configuration, certificates, user provisioning and testing authorised and unauthorised access. The class also covered Azure management groups, Azure and Entra role-based access control, scopes, role assignments, deny assignments, custom roles and zero-trust principles. Finally, it introduced Privileged Identity Management, just-in-time role activation, approval workflows, time-bound eligibility and the need to protect highly privileged roles.

The session covered non-relational database models, focusing on DynamoDB key-value and document data, primary keys, global tables and security monitoring. It compared AWS database services for relational, document, graph and data warehouse workloads, including how to select an appropriate database model. A practical activity migrated a café application’s MariaDB database from an EC2 instance to Amazon RDS, using backups, Secrets Manager, private networking and security-group rules. The session also covered Azure network and application security groups, remote desktop and web access rules, user-defined routes, service tags, virtual network peering, VPN gateways and route precedence.

The session covered Azure virtual network routing, including route prefixes, route priority, system routes, user-defined routes and Border Gateway Protocol (BGP) routes. It compared virtual network peering and virtual private network (VPN) gateways, including hub-and-spoke designs, gateway transit, site-to-site and point-to-site virtual private networks (VPNs), active-active and active-standby configurations, and Virtual WAN hubs. Azure ExpressRoute was introduced as a private, high-bandwidth connection to on-premises networks, including its use with VPN encryption and route selection. The class also examined encryption at rest and in transit, Azure Key Vault, virtual network encryption, and security practices such as segmentation, network security groups, zero trust, privileged access, perimeter networks and secure remote administration. Students practised creating Virtual WAN, hubs and VPN-related resources with Azure PowerShell, then reviewed Network Watcher tools, service endpoints and private endpoints for private access to Azure services.

The session reviewed preparation for the Azure Security Engineer Associate certification, including the need to understand Azure services, pricing tiers and role-based permissions rather than memorising every detail. It covered securing Azure networking through network security groups, user-defined routes, service endpoints, private endpoints, private link services, VPN connectivity and Azure Firewall. Public access security was explored through Transport Layer Security (TLS) certificates, Azure Application Gateway, load balancing, health probes, Web Application Firewall rules, bot protection, Azure Front Door and distributed denial-of-service (DDoS) protection. Students completed and discussed practice questions on secure networking, then began the next topic on securing compute resources with Azure Bastion for protected remote access to virtual machines.

The session reviewed deploying container images from Azure Container Registry to Azure Kubernetes Service, including Dockerfiles, image manifests and digests, managed identities, role assignments, pods, services, load balancers and public versus private access. It then introduced Azure storage services, including blobs, files, queues, tables, disks and data lake storage, with emphasis on choosing appropriate storage types. Access control for storage was covered through storage account keys, Microsoft Entra ID role-based access control, managed identities, access control lists, anonymous blob access and shared access signatures. The class also considered key rotation, least-privilege roles, resource locks, soft deletion, versioning, snapshots, redundancy, customer-managed keys and double encryption. A lab exercise configured network security rules and service endpoints so that a private subnet could access an Azure file share while being denied internet access.

The session reviewed security measures for Azure Kubernetes Service, storage, Structured Query Language (SQL) databases and virtual machines, including network isolation, soft delete, backups, encryption, Azure Bastion and access-key rotation. It explained how Azure Disk Encryption protects data at rest and outlined its requirements, including a Key Vault, supported virtual machines, network connectivity and the required extension. The class introduced Azure Policy and policy initiatives, covering scopes, parameters, effects, compliance auditing and remediation of existing resources. It then examined Azure Key Vault, including role-based access control, managed identities, keys, secrets, certificates, hardware security modules, certificate lifecycles, key rotation and backups. Students began a practical exercise to create a Key Vault and use Always Encrypted with a database.

The session reviewed Azure Monitor and Log Analytics, including workspaces, tables, data collection rules, transformations using Kusto Query Language, agents and regional data collection endpoints. It explained just-in-time virtual machine access as a way to reduce attack surfaces by temporarily opening Secure Shell (SSH) or Remote Desktop Protocol (RDP) access through network security groups and firewalls. The class covered Microsoft Defender for Cloud capabilities for containers, DevOps and artificial intelligence (AI) services, including posture management, image and vulnerability scanning, agent-based protection, secret scanning, prompt-injection detection and sensitive-data controls. It then introduced Microsoft Sentinel, covering log types and retention, analytics rules, alerts, incidents, connectors, playbooks and Logic Apps for automated incident response. Students were directed to complete a final practical lab on Log Analytics, Defender for Cloud, just-in-time access and Sentinel playbooks.

The session focused on preparation for the AZ-500 Azure Security Engineer certification, including the exam format, renewal requirements and use of Microsoft Learn during the assessment. Students completed and reviewed identity and access management quiz questions covering app registrations, service principals, managed identities, administrative units, authentication methods and password protection. The class examined Microsoft Entra ID roles and least-privilege access, including Global Reader and privileged identity management. Conditional Access policies, grant and session controls, multi-factor authentication, device trust and access from untrusted locations were also discussed. Students were then directed to continue with a quiz on Azure network security.

The session introduced the structure and assessment approach of an LPIC-focused Linux course, including demonstrations, practical exercises and timed quizzes. It covered Linux origins, open-source distributions, the layered Linux architecture, and common uses of Linux in servers, cloud computing, mobile devices and embedded systems. The class examined kernel modules, hardware detection, Basic Input/Output System (BIOS) and Unified Extensible Firmware Interface (UEFI) boot systems, pseudo-filesystems such as /proc and /sys, and device management through udev. Practical activities used commands including uname, lspci, lsusb, lsmod, modinfo, modprobe, grep and cat to inspect hardware, drivers, modules and system information. Students also practised safely loading and removing modules in a virtual machine, using sudo privileges, redirection and pipes, and identifying device naming conventions.

The session reviewed Linux booting and system management for certification preparation, including Master Boot Record (MBR), UEFI, EFI system partitions, GRUB, kernel parameters, initramfs, kernel ring buffers and boot logs. It compared legacy System V run levels with systemd targets, including rescue, emergency, multi-user and graphical modes, and explained how to inspect or change current and default targets. Practical command demonstrations covered systemctl, journalctl, dmesg, runlevel, shutdown, reboot, wall, process inspection, symbolic links and service enablement. The class also examined graceful and forced process termination using SIGTERM and SIGKILL, output-error redirection to /dev/null, and background jobs in the shell.

The session reviewed Linux storage concepts, including Logical Volume Manager (LVM) physical volumes, volume groups and logical volumes, swap space, mount points, and standard directories such as /var, /var/log, /media and /root. It explained the LPIC-1 examination structure, question formats, topic weighting and approaches to answering certification-style questions. The main topic was GRUB and the boot process: installing GRUB, generating its configuration, configuring boot-menu settings, and distinguishing GRUB 2 from legacy GRUB numbering and configuration files. Students practised recovering from a missing GRUB configuration by entering the GRUB shell, locating the correct partition, setting the root device, loading the kernel and initramfs, booting manually, and regenerating the configuration.

The session introduced Linux shells, especially Bash, and explained why command-line work remains important for administration and automation. It covered how the shell processes commands, including variable expansion, command lookup order, aliases, functions, built-ins, executables, and the PATH environment variable. Practical demonstrations showed how to inspect commands with type, which, man, apropos and help, create and run scripts, alter PATH, and use quoting and escaping for special characters and spaces in filenames. The class also covered shell and environment variables, exporting variables to child shells, unsetting variables, command history, and keyboard shortcuts for efficient command-line editing.

The class compared package management on Debian, Red Hat-based and openSUSE systems, distinguishing low-level tools such as RPM from high-level tools such as YUM, DNF and Zypper. It covered installing, querying, verifying, extracting and removing RPM packages, managing repositories and caches, and using package searches to identify providers of files or commands. Virtualisation was introduced through hypervisors, type 1 and type 2 models, virtual-machine migration, KVM, copy-on-write storage, cloning requirements and containers such as Docker. The session then covered Linux file management, including paths, file types and permissions, and demonstrated commands for listing, creating, copying, moving, deleting, archiving and finding files, with glob patterns and recursive operations.

The session introduced basic Bash scripting, including shebang lines, executable permissions, variables, command substitution and relative paths. Students practised creating a diagnostic script that generated report and error-log files, using grouped commands, redirection, here documents and here strings. The class reviewed standard output, standard error and standard input, including how redirection order affects where messages are sent. It then covered pipelines, the tee command, safe processing of filenames with spaces using find, print0 and xargs, and placeholder-based commands. Practical activities used log and comma-separated values (CSV) files to filter, count, sort and report on data with commands such as grep, cut, sort, uniq and wc.

The session covered Linux process scheduling, including process priorities, niceness values and the distinction between real-time system processes and normal user processes. It demonstrated how to inspect priorities with top and ps, start commands with adjusted niceness using nice, and alter the priority of running processes with renice, including the permissions required for higher priority. Practical scenarios explored reducing the impact of CPU-intensive compression tasks and giving urgent backup processes greater priority. The class then reviewed basic and extended regular expressions, using grep to search log files with anchors, character classes, quantifiers, alternation and case-insensitive matching. It also introduced grep options for filtering and recursive searches, alongside sed for stream editing, substitutions, line selection and safe in-place file changes.

The session covered Linux file-system integrity, including journalling, disk-usage checks with du and df, inode exhaustion, and repair checks using fsck. It compared tools for ext4 and XFS file systems, including tuning reserved space, resizing, inspection and the limitation that XFS cannot be shrunk. Students practised configuring persistent mounting by identifying a partition with blkid, adding a six-field entry to /etc/fstab, testing it with mount -a, and confirming the mount after rebooting. The class then introduced Linux ownership and permissions for users, groups and others, using symbolic and numeric chmod modes. It also explained default permission limits through umask and special permissions including set-user-ID, set-group-ID and the sticky bit.

The session covered Bash shell variables, including assignment syntax, valid names, quoting, escaping special characters, and variable substitution. It explained local shell variables, exported environment variables, read-only variables, unsetting variables, and how child shells inherit exported values without sharing later changes. Students examined environment-inspection commands, temporary clean or modified environments, common variables such as PATH and prompts, and ways to alter PATH safely. Practical activities tested variable scope, quoting, exports, read-only behaviour, unsetting, and environment manipulation. The class then introduced aliases and shell functions, including arguments, local function variables, return codes, persistence through shell configuration files, command lookup order, and removing aliases or functions.

The session practised Bash scripting through an audit script that scans a directory and identifies symbolic links, directories and regular files. It covered file tests, including checks for links, directories, regular files, empty files and files newer than a reference file. The script used for loops, if/elif conditions, case pattern matching to classify file extensions, variables, command substitution, basename, and a while-loop countdown with arithmetic. The session also introduced X11/Xorg as a legacy Linux graphical display system, explaining its client-server model, modular extensions and the role of display managers.

The session practised Linux user and group administration, including creating groups and users, setting primary and supplementary groups, assigning login shells and passwords, and using root privileges safely with sudo. It covered locking and unlocking accounts, enforcing password changes, setting password ageing policies, and using the skeleton directory to create default files and folders for new users. The class examined the roles and contents of /etc/passwd, /etc/shadow, /etc/group and related configuration files, alongside commands such as useradd, usermod, userdel, groupadd, getent and id. It also introduced automated task scheduling with cron and anacron, including crontab fields, timing syntax, missed jobs and output redirection.

The session covered Linux localisation, including time zones, locales, language settings, regional formats and character encodings. It explained the use of Coordinated Universal Time (UTC), the TZ environment variable, time-zone files and tools such as date, timedatectl and tzselect. Students examined locale variables including LC_ALL, LC_TIME, LC_MONETARY and LC_COLLATE, and learnt why scripts should use the standard C/POSIX locale for predictable behaviour. Character encodings were compared, particularly ASCII, ISO-8859-1 and UTF-8, and iconv was used to convert files between encodings. The class then covered system-time maintenance: hardware and system clocks, Network Time Protocol (NTP) synchronisation, NTP strata, ntpd and chrony, followed by practical command exercises using date, hwclock, timedatectl and ntpq.

The session covered Linux mail systems, including the roles of mail user, transfer and delivery agents, common MTA implementations, aliases, per-user forwarding, mail queues and command-line mail use. It also covered Common UNIX Printing System (CUPS) printing, including its daemon, web interface, configuration files, printer drivers and PPD files, network printing protocols, print queues, job control and printer classes. Practical-style questions reviewed installation, service status, configuration locations and common printing commands. The introduction to networking explained the TCP/IP stack, IPv4 and IPv6 addressing, address classes, private networks, subnet masks, gateways, NAT, ports, and the TCP, UDP and ICMP protocols.

DevOps was introduced as collaboration between development and operations, supported by communication and automation. Waterfall and agile approaches were compared through iteration, stakeholder feedback and sustainable working practices. Reliability discussions covered monitoring, service objectives and the expectation that failures will occur. Semantic versioning and naming conventions introduced ways to communicate changes clearly. Students began a small project lab with documentation and a change log, preparing to use Git and Node.js as part of the practical work.

The Git workflow covered repositories, staging, commits, remote updates and inspection of differences. Automated testing was discussed through unit, functional, integration and end-to-end checks, including browser automation. Test-driven development introduced a cycle of writing a failing test, implementing the behaviour and refactoring while keeping the checks passing. Students began a JavaScript lab for user-related application programming interface functionality. Self-contained tests, setup, validation and cleanup connected the method with tests that are fast enough to use repeatedly.

Continuous integration and continuous delivery or deployment connected version control, tests and releases. Infrastructure as code then introduced declarative and imperative approaches, repeatable application of configuration, and mutable or immutable infrastructure. Vagrant provided a setting for managing virtual machines, while Ansible introduced declarative provisioning. Students worked on labs using shell provisioning and Ansible to deploy and check a GitLab environment. Earlier discussion of small changes and testing remained relevant as the subject moved from application code to its infrastructure.

Containers were compared with virtual machines through isolation, shared operating-system resources and portability. Docker demonstrations covered obtaining images, running containers and managing their lifecycle. Dockerfiles introduced custom builds through base images, copied files and build commands, including tagging and troubleshooting. Storage volumes addressed data that must persist, while Docker Compose described applications with several containers. A WordPress site and MySQL database illustrated this arrangement, connecting application packaging with the services and data it needs to run.

Kubernetes introduced deployment, networking, scaling and recovery across a cluster. The class examined control-plane and worker components, then used manifests and commands to inspect and change resources in Minikube. A demonstration showed a deployment replacing a deleted managed pod, unlike a standalone pod. Namespaces, labels and services helped organise the workloads. Configuration, secrets and persistent storage were introduced before students were directed to practical labs, extending the discussion from individual containers to the system that manages them.

The class traced a pod request through authentication, scheduling and container creation before examining storage choices. Temporary volumes, host-mounted data, configuration and secrets raised different persistence and security questions. Demonstrations covered static and dynamic provisioning through persistent volumes, claims and storage classes. Binding, reclaim policies and pending workloads were investigated, including checking data after pod replacement. Students were directed to practise temporary and host-path volumes, with further persistent-volume work offered as an optional exploration rather than assumed completed work.

Cloud-native architecture linked loosely coupled services with containers and delivery practices. Kubernetes networking was examined through pod communication and stable service addresses, with demonstrations of different service types and troubleshooting. Load balancing and ingress routing introduced distinctions between transport and application-level traffic handling. Service meshes then brought together observability, encrypted service communication and traffic control, including canary releases. The discussion connected these mechanisms with the architecture around them rather than presenting orchestration as simply another way to start a container.

Grafana introduced dashboards over metrics queried from Prometheus. The class examined connections, local access, query-based panels and imported dashboard definitions, then discussed related tools for logs, traces and metric storage. GitOps connected declarative infrastructure with Git as the record of intended configuration. Push and pull approaches were compared, including Argo CD's reconciliation of Kubernetes applications. Students were asked to complete labs using the monitoring and reconciliation tools, bringing observation and configuration management into the same operational discussion.

The session introduced big data as data that cannot be stored or processed effectively by a single machine, focusing on volume, velocity and variety. It explained distributed systems, horizontal and vertical scaling, clusters and nodes, along with the benefits and challenges of distributing computation across networked machines. The consistency, availability and partition tolerance (CAP) theorem was used to compare consistency, availability and partition tolerance in distributed data storage. The Hadoop ecosystem was outlined, including Hadoop Distributed File System (HDFS) for storage, Yet Another Resource Negotiator (YARN) for resource management, and processing tools such as MapReduce and Spark. Students began a practical activity by connecting securely to a Hadoop edge node through Secure Shell (SSH) and practising basic Linux command-line use.

The session reviewed distributed systems, Hadoop HDFS and YARN, including master, worker and edge nodes, replication, fault tolerance and high availability. It distinguished online transaction processing (OLTP) from online analytical processing (OLAP) systems and compared databases, data lakes, data lakehouses and data warehouses, including atomicity, consistency, isolation and durability (ACID) properties. The class introduced Apache Hive as a data-warehouse tool built on HDFS, using HiveQL and execution engines to query stored data. It covered external versus managed Hive tables, row-based and columnar file formats, Hive partitioning, and the bronze, silver and gold stages of the medallion architecture. Students then began practical Hive exercises creating and querying external and managed tables, including use of ORC files.

The session reviewed core big-data concepts, including the three Vs, data types, horizontal versus vertical scaling, networking risks and the CAP theorem. It covered Hadoop’s main components: HDFS for distributed block storage, YARN for cluster resource management, and MapReduce for distributed processing. The class examined how HDFS splits and replicates files, why small files create metadata overhead, and why processing should be located with the relevant data blocks where possible. MapReduce was introduced through a word-count example, explaining map, shuffle and sort, reduce, network communication, and disk-based fault tolerance. Students then worked on Hadoop-based Python MapReduce word-count exercises and began designing a MapReduce job from scratch.

The session reviewed distributed-system reliability, including single points of failure, standby NameNodes, split-brain scenarios, leader election and ZooKeeper heartbeats. It compared MapReduce and Spark, covering disk-based versus memory-based fault tolerance, resilient distributed datasets, transformations and actions, lazy evaluation, and narrow versus wide transformations and shuffles. The teaching then introduced Spark DataFrames and Spark Structured Query Language (SQL) as higher-level, more readable alternatives to low-level resilient distributed dataset (RDD) programming, explaining schemas, the Catalyst Optimiser and the benefits of explicitly defining schemas for large production data sets. Students began a practical Docker-based Jupyter lab using New York City taxi data to explore DataFrame operations, SQL queries and joins, with exercises requiring work in both PySpark and Spark SQL.

The session introduced real-time event streaming, distinguishing unbounded streams from bounded datasets and comparing hard, soft, near-real-time and batch processing requirements. It reviewed stream-processing concepts including event time versus processing time, windows, triggers and watermarks, and strategies for refining aggregated results. The class then examined Kafka as an event-streaming platform, covering events, producers, consumers, brokers, topics, partitions, offsets and consumer groups. It explained partitioning by round-robin allocation or message keys, replication through leaders and followers, producer acknowledgements and delivery guarantees, and leader election using KRaft rather than ZooKeeper. Students were asked to deploy a Kafka cluster in containers, run a consumer, and optionally process streamed events with Python, Spark or an extract, transform and load (ETL) service.

The session reviewed OLAP and OLTP workloads, row-based and columnar file formats, the medallion architecture, Apache Spark, and Kafka’s publish-subscribe model. It introduced Apache NiFi as a tool for managing data flows and compared ETL, extract, load and transform (ELT) and light-transformation loading pipelines. The class covered NiFi’s security, scalability, delivery guarantees, data provenance and lineage, clustering, registry-based version control, and core components including flow files, processors, connections, funnels and process groups. It also considered why NiFi is best suited to moving data and carrying out light transformations rather than heavy processing. Students began a practical Docker-based lab to build, version and document a basic NiFi data flow.

The session reviewed Apache NiFi as a tool for building ETL and ELT data flows, contrasting transformation before loading with transformation after loading into a data lake. It covered NiFi architecture, including flow files, metadata attributes, content, provenance, repositories, processors, controller services and clustering. The class demonstrated the NiFi interface, process groups, ports, funnels, connections, relationships, queues, back-pressure thresholds, load balancing and debugging. It also explained scheduling, retry and penalty behaviour, parameter contexts, expression language, and version-control alternatives following the planned retirement of NiFi Registry. Students were assigned sequenced labs to build increasingly complete pipelines, culminating in consuming Kafka streams with NiFi, transforming the data, and loading cleaned results into PostgreSQL.

The session reviewed distributed cluster roles and introduced four security principles: identification, authentication, authorisation and encryption. It explained how LDAP, Kerberos, Apache Ranger, Knox and Atlas can support identity management, ticket-based access, role-based permissions, gateway access and governance in Hadoop ecosystems, with comparisons to cloud-native tools. The class then compared file, block and object storage, focusing on object storage features such as buckets, metadata, flat namespaces, immutability, S3-compatible application programming interfaces (APIs) and storage tiers. Software-defined storage, MinIO, Ceph and erasure coding were discussed as ways to provide scalable, resilient cloud storage. Students were assigned a lab to deploy MinIO in Docker and create and manipulate object-storage buckets.

The session introduced the course’s focus on probability, statistics and their role as foundations for machine learning, with R and RStudio as supporting tools. It reviewed mathematical notation for sums, products and sets, including unions, intersections and complements. Descriptive statistics were covered through frequency tables, bar charts, histograms, density plots and empirical cumulative distribution functions, with emphasis on interpreting distribution shape. The class defined quantiles, the median, mean, variance, standard deviation, interquartile range, skewness and kurtosis, and used box plots to examine spread and potential outliers. It then introduced multivariate descriptive analysis using contingency tables, scatter plots, covariance and correlation, stressing that correlation does not establish causation.

The session completed an introduction to probability distributions for finite, countably infinite and continuous sample spaces. It covered conditional probability, Bayes’ theorem and base rates through diagnostic-test, screening, production-defect and transmission examples, as well as the Monty Hall problem. Independence, incompatibility and mutual independence were distinguished using coin-toss and permutation examples. Students then completed practice multiple-choice questions on descriptive statistics, including means, medians, empirical cumulative distribution functions and probability calculations. The session ended by introducing random variables as functions mapping outcomes to real-number values and motivating probability distributions for them.

The session reviewed random variables through uniform, binomial, Poisson and normal distributions, focusing on their parameters, probability mass or density functions, cumulative probabilities, quantiles, means and variances. Simulated samples were compared with theoretical distributions to show how observed data can differ from ideal probability models. The class then introduced multivariate random variables, joint and marginal distributions, conditional distributions, independence, covariance and correlation, including a bivariate normal simulation and covariance matrix. It concluded with an introduction to convergence, random samples that are independent and identically distributed, parameter estimation, and the motivation for the law of large numbers and central limit theorem.

The session reviewed descriptive statistics, probability theory, random variables, probability distributions, convergence, the law of large numbers and the central limit theorem. It introduced estimators and estimations, including bias, variance, mean squared error and the use of large samples to improve estimates. Confidence intervals were explained as ranges around an estimate associated with a chosen risk level, and a practical activity used one-sample t-tests in R to calculate 95% and 99% confidence intervals for mean height. Statistical hypothesis testing was then introduced through null and alternative hypotheses, rejection regions, p-values, significance levels, and Type I and Type II errors, with examples involving coin tosses and comparisons of group means. The session concluded by outlining common tests for one mean, two means and independence, in preparation for further study.

The session introduced foundational data-engineering practices for building reliable Python projects. It covered reproducibility, determinism, traceability and observability, including the importance of immutable raw data, run manifests, structured logs, configuration management, isolated environments and basic smoke tests. A retail-data scenario was used to illustrate how changes in real-world data or in a pipeline can affect results and why systems must distinguish between them. Students began a practical exercise to create a structured project repository, separating input data, source code, generated data, tests and run artefacts, and discussed using Python, virtual environments, Git, Makefiles and Pytest. Idempotency was explained as the ability to repeat an operation safely without altering the outcome or damaging the project structure.

The session introduced SQLite as a Python-based tool for creating a relational analytics layer from raw product and order data. Students reviewed relational modelling, including tables, rows, columns, primary keys, foreign keys and constraints such as non-null and non-negative values. The class covered creating and applying an Structured Query Language (SQL) schema, connecting to a database from Python, enforcing foreign-key checks, and verifying that database files and tables were created correctly. Planned practical work involved loading comma-separated values (CSV) data, identifying deliberately introduced errors, running data-quality checks for nulls, duplicates and invalid values, and producing manifests and logs for traceability.

The session introduced data quality as a prerequisite for reliable data engineering, analytics and later machine-learning work. It explained the use of raw, clean, structured and analytics layers, with the clean layer acting as a quality gate before data is loaded into a database. Students practised designing validation checks for schema compliance, required fields, numeric and date values, duplicates, value ranges and foreign-key consistency, using a deliberately invalid product reference to demonstrate safe failure. The class also covered fail-fast recovery, quality statuses such as green, yellow and red, and extending manifests with quality metadata and reports. It additionally outlined the role of monitoring, drift, security hardening and adversarial data poisoning in production artificial intelligence (AI) and data pipelines.

The session examined how reliable data pipelines depend on traceability, reproducibility and observability. It explained how duplicate data and weak validation can cause serious service failures, using a major cloud-service outage to illustrate the business impact. The class explored observability for AI systems, including monitoring logs, metrics, costs, retrieval quality, model drift and mismatches between training and production data. It then introduced extract, transform and load (ETL) practices for incremental loading, watermarking, safe re-runs, full refreshes and backfills. Students were asked to run a supplied pipeline twice and inspect its manifest to confirm that incremental processing was stable and did not create duplicates.

The session linked data-engineering pipelines to later machine-learning work, emphasising that raw data should remain immutable, clean data should be validated, and workflows should be reproducible and traceable. It defined a machine-learning feature as a data-derived variable, often created from existing columns, rather than a software capability. Python and Pandas concepts were revised, including DataFrames, imports, functions, parameters, return values, assignments, dictionaries, lists, merges, grouping and aggregation. Code was examined through four perspectives: syntax, meaning, purpose and possible failure modes. Students were asked to analyse helper functions and run a small analytics workflow that loaded clean data, checked candidate keys, joined orders to products, calculated estimated revenue and summarised results by category.

The session introduced pipeline health monitoring as a prerequisite for reliable machine-learning work. It covered checks at run, data and analytical levels, including successful runs, expected output files and manifests, row and null counts, duplicate keys, category distributions, grouped revenue and quantity summaries, and engineered-feature rates. Students were asked to run a Python monitoring script on their own projects, inspect recent manifests and outputs, and identify unexpected changes that could indicate data or model drift. The class also discussed when to retain exploratory work in scripts and when to move stable, reusable work into Jupyter notebooks, with Jupyter preferred over collaborative notebook tools for robust projects. Binary threshold-based features and their grouped rates were revisited as preparation for later modelling, especially time-series analysis.

The session introduced baseline machine-learning models as simple, interpretable reference points for assessing whether more complex models are worthwhile. It covered the distinction between features (X) and targets (Y), train-test splitting, random states, class stratification, model fitting, loss, and the purpose of cross-validation. A strong emphasis was placed on data leakage, including duplicate records, target information entering features, future information, and preprocessing the full dataset before splitting. Students began using Jupyter notebooks and Python tools such as pandas, pathlib and scikit-learn to locate cleaned data, define features and targets, and prepare data for a dummy classification baseline.

The session covered safe machine-learning pre-processing, with an emphasis on splitting training and test data before fitting transformations in order to prevent data leakage. Numeric and categorical features were distinguished, including missing-value imputation, numeric scaling and one-hot encoding of categories. Scikit-learn pipelines and column transformers were used to apply the appropriate transformations consistently before logistic-regression modelling and evaluation with accuracy and a confusion matrix. Students practised running and annotating a notebook, explaining the purpose of code blocks, imports and workflow stages. The session also introduced time-based splitting and data drift, comparing earlier and later data to assess whether changing data contexts could affect model performance.

The session reviewed the structure of a supervised machine-learning workflow using logistic regression, including the distinction between input features (X) and target labels (Y). It covered train/test splitting, reproducible splits using a random state, data leakage, and why preprocessing should be performed within pipelines, with column transformers applying different treatments to numerical and categorical data. Students practised interpreting code, accuracy, confusion matrices, incorrect predictions and error slices, while considering the limitations of small datasets. The class also discussed data drift over time, cautious reporting of evidence and recommendations, and how to give specific, constructive critiques of a model. Mock assessment formats were explained and practised through multiple-choice and short written questions.

The session introduced web applications as client–server systems, explaining Hypertext Transfer Protocol (HTTP) requests, web servers, front-end development in the browser and back-end development on the server. It covered HTML as a semantic markup language for structuring content, including document structure, headings, paragraphs, links, images, block and inline elements, lists, tables and forms. The importance of semantic markup, accessibility text for images, browser compatibility and search-engine indexing was discussed. CSS was introduced for presentation, including internal, external and inline styles, selectors, specificity, positioning, fixed and relative units, and colour formats. A practical example began building a responsive blog homepage using semantic HTML elements and a linked stylesheet.

The session introduced JavaScript as a client-side, dynamically typed language used alongside HTML and CSS to create interactive web applications. It covered variable declarations with var, let and const, scope, primitive and reference values, functions, arrays, loops, conditional statements, equality operators and switch statements. Students learnt how to include JavaScript in HTML, how script loading order affects page rendering, and how to use Document Object Model (DOM) selection and manipulation to change content, styles and CSS classes. The class also demonstrated event handling, including clicks, form changes, preventing default browser behaviour and updating a form summary dynamically. The afternoon began a JavaScript Kanban-style task board, using DOMContentLoaded, DOM element selection, task creation and data attributes.

The session introduced PHP as a server-side scripting language for creating dynamic web applications, generating HTML, and interacting with sessions, forms and databases. It covered the CGI model, PHP’s use alongside HTML, the need to separate logic from presentation, and the role of MVC-style architecture. Students practised PHP variables, weak and dynamic typing, type casting, control flow, arrays, associative arrays, loops, functions, parameters and common debugging and string functions. The class then demonstrated handling GET and POST form data, checking submitted inputs, and explained basic security concerns when processing login details. In the afternoon, work began on a multi-page PHP example intended to filter, sort and paginate tabular data using shared includes, utility functions and a static dataset.

The session introduced the Model–View–Controller architectural pattern in PHP, relating it to design patterns, SOLID principles and separation of responsibilities. It explained how controllers process requests, call models for data and business logic, and pass results to views that generate HTML, with routing used to select controller actions from URLs and HTTP methods. PHP Data Objects (PDO) were covered for connecting PHP to Structured Query Language (SQL) databases, including prepared statements to prevent SQL injection, exception handling and transactions for reliable multi-query operations. A practical example built a small project-management application with a database connection, create, read, update and delete (CRUD) model methods, HTML views, a controller and an index.php router. The session concluded by outlining a later extension involving authentication and further practical work.

The session introduced application programming interfaces, distinguishing general application programming interfaces (APIs) from web and Representational State Transfer (REST) APIs, and explaining how REST APIs separate front ends from back ends for reuse across web and mobile applications. It covered stateless, resource-based application programming interface (API) design, the HTTP methods GET, POST, PUT and DELETE, idempotency, and common HTTP status codes including redirects and timeouts. Authentication approaches were discussed, including API keys, bearer tokens and OAuth, alongside the purposes of authentication and authorisation. The class explained middleware for tasks such as authentication, validation, logging and Cross-Origin Resource Sharing (CORS), stressing that CORS is a browser restriction rather than server security. A PHP REST API was then built around a user resource, using request and response classes, middleware, routing, JavaScript Object Notation (JSON) responses, database access, and a simplified object-relational mapping model.

The session focused on consuming REST APIs with JavaScript in front-end web applications. A country browser was built using an unauthenticated API, covering asynchronous functions, promises, async/await, fetch requests, HTTP response checking, JSON parsing, sorting and displaying returned data. The interface included dynamically generated country cards, a details modal, event listeners, search and region filtering, and handling object values such as languages and currencies. A second example demonstrated making authenticated POST requests to an artificial intelligence (AI) service API, structuring prompts, alternating messages between two agents, managing conversation state, and explaining why API keys must not be exposed in production front-end code. Students were then introduced to a weather-dashboard exercise using API data.

The session introduced microservice architecture and compared it with monolithic applications, focusing on domain boundaries, independent services and separate data ownership. It covered benefits such as targeted scaling, resilience and easier evolution, alongside drawbacks including distributed-system complexity, technical debt, service coordination and observability. Synchronous API calls were contrasted with asynchronous event-driven communication using message brokers, with order processing used to explain eventual consistency and saga-style workflows. Good microservice practices included explicit API contracts, idempotent requests, failure handling, logging, metrics, independent deployment and continuous integration and continuous delivery (CI/CD). A practical Node.js exercise began by setting up separate services with Express, Axios and SQLite, then creating product API routes to retrieve products and partially update stock.

The session introduced software testing, distinguishing unit tests for isolated logic from integration tests for interactions between components such as databases, APIs and controllers. It explained the benefits of testing, including preventing regressions, supporting refactoring, improving maintenance and measuring code coverage. Practical PHP examples used PHPUnit and Pest to write assertions, parameterised tests with data providers, exception tests, mocks and factories. Integration testing was demonstrated with a separate test database, including resetting data so that each test remains independent and predictable. The project brief was introduced: teams will build a smart-city data dashboard using external APIs, PHP with Model–View–Controller (MVC) and REST endpoints, a SQL database, JavaScript visualisations, authentication, weather data, analytics and charts.

The session introduced the course structure and its aim of preparing students to participate in or lead data science projects. It contrasted traditional, waterfall-style project management with agile approaches, explaining time-boxed sprints, sprint reviews, retrospectives, planning and visual task boards. A project was defined as a temporary undertaking with a unique objective, a defined timescale and required resources, distinguishing it from routine operations. The class also examined product and sprint backlogs, prioritisation, team commitment, transparency and measuring progress. Business cases, break-even points, return on investment and the need to reassess a project when business conditions change were introduced.

The session began with sprint planning and reflection, using completed work and team capacity to agree a realistic commitment for the next sprint. It covered project vision statements, the limitations of AI-generated content, and the need to understand project-management concepts well enough to assess artificial intelligence (AI) outputs critically. Key traditional project-management concepts included the triple constraint of scope, time and cost; project life-cycle phases; uncertainty, risk and the rising cost of change; and the Project Management Institute (PMI) waterfall framework, including project charters, planning, resources, communication, procurement and stakeholder management. Students practised preparing elements of a project charter and assigning stakeholder roles through a responsible, accountable, consulted and informed (RACI) matrix, then discussed stakeholder power and influence. The class also covered Gantt charts, task estimation, S-curves, earned value, cost and schedule variance, key performance indicators (KPIs), and the Plan-Do-Check-Act cycle.

The session used a simulated sprint review, retrospective and planning exercise to demonstrate approval of completed work, velocity tracking, forecasting and commitment to a minimum sprint scope. It introduced Agile values from the Agile Manifesto, stressing individuals and interactions, working software, customer collaboration and responding to change whilst recognising the continuing value of plans, documentation and contracts. Agile and waterfall approaches were compared in terms of fixed constraints, planning, suitability for different levels of uncertainty, stakeholder involvement and regulated environments. The class examined timeboxing, incremental delivery, technical debt, minimum viable products, proof of concepts, product backlogs, prioritisation and Agile contract models. It also covered the roles of the product owner, Scrum Master and self-managing cross-functional teams, followed by a scenario activity, quiz and video on Agile product ownership.

The session showed how an agile backlog can be adapted as new information emerges, using prioritised user stories and changing investigation scenarios to illustrate this process. It emphasised the importance of direct, timely communication for agile teams, particularly where teams are distributed. Agile software development practices included automated testing, continuous integration and delivery, code standards, collective code ownership, technical-debt reduction, and responsible use of AI-assisted programming. The class then introduced scaled agile working through Scaled Agile Framework (SAFe), including Agile Release Trains, programme increments, programme increment (PI) planning, cross-team dependencies, and the roles of product manager, Release Train Engineer and system architect. It also considered how agile delivery can be connected with wider business strategy and product value.

The session introduced customer relationship management (CRM) data modelling in Dataverse, including tables, primary and foreign keys, and one-to-many, many-to-one and many-to-many relationships. It compared on-premises and cloud CRM deployments, and covered Dataverse features such as application programming interfaces (APIs), security, auditing, business rules, workflows, duplicate detection, reporting and integrations. Students learnt how development, test and production environments are managed, including environment types, access groups, backup, copying and solution deployment. Practical activities involved accessing a shared CRM environment, creating account and contact records, creating a solution with a publisher and prefix, and creating, publishing and testing a custom table. The session also explained table ownership, activity tables, virtual tables, auditing, quick create forms and record management.

The session began with a practical exercise in exporting account data to Excel, amending a phone number, importing the file back into the CRM system, and checking that the change had been applied. It then covered Dataverse security, including business units, security roles, record privileges, access levels, teams, column-level security and hierarchy security. Further topics included environment analytics, storage capacity, auditing, duplicate detection, bulk deletion and long-term data retention. The class also introduced model-driven, canvas and Power Pages applications, before practising the creation of a model-driven app with grouped tables for customer and sales functions.

The session covered testing and troubleshooting Power Automate flows using Flow Checker, test runs, run history, action statuses and error details. It also explained administrative tasks such as monitoring flow activity, reviewing run histories and sharing flows with appropriate permissions. Business rules were introduced as a no-code way to apply conditions and actions, including showing, hiding, enabling, disabling or requiring form fields, with a practical exercise to control four contact fields according to whether an account had been selected. The class then introduced business process flows as stage-based guides for users, including their steps, limits, associated tables, conditional branches and use in opportunity management.

The session explained the CRM sales pipeline, from creating leads through imports, website forms or direct contact, to recording follow-up activities such as calls, emails, meetings and tasks. Leads can be qualified to create account, contact and opportunity records, or disqualified with a recorded reason while remaining available for later reactivation. Opportunities use price lists and product line items to calculate prices and totals, then progress through quotes, orders, fulfilment, payment and invoicing. The class also distinguished system-generated record IDs from customer-facing quote and order numbers, discussing uniqueness and restrictions on changes after creation. A practical activity asked students to carry out both a successful sales-pipeline case and a disqualified-lead case in the Sales Hub application.

The session introduced digital marketing as a strategic process for attracting attention, creating value and building relationships, rather than simply advertising. It focused on personal branding for computing students, including professional visibility, niche definition, unique selling propositions and the use of LinkedIn as a professional landing page. Students used emojis to consider how visual identity shapes first impressions, searched for their names online, and reviewed how recruiters use keywords and search tools. The class covered buyer personas, networking, reciprocity and search engine optimisation (SEO) principles, particularly the placement and repetition of relevant skills and keywords within a LinkedIn profile. Students also used artificial intelligence (AI) tools to draft and refine professional headlines describing their skills, interests and intended sectors.

The session explored search engine optimisation and search engine advertising, including crawling, indexing, ranking factors, backlinks, metadata, content quality and trust signals. Students examined how keywords support online visibility, with particular emphasis on long-tail keywords, search intent and using Google Trends to identify emerging topics. The class compared the longer-term benefits of SEO with paid search advertising, including bidding, cost per click and quality scores in Google Ads. Activities included refining LinkedIn profiles for keyword relevance, identifying suitable career-focused keywords, analysing competitor profiles and using benchmarking to identify gaps and plan content.

The session examined content marketing for professional platforms, particularly LinkedIn, and began with an activity identifying posts that attract attention while scrolling. It covered inbound marketing, four broad types of content, the attention, interest, desire and action (AIDA) framework, storytelling, calls to action, social proof, readability, keyword use and repurposing a longer idea into shorter posts. Students used AI prompts to draft and adapt posts about their own projects, compared direct and storytelling styles, and experimented with generating accompanying visuals. The class also considered LinkedIn engagement signals, profile visibility, networking, direct messages, groups, editorial calendars, analytics, newsletters and employee advocacy.

The session reviewed how to create professional short-form videos, focusing on clear audio, lighting, captions, strong hooks and maintaining audience attention. It covered repurposing video into other content formats and planning LinkedIn content using a balance of educational, personal-brand and promotional posts. Students learnt about organic and paid social media, advertising formats, A/B testing, campaign metrics, tracking through Urchin Tracking Module (UTM) parameters and Google Analytics, and the importance of General Data Protection Regulation (GDPR) compliance. The class introduced marketing automation tools, explaining triggers, actions, filters, customer relationship management (CRM) use and workflows that connect platforms such as LinkedIn, GitHub and email. Students were encouraged to post content, track personal-brand performance in a dashboard, and use data to guide future strategy.

The session introduced the relevance of commercial and intellectual property law to data science, covering contracts, employment or freelance status, company matters, intellectual property and professional liability. It examined AI-related liability through examples involving training data, privacy, autonomous vehicles, algorithmic harm and the possible responsibility of users, developers, providers and employers. The class distinguished civil and professional liability, including risks such as financial losses, discriminatory outputs, intellectual property infringement and defamation, and noted the role of professional indemnity insurance. It then began contract law by defining contracts as legally binding mutual obligations, including informal everyday agreements, and explained the pre-contractual phase. Activities considered good faith, duties to inform and maintain confidentiality, abusive termination of negotiations, and the purpose and key terms of non-disclosure agreements.

The session examined IT, data and artificial intelligence (AI) contracts, contrasting time-based service contracts and obligations of means with fixed-price contracts and obligations of results. It considered software development, maintenance, software-as-a-service and licensing agreements, focusing on how control over a system affects the allocation of technical, operational and financial risk. The class also covered data-sharing, data-provision, model-training, AI partnership and platform-access agreements, including data rights, intellectual property, confidentiality, liability and governance. Students classified example clauses and contracts, identified which party bore particular risks, and suggested improvements such as measurable performance criteria, clearer ownership terms, security standards and formal change-management procedures.

The session examined workplace harassment, sexual harassment and discrimination, including their legal definitions, evidential issues, employer prevention duties, reporting channels and protection against retaliation. It then covered employee surveillance and data protection, stressing legitimate purpose, proportionality, transparency, data minimisation, purpose limitation and storage limits. The class compared resignation, dismissal and mutual termination of employment contracts, alongside non-compete and intellectual property clauses. It also considered freelancing, the risk of reclassifying a freelancer as an employee, the legal benefits of incorporating a business, suitable French business structures, and civil, criminal and tax liabilities in data-related work.

The session examined intellectual-property issues raised by generative AI, including whether AI systems can be regarded as writers or artists and whether their outputs can receive copyright protection. Students debated these questions and considered the importance of human authorship, creative control, intention and originality, using the example of a non-human taking photographs to discuss the relationship between copyright protection and human authorship. The class reviewed disputes concerning AI training data, reproduction of copyrighted material, trademarks, memorisation of source works and possible compensation mechanisms for creators whose works are used to train models. It also considered the use of AI in legal practice, stressing the need for reliable, specialised systems, human review and collaboration between lawyers and engineers to protect fundamental rights. The session then introduced competition law, its aims of protecting consumers, innovation and efficient markets, and its relevance to dominant digital and AI-based platforms.

The session introduced the legal, ethical and geopolitical issues raised by data and artificial intelligence, emphasising that regulation varies across jurisdictions and societal contexts. It explored why artificial intelligence (AI) and data engage areas including data protection, liability, intellectual property, constitutional law, international law and discrimination. Students considered the limits of using AI in legal decision-making, including predictive systems for human-rights cases, balancing legal certainty and efficiency against human interpretation and the evolving nature of law. The class also examined definitions of AI, the distinction between narrow and general AI, calls to regulate future technological risks, and the possible legal personhood of robots. A case discussion considered arguments for and against a conversational robot inheriting an owner’s assets.

The session examined the development and purpose of the European Union (EU) AI Act, including tensions between innovation, competitiveness, sovereignty, public regulation and private ethical codes. It distinguished legal obligations from voluntary ethical commitments, explaining why enforceable rules and sanctions are significant. The class explored the Act’s risk-based model, covering prohibited, high-risk, limited-risk and minimal-risk AI systems, alongside the duties imposed on providers and other actors. It also considered the Act’s extraterritorial reach, exclusions such as military and research uses, enforcement mechanisms, regulatory sandboxes, and the particular rules for general-purpose AI models. Students discussed practical difficulties in assessing risks to fundamental rights, democracy and human dignity, as well as potential conflicts between European and international regulatory approaches.

The session introduced data protection law through discussion of children’s data, profiling, algorithmic bias and the limits of consent in digital services. It examined why data protection is important for AI, comparing the European rights-based approach with the more sector-specific approach in the United States. The class covered privacy as a broader concept than information control, including dignity, intimacy, home and communications, and considered the EU Charter rights to privacy and personal-data protection. It then introduced the General Data Protection Regulation (GDPR), including personal data, identifiable natural persons, processing activities, material and territorial scope, and the basic obligations on organisations processing data. Students discussed examples involving health data, policing, profiling, data transfers and cross-border services.

The session examined GDPR data-subject rights in AI systems, including access, rectification, erasure, restriction of processing, portability and objection, and explained privacy by design across training and deployment. It considered how biased datasets and algorithmic design can create or reinforce discrimination, and discussed fairness, auditing, impact assessments and ethics by design. The class then introduced the EU Data Act, its application to data from connected products and related services, its relationship with the GDPR, and rules on user-led data sharing, competition, gatekeepers, contracts, compensation and dispute resolution. The final section used neurotechnology to explore mental privacy, brain data, cognitive liberty, and the need for ethical and legal safeguards against misuse by companies or governments.

The session examined the ethical, legal and professional responsibilities of scientists and data specialists in relation to autonomous lethal weapons and AI used in conflict. It considered the limits of existing regulation, particularly the military exemption in the AI Act, and debated whether emerging technologies should be regulated or prohibited before they are fully developed. The class compared arguments for and against autonomous weapons, including meaningful human control, bias, accountability, international consensus and historical preventive bans on certain weapons. It also discussed whether advanced AI systems merely imitate reasoning or might develop forms of understanding or consciousness, and considered the implications for law and responsibility. Finally, the session explored corporate due diligence, value-chain oversight and contractual controls through examples of technology companies supplying tools that may be used for immigration enforcement, surveillance or defence.

The session introduced the course aims, including self-awareness, relationship management, feedback, ownership, employability and a brief consideration of employment rights and duties. Students distinguished between transferable soft skills and job-related technical skills, then reflected on their own strengths, development areas, values and preferred working environments. Effective communication was explored through non-verbal, vocal and verbal elements, active listening, assertiveness, congruence and metacommunication. Students completed group and individual reflection activities, presented examples from their experience, and practised using the situation, task, action and result (STAR) structure to communicate skills and achievements clearly.

The session explored assertive communication, including adapting messages to the listener, respecting different viewpoints, using an appropriate tone and accepting feedback. It examined levels of active listening, with emphasis on asking open questions, rephrasing accurately and avoiding premature advice when coaching someone through a problem. Students completed a coaching role-play on time management and procrastination, then reviewed how deeper questioning can help someone identify their own solutions. The class also introduced the Myers–Briggs Type Indicator (MBTI) preference framework and used it as a discussion framework for communication styles, motivation, team complementarity and role allocation. In a group activity, students designed and presented a plan for a school graduation event, including objectives, roles, logistics, sponsorship, communication and success measures.

The session revisited constructive feedback, including active listening, separating facts from judgements, checking availability, avoiding public criticism, and using the FEED structure: facts, impact or feelings, expectations or needs, and a demand or call to action. Students received practical feedback on CVs and LinkedIn profiles, focusing on clear job titles, measurable achievements, relevant technical and soft skills, consistent language, recommendations, and professional online activity. The class introduced emotional intelligence as recognising emotions, identifying the needs or messages behind them, and responding with empathy, clear communication and action. Different responses to joy, sadness, anger and fear were discussed, alongside conflict management and the importance of addressing hidden tensions through feedback. In a peer activity, students identified stressful situations and considered preparation, communication, prioritisation and support-seeking as possible responses.

The session explored management through balancing achievement of results with care for and development of people, including feedback, delegation, conflict management and setting boundaries. Students considered circles of control, influence and concern, and discussed routines that help them focus energy on controllable actions. The class introduced specific, measurable, achievable, relevant and time-bound objectives and objectives and key results (OKRs), distinguishing ambitious objectives from measurable key results and action plans; students then drafted and peer-reviewed personal, academic and career-related OKRs. Further time-management tools included an effort-and-impact prioritisation matrix, task scheduling, delegation and dropping low-value work. Students compared ideas from productivity approaches, including capturing and reviewing tasks, breaking work into next actions, building small habits, reducing distractions and using timed work sessions.

The session introduced measures used to assess the environmental impact of IT, including kilowatt-hours, carbon dioxide equivalents, global warming potential, power usage effectiveness and water usage effectiveness. It examined the growing energy demand of data centres and artificial intelligence (AI), explaining the efficiency–consumption rebound effect and the main roles of computing equipment, cooling, backup systems and infrastructure. Different data-centre cooling methods were compared, with particular attention to trade-offs between electricity consumption and water use, as well as the importance of local water scarcity. The class compared public cloud services with on-premises data centres, considering server utilisation, energy efficiency, renewable-energy claims, carbon offsets and lifecycle emissions. Students explored cloud carbon-reporting tools and learned to distinguish direct, energy-related and supply-chain emissions across Scopes 1, 2 and 3, including location-based and market-based reporting.

The session reviewed sustainability in IT, including power usage effectiveness, water usage, greenhouse-gas reporting scopes, life-cycle emissions, and the Jevons paradox. It examined sustainability claims made by major technology and AI companies, distinguishing genuine emissions reductions from renewable-energy matching and carbon offsetting. The class explored data-centre cooling systems, the role of air, water, temperature and humidity control, and the energy used by heating, ventilation and air conditioning (HVAC) and airflow equipment. Examples of data centres of different scales were used to compare efficiency, grid carbon intensity and the environmental effects of expanding AI infrastructure. Students completed calculations comparing data-centre efficiency and annual carbon emissions for sites in France and Ireland.

The session introduced the environmental impact of AI, including the energy used in model training and inference, and the role of AI in forecasting electricity-grid demand. It explained deep learning as a form of machine learning based on neural networks, covering neurons, weights, biases, activation functions, layers, classification and regression outputs. Training concepts included loss functions, optimisers, batch size, epochs, train-test splits, underfitting and overfitting. Students experimented with neural-network complexity in an interactive playground and began setting up Amazon Web Services (AWS) SageMaker and JupyterLab for a lab on image classification and carbon-aware computing.

The session introduced time-series analysis for understanding and forecasting energy consumption in smart grids. It explained why temporal ordering prevents random train-test splits, and showed how lagged values, baseline forecasts and R-squared can be used to evaluate predictions. The class covered trend, seasonality, residuals, stationarity, differencing, autocorrelation and partial autocorrelation, leading to autoregressive integrated moving average (ARIMA) and seasonal ARIMA forecasting models with confidence intervals. Students then began an AWS SageMaker Canvas activity using French hourly electricity-consumption data, configuring and training forecasting models, comparing holiday settings and discussing weighted quantile loss.