Object-Oriented Programming

Object-Oriented Programming

In this module, students develop object-oriented programming skills using the object-oriented programming language Python. In addition, students will understand the differences between object-orientation and procedural programming, as well as the difference of the design process. With the skills learned, students will be using techniques and tools for designing and implementing testing and debugging object-oriented programs.

Outcomes

  • Summary of the learning outcomes

I will learn to:

  • assess and evaluate object-oriented programming and compare it to other programming concepts critically
  • create and design an object-oriented program using appropriate design principles
  • implement and use proper data structures for a given problem
  • propose object-oriented programming solution by using an modelling language like UML.

  • Units

The units of the module to achieve those learning outcomes:
Unit 1:An Introduction to Python Programming and the OO Programming Paradigm
Unit 2:Object Oriented Analysis - Initial Steps towards Programming in Python
Unit 3:UML
Unit 4:Applying a UML Model to a Program Implementation: UML in Practice
Unit 5:More on Classes
Unit 6:Abstract Methods and Interfaces
Unit 7:Debugging / Error Handling, Data Structures and Data Search
Unit 8:Data Structures and Data Search in Practice
Unit 9:Packaging and Testing
Unit 10:Testing Code in Practice
Unit 11:Pointers, References & Memory, and Design Patterns
Unit 12:Working with Design Patterns to Structure Code

  • Reflection

What exactly have I learnt and how?

The second module of my postgraduate certificate course was more than challenging. The module introduced me to object-oriented programming and the techniques surrounding this style of programming. Furthermore, as with the first module, the chronological structure of the course enhanced my learning tremendously. The teaching process slowly but surely taught me the theories and practices of object-oriented programming week by week (unit by unit). In addition, the seminars and activities from the units gave me a better understanding than the reading part of the units. As a result, the learning outcomes were plentifuller than in the first module. In addition, the object-oriented programming course was the most crucial part of my learning success.
Learning by doing! The practical part of the module is the most crucial factor that increases my skills faster than any other learning method. Thanks to the object-oriented programming course on Codo, I am one step closer to mastering another concept of Python. However, I know I still have a lot to learn to reach my goal, but I can apply the object-oriented programming style at a significant level. All in all, the exercises have confirmed to me once again that practice brings the most outstanding learning success and not just theory.
While working out the units, I realised that the object-oriented principle is a powerful concept related to reality instead of using functions and logic. I have learnt about the object-oriented benefits: Encapsulation, abstraction, inheritance and polymorphism. Encapsulation is the process of combining data and functions into a single unit called a class. Hence it reduces complexity and increases reusability. Abstraction prevents a user from creating an object of that class and compels a user to override abstract methods in a child class. Like encapsulation, it reduces complexity and also isolates the impact of changes. With inheritance, children's classes can inherit all the methods and attributes of the parent's class and add more to the class hierarchy. As a result, it eliminates redundant code. Lastly, polymorphism is the ability of a programming language to present the same interface for several different underlying data types. Logically, code can be reduced, and ugly case statements can be redefined.
I learned that Python's modularity concept allows developers to use created classes and other already created structures. This way, an entire system can be built without creating new code - a game-changing concept. I know how time-consuming it is to create new code, especially in the real world, where developers must adapt to the pressure and speed of technological progress. I also learned how to implement data structures in object-oriented programming and how to test code. In the first module, I received negative feedback about the testing part of my contact book programme. There was no testing concept, so I tested my code manually. Finally, I learned about test runner modules like "unittest" in this module. As I said before, reusable classes and methods are game changers, and the reusable module "unittest" is proof of that. It's an excellent tool for testing code; I'll use it in the future. The task of implementing a driverless car system was the ultimate test of the skills I learned during the object-oriented module. As I explained in Lesson 11, my knowledge of object-oriented programming was zero when I started. After I handed in the assignment, I could see my learning result on the screen. My input was working out all the tasks during the units, and the output was the assignment. I am happy about my achievement and proud to see where I have come from and where I have arrived.
Next, I was exposed to the software design principle Unified Modelling Language (UML), which helps developers create diagrams about software functionality before it is converted into code. With the standardised UML diagrams, it is easier to communicate with developers and get an overview of the software system design at many stages of the software development life cycle. However, I found it challenging to design these diagrams properly to implement them in code. For example, I had difficulty designing the class diagram for the driverless car because the relationships between the classes were complex. The more classes, the more complex the development will be. Furthermore, when creating the system implementation assignment, I had to change the classes and methods that I expected before implementation. Therefore, the diagram should not just be a short sketch but should contain all the information about the software to increase the quality and efficiency of the development. One disadvantage is that the diagrams are not 100% reliable if they are not appropriately designed. In addition, the creation of diagrams is very time-consuming. Nevertheless, it is a design, a great approach, and support for system development. Finally, the design patterns are another great material that works like a blueprint for code that the developer can adapt to solve a particular design problem in their code. Unfortunately, design pattern implementation activities were too few in this module to be used in my system implementation assignment.
The last assignment of this module was the submission of my e-portfolio. I must admit that writing and thinking about what I have learned and how is very time-consuming! However, after applying effort and committing myself to my e-portfolio, I have begun to understand and appreciate the significance of the e-portfolio process. I am glad I have already developed my e-portfolio in the first module. Since the structure of my e-portfolio is built, I only need to update each unit page and upload the projects of those units. Overall, the e-portfolio helps students track their development, create better collaboration with their peers by providing feedback, gain invaluable experience by thoroughly reflecting on their educational journey, reaffirming their commitment to education, monitor their personal growth, and engage in transformative learning by reviewing their materials.
I need to learn more about existing code and design patterns to feel more confident and efficient in programming an object-oriented program. Moreover, to increase my learning outcome, I have to focus more on the practice part since learning by doing is the best method to increase my learning outcomes. After all, I will take everything I have learned with me for my future and look forward to creating my projects.

  • Skills Matrix and Action Plan

What skills have I gained or enhanced as a result of this module and how can I use it? What else do I need to learn?

Other Modules

Launching into computer science

Launching into Computer Science

The module explores the computer's fundamental theories and practices and then progressively examines trends and current developments in computer science.

Secure Software Development

Secure Software Development

This module introduces students to secure software development's fundamental concepts and skills. Students will be provided with an overview of traditional and modern Software Development LifeCycle (SDLC) models.

Contact Me