MSc in Data Analytics with Artificial Intelligence.

The session introduced calculus as a foundation for optimisation, machine learning and statistical modelling. It defined functions, linear and affine functions, and common nonlinear functions including powers, exponentials and logarithms. Derivatives were explained as local slopes, with rules for sums, constants, powers, products, quotients and composite functions, alongside links to neural-network differentiation. The class then extended derivatives to several variables through partial derivatives, higher-order and mixed partial derivatives, and their use in describing slopes in different directions. Taylor series and Taylor polynomials were presented as local approximations, with applications to numerical computation, optimisation methods and interpolation.

The session began with a recap of the product rule for derivatives, using a rectangle-area argument and the limit definition to show why the small product of two variations vanishes. It then introduced vectors as one-dimensional arrays, covering vector addition, scalar multiplication, linear combinations, and the importance of matching dimensions in mathematical and programming operations. Linear independence, dependence, collinearity and bases were explained as ways to identify redundant variables and reduce the dimensionality of data. The dot product, orthogonality, vector norms, normalisation and orthonormal bases were developed, with links to correlation, variance, regression and numerical scaling. The class also introduced changes of basis, including their role in principal component analysis (PCA), compression and viewing data from more informative directions.

The session examined matrix inverses, showing that a square matrix is invertible exactly when its columns are linearly independent, equivalently when it has full rank. It introduced matrix rank, numerical sensitivity near singular matrices, and the special simplicity of diagonal matrices, whose inverses and determinants can be computed element by element. Determinants were defined and calculated for two-by-two and three-by-three matrices using minors and cofactors, with discussion of why this recursive method is impractical for large matrices. The class then introduced trace, eigenvalues and eigenvectors for symmetric matrices, deriving the characteristic equation and using orthonormal eigenvectors to diagonalise a matrix through a change of basis.

The class examined how eigenvalues and eigenvectors in data analysis can reveal approximate linear relationships and support linear regression, including the effect of scaling variables and interpreting small eigenvalues as residual error. It covered adding an intercept through centring variables or including a column of ones, comparing resulting coefficients with a statistical regression model, and avoiding overfitting by selecting simpler models and validating them. The session also explained how changing to eigenvector coordinates can reveal trends in data that are not visible when plotting individual variables, linking this to principal component analysis. It then introduced positive-definite matrices and quadratic forms through the signs of eigenvalues, with applications to convexity and optimisation. Finally, it introduced complex eigenvalues of non-symmetric matrices, complex-number arithmetic, Cartesian and polar forms, and the use of complex exponentials in trigonometry and Fourier transforms.

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 R as free, cross-platform software and explained its role alongside Python in professional data science workflows. Students were shown how to install and use R with RStudio, including arranging the interface panels for code, console output, plots and files. The class covered calculations, vectorised operations, built-in functions, variable assignment, and the creation of vectors using concatenation, sequences and repetition. It then introduced matrices, data frames and lists, including their structures, data types and methods for accessing and modifying values. Practical exercises used indexing, missing values and conditional selection to extract and update data, including calculating summaries for selected groups in a data frame.

The session reviewed how to replace missing values in data-frame variables with their non-missing mean values in R. It introduced function calls, argument ordering and naming, return values, for and while loops, conditional statements, and the use of switch. Students practised writing custom functions, including a general function to impute missing values, and considered scope, function masking, package-qualified calls, and passing additional arguments with .... The class then covered base R graphics, including plot types, axis limits, adding lines, points, titles, labels, legends, text, reference lines and shaded regions. It also introduced histograms, the importance of choosing an appropriate number of bins, and comparing a histogram with an estimated density curve.

The session reviewed histograms, density estimates and box plots, including how to write functions that combine these displays and pass optional arguments to sub-functions. It covered visualising multivariate data with box plots, scatter plots, pairs plots, categorical summaries and legends, using the iris data set as an example. The class introduced ggplot2, including installation and loading of packages, and created histograms, density curves, box plots, bar charts, pie charts, scatter plots and fitted regression lines using vehicle data. It also explored grouping, colouring and faceting plots by categorical variables to assess relationships within subgroups. Finally, it demonstrated how to create an R package containing functions and data, write documentation, build it, install it locally and load it for use.

The class introduced the dplyr package for manipulating large datasets in R, using New York City flight data as an example. Students practised filtering rows with conditions, compared dplyr filtering with base R, and considered the different treatment of missing values. They also used arrange to sort records, select to retain relevant variables, and mutate to create calculated variables such as delay changes and distances in kilometres. The session covered summarise and group_by for calculating and comparing delay statistics by airport, month and airline, with visualisations produced using ggplot. Finally, the pipe operator was introduced for chaining data-processing steps without storing unnecessary intermediate datasets.

The session introduced the structure of the machine learning course, including its focus on exploratory data analysis, feature engineering and modelling within a complete machine learning pipeline. A group project was outlined in which students were asked to use book metadata to predict Goodreads ratings, clean and analyse imperfect data, compare at least two models, and deliver code, a simple application, a report, a video demonstration and a GitHub repository. The class emphasised that machine learning begins with a clearly defined problem, suitable data and an understanding of how a human would approach the task. It also reviewed Python foundations needed for machine learning, including built-in data structures, mutability and immutability, indexing, conditions, loops and functions.

