REFLECTIVE REPORT

Z02DT – SOFTWARE AND

DATABASES

Student Id:
Student Name:

Uncontrolled if printed
TABLE OF CONTENTS

No table of contents entries found.

[Student Number] Page 1 15/07/2024

LIST OF ILLUSTRATIONS

No table of figures entries found.

LIST OF TABLES

No table of tables entries found.

[Student Number] Page 2 15/07/2024

INTRODUCTION (150 WORDS+-)

 Background (Scope of your project)

 Specify report aims and outline

The goal of the School Management System project was to improve and simplify the
administrative procedures in educational facilities. It includes features like grade reporting,
attendance tracking, course management, and student registration. The goal of this report is
to present a thorough analysis of the project's journey, including everything from database
architecture and object-oriented programming (OOP) principles to software development
practices. As a thorough case study of modern software development techniques, it will also
addresses ethical issues in software design and data storage, reflecting on decisions made,
their efficacy, and possible future improvement areas.

FINDINGS AND ANALYSIS

SOFTWARE DEVELOPMENT LIFECYCLE (SDLC) (150 WORDS+-)

 Briefly describe SDLC and its phases.

 Reflection on the different SDLC phases and tasks you have completed within your
project.
 What is the best SDLC fit for your project (Traditional or Agile) and why (justify your
answer with proper evidence from credible academic resources).
 Reflect on the effectiveness of your choices, why you made this choice and not the
others, what would have happened if you had chosen other options, and what
would you change next time?
 Refer to any additional appendices if needed such as a project Plan!

A methodical and effective approach to producing software applications is the Software Development
Life Cycle (SDLC). Requirement analysis, design, implementation, testing, deployment, and
maintenance are some of its discrete phases. Looking back on the project, the identification of the
requirements for a school management system and the creation of an Entity-Relationship Diagram
(ERD) occurred at the critical early stages of Requirement Analysis and Design. Writing Python code
for database integration and CRUD operations was part of the implementation. Testing would
guarantee dependability and functionality.

This project was best suited for an agile methodology. When I was creating this complicated system
for a school management application, its iterative approach made it possible to adapt flexible to
changing requirements. Agile methodology made it easier to adapt and improve continuously, which
is essential considering how I had to change and or add different aspect into the code every few
minutes. I chose agile method over Waterfall method because it was more flexible and required client
input which is what would be needed in a school database system.

REQUIREMENT ELICITATION AND ENGINEERING (150 WORDS+-)

[Student Number] Page 3 15/07/2024

  Briefly describe what requirement elicitation and engineering are and reflect on the
techniques you have used, how effective it is and why.
 Briefly describe FURPS and MoSCoW, its importance and evaluate its use within your
project.
 Describe how you derived and prioritised your development tasks using the
requirements solicitation and analysis process.
 Refer to appendix 1 (REQUIREMENT CATALOGUE USING FURPS & MOSCOW)

The gathering of requirements and engineering were essential to determining and specifying
the system needed in my School Management System project. To obtain thorough
requirements, I used observational research, surveys, and interviews. These methods
worked effectively for creating a balance between quantitative data and qualitative insights,
guaranteeing a comprehensive grasp of the various needs of users.

