University of Essex Online · CertHE Computer Science · Level 4 · Tutor: Dr Anupam Mazumdar
This module introduced the object-oriented paradigm, building on the procedural foundations of the previous module and reshaping how I approach software design.
Design abstract data types and interfaces using Abstract Base Classes to define clear contracts between components.
Apply information hiding through private attributes, property getters and setters, and integrity validation.
Build class hierarchies that share and extend behaviour, using constructors and super() correctly.
Implement method overriding and runtime method dispatch to write flexible, extensible code.
Apply software engineering concepts and design patterns within object-oriented systems, including composition.
Explain technical concepts clearly through code, documentation, presentation slides, and a recorded video.
Two assessed components made up this module: an individual presentation built around a coded system, and an end-of-module test combining code and written answers.
An object-oriented Online Shopping System built in Python, accompanied by a presentation (PowerPoint) and a recorded video explaining the concepts. The system demonstrates all four pillars of OOP through a realistic e-commerce workflow: products, customers, and order processing with discount logic.
Technical highlights include abstraction via Abstract Base Classes (an Orderable interface and an abstract User class); encapsulation through a private price attribute with a property getter/setter and validation; inheritance through a PremiumCustomer subclass; and polymorphism through method overriding of the discount calculation, dispatched at runtime. The code also uses type hints, composition, and constructors and destructors, with Harvard-referenced sources cited throughout.
A very strong and coherent understanding of core OOP principles, clearly aligned with the brief. Application was described as a significant strength — a functional, well-integrated system demonstrating real-world workflow and interface-driven design, reflecting high practical competence. Strong engagement with academic and professional sources. Suggested improvements: more explicit critical evaluation of limitations and trade-offs, and greater system complexity such as persistence.
An end-of-module individual test completed directly on the learning platform, combining practical coding tasks with written answers. The test assessed understanding of object-oriented principles, design patterns, software engineering concepts, and collaborative development practices.
Very good understanding of OOP principles, design patterns and software engineering concepts, explained clearly and supported with relevant examples and references. Practical implementations described as functional, well structured, and effectively applying software engineering theory to realistic scenarios, with good awareness of modularity and design patterns. References integrated appropriately to support the technical explanations.
Written using the 3 W's framework (What / So What / What Next), as recommended by the UoEO Department of Computing.
This module was, in fact, a little more difficult for me than the procedural one, because I knew nothing about OOP until now — so everything was new. I had to adapt and change the way I see code. I learned concepts that took me a while to fully understand, such as inheritance and polymorphism. The module was assessed through an individual presentation (a coded Online Shopping System, with a PowerPoint and a recorded video explaining the concepts) and an end-of-module individual test combining code and written answers.
Although the subject was harder to grasp at first, I found that programming with OOP was actually much easier in practice. While procedural programming is simpler overall, OOP makes everything easier when it comes to the actual act of programming — especially in terms of reasoning through a problem. Having just built a fully procedural project in the previous module, I could feel how the procedural fundamentals underpinned my understanding of object-oriented design.
This was my strongest programming module so far. A large part of that came from lessons carried over from earlier modules — particularly referencing, which I now applied confidently from the start, citing sources such as PEP 8, the Python documentation, and academic texts directly within my code. Being almost a year into the course, I can see how I am gradually adapting and improving — not just my technical skills, but my understanding of how to learn and apply what I have learned.
In my Online Shopping System, I demonstrated the four pillars of OOP: abstraction through Abstract Base Classes (an Orderable interface), encapsulation through private attributes with property getters and setters, inheritance through a PremiumCustomer subclass, and polymorphism through method overriding of the discount logic, dispatched at runtime.
I feel much more prepared to program now, and even more curious about other areas, such as data and other programming languages. I will certainly use OOP for the rest of my life in programming. That said, having only just started Web Application Development, I do not yet know how to implement these concepts within HTML and CSS — and connecting object-oriented thinking to web technologies is something I look forward to exploring. With both procedural and object-oriented paradigms now in my toolkit, I am better equipped to choose the right approach for each situation.
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 |
|---|---|---|---|---|
| Object-oriented Design | None | Proficient | Online Shopping System using all four OOP pillars | Apply OOP to larger systems and connect it to web technologies |
| Abstraction & Interfaces | None | Competent | Abstract Base Classes (Orderable, User) defining contracts | Explore protocols and more advanced interface design |
| Encapsulation | None | Proficient | Private attributes with property getters/setters and validation | Apply consistently to protect data integrity in all systems |
| Inheritance & Polymorphism | None | Competent | PremiumCustomer subclass; runtime method overriding | Practise designing class hierarchies that avoid over-engineering |
| Referencing in Code | Developing | Proficient | Confident Harvard citations from the start (PEP 8, docs, texts) | Maintain as standard practice; broaden to peer-reviewed sources |
| Technical Presentation | Basic | Competent | Slides and recorded video explaining the coded system | Reduce content density for clearer delivery (per feedback) |