SWE5201 - Advanced Programming Assignment - Regent College

Assignment Task

Introduction

The student information system is critical to any educational institution's infrastructure. It enables the management and organisation of student records, course enrolment, and other essential administrative functions. In this project, we are tasked with developing a student information system for Regent College London that incorporates advanced programming techniques such as object/relational mappers, encapsulation, polymorphism, inheritance, interfaces, enumerations, refactoring design patterns, and testing methodologies.

The goal of this project is to create a system that is efficient, effective, easily maintainable, and scalable. We can develop a modular and reusable program by utilising advanced programming techniques, allowing for more accessible updates and modifications as needed. Additionally, using appropriate testing methodologies will help ensure that the program meets all the required specifications and functions as intended.

This report will document the implementation and testing of the student information system, including the advanced programming approaches used and the development of the solution over time. We will also discuss the testing methodology used to verify that the program meets the requirements and evaluate the application's overall success. The report will also include significant variations from the original design and explanations. Overall, this project aims to develop a student information system that is efficient, maintainable and meets the needs of Regent College London.

Part

1: Design Patterns and Advanced Programming Approaches

In this project, we have employed various advanced programming techniques to develop an efficient, maintainable, and testable student information system. This section will discuss the advanced programming approaches used and why we believe they lead to a better final program overall.

Object/Relational Mappers (ORMs): 

We have used ORMs to map our database tables to objects, making manipulating data in the application easier. Using ORMs can reduce the boilerplate code required to manage database interactions, leading to cleaner and more readable code. Additionally, ORMs provide an abstraction layer between the database and the application, making it easier to swap out database technologies if needed.

Encapsulation: 

We have extensively used encapsulation in our implementation, encapsulating data and behaviour within classes and objects. Encapsulation helps reduce coupling between different application components, leading to more modular and reusable code. Encapsulating data and behaviour can protect the application from unintended changes and promote code correctness.

Polymorphism: 

We have employed polymorphism in our implementation to enable code reuse and dynamic behaviour at runtime. Polymorphism can create a common interface for different classes, enabling them to be used interchangeably. This leads to more modular and extensible code, allowing us to add new functionality to the application without modifying existing code.

Inheritance: 

We have used inheritance to create a class hierarchy that shares expected behaviour and attributes. Using inheritance, we can create a more natural and intuitive code structure, making it easier to understand and maintain. Inheritance also enables us to reuse code, reducing the amount of boilerplate code required and promoting code correctness.

Interfaces: 

We have employed interfaces to define a standard contract for classes that implement them. By using interfaces, we can create a common language between different application components, promoting modularity and extensibility. Interfaces also enable us to swap out implementations of components without modifying existing code, leading to more maintainable and scalable code.

Enumerations: 

We have used enumerations to define a set of named constants representing discrete values. By using enumerations, we can create more readable and expressive code, reducing the risk of errors and promoting code correctness. Enumerations also enable us to create a common language between different application components, promoting modularity and extensibility.

Refactoring Design Patterns: 

We have employed refactoring design patterns to improve the quality and maintainability of our code. By using refactoring patterns, we can identify and remove code smells and promote code correctness. Refactoring patterns enable us to create more modular and reusable code, leading to more efficient and practical applications.

Overall, the advanced programming techniques used in this project enable us to create an efficient, maintainable, and testable student information system. We can create a more modular, reusable, and extensible codebase by using ORMs, encapsulation, polymorphism, inheritance, interfaces, enumerations, and refactoring design patterns. These techniques also promote code correctness and reduce the risk of errors, leading to a more efficient and practical application.

2: Implementation and Evolution of Solution

This section will discuss the development and evolution of our student information system solution, including the design patterns and refactoring techniques used to improve the code's quality and maintainability.

Initially, we analysed the requirements and designed the system's architecture. We identified the different components required for the application and how they would interact with each other. We also identified the data structures needed to store and manipulate data within the application. We then proceeded to implement the different functionalities of the system, ensuring that each component was well encapsulated and followed the principles of polymorphism and inheritance.

As the implementation progressed, we identified several areas where the code quality could be improved. We used refactoring design patterns to improve the quality of the code by eliminating code smells and promoting code correctness. For example, our application used the Template Method pattern to create a template for the different CRUD (Create, Read, Update, Delete) operations. We also used the Singleton pattern to ensure that only one database instance was created and used throughout the application.

As we continued to refine the code, we also identified areas where the original design required modification. For example, we added functionality to allow students to enrol in courses and departments to view a list of enrolled students. We also added a feature to allow students to view their progress in different modules.

Throughout the implementation, we used version control to manage changes to the codebase and ensure that we could revert to earlier versions if needed. We also used a continuous integration and continuous deployment (CI/CD) pipeline to automate testing and deployment.

In summary, the implementation and evolution of our solution involved a thorough analysis of the requirements and a well-thought-out design of the system's architecture. We used advanced programming techniques such as encapsulation, polymorphism, inheritance, interfaces, enumerations, and refactoring design patterns to develop a modular, reusable, and extensible codebase. We also identified areas where the original design needed modification and made use of version control and CI/CD pipelines to manage changes to the codebase and automate testing and deployment.

3: Testing Methodology

This section will discuss the testing methodology used to verify that our student information system meets the requirements and functions as intended. We will also provide an overview of the test cases developed and the challenges faced during testing.

We employed a combination of manual and automated testing methodologies to ensure that our application met the requirements and was error-free. We used unit testing extensively to test individual components of the application and integration testing to test the interaction between different components. We also used acceptance testing to verify that the application met the requirements and user acceptance testing to get end-user feedback.

We used a test-driven development (TDD) approach for unit testing to ensure that each application component was thoroughly tested before moving on to the next component. We wrote unit tests for each method and function, ensuring each test case covered different scenarios and edge cases. We also used mocking frameworks to mock external dependencies and isolate the component under test.

For integration testing, we used a combination of automated and manual testing to test the interaction between different application components. We used automated tests to test the integration between the application and the database and manual tests to test the integration between the application and the user interface.

For acceptance testing, we used a combination of manual and automated testing to verify that the application met the requirements. We used test cases to verify that the application met each requirement and manual testing to ensure the user interface was intuitive and easy to use.

During testing, we faced several challenges, including identifying edge cases and ensuring that the application was scalable and maintainable. We also encountered issues with database performance and identified areas where the code quality could be improved. To overcome these challenges, we used profiling tools to identify performance bottlenecks and refactoring techniques to improve the quality of the code.

In summary, the testing methodology used in this project involved a combination of manual and automated testing techniques to verify that the application met the requirements and functioned as intended. We used unit, integration, acceptance, and user acceptance testing to ensure the application was thoroughly tested. We also encountered several challenges during testing, including identifying edge cases and ensuring the application was scalable and maintainable. We overcame these challenges by using profiling tools and refactoring techniques to improve the quality of the code.

4: Results and Conclusion

In this section, we will summarise the key results of our testing and evaluate the overall success of our student information system implementation in meeting the requirements.

This SWE5201 – Engineering has been solved by our PHD Experts at My Uni Paper.