The session reviewed pandas data frames, including their tabular structure, indexing, comma-separated values (CSV) import, and the use of head(), tail() and describe() for inspection. It introduced the Titanic data set as a continuing case study and defined the machine-learning task as predicting passenger survival from available passenger information. The class examined data quality issues such as missing ages, identified the target column and ground truth, and discussed class imbalance and its effect on model bias. It also interpreted summary statistics, distributions, standard deviation and outliers, considering when unusual cases should be retained, removed or contextualised through additional features.

The session reviewed exploratory data analysis and feature engineering using the Titanic data set, including handling missing values, removing unhelpful columns and considering bias when retaining scarce passenger profiles. It demonstrated how to extract structured titles from unstructured name text using string splitting, indexing, slicing, functions and DataFrame apply operations, then create and analyse a new title feature. The class examined how uneven category frequencies can limit the usefulness of a feature for machine-learning models. It also introduced data visualisation with Plotly, using wine-quality data to inspect distributions, relationships and outliers, housing data to map prices geographically, and stock and country data to show changes over time.

The session completed exploratory analysis and feature engineering for a Titanic survival prediction task. It examined missing data, gender, passenger class, age distributions, fares and outliers, using bar charts, pie charts, histograms, distribution plots and box plots to identify relationships with survival. The class discussed removing unhelpful columns, imputing missing ages using grouped averages, and preparing data so that it is numerical and suitable for machine learning. It introduced ordinal/label encoding and one-hot/vector encoding, including their trade-offs, the k−1 rule, and the encoding of binary and passenger-class variables. The session then introduced the distinction between training and testing data, explaining how models learn from labelled examples and are evaluated on unseen examples.

The Web was distinguished from the Internet as a distributed hypermedia application, built around Uniform Resource Locators (URLs), the Hypertext Transfer Protocol (HTTP) and Hypertext Markup Language (HTML). The session traced a path through structured documents using Extensible Markup Language (XML) to linked data and Resource Description Framework (RDF) graphs. Knowledge graphs connected named entities and relationships across datasets, supporting search, recommendation, integration, validation and reasoning. Retrieval-augmented generation was another application considered. The discussion also examined data collection, tracking, algorithmic influence and biased datasets, bringing privacy, accessibility and ethics into the technical picture.

RDF statements were studied as triples forming directed, labelled graphs. Uniform Resource Identifiers (URIs), literals and blank nodes supplied the building blocks for linking data across datasets. Students practised graph completion and learnt N-Triples, Turtle and RDF/XML syntax, including prefixes, namespaces, typed values and language tags. Activities included validating, converting and visualising data, creating a personal RDF profile and examining an external library dataset. The practical guidance was to test incrementally and check generated RDF rather than copying the output of artificial intelligence without verification.

SPARQL, the query language for RDF, introduced a way to ask questions by matching patterns in a graph. Students constructed patterns with triples, variables, prefixes and filters, then practised SELECT queries, distinct results, ordering and pagination. Remote endpoints such as DBpedia and Wikidata provided datasets to query. Further exercises used optional patterns, alternatives, exclusions and supplied values, alongside type and language tests, casting and string functions. Translating natural-language requests into queries connected the syntax to a precise account of which graph matches should be returned.

Ontologies were introduced as shared, formal vocabularies that give data meaning and support logical inference. Classes, properties and their definitions were distinguished from taxonomies, thesauri and validation schemas such as Shapes Constraint Language (SHACL). A museum modelling exercise exposed ambiguity, user needs, domain expertise and cultural assumptions. RDF Schema (RDFS) then provided classes, subclass and subproperty hierarchies, domains and ranges. Examples showed how these declarations allow additional types and relationships to be inferred, making the consequences of a model’s definitions visible in the graph.

An RDFS lab showed how loading a schema and enabling reasoning changes the available triples and query results. The Web Ontology Language (OWL) introduced richer class definitions and property relationships, including intersections, disjointness, equivalence, restrictions, inverse relations and property chains. Students interpreted axioms and predicted inferred facts from small graphs, using biological and organisational examples. Restrictions on values and cardinalities extended the modelling possibilities. Open-world reasoning and the absence of a unique-name assumption were central cautions: incomplete information and different names cannot simply be treated as proof of absence or difference.

Media Fragments and a media-resources ontology introduced descriptions of image regions, audiovisual segments and tracks. Students considered how to assess existing vocabularies through their definitions, scope, reuse and expressivity, and how validation supports data quality. The session surveyed mappings from relational databases, HTML, JavaScript Object Notation (JSON) and comma-separated values (CSV) into RDF. JSON for Linking Data (JSON-LD) contexts and other mapping standards connected familiar formats to graphs. Practical work included extracting embedded triples, interpreting mappings and converting profiles to JSON-LD. The Linked Data Platform introduced managing RDF resources and containers through HTTP operations.

The session introduced time series as regularly spaced observations indexed by time, with the aim of forecasting future values. It used plotted examples to distinguish seasonal patterns with fixed frequency, cycles with variable frequency, trends, changing seasonal amplitude, and the role of external information in forecasting. Students were shown how to create and plot time-series objects in R, including specifying frequency and start dates, producing seasonal plots, and treating missing values through interpolation. The class covered descriptive statistics, autocorrelation and partial autocorrelation plots, how these can indicate trends or seasonality, and tests for whether autocorrelation is present. Students practised loading a dataset, constructing a time series, identifying its patterns, and aggregating monthly observations into annual totals.

