Object Oriented Development COM534
The Object-Oriented Analysis, Design and Development (OODD) module introduces you to the complete process of developing software using object-oriented approaches. Throughout the module, you learn how to analyse user requirements, design software solutions, implement applications in Kotlin, create user interfaces, work with databases and test software effectively. The module combines theoretical software engineering concepts with practical programming skills, helping you develop a professional approach to software development. The module begins by introducing Kotlin as the primary programming language and develops your understanding of its syntax, data types, control structures, functions and object-oriented features. You learn how Kotlin differs from Python, how it operates on the Java Virtual Machine, and why it has become an important language for modern software and Android development. This foundation prepares you for building larger object-oriented systems throughout the module.
As the module progresses, you explore the fundamental principles of object-oriented programming, including encapsulation, inheritance, aggregation and polymorphism. You learn how to design classes that represent real-world entities, how to control access to data, and how relationships between classes can be structured to improve maintainability and code reuse. These concepts help you move from writing simple programs to designing more complex and scalable software systems.
A significant part of the module focuses on analysis and design techniques. You learn how to investigate problem statements, identify important system entities and model them using UML artefacts such as domain models, class diagrams, use case diagrams and sequence diagrams. These techniques help you understand how software requirements can be translated into technical designs before implementation begins, reducing development risks and improving software quality.
The module also develops your understanding of professional software development practices. You learn about collaborative development, use case documentation, version control concepts and software development workflows. These skills mirror industry practices and help prepare you for working within development teams and managing larger software projects. Building on the fundamentals, you explore more advanced Kotlin features, including interfaces, lambda expressions and functional programming concepts. These techniques allow you to write code that is more flexible, reusable and maintainable while introducing programming paradigms commonly used in modern software development.
The practical focus of the module continues through the development of graphical user interfaces using Compose Multiplatform. You learn how user interfaces are built using composable components, layouts, state management and event handling. As your skills develop, you work with more advanced user interface features such as lists, modifiers and dynamic content, allowing you to create interactive applications that respond effectively to user input.
You are also introduced to database development, enabling your applications to store and retrieve data persistently. This expands your applications beyond simple in-memory programs and introduces concepts that are essential in many commercial software systems where data management is a fundamental requirement.
In the later stages of the module, you examine software architecture and quality considerations through topics such as coupling, cohesion and design patterns. You learn how software can be structured to minimise dependencies, improve maintainability and encourage reuse. These concepts help you evaluate and improve the design quality of your own software solutions.
The module concludes with software testing using JUnit, where you learn how to develop automated unit tests that verify the behaviour of individual components. You explore assertions, test cases, test setup procedures and testing strategies that contribute to software reliability and quality assurance. Alongside testing, you gain experience working with dates and times in Kotlin applications. The OODD module develops your ability to move confidently through the entire software development lifecycle. By the end of the module, you should be able to analyse requirements, create UML models, design object-oriented systems, develop Kotlin applications, build user interfaces, work with databases, apply sound design principles and test software using professional software engineering practices.
OODD Module: Overview
1. Introduction to Kotlin
- Introduction to Kotlin as a modern object-oriented programming language.
- Understanding the Java Virtual Machine (JVM) and cross-platform development.
- Using variables, data types, operators and control structures.
- Writing functions and creating simple Kotlin applications.
- Exploring Kotlin features such as type inference and null safety.
2. Encapsulation and Inheritance
- Understanding the principles of object-oriented programming.
- Using public and private access modifiers.
- Applying encapsulation to protect data and improve reliability.
- Creating class hierarchies using inheritance.
- Reusing code through superclass and subclass relationships.
3. Aggregation and Polymorphism
- Exploring relationships between objects and classes.
- Understanding aggregation and object composition.
- Using polymorphism to support flexible software design.
- Designing systems where objects can behave differently through shared interfaces.
- Building more maintainable and reusable code structures.
4. Introduction to Analysis and Design: Domain Models and Use Cases
- Understanding the purpose of software analysis and design.
- Introduction to UML (Unified Modelling Language).
- Creating domain models from problem statements.
- Identifying classes, attributes and relationships.
- Developing use case diagrams to represent user interactions.
5. Use Case Texts and Basic Git Merging
- Producing detailed use case descriptions.
- Documenting system behaviour and user requirements.
- Understanding version control fundamentals.
- Introduction to Git workflows and collaboration.
- Resolving simple code merge conflicts.
6. Further Kotlin Language Features: Lambdas and Interfaces
- Implementing interfaces in Kotlin.
- Understanding abstraction and contracts between classes.
- Using lambda expressions and functional programming techniques.
- Passing functions as parameters.
- Writing more concise and flexible code.
7. Introduction to GUI Applications with Compose Multiplatform
- Building graphical user interfaces using Compose.
- Understanding composable functions.
- Creating layouts and interface components.
- Managing application state.
- Handling user interaction and events.
8. Further Compose
- Using modifiers to customise user interfaces.
- Working with forms, lists and dynamic content.
- Managing state effectively within applications.
- Implementing lazy lists for efficient rendering.
- Building more advanced and responsive user interfaces.
9. Sequence Diagrams
- Understanding object interactions over time.
- Creating UML sequence diagrams.
- Modelling message passing between objects.
- Representing system behaviour dynamically.
- Supporting detailed software design and documentation.
10. Introduction to Database Development with Kotlin
- Connecting Kotlin applications to databases.
- Storing and retrieving persistent data.
- Understanding database operations and queries.
- Managing application data beyond program execution.
- Integrating databases into software systems.
11. Coupling, Cohesion and Design Patterns
- Understanding software architecture principles.
- Applying low coupling and high cohesion.
- Evaluating software quality and maintainability.
- Exploring common design patterns.
- Designing systems that are easier to extend, test and reuse.
12. Testing with JUnit; Dates and Times
- Understanding the importance of software testing.
- Creating automated unit tests using JUnit.
- Using assertions to verify software behaviour.
- Applying test setup and teardown procedures.
- Working with dates and times in Kotlin applications.
Across the 12 topics, you will develop skills in:
- Object-oriented programming using Kotlin.
- Software analysis and UML modelling.
- Requirements gathering and system design.
- User interface development with Compose.
- Database integration and data management.
- Professional software engineering practices.
- Software architecture and design quality.
- Automated testing and quality assurance.