I prioritised and categorised requirements using the FURPS (Functionality, Usability,

Reliability, Performance, Supportability) and MoSCoW (Must have, Should have, Could have,
Won't have) approaches. While MoSCoW directed the prioritisation and focused
development on crucial functionality like student record management before moving on to
additional features, FURPS assisted in logically arranging needs.

The 'Must have' requirements were used to determine the development tasks and their
priority, resulting in a staged and systematic approach to development.

OBJECT ORIENTED PROGRAMMING (OOP) PRINCIPLES (200 WORDS+-)

 Briefly describe what is OOP and evaluate its use within your project.
 Discuss OOP Principles (such as Encapsulation, Inheritance, etc) and reflect on its
usage within your project with proper justification, refer to appendix 2 as it should
include screenshots from your Python code as an evidence of applying OOP.
 Reflect on the effectiveness of your choices: why you made this choice and not the
others and what would have happened if you had chosen other options.
 What would you change next time?

The programming model known as object-oriented programming, or OOP, organises software around
objects and their interactions as opposed to functions and logic. Since it makes it possible to break
large systems up into smaller, more manageable components, this method is very helpful for
managing complex systems. OOP played a key role in organising and arranging the wide range of
features needed for effective administrative management in my School Management System project.
The system mimicked real-world entities by encapsulating data and methods under classes like
"Student," "Teacher," and "Course," improving both clarity and maintainability.

Encapsulation, inheritance, and polymorphism—three OOP principles—were carefully implemented

during the School Management System's development. i was able to reduce dependencies and
increase data integrity by grouping data and functions into discrete units through encapsulation. In
my 'Student' class, for example, encapsulation allowed for regulated access through public methods
while maintaining the security of the students' personal information. As demonstrated by the 'Person'

[Student Number] Page 4 15/07/2024

class, which functioned as the foundation for the 'Student' and 'Teacher' classes, inheritance was used
to create a hierarchical relationship between classes. This lowered the amount of redundant code
while simultaneously improving the system's scalability and evolution. My system's flexibility was
increased by polymorphism, which allowed me to use the same interface for several underlying data
types. This was demonstrated with methods that, although common to several classes, could carry
out specific tasks based on the class instance.

Upon reflection, it is evident that the most of OOP played a crucial role in managing the complexity of
the system. Given the interrelated nature of the system's features, the procedural programming
approach—the alternative—might have presented scalability and code management issues. In
subsequent iterations, investigating more complex OOP elements like design patterns can improve
the system's resilience and further simplify the development process. This would enable an even
more structured approach, improving the application's simplicity and usability and bringing it closer to
the atmosphere of a classroom setting.

PROGRAMMING CONSTRUCTS (150 WORDS+-)

 Briefly describe the main programming constructs in Python and evaluate its use
within your project such as Conditional Statements, Iterations, etc.
 Refer to appendix 3 as it should include screenshots from your Python code as
evidence of utilizing different programming constructs.
 Discuss any one piece of your code that you are proud of, and the challenges you
faced developing it.

The basic Python programming elements, like conditional statements and iterations, were
essential to the efficacy and functionality of my School Management System's development.
These features worked particularly well for implementing sophisticated reasoning in a
comprehensible way because of Python's simplicity and readability. To control the
application's flow depending on specific requirements, I used conditional statements such as
if, elif, and else. In user authentication, where user credentials were checked to provide the
right access, this was very clear. While processing student records or going through course
lists, for example, iterations—specifically, for and while loops—were essential.

One notable feature of the project was how I implemented the grading system, which is
shown in Appendix 3. It processed and categorised student grades using a combination of
iterations and conditional expressions. Still, the dynamic report creation section is the most
notable part of the code. Developing a flexible system that can provide customisable reports
with different formats and data types was a major difficulty for this particular part of the
project. A sophisticated grasp of Python's data processing and inventive use of its
programming constructs were needed to solve the problem. The development of this
feature, with its complex logic and requirement for thorough testing, improved the
operation of the system and offered an invaluable opportunity to learn about advanced
programming and problem-solving techniques.

[Student Number] Page 5 15/07/2024

DATABASE DESIGN

DATABASE DESIGN (ERD AND NORMALISATION) (200 WORDS+-)

 Evaluate the use of SQLite as your chosen RDBMS. Reflect on the effectiveness of
that choice: why this option not the others, and what would you change next time.
 Briefly describe ERD and its usage/importance, and reflect/evaluate how
useful/effective it is within your project.
 Describe how you designed your database following the database design principles.
 Reflect on your proposed ERD for your assignment including the reasons behind the
choice of the datatypes and any database constraints applied and any assumptions,
refer to appendix 4 (ERDs).
 Briefly describe Database Normalisation, its importance, and evaluate its effective
usage within your project.
 Reflect on how you applied Normalisation within your assignment, showing the
steps you undertook and include details in an additional appendix if needed.

Due to its ease of use and effectiveness, SQLite was my choice for the Relational Database
Management System (RDBMS) when I was building my school management system. This choice had a
big impact on how my project was designed and carried out. Given the complexity and scope of
myproject, SQLite's lightweight and self-contained architecture was a perfect fit. The product
provided minimal configuration and convenience of setup, which was essential considering the
limited resources of our project. Although SQLite satisfied our data management needs, I
acknowledge that PostgreSQL, a more powerful solution, would be a better choice for larger projects
with more extensive data handling requirements. In the future, I would pick an RDBMS based on the
size and complexity of the project.

Entity-Relationship Diagrams (ERDs) played a key role in our project. My database structure was
clearly represented visually using ERDs, which made it easier to grasp the links between the data.
This visualisation was really helpful in making sure that the database schema was logical and efficient.
I followed fundamental database design guidelines that prioritised data integrity and normalisation.
This method improved the database's scalability and maintainability while also streamlining data
management. In order to enhance data integrity, reduce redundancy, and guarantee logical data
organisation, I used normalisation up to the third normal form. After giving this approach some
thought, I saw how crucial careful planning is to the database design process, particularly when it
comes to defining datatypes and putting constraints in place to protect relationships and data
integrity.

DATABASE DESIGN (SQL) (100 WORDS+-)

 Evaluate SQL usage within your project (refer to appendix 5 which should include
samples of DDL/DML SQL Statements).

[Student Number] Page 6 15/07/2024

  You can also create an additional appendix to include screenshots of your table
structures within the database (to show columns or data within your database
tables).

For database interface in my School Management System project, SQL was essential. I've
demonstrated how to create tables, insert data, and query data using DDL and DML instructions in
Appendix 5. This was essential for effectively handling complicated queries and facilitating Python
integration. My well-organized database is graphically represented in an additional appendix, which
also shows how successfully SQL was used to organise and manage the system's data.

TESTING (150 WORDS+=)

 Briefly describe software testing.

 Describe the types of testing have you conducted for your project and why?
 Reflect on the effectiveness of that choice: why you made that choice and not the
others, what would have happened if you had chosen other options, and what
would change next time.
 Include your test logs in appendix 6 and refer to these appropriately within your
reflection on testing.

One of the most important stages of software development is software testing, which is
assessing a system or individual parts to see if they satisfy the requirements. I used unit,
integration, and user acceptability testing, among other testing methodologies, in my School
Management System project. While integration testing made sure that these parts
functioned as a cohesive one, unit testing enabled me to test each component separately for
accuracy. User acceptance testing was crucial since it confirmed the system's usability and
functionality by gathering input from real users. Considering the efficacy of this strategy, I
think the project's performance was greatly influenced by my decision to concentrate on
certain testing kinds. I might have learned more about the system's performance under high
load circumstances, though, if I had done more thorough stress testing. In order to
guarantee even more durable and dependable software, I intend to include a wider variety
of testing—including stress testing—into future projects. Appendix 6 has some test logs that
show the results of these testing procedures.

CONSIDERATION OF THE ETHICAL ISSUES IN SOFTWARE DESIGN AND DATA

STORAGE (100 WORDS+-)

 Discuss and evaluate your consideration of the ethical issues in software design and data
storage such as GDPR.

I looked into ethical concerns when creating my school management system, especially those related
to data storage and GDPR compliance. This required guaranteeing user data privacy and putting in

[Student Number] Page 7 15/07/2024

place strict data protection procedures. Acknowledging these moral guidelines was not only
compliant with the law but also increased confidence in the dependability and integrity of the system.

CONCLUSION AND AREAS OF FURTHER IMPROVEMENT (150 WORDS+-)

 Summarise the main points and include a critical analysis on how you would do this
project differently in the future.
 Include your overall thoughts about how the project went, what you have learned
during the module and how this might benefit you in the future.
 Describe the state of your database as it is and consider any recommendations that
you might consider where you to continue its development in the future.

As I think back on the School Management System project, I see how crucial it is to
incorporate innovative testing techniques for thorough coverage and select a more reliable
RDBMS for scalability. The project was a worthwhile experience that improved my
knowledge of database architecture and object-oriented programming (OOP) in software
development. Currently, the database effectively meets project requirements but remains
basic. Future improvement could involve adding complex queries and improving efficiency
for handling larger datasets—these being skills that will definitely help me in my future
software development projects.

LIST OF REFERENCES

Use APA 7TH and arrange entries in alphabetical order. Ensure your entries match your in-text
citations.

APPENDIX 1 – REQUIREMENT CATALOGUE USING FURPS & MOSCOW

Functionality: A database table can be created, new student records can be added, records can be
shown, and records can be removed using the code. These features serve as the system's essential
functioning requirements.

Usability: The system's user interface includes functions like enroll_student, remove_student, and
display_records. They have a command-line interface for interaction, although a graphical user
interface would be more user-friendly.

Reliability: The enroll_student function in the code provides some basic error handling, which can be
related to reliability requirements. However, a dependable system would require more thorough
error management.

Performance: The code makes no mention of performance requirements at all. Performance issues in
practice could be resolved by making sure the code functions well and by optimising database
queries.

Supportability: No particular features, like logging or user assistance tools, are included in the code.

[Student Number] Page 8 15/07/2024

Features like adding, reading, and deleting entries, as well as generating tables, may be deemed
"Must have" because they are necessary for the system's fundamental functions.

Should have, Could have, and Won't have: The code does not explicitly reflect these types. Usually,
they would have an impact on the features and functionalities that are given priority for execution.
"Should have" features, for example, could be extra fields or validation checks that are required for a
completely functional system but aren't included in the code.

APPENDIX 2 - PYTHON CODE SAMPLES SCREENSHOTS OF OOP

Class Definition: class is defined, which

encapsulates all the functionality
related to managing school records.

Constructor: The __init__() method is

used to connect to the SQLite database
and initialise the class properties.

Encapsulation: This helps in organizing

and managing the codebase effectively
for example ‘create_table’.

Methods: 'remove_student' and other

class methods are defined to carry out
specific tasks relating to the school
management system. This complies to
the encapsulation principle and
enables code reuse.

Object Instantiation: To represent a particular

school management system, an instance of
the SchoolManagementSystem class (sms) is
created. In keeping with the OOP concept of
objects, this instance contains its own data
and behaviour.

[Student Number] Page 9 15/07/2024

APPENDIX 3 - PYTHON CODE SAMPLES SCREENSHOTS OF PROGRAMMING
CONSTRUCTS

Used at the beginning of the code to

import the sqlite3 module.

Defines the ‘SchoolManagementSystem’

class.

Used to initialize the

‘SchoolManagementSystem’ class with a
database name

Conditional Statements (if, elif, else)

used to handle different user choices in
the main menu.

User Input (input function) used to get

user input for menu choices and student
information.

Database Interaction (‘execute’,

‘fetchall’, ‘commit’), executes SQL
queries, fetches records, and commits
changes to the database.

Exception Handling (try, except) used to

catch any errors that may occur during
database operations.

Method Definition: Defines the

‘display_records’ method within the
‘SchoolManagementSystem’ class:

[Student Number] Page 10 15/07/2024

APPENDIX 4 - ENTITY RELATIONSHIP DIAGRAMS (CONCEPTUAL, LOGICAL, AND
PHYSICAL)

Student

Attributes: STUDENT_ID (Primary Key), FIRST_NAME, LAST_NAME, EMAIL, PHONE_NO, GENDER, DOB
(Date of Birth), GUARDIAN_NAME, GUARDIAN_EMAIL, GUARDIAN_PHONE.

Relationships:

Guardian: One-to-many (1:M). A student has one or multiple guardians.

(The following are hypothetical relationships not present in the code but common in school systems)

Teacher: Many-to-many (M:M). A student is taught by many teachers across different courses.

Course: Many-to-many (M:M). A student enrolls in multiple courses.

Attendance: One-to-many (1:M). Multiple attendance records are linked to each student.

Class: Many-to-many (M:M). A student is part of many classes.

Department: Many-to-one (M:1). A student belongs to one department, which has many students.

Guardian (Inferred entity based on student attributes)

Attributes: GUARDIAN_ID (Primary Key), FIRST_NAME, LAST_NAME, EMAIL, PHONE_NO.

[Student Number] Page 11 15/07/2024

Relationships:

Student: Many-to-one (M:1). A guardian can be related to multiple students.

(The following entities are hypothetical and not defined in the provided code but are typical for a
School Management System)

Teacher

Attributes: Teacher ID, Name, Department ID.

Relationships:

Student: Many-to-many (M:M). Teaches multiple students across various courses.

Course: One-to-many (1:M). Teaches multiple courses.

Class: One-to-many (1:M). Teaches or oversees multiple classes.

Department: Many-to-one (M:1). Belongs to one department, which includes many teachers.

Course

Attributes: Course ID, Title, Description, Department ID.

Relationships:

Student: Many-to-many (M:M). Enrolled by multiple students.

Teacher: One-to-many (1:M). Taught by one or a few teachers.

Department: Many-to-one (M:1). Offered by one department, which offers multiple courses.

Attendance

Attributes: Attendance Record ID, Date, Status, Student ID, Course ID.

Relationships:

Student: One-to-many (1:M). Linked to multiple attendance records for each student.

Course: One-to-many (1:M). Each course has attendance records for multiple students.

Class

Attributes: Class ID, Name, Teacher ID, Course ID.

Relationships:

Student: Many-to-many (M:M). Includes many students.

Teacher: One-to-many (1:M). Led by one teacher who may lead multiple classes.

Department

Attributes: Department ID, Name, Head of Department.

[Student Number] Page 12 15/07/2024

Relationships:

Student: One-to-many (1:M). Has many students.

Teacher: Many-to-one (M:1). Includes many teachers.

Course: One-to-many (1:M). Offers multiple courses.

APPENDIX 5 – SAMPLES OF DDL/DML SQL STATEMENTS USED

DDL (Data Definition Language):

Used to create the database table for school

management system.

DML (Data Manipulation Language):

Used to insert student records into the

database.

Used to select records from the database

Used to delete records from the database

APPENDIX 6 – TEST LOGS

To view a student record, the user picks option 2.

The student's first and last names are entered.

When a student is not enrolled, the system notifies them and

requests their enrollment.

After selecting "yes," the user is asked for more information,

including their email address, phone number, gender, date of
birth, and guardian details.

The system verifies that the student has been successfully

added after all the information has been entered.
[Student Number] Page 13 15/07/2024
 The user chooses option 2 to view student records.

They are asked to enter the student's first and last

names.

The system displays the record for the student matching

the names provided.

When attempting to add a student with

a name that matches an existing record,
the system asks if it's a different student
with a similar name.

The user confirms it is a different

student and is prompted to enter the
student's email to show its different
students.

For access to student records, the user chooses option 2.

When a user enters a first and last name that appears in more than one record, the system asks for
more details.

Once the user enters the email, the system shows the record of the particular student that is linked
to the email.

[Student Number] Page 14 15/07/2024

The user selects option 3 to remove a student record.

After entering the student's first and last names that match multiple records, the system asks for
additional information.

The user provides the student's email, and the system confirms the specific student record has
been removed.

In order to delete a student record, the user

chooses option 3.

When a user enters their first and last name,

the system cehcks the database for any
matches and once they found none they inform
them “No student found with this name”.

The user chooses option 2 to view student records.

The system asks if they want to view a single record or all records.

The user either chooses

APPENDIX 7 – 'single'
OUTPUT and enters the student's first and last names or types ‘all’.
SCREENSHOTS

The system
Include then displays the
screenshots record
of your for the
output UIsstudent matching
to show samplesthe names
of how if provided
your program one other(such
operates wise as
it main
displays all the data on the database.
menu and other operations)

[Student Number] Page 15 15/07/2024

 General Notes:

Please delete this section before submission

 IMPORTANT NOTE: These contents are advisory and indicative only

of the items that you may wish to include in your report. They
should not be considered as a checklist for the assessment or the
marking scheme.
 Make sure you use APA in-text citation and referencing, also use
proper academic writing style. It is recommended to use Locate,
Biblu, and Google Scholar to better utilize credible academic
resources.
 Ensure you caption and cite your tables and figures in APA 7th. See the
examples here.
 Report overall words count excluding the table of content, tables,
figures and appendices must be 1500 words +-10%
 The word count allocation per section is only a guidance and can be
changed as you deem appropriate.
 Use Calibri/Ariel/Times New Roman font consistently (size 11/12)
 Do not forget to proofread your report before you submit. You can
use Grammarly.
[Student Number] Page 16 15/07/2024

Useful resources:

 APA Referencing Guide: https://libguides.coventry.ac.uk/cucapa