The session reviewed exponential smoothing for forecasting time series with trend and seasonality, and time-series cross-validation for comparing forecasting methods using rolling training periods. It introduced additive decomposition into trend, seasonal pattern and residual noise, noting that multiplicative series can be made additive through a logarithmic transformation. Moving averages and the decomposition function were used to estimate and remove trend and seasonality for exploratory analysis, while their limitations for extrapolating trends were explained. Differencing operators were introduced to remove polynomial trends and seasonal patterns, with seasonal differencing followed by first differencing used to obtain approximately stationary series. Students assessed residual autocorrelation using autocorrelation plots and Box tests, then practised this on air-passenger and Google stock-price data.

The session introduced backshift notation and used it to express autoregressive integrated moving average (ARIMA) models, including how ordinary differencing converts a non-stationary series into one that can be modelled with autoregressive and moving-average terms. Seasonal ARIMA (SARIMA) models were explained as combining regular and seasonal dependence, seasonal differencing, and lagged relationships at multiples of the seasonal period. Students practised identifying candidate SARIMA orders from autocorrelation and partial autocorrelation plots, fitting models, checking residual independence, comparing models using the Akaike information criterion (AIC), and producing forecasts for retail-index and San Francisco precipitation data. The class also covered heteroscedasticity and the Box–Cox transformation, including estimating the transformation using training data and applying the resulting model to forecasts on the original scale. A final exercise asked students to select a SARIMA model for airline-passenger data using Box–Cox transformation, differencing, autocorrelation diagnostics, and train-test evaluation.

The session reviewed forecasting methods for univariate time series, including exponential smoothing, ARIMA models and machine-learning approaches using lagged observations. It stressed that methods should be compared through time-series cross-validation rather than a single training and test split, with the test horizon matching the required forecasting horizon. The class introduced multivariate time series forecasting using known future covariates, fitting time-series linear models with trend and seasonal effects and then modelling correlated residuals with ARIMA to form dynamic regression models. An electricity-demand example used temperature, squared temperature and working-day status, showing how nonlinear covariate effects and seasonal information can improve forecasts. Students practised splitting the data, fitting models, diagnosing residual autocorrelation, and comparing dynamic regression, neural-network and random-forest forecasts.

The session introduced modelling as a purposeful simplification of reality used to understand relationships and make predictions. It compared statistical models, Markov models, system dynamics, microsimulations and agent-based models, emphasising heterogeneity, interactions between agents, feedback loops and unintended consequences. Predictive modelling was discussed through regression, uncertainty, extrapolation beyond observed data, parameter estimation and Monte Carlo simulation. Markov models were introduced through state transitions, transition matrices, steady states and the distinction between discrete and continuous time. Students were also introduced to NetLogo, opened a segregation model from its library, and explored the software’s interface, documentation, code tabs and support resources.

The session compared population-averaged system dynamics models with agent-based models, using alcohol use and disease transmission to show how individual histories, heterogeneity and network structure can affect outcomes. It explained Jensen’s inequality and why averaging individual characteristics before modelling non-linear processes can give different results from modelling individuals first and then averaging. Agents were defined through states, transitions, behavioural rules, interactions, networks and environmental resources, with discussion of deterministic and stochastic rules and multiple linked state diagrams. The class introduced decision modelling for selecting between actions under uncertainty, including predictive and prescriptive analysis, decision trees, expected values, utilities, Monte Carlo simulation and Bayesian use of broad and local data. Examples considered clinical treatment choices and emergency responses to wildfire risk, emphasising problem formulation, stakeholder criteria, uncertainty and the costs of possible outcomes.

The class introduced the ODD protocol for documenting agent-based models: Overview, Design Concepts and Details. It examined how to define a model’s purpose, entities, variables, rules, population, boundaries, and temporal and spatial scales. The session compared discrete and continuous time, and explained why update order, synchronisation and sequential processing can affect model outcomes. Design concepts including emergence, agent objectives, adaptation, learning, prediction, sensing, interaction and stochasticity were illustrated through predator–prey and disease-spread models. Students also considered how randomness can produce small or large epidemics and why models should include only the complexity needed for their purpose.

The session examined verification, calibration and validation of agent-based models, distinguishing internal testing, fitting models to observed data, and testing predictions or comparisons with other models. It covered calibration strategies for uncertain numerical and categorical parameters, steady states and transitions, time-series fitting, uncertainty bands, and the importance of choosing criteria that match a model’s purpose. Sensitivity, uncertainty and robustness were differentiated, with experimental designs, Monte Carlo simulation, regression and decision trees introduced as ways to assess parameter effects and interactions. The class also considered sources of uncertainty, including parameter estimates, model structure, output interpretation and unpredictable future events. Finally, it used simple epidemic models to explain the susceptible–infectious–recovered (SIR) framework, reproduction numbers, herd immunity and the value and limitations of theoretical models.

