UQ MATH2504/MATH7504 (Sem 2, 2026)
Programming of Simulation, Analysis, and Learning (Data) Systems (aka Programming for Mathematicians)
UNDER CONSTRUCTION
This course introduces programming as well as software architecture and development with a focus on numerical mathematics, computer algebra, statistics, and data analysis. Students learn to implement algorithms using sound software practices to create organised, maintainable, and extendable code.
This course is intended for Mathematics students in their fourth semester or higher, with prior knowledge of calculus, linear algebra, basic statistics & probability, and some elementary discrete mathematics. While the first unit introduces basic programming, students are expected to have some experience with scripting languages (e.g., Julia, R, MATLAB, Python) and be familiar with code, variables, loops, and conditionals.
The programming language for this course is the Julia language. Julia is a modern compiled programming language which solves the two-language problem usually present in scientific computing and data science/Machine Learning applications: It is in many ways is easy to work with, similarly to other scripting languages, with a syntax particularly adapted to Mathematics. However, Julia also allows one to create efficient, well-structured code, on par with languages such as C++ and Fortran.
The bulk of MATH2504 is taught by industry professionals, with this year's lecturers being Dr. Paul Bellette and Dr. Claire Foster. A part of the course is taught by Dr. Paul Vrbik. The course coordinator is Dr. Dietmar Oelz (Ölz) (d.oelz@uq.edu.au).
The course content is broken into 8 study units and delivered via 3h of weekly lectures which involve both live demonstrations and theory. There is also a perspective seminar presented by guest speaker Dr. Anna Foeglein aimed at presenting students with further insights about mathematicians and statisticians working with software in industry.
There are weekly practicals of two types: standard practicals (PRA1) and support practicals (PRA2). Standard practicals cover core material associated with assessment at the base level of the course, while support practicals are a means to offer support to students dealing with more basic issues regarding assessments. It is recommended for all students to attend the standard practicals. For students that have less programming background or require extra help with assignments it is recommended to attend one or more of the support practicals. In any case, since practicals are two hours long, it is recommended to use the practical time to receive help for assessment tasks. Practicals are scheduled on most weeks including the first week.
To prepare for the course, please install the latest version (1.12.x) of the Julia programming environment from the Julia website on your computer, run it and start by evaluating simple sums of two numbers.
Pillars of Study and Goals
There are 4 main pillars of study in this course:
- The use of a variety of features of a programming language (Julia in this case).
- Technical tools such as: Unix, git, IDEs and Jupyter.
- Mathematical and statistical algorithmic concepts, their theoretical analysis, and implementation.
- Solid software development practices - with a view towards employability.
Ideally, after completion of this course a student will have the ability to continue self study of software and programming concepts after getting a 'jump-start' via this course. The student would ideally be able to work independently on projects for more advanced third and fourth year courses, and/or produce efficient code as part of Honours or higher degree research. Importantly, the student would have tools for contributing to open sourced projects, startup-teams, and be hirable in analytic software focused jobs in industry.
Clearly a one semester course cannot transform a mathematician into a software engineer, however we hope that through the course content, students will be able to further themselves on such a path if needed.
Study Units
The course is composed of the following 8 study units. Each of the units feeds most of the pillars of study. The early units build up basic Julia, computer science, and tooling knowledge (mostly pillars 1 and 2), whereas the later units focus on deeper mathematical stories, mostly feeding pillars 3 and 4. Specifically with respect to pillar 3 (mathematical and statistical algorithmic concepts), there are four main concepts: numerical mathematics and ODEs (Unit 4), computer algebra systems (Unit 6), Monte Carlo and discrete event simulation (Unit 7), and data processing (Unit 8). Clearly some of these concepts are often taught (often at greater depth) in other specialized courses. However in this course, the focus is software implementation.
Here is detail of the content of each of the Units:
- Unit 1- Hello World Bootcamp: Getting your basic programs to run. Variables, arithmetic, logical statements, conditionals, iteration, functions, scope.
- Unit 2- Basics: Basics of computation, arrays and similar structures, strings, input and output, the Julia language, Jupyter notebooks, REPL (command line), and markdown.
- Unit 3 - On Algorithms and more: Sorting algorithms and their analysis. Quantifying performance via empirical measurement. Quantifying performance via mathematical analysis. Compilation steps. Memory organization. Representation of variables and quantities in memory. Additional tools: Unix command line, Git and GitHub like systems, IDEs (Integrated Development Environments).
- Unit 4 - On data files, and basic numerics: Standard file formats (e.g. CSV, JSON), reading and writing to files, web input, basic plotting with Julia, basic descriptive statistics and statistical plotting with Julia, representation of floating point numbers, numerical inaccuracy issue (e.g. numerical derivatives), solutions of ODEs using standard methods, basic matrix operations and performance considerations, usage of third party packages and the Julia package manager. Usage of language features for dealing with special structures (e.g. sparsity). Further profiling and debugging tools and the basic usage of a debugger.
- Unit 8 - Working with heterogeneous datasets: Dataframes and data and more on memory management. Exploratory data analysis and visualization. Further language features. More on design principles of packages and interfaces.
- Unit 5 - More language features for software architecture: Julia types and multiple dispatch, defining structures and designing types.
- Unit 7 - Monte Carlo and discrete event simulation: Pseudo-random number generators, from uniform distributions to any distribution, basic Monte Carlo based statistical analysis, discrete event simulation modelling and simulation engines. Modular software design. Additional language features including meta-programming and further understanding of the compilation process. More on type inference and performance implications.
- Unit 6 - Computer algebra systems and symbolic computation: Background from elementary number theory, polynomial arithmetic, GCD and Euclid's algorithm, factoring mod p.
Assessment
These are the 5 assessment items. The first 4 are due during semester and worked on progressively during the course. The last item is the final exam. BigHW and Project 1 are to be worked on in pairs (or groups of 3 in special cases). The other items are individual.
-
Quiz (18%, in-person during class): Covering the very basics of programming.
-
BigHW (16%): Jupyter and REPL, basic Julia functionality and small programs – analysis of sorting, using an IDE, using Unix, using GitHub, file input output, and numerical mathematics. (HW in pairs).
-
Project 1 (16%): Discrete event simulation (project in pairs). This project requires the students to structure files and code independently.
-
Project 2 (18%): Symbolic computation. This projects builds on existing code supplied to the students.
-
Final exam (32%) during examination period. Hurdle: To obtain a course grade better than 3, the student must achieve 40% or above on the final exam.
See
submission instructions below.
Schedule
- Lecture Monday (2hrs): 4pm – 6pm, 01-E215, Forgan Smith Building (East Wing)
- Lecture Tuesday (1hr): 5pm – 6pm, 01-E215, Forgan Smith Building (East Wing)
- Standard practicals (PRA1) - choose one of:
- Support practicals (PRA2) - only optional. Choose one of:
- Consultation Hour: Weekly, Tues 4pm (up to 4:50pm)
Here is the schedule listing the lecturers, units of study, practical activity per week, and assessment. As an aid, also see the
2026 UQ Calendar.
| Week |
Monday
Date |
Monday
4pm |
Monday
5pm |
Tuesday
5pm |
Standard
Practical |
Support
Practical |
Assessment Due
(Friday) |
Consultation Hour |
| 1 |
Jul-27 |
Unit 1 (DO) |
Unit 1 (DO) |
Unit 1 (DO) |
A |
✓ |
|
DO |
| 2 |
Aug-3 |
Unit 1 (DO) |
Seminar (AFg) |
Quiz preparation |
B |
✓ |
|
DO |
| 3 |
Aug-10 |
Quiz |
Unit 2 (PB) |
Unit 2 (PB) |
B |
✓ |
|
PB, DO |
| 4 |
Aug-17 |
Unit 2 (PB) |
Unit 2 (PB) |
Unit 3 (PB) |
C |
✓ |
|
PB, DO |
| 5 |
Aug-24 |
Unit 3 (PB) |
Unit 3 (PB) |
Unit 3 (PB) |
D |
✓ |
|
PB, DO |
| 6 |
Aug-31 |
Unit 4 (PB) |
Unit 4 (PB) |
Unit 4 (PB) |
- |
- |
BigHW |
PB, DO |
| 7 |
Sep-7 |
Unit 5 (CF) |
Unit 5 (CF) |
Unit 5 (CF) |
- |
- |
|
CF, DO |
| 8 |
Sep-14 |
Unit 7 (CF) |
Unit 7 (CF) |
Unit 7 (CF) |
E |
✓ |
|
CF, DO |
| 9 |
Sep-21 |
Unit 7 (CF) |
Unit 7 (CF) |
Unit 6 (PV) |
E |
✓ |
Project 1 |
CF, DO |
| Break |
|
|
|
|
|
|
|
|
| 10 |
Oct-5 |
- |
- |
consultation (4 pm), Unit 6 (PV) |
F |
✓ |
|
PV, DO |
| 11 |
Oct-12 |
Unit 6 (PV) |
Unit 6 (PV) |
consultation (4 pm), Unit 6 (PV) |
F |
✓ |
|
PV, DO |
| 12 |
Oct-19 |
Unit 6 (PV) |
Unit 8 (CF) |
consultation (4 pm), Unit 8 (CF) |
F/G |
✓ |
Project 2 |
PV, DO |
| 13 |
Oct-26 |
Unit 8 (CF) |
Unit 8 (CF) |
wrap up |
G |
✓ |
|
CF, DO |
* All four lecturers, PB, CF, PV, and DO are introduced in the first lecture.
Standard Practicals
There are 9 standard practicals (A-I) in total and this is a description of each practical.
- Practical A - Installation and basics: Installation. Using Jupyter. Basic Julia code running in Jupyter. Basic Julia REPL. Basic simple programs with variables, conditional statements, and loops.
- Practical B - More on basic tools and Julia essentials: Basic LaTeX formulas. Basic HTML in Jupyter. Variables, logical statements, conditional statements, loops, generic functions, scope, arrays, input/output, and a few more Julia essentials.
- Practical C - Unix, GitHub, and an IDE: Using git, GitHub, Unix commands for file manipulation and git, and basic IDE usage (Visual Studio Code).
- Practical F - Towards project 1: Design patterns used in a discrete event simulation engine.
- Practical E - Towards project 2: How to create, manage, and submit projects with multiple files, and GitHub. Examples towards project 2.
- Practical G : Working with dataframes.
Support Practicals
Students may choose to join support practicals (PRA2) in addition to the standard practicals. If scheduling allows students may even join more than one such practical. In the support practicals, a casual academic helps the students with individual questions related to the course material or (non-quiz) assessments.
Assessment Submission instructions
-
Each assessment item is to be handed in with an experience voice recording. In the voice recording, the student(s) state how they felt working on the assessment, what they found easy, difficult, dull, or interesting, and importantly state (if true) that the work is their own.
-
The three projects (1-3) are to be handed in via GitHub. In these cases, the students are to create repositories for the submission. BigHW, is in a more laid out and pre-specified format.
-
For the three projects (1-3), in addition to the GitHub, a single PDF file including printouts of all student source code should also be handed in. This is for easy annotation feedback of markers.
Software Installation
It is recommended that you have the following on your machine:
From week 1 (or prior):
From week 3 (or prior):
With the software installed, please bring your laptop to practicals (and ideally to the lectures). In exceptional circumstances, where you plan to attend a face to face practical and cannot bring your laptop, you may install Julia and the associated software on the Windows desktop machines available in the practical classroom. This is a workable solution but is not ideal. The installation may take several minutes and it is not guaranteed that it will remain on the machine over time. Hence whenever possible, bring your laptop.
Additional Resources
Here are additional resources that may be of use for the course (or for introductory Julia programming in general). None of these are mandatory as there are plenty of examples in the lecture units and practicals. That is, it is recommended that you try running every bit of code from the lectures and practicals, investigate it, look at the Julia help to explore. Nevertheless, you may find some of these additional resources helpful as well:
Back to top