University of Essex Online · CertHE Computer Science · Level 4 · Tutor: Thomas O'Daniel
This module established the core foundations of programming in Python, with an emphasis on procedural design, reliable code, and writing software within an academic context.
Design and build programmes using a procedural paradigm: functions, control flow, and modular code organisation.
Work effectively with Python data structures — particularly lists and dictionaries — to model and manipulate data.
Build robust programmes that handle user mistakes gracefully using try/except blocks and validation routines.
Apply algorithms and built-in functions to solve problems efficiently, simplifying logic where possible.
Structure code across multiple files following principles such as the Single Responsibility Principle.
Document code professionally, test and debug systematically, and reference technical sources correctly.
Three assessed components made up this module: a collaborative discussion forum, a mid-module finance application, and an ambitious end-of-module text adventure game.
A collaborative forum where students shared their programming journeys and gave each other feedback. My initial post, "Relearning Python," reflected on returning to the language after a two-year break — the challenge of relearning dictionary structures, and the moment I replaced verbose manual logic with the built-in max() and min() functions to find the highest and lowest expense categories. I also described an unexpected hardware failure that forced me to migrate my work to a different machine, which taught me the value of planning logic on paper before coding.
Knowledge and understanding marked at the highest level (1st): posts identified relevant challenges and showed strong understanding, with the emphasis on "planning on paper" praised as a valuable fundamental technique. Communication also marked at 1st: writing relevant and insightful, peer responses consistently constructive. The main area to improve was referencing — no formal citations were included, which was a requirement at this level.
A command-line personal finance tracker built in native Python (no external libraries such as Pandas). It manages income and expenses using lists of dictionaries, with automatic data persistence through the csv module. The programme features robust error handling — try/except validation for numerical input and a custom date-validation algorithm that accounts for month lengths and leap years.
The code follows the Single Responsibility Principle, split into a main interface module and a separate operations module. Features include categorised transactions, a tabular view of all records, a monthly filter, and a statistical summary that identifies the highest and lowest spending categories using max() and min().
Distinction in Knowledge, Application, and Structure. The architecture was praised as coherent and thoughtfully explained; the modular approach, logical control structures and emphasis on input validation reflected strong skills. The Single Responsibility Principle was specifically commended. Referencing was marked as a Pass — the one area to strengthen, as no external references were included.
An ambitious text adventure game built in Python with a procedural architecture. The player explores a haunted castle to find the legendary Golden Key, while being hunted by a ghost. This was my most complex project of the programme so far, and the one I am most proud of.
Technical highlights include an A* pathfinding algorithm (with a Manhattan distance heuristic) driving the ghost's pursuit of the player; the castle modelled as a bidirectional graph using coordinate tuples; a data-driven item registry separating static data from mutable session state; a structural map validator preventing navigation crashes; and an event-driven game loop. I deliberately maintained a 100% procedural paradigm, avoiding classes throughout.
I researched academic and technical sources to build the more advanced components — particularly the ghost AI — and cited them directly within the code and documentation.
Distinction in Knowledge, Structure, and Referencing. The graph-based map, shortest-path algorithm and systematic problem-solving were praised, along with well-structured, modular, clearly commented code. Referencing was specifically commended — relevant sources correctly cited in Harvard style within both code and documentation. One limitation: the use of the tkinter import was judged to fall outside the assignment's native-Python scope, which capped the "Application of theory to practice" criterion at 50%.
Written using the 3 W's framework (What / So What / What Next), as recommended by the UoEO Department of Computing.
This module taught me a great deal about programming. I already knew many of these concepts, but it had been a while since I last programmed, so I gradually got back into the swing of it. Most importantly, the module taught me how to write code within an academic context. It was assessed through a collaborative discussion forum, a mid-module Financial Transaction Program (a CLI finance manager built in native Python), and an end-of-module project — a text adventure game.
For the final project, I wanted to push myself. I used the research skills I had learned in Module 1 to find academic and technical sources that would help me build something I could be proud of. This was especially important for the ghost's behaviour, which was complicated to implement without prior knowledge. Through that research I was able to build an A* pathfinding algorithm with a Manhattan distance heuristic, modelling the castle as a bidirectional graph.
One important lesson came from the use of tkinter. I had researched the matter thoroughly, and my sources indicated that tkinter is part of Python's standard library — effectively native. On that basis, I believed it was acceptable to use for the game's interface. My tutor, however, considered that it fell outside the "native Python only" scope of the assignment, and this capped my mark in the "Application of theory to practice" criterion at 50%. I explained my reasoning that it was considered native, but the tutor maintained his position, so there was nothing further I could do. It was a valuable lesson in clarifying the exact boundaries of an assignment's requirements before committing to an ambitious technical decision.
A clear point of progress was referencing. In Module 2, I had not realised that referencing was required even inside code. After that, I learned that in the academic world referencing must be present in absolutely everything I produce, regardless of what it is. I applied this consistently in the text game, citing my sources directly within the code and documentation — and as a result, my "Reading and Referencing" mark rose to a Distinction.
This module leads directly into Object-Oriented Programming, and I think it is a logical step in the learning ladder. While I still feel that procedural and OOP are simply different ways of working — and that perhaps they could even be taught together — separating them in the learning hierarchy makes sense. I am certain that everything I learned here will carry forward: even though OOP is a different way of programming, procedural programming teaches the fundamentals that are also embedded within OOP, so it will be extremely useful. Above all, I will keep applying referencing to everything, and I will clarify an assignment's exact constraints before pursuing ambitious additions.
An assessment of the skills gained or enhanced during this module, with evidence and a forward-looking action plan.
| Skill | Before | After | Evidence | Action Plan |
|---|---|---|---|---|
| Procedural Programming | Rusty | Proficient | Finance Manager and full text-adventure game in procedural Python | Transfer procedural fundamentals into OOP in the next module |
| Data Structures (dicts/lists) | Basic | Proficient | Lists of dictionaries; graph modelled with coordinate tuples | Apply to more complex data modelling and databases |
| Algorithms | None | Competent | A* pathfinding with Manhattan heuristic; max()/min() optimisation | Study formal algorithm design and complexity analysis |
| Error Handling & Validation | Basic | Proficient | try/except routines; custom leap-year date validation | Continue building defensive, robust code |
| Modular Code Design | Basic | Proficient | Single Responsibility Principle; 5-module game architecture | Apply modular thinking to OOP class design |
| Referencing in Code | Unaware | Proficient | Pass (mid-module) → Distinction (final): Harvard citations in code | Maintain consistent referencing across all work, always |