The session introduced the course structure, progressing from linear and logistic regression to generalised linear models, model comparison and potentially non-linear models, with an emphasis on practical work in R. It recapped descriptive statistics, including mean, median, variance, standard deviation, quartiles, interquartile range, skewness, kurtosis, box plots, covariance and correlation. It reviewed probability spaces, conditional probability, Bayes’ theorem, independence, random variables, cumulative distribution functions, probability mass and density functions, expected value, variance, standard deviation and common distributions. The class also covered independent and identically distributed random samples, the law of large numbers and the central limit theorem as bridges between probability theory and statistical inference. Students then revised RStudio basics, including scripts, variables, vectors, data frames, filtering, missing values, summaries, plots, packages and initial exploration of the penguins data set.

The session introduced simple and multiple linear regression, defining predictors, responses, intercepts, slopes, residuals and random error. It explained least-squares estimation, assumptions about independent, constant-variance and normally distributed errors, and residual diagnostic plots including residual histograms, quantile–quantile plots and fitted-value-versus-residual plots. Model interpretation covered coefficient tests, p-values, the F-test, residual standard error and R-squared, including its relationship to correlation and variance explained. The class also discussed confounding, correlated features, outliers and non-linearity, and began practical work comparing regression models using a four-dataset example and a COVID mortality dataset.

The session reviewed multiple-choice questions on R-squared, Pearson correlation, statistics as functions of samples, least-squares residuals, confidence intervals, and Type I and Type II errors. Logistic regression was recapped as a generalised linear model for classification, using log odds, odds ratios, likelihood, deviance and model coefficients. Students worked with a diabetes dataset to explore missing values, correlations, hypothesis tests, categorical variables and several logistic-regression models. The class compared model variables and performance, interpreted predicted probabilities and odds ratios, and constructed confusion matrices using a chosen classification threshold. Accuracy, precision, recall and F1 score were discussed, including the trade-off between false positives and false negatives when changing the threshold.

The session recapped generalised linear models, focusing on response distributions, link functions, residuals and model diagnostics. A car-insurance exercise used Poisson regression to model claim counts from district, vehicle group and age, including the use of an offset to model claim rates per policyholder. The class considered overdispersion, interpretation of coefficients and rate ratios, and the role of possible confounding factors. A further exercise introduced comparison of Gaussian and Gamma generalised linear models with a log link for modelling wages using education, age, sex and language.

Customer targeting introduced decisions about products, prices, channels and promotion. Market research and statistical methods were considered alongside predictive models, including trees, logistic models and neural networks. Demonstrations used visual analysis, dashboards and models of organic-product purchasing. Age, purchasing frequency, recency and spending illustrated possible customer information. The session also considered production constraints such as performance, traceability, security and compliance, keeping the comparison of models connected to the setting in which their predictions might be used.

Data strategy, architecture, governance and staffing framed the financial-analysis work. The class discussed targeted applications and the limits of broad claims about generative artificial intelligence. Activities compared companies through profitability, liquidity, solvency and cash-flow indicators across several industries. Segmentation and dashboards supported credit and portfolio discussions. Non-linear models, feature importance and scenarios then introduced default-risk analysis with incomplete financial and economic information, including initial feature selection rather than an asserted finished underwriting system or validated lending outcome.

Maintenance was examined through availability, reliability, safety and cost across industrial equipment, buildings, transport and software. Historical and systems-engineering approaches introduced lifecycle support and continuous improvement. The class distinguished operational maintenance from security maintenance and compared preventive and corrective approaches. Systematic, condition-based and predictive work sat alongside temporary and permanent repairs. Inspections, documentation and evaluation were considered with the risk of over-maintenance, making the discussion about choosing an appropriate intervention rather than assuming more maintenance is always better.

Mean time between failures and mean time to repair introduced calculations of reliability and availability. The class considered how equipment behaviour changes across its lifecycle. Five Whys, Pareto analysis and the Maxer method provided approaches to causes and priorities. Computerised maintenance management systems brought together assets, work orders, spares and history. Their integration with enterprise resource planning connected maintenance records with financial and production information, extending the session beyond isolated calculations to the systems that support operational decisions.

Environmental risk was examined through hazards, likelihood, consequences, mitigation and monitoring. Natural processes, climate, pollution, biodiversity and human activity were considered as interconnected rather than separate categories. Videos and discussion introduced impact assessment, risk matrices, waste and wastewater. Unequal exposure and the costs of poor air quality and climate effects broadened the analysis beyond technical measures alone. Citizen science concerning invasive species provided another example of gathering information, while the session retained attention to both local and wider consequences.

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 purpose of data warehousing and extract, transform and load (ETL) within business intelligence, focusing on collecting, integrating, modelling and delivering data for decision-making. It explained ETL and extract, load and transform (ELT) processes, data sources such as files, databases and enterprise resource planning systems, and the importance of working from stakeholder requirements and intended reporting outcomes. The class covered staging, operational data storage and data warehouse layers, including bronze, silver and gold data, data marts, and central versus departmental warehouse architectures. It distinguished transactional online transaction processing (OLTP) databases from analytical online analytical processing (OLAP) databases, and stressed trusted, consistent key performance indicators (KPIs) and reusable data models. Students installed and configured Visual Studio, SQL Server Integration Services (SSIS) and SQL Server databases, then explored the SSIS project interface and its control-flow and data-flow tasks.

The session reviewed the role of a staging area in an ETL pipeline and demonstrated loading a sales comma-separated values (CSV) file into a staging database using SSIS flat-file sources, OLE DB destinations and table truncation. It then considered how to design an operational data store to analyse sales by employee, customer and geography, including incorporating geographical information into employee and customer data. A practical SSIS flow was built for employee data, using derived columns to create email addresses and clean salary values, data conversions for salary and birth dates, and a lookup to enrich records with country and continent data. The class also covered column sizing, destination mappings, data viewers for checking transformations, and identifying invalid date values with SQL TRY_CONVERT.

The session developed an operational data store (ODS) sales ETL flow by selecting sales fields, cleaning decimal separators, converting monetary and date values, resizing text columns, and loading the resulting data into an ODS sales table. Technical error handling was configured to redirect rejected rows, record metadata about conversion failures, combine reject streams, and review the resulting errors. The class then introduced data warehouse modelling, distinguishing fact tables containing analysable events and measures from dimension tables containing descriptive attributes. It compared star, snowflake and constellation schemas, and explained primary and foreign keys alongside natural and surrogate keys. Finally, it covered slowly changing dimensions, including types 0, 1, 2 and 3, and how each approach handles changes and historical dimension data.

The session covered the implementation of Slowly Changing Dimensions (SCD) types 2 and 3 in SSIS for employee data. SCD type 2 was explained as retaining historical versions through separate rows, start dates and end dates, while type 3 stores a previous value in an additional column. A customer dimension was then configured using the SSIS Slowly Changing Dimension wizard, including fixed, changing and historical attributes and the use of business keys. The class also began building a sales fact-table ETL flow, looking up surrogate keys for customer, employee and date dimensions, handling missing references with an unknown key value of -1, and logging functional rejects. Data-type alignment between source dates and the date dimension was addressed before mapping the final fact-sales fields.

The session introduced Neo4j as a native, schema-optional graph database and compared its relationship-focused storage with relational databases. It covered graph theory fundamentals, including nodes, relationships, directed and weighted graphs, labels, properties and shortest-path traversal. Students explored common graph-database applications such as fraud detection, recommendation systems and network analysis. The class introduced Cypher syntax for matching, filtering and returning nodes and relationships, using a movie graph dataset for practical queries. Students also practised creating nodes and relationships with MERGE, updating or removing properties, and using conditional creation and matching behaviour.

The session demonstrated how to import comma-separated values (CSV) data into Neo4j, create uniqueness constraints, load person, location and visit nodes, and create relationships between them. It then introduced intermediate Cypher querying, including case-insensitive string filtering, checking query plans with EXPLAIN and PROFILE, and writing efficient graph traversal patterns. Further activities covered OPTIONAL MATCH, ordering, filtering null values, limiting and paginating results, and removing duplicates with DISTINCT. The class also practised map projections and CASE expressions to customise returned JSON-style objects and categorise movie runtimes.

The session introduced cloud computing models, service types and deployment approaches, including the benefits and limitations of public, private, hybrid and multi-cloud environments. It compared using Neo4j through Amazon Web Services (AWS), Google Cloud and Azure marketplaces, including single instances, clustered deployments, containers and relevant certification routes. The class then practised intermediate Cypher queries using aggregation functions such as COUNT, COLLECT, SUM, AVG, MIN and MAX, alongside DISTINCT, UNWIND, list indexing and list slicing. It also covered date, time and duration values in Cypher, including calculating intervals and converting timestamps for comparisons. Students continued the COVID graph mini-project exercises.

The session introduced NoSQL databases, explaining how document, graph, wide-column and key-value databases differ from relational databases and suit different use cases. It compared SQL and NoSQL in terms of schema flexibility, scalability, transaction guarantees, querying, performance, security and vendor lock-in. MongoDB was presented as a document-oriented database using Binary JSON (BSON), with databases, collections, documents, fields, embedded documents, arrays and object IDs. Students installed MongoDB and Compass, created databases and collections, inserted, deleted and updated documents, and imported a restaurant dataset. The class then explored filtering, projections, sorting, pagination, logical operators, comparisons, field existence, regular expressions and array queries, before introducing equivalent operations through the PyMongo Python library.

The session introduced MongoDB aggregation pipelines, in which documents pass through ordered stages such as $match, $project, $group, $unwind, $sort and $lookup. It demonstrated accumulator operations including counts, sums, averages, minima, maxima, and first or last values, alongside reshaping, cleaning and constructing fields within pipelines. Examples used restaurant data to calculate statistics by borough and cuisine, flatten arrays of inspection grades, create map-ready outputs, and obtain random samples. The class then covered indexes, explaining collection scans versus index scans and the use of single-field, compound, text, unique, time-to-live (TTL), wildcard, collation and geospatial indexes. Practical work was assigned to create indexes and write queries and aggregations that generate a restaurant report.

Data formats were distinguished from web programming languages and human-readable presentation. XML introduced nested elements, attributes, declarations and a tree structure, alongside the distinction between well-formedness and validation. Namespaces, resource identifiers and language tags addressed how names and context are expressed. Students created, formatted and viewed a simple document in an editor and browser. Comparison with JSON and graph-based semantic data placed the exercise within a wider discussion of representations used to exchange information between systems.

XML Schema introduced simple and complex types, element and attribute declarations, and rules governing how often information can occur. Ranges, patterns and enumerations constrained values, while type extension offered a way to build on definitions. Students created and validated schemas for bibliography and film data, deliberately adding or removing information to test the rules. Namespace and schema-location declarations connected documents to their definitions. Work then began on more precise types for a curriculum example within the session.

XPath expressions introduced paths, tests and conditions for selecting nodes in an XML tree. Extensible Stylesheet Language Transformations (XSLT) then used matching templates to generate other representations. The class examined template application, default rules, specificity, extracted values and dynamically constructed output. Catalogue and film examples supported activities in filtering, counting, sorting and formatting results for web presentation. The focus was on transforming existing structured information through declared rules rather than manually reproducing each output record by hand.

JSON objects, arrays and primitive values were compared with XML structures. Ordered collections and repeated items led into JSON Schema rules for properties, required fields, types and constraints. Students created representations and schemas for bibliographies, catalogues and film data, then changed the data to test validation. Restrictions on additional information and dependencies extended the contract beyond basic types. The class also prepared to transform XML film records into JSON using XSLT, carrying the transformation theme across formats.

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 Rust as a systems programming language chosen for performance, memory safety, concurrency and use in data-intensive applications. It covered Rust tooling, including Cargo projects, crates, the Cargo.toml manifest, building and running programs, and configuring an editor with Rust analysis and debugging support. The class explained memory management through the stack and heap, including scope, allocation, fixed and dynamic data, strings and pointers. It also introduced immutable and mutable variables, ownership, moving values, cloning, borrowing through references, and basic control structures and functions.

The session examined Rust lifetimes, explaining how references must remain valid and how explicit lifetime annotations prevent dangling references at compile time. It covered Option and Result types for handling missing values and failures, including matching, unwrapping, default values and propagating errors with the question-mark operator. The class introduced structs for grouping related data, their instantiation and mutation, ownership implications when copying fields, and implementation blocks for adding methods and constructor-like functions. It then introduced traits as shared behaviour across types, using the Iterator trait and operations such as next, map, filter, take and collect in preparation for building a linked-list example.

The session reviewed Rust exercises on lifetimes and references, mutable borrowing in structs, generic functions, Option and Result types, iterators, collections, and filtering data. It compared core data structures such as vectors, double-ended queues, heaps, hash maps, hash sets, B-tree maps and sets, focusing on their operations, complexity and appropriate use cases. Advanced structures including graphs, trees and spatial trees were introduced, alongside graph traversal and shortest-path concepts. The class then covered modularity, separation of concerns, encapsulation, abstraction, decoupling, interfaces, reuse and testing, before beginning a modular Rust graph implementation using type aliases, structs and derived traits.

The session covered software testing in Rust, including the purposes and distinctions of unit, integration and property-based tests. It demonstrated how to write and run tests with Cargo, use assertions, test error conditions and private functions, mock external dependencies, organise tests, and keep tests independent and focused on behaviour. Practical examples applied unit and integration tests to graph structures and algorithms. The class also introduced benchmarking, code coverage, debugging and profiling, before reviewing core Rust principles such as ownership, borrowing, memory safety, modularity and error handling.

The session introduced C# as an object-oriented language used with the .NET platform and Common Language Runtime, including automatic memory management and just-in-time compilation. It covered Visual Studio project organisation, solutions, projects, namespaces, program entry points, primitive and reference types, operators, functions, conditions and loops. Practical examples demonstrated type conversion, integer division, user input validation with TryParse, and the differences between casting and parsing. The class also examined arrays, multidimensional and jagged arrays, and dynamic data structures including lists, linked lists, stacks and dictionaries. A merge sort example was introduced to illustrate divide-and-conquer sorting and its time complexity.

The session introduced object-oriented programming, defining objects as entities with state, behaviour and identity, and classes as blueprints containing attributes, methods and constructors. It covered encapsulation through public and private members, static members, the current-instance reference, properties, constructors and method overloading, using bank-account and fraction examples in C#. SOLID design principles were introduced, particularly single responsibility and open–closed principles, with discussion of maintainability, extensibility and testability. The class also introduced the Unified Modelling Language (UML), including use case diagrams for identifying actors and system requirements, and class diagrams for modelling attributes, methods, visibility and static members. Finally, it began explaining horizontal relationships between classes, including association and aggregation.

The session covered object-oriented relationships: inheritance through generalisation and specialisation, and interface realisation as a contract for shared capabilities. It explained polymorphism, abstract classes and methods, method overriding, virtual methods, protected access, base-class constructors, casting, and the difference between overriding at runtime and overloading at compile time. Examples modelled animals, vehicles, flying objects, database connectors, property ownership and transaction records. A practical C# example used abstract transaction classes, sales and refund specialisations, Language Integrated Query (LINQ)-based reporting, and interchangeable comma-separated values (CSV) and JavaScript Object Notation (JSON) data exporters through an interface. Students were set a guided UML-based exercise to build an Internet of Things (IoT) data pipeline using these concepts.

The session introduced model–view–controller (MVC) architecture, separating an application into models for data and logic, views for presentation, and controllers for handling input and coordinating the other components. A console-based user-management example was developed to demonstrate this separation, including input validation, menus, error handling and exception handling. The class then covered creational, structural and behavioural design patterns, focusing on singleton, factory, adapter and observer patterns, including their purposes and limitations. These ideas were applied to a sensor-data pipeline using a factory to convert database records into reading objects, a repository and Entity Framework with SQLite for data access, report generation, and CSV and JSON export. The example was extended with an observer-based event system to notify application observers when database, reporting and export actions occurred.

The session introduced the scope of advanced Excel, including pivot tables, data transformation and modelling with Power Query, Power Pivot and Data Analysis Expressions (DAX), and a later introduction to Visual Basic for Applications (VBA). It examined Excel as a powerful but potentially risky tool, focusing on data completeness, accuracy, validity, access control, versioning and the dangers of links between separate workbooks. Students were taught to treat spreadsheets as systems with distinct input, processing and output areas, using ideas drawn from software architecture. Design priorities such as relevance, simplicity, scalability, robustness, auditability and productivity were discussed as trade-offs. The class then began independent work through exercises on pivot tables.

The session reviewed spreadsheet risk management using completeness, accuracy, validity and restricted access, alongside trade-offs between usability, simplicity, robustness and productivity. It introduced a level-one Excel architecture that separates input, processing and output areas, using Excel tables, lookups, aggregations, pivot tables and GETPIVOTDATA to create stable reports. Students worked on a billing-report exercise involving a date dimension, data enrichment with XLOOKUP, a pivot table, and a report or dashboard. The class also discussed continuous date dimensions, handling unmatched lookup values as data-quality and referential-integrity issues, and the purpose of dynamic array functions, including UNIQUE, SORT and FILTER.

The session introduced Power Query as Excel’s extract, transform and load tool, and compared level 2 spreadsheet architecture with a grid-only approach. It explained how Power Query connects to external sources, transforms data before loading it, and can load results to an Excel table, a PivotTable cache or the data model. The class covered the importance of managing data types, including choosing efficient date and currency types, and discussed when calculations or aggregations should be performed in Power Query rather than in the grid. A demonstration showed how to create queries from Excel tables, review and edit transformation steps, use connection-only loading, navigate between Excel and the Power Query Editor, and begin working with M code and the Advanced Editor. The session also clarified the use of number formats for PivotTable values.

The session introduced Power Pivot as Excel’s business-intelligence tool and compared a level 2 spreadsheet design with a level 3 design based on a data model. It explained how Power Query prepares separate fact and dimension tables, which are then related in a data model rather than merged into one large table. The class covered relational-database concepts including primary and foreign keys, relationship cardinality, normalisation, denormalisation, star schemas and snowflake schemas. It distinguished online transaction processing (OLTP) databases, which are designed for transaction writing, from online analytical processing (OLAP) databases, which are designed for analytical reading, and linked the transformation between them to extract, transform and load (ETL) processes. The session also introduced DAX measures, filter context, Power Pivot tables, and the differing roles of Excel and Power BI for reporting.

The session developed a darts-scoring challenge by reshaping raw game data into a long table containing game, player, turn, throw and score information. It covered using Power Query to unpivot data, split score strings, merge lookup tables and prepare data before applying game rules in the worksheet with running totals and indicator columns for new turns, wins and losses. The class also reviewed report design and compared histogram outputs, focusing on informative titles, clear axes, precision, white space and information density. The later section introduced VBA, including modules, procedures, object hierarchies, properties, methods, variables, data types, scope, the Visual Basic Editor, and executing or debugging code with F5 and F8.

The session introduced SAS Viya and SAS Visual Analytics as tools for exploring data, creating reports and dashboards, and communicating business value from analytics. It distinguished exploratory data visualisation from traditional business intelligence reporting, including the role of in-memory distributed data processing. Practical demonstrations covered bar charts, maps, geographic hierarchies, measures and categories, formatting, filters, display rules, interactive actions, pop-up pages and dashboard controls. The class also discussed the use of analytics and machine learning in production settings, particularly for compliance, fraud detection, risk modelling, pharmaceutical trials and sales forecasting. Students were guided to access the learning platform and begin a hands-on visual analytics tutorial.

The session introduced supervised predictive modelling for large datasets, focusing on how historical outcomes can be used to predict future customer behaviour. Using a supermarket campaign dataset, students explored target variables and predictors, created grouped categories, and examined relationships through charts and linked selections. The class built and compared decision trees, random forests, gradient boosting, logistic regression and neural networks, considering measures such as misclassification rate, receiver operating characteristic (ROC) curves, area under the curve (AUC) and lift. It emphasised ranking customers by predicted likelihood rather than making only binary decisions, and used lift and return-on-investment calculations to select an effective campaign target group. Students were set practical exercises to reproduce the analysis and evaluate models on further datasets.

The session reviewed the use of SAS Visual Analytics for business intelligence, including the distinction between departmental reporting and secure corporate reporting with data lineage, auditability and regulatory compliance. It introduced relevant professional certifications in statistics, SAS programming, visual analytics and visual statistics, and explained how associated e-learning materials and practical exercises can support preparation. Marketing analytics was explored through mass marketing, segmentation and relationship marketing, with a focus on machine-learning ranking models, control groups, incremental response and targeting customers with appropriate offers. The class also considered dynamic pricing, customer data, campaign management, model deployment and the importance of data quality, traceability, return on investment and maintaining data projects in production. Students were assigned visualisation and modelling exercises, with reports and an executive summary to explain the work.

The session introduced analysis and design as the work required before implementation, stressing the need to clarify requirements and plan solutions before writing code. It examined software complexity through the large number of possible system states, using general-purpose tools such as spreadsheets to show why complete testing is often impossible. The class compared information technology challenges with mathematically modelled engineering problems, and discussed the limitations of generative artificial intelligence and machine learning as tools for reasoning and software development. It defined information systems as organised processes for transforming data into information and potentially knowledge, with data models enabling useful access to raw data. The session also used the house-building analogy to explain requirements analysis, design, implementation, compliance, integration, security, maintenance, liability and software quality.

The session introduced information-systems analysis as the phase for understanding business needs before making design or technology choices. It covered requirements, stakeholders, business rules, events, data attributes and data dictionaries, emphasising the need to distinguish what a system must achieve from how it will be implemented. The class compared models and methods, explaining that models represent reality while methods provide steps for operating on a model, and discussed why analysis relies on clear, simple models rather than a guaranteed method. Examples involving JavaScript Object Notation (JSON), Extensible Markup Language (XML) and user-interface prototyping illustrated the importance of precise terminology, data representation, validation, and documenting operational requirements.

The session introduced context diagrams for analysing an information system as a black box, identifying external actors, events and time-driven triggers. It explained the distinction between data-carrying events and signals, and compared pulling data from external sources with receiving pushed data through gateways, queues and agreed protocols. The class examined application programming interfaces (APIs) as interfaces exposing reusable software functions, particularly for exchanging data between systems. It then modelled responses to events as action flowcharts, using checks for mandatory attributes and duplicates before creating a customer, and distinguished programming from coding and software engineering. The session also began data-dictionary analysis, discussing attributes, identifiers, universally unique identifiers (UUIDs), relational versus graph databases, scalability, transaction management and data-privacy implications of universal identifiers.

The session examined the relational data model, including relations, attributes, tuples, primary keys and foreign keys. It explained how functional dependencies are identified through business context and used to derive tables, keys and associations, with one-to-one relationships considered before many-to-many relationships. Relational algebra was introduced as the basis of Structured Query Language (SQL), covering selection, projection and joins, alongside query planning and optimisation using database statistics. The class began normalisation, focusing on first normal form and atomic values, then second normal form and the problems caused by partial dependencies in composite keys. A human-resources allocation example was used to show data inconsistency, redundant storage and the need for programmed checks to enforce dynamic constraints such as overlapping employment periods.

The session introduced the role of a Power BI data analyst and the overall workflow of preparing, modelling, visualising, analysing and managing data. It explained how data can be drawn from sources such as SQL Server databases, comma-separated values (CSV) files, cloud services and business applications, and distinguished between importing data locally and using DirectQuery. Students practised configuring regional settings, restoring a sample database, and loading six database tables plus two CSV tables into Power BI Desktop. The class also demonstrated Power Query features for checking data quality, handling errors, blanks and duplicates, changing data types, renaming or removing columns, merging columns, creating calculated columns, and applying or reversing transformation steps. Relationships between tables, including one-to-many and many-to-many relationships, were introduced as the basis for later report and dashboard design.

The session reviewed Power BI data modelling, including creating and editing relationships, managing active and inactive links, and hiding intermediary tables used to support many-to-many relationships. It explained filter direction in relationships and the need to avoid ambiguous filtering paths in a data model. Students compared predefined quick measures with custom measures and calculated columns written in Data Analysis Expressions (DAX). Basic DAX syntax was demonstrated for constants, column references, arithmetic calculations, aggregate functions and names containing spaces, alongside setting up financial-year date handling. Students then worked on labs covering model configuration, DAX expressions and date sorting.

The session reviewed Power BI data preparation, including checking data quality, renaming tables and columns, merging columns and tables, removing duplicates and unnecessary fields, changing data types, and using applied steps for troubleshooting. It covered data modelling through one-to-many, many-to-one and many-to-many relationships, including bridge tables, active or inactive relationships, and filter propagation directions. The class also discussed quick measures, custom DAX measures, calculated tables and columns, financial date tables, CALCULATE, REMOVEFILTERS and time-intelligence functions. The main focus then moved to report design: selecting and formatting visualisations, using cards, tables, maps and charts, applying filters and slicers, and planning interactive report layouts. Students began a lab activity to create the first part of a multi-page report.

The session reviewed the Power BI workflow: loading data, cleaning and transforming it, managing columns and recorded query steps, and modelling relationships between tables. It covered DAX calculated columns, measures and tables, financial date tables, filter direction, and report design features including visuals, slicers, drill-through, conditional formatting, synchronised slicers, bookmarks and buttons. Students continued a practical exercise on report design and publishing work to the Power BI service. The new topic introduced dashboards: pinning visuals from reports, combining content from different reports, adding images and titles, using natural-language Q&A, viewing refresh times, and understanding gateways for refreshing on-premises data.

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 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 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.