Table of Contents

I. Introduction .................................................................................................................. 2
II. Design and Development ........................................................................................... 3
2.1 View_tracks.py:..................................................................................................... 3
2.2 Create_Track_List: ............................................................................................... 4
2.3Update_Tracks:...................................................................................................... 4
III. Testing and Faults ..................................................................................................... 5
IV. Conclusions, Further Development, and Reflection ................................................ 7

Figure 1: View_tracks.py ................................................................................................ 3

Figure 2: create_track_list.py ......................................................................................... 4
Figure 3: update_track.py .............................................................................................. 5
Figure 4: Test table track_library.py .............................................................................. 5
Figure 5: Test table Library_item.py............................................................................... 6
Figure 6: Test table create_track_list.py ........................................................................ 6
Figure 7: Test table update_track.py ............................................................................ 7

I. Introduction

Object-oriented programming (OOP) has become a key paradigm in modern

software development, effectively modeling real-world entities and relationships. This
coursework allowed me to apply OOP principles by simulating a jukebox application,
addressing challenges like UI design, efficient data handling, and robust error
management.

The goal was to develop a jukebox simulation that highlights core OOP concepts
such as abstraction, encapsulation, inheritance, and polymorphism, which are vital
for scalable software systems (Booch, 2005). The project included functionalities like
viewing track details, adding tracks to a playlist, and updating ratings, reflecting
common multimedia application features (Fowler, 2004). Additionally, it introduced
unit testing and validation to enhance software reliability.
Through this coursework, I gained technical skills and a deeper understanding of the
software development lifecycle, particularly the iterative processes of design,
implementation, and testing.
II. Design and Development
Using the Tkinter library in Python, the program's simple graphical user interface
(GUI) was created to closely mimic a music player application. This interface
facilitates user interaction with the application, including handling the process of
creating a music library, playing playlists and updating tracks, switching between
different user profiles, and performing playlist playback functions. The basic code is
mainly built on the view_tracks.py file, which serves as the core component, although
it has undergone specific modifications and improvements to meet the program's
requirements. Below is a series of screenshots taken at different stages of the
development process, showcasing both the interface design and the functionality of the
application.

2.1 View_tracks.py:
This Python script creates a graphical user interface (GUI) for viewing detailed information
about tracks using the Tkinter library. The GUI window, complete with buttons that allow the
user to list all tracks and check some detailed information about the track, is instantiated by
the view_tracks.py class. The script retrieves the track name, artist, director, and playing time
of the track from the track library module when the "View track" button is pressed. If the
track is located, the relevant components are loaded and displayed, and the track details are
given in a text box. An error message is thrown if the track cannot be located. A list of all
tracks in the collection is provided by the "List all tracks" button.

Figure 1: View_tracks.py
2.2 Create_Track_List:
The Tkinter library is used in the "Create track list" script to provide a graphical
user interface (GUI) for creating a track list. The GUI window, which has buttons to list
all tracks, add tracks to the playlist, play the playlist, and reset the playlist, is
instantiated by the "Createtracklist" class. To ensure seamless interaction, each button is
associated with specific functions defined in the script using the "def" keyword. By
entering a track number into the input field and clicking the "Add Music" button, the
user can add a track to their playlist. When necessary, this method displays "Music
'{key}' not found! Please enter another ID" to improve user feedback by using an "if"
statement to validate the input track. Additional tracks are displayed in a separate
scrollable text box. The tracks in the playlist are viewed by clicking the "Play Playlist"
button, which also increases the play count for each track. On the other hand, the "Reset
Playlist" button, managed by the update_text_playlist function, uses a "for" loop to
iterate over the list to update the playlist contents.

Figure 2: create_track_list.py

2.3Update_Tracks:
The Tkinter library is used to provide the intuitive graphical user interface
(GUI) in the "Update Track" interface. The task of initializing the GUI window and
assembling the necessary parts belongs to the `Updatetrack` class. When updating a
track, the user is asked to enter the updated rating and the track index number into
the relevant input fields. The application will attempt to update the rating for the
selected track when the "Update Track" button is pressed, displaying an error
message if the track index or rating is incorrect, or a success message if not. The
"Update Track" button has a built-in "try-but-except" system to gracefully handle
possible errors, so that both the track number and rating can be updated.
Additionally, "if" statements are used to verify the entered track name and rating,
outputting appropriate error messages in case either is determined to be incorrect. A
confirmation dialog will appear and provide the user with the revised track name
and rating if the rating and track name are accepted.
 Figure 3: update_track.py

III. Testing and Faults

We fixed bugs in the {library_item.py} file during the testing phase, focusing on
improving function declarations and strengthening error handling. By ensuring correct
function definitions through the proper use of the "def" keyword, the functionality of
the {library_item} module was improved. Furthermore, adding "try-except" and
@property methods improved error handling and successfully handled potential
problems. To verify these changes, a comprehensive test bench was created to address
a number of contingencies, including incorrect track names, artist information, and
ratings. Each test carefully evaluated how the system responded, ensuring that
appropriate error messages were displayed when incorrect input was entered.
Successful implementation of these evaluations validated the effectiveness of our
modifications, significantly improving the reliability of the library_item.py file and
strengthening the overall resilience of the system. The test table for this section is as
follows:

Test_track_library.py

Figure 4: Test table track_library.py

 Although the faults found in the `library_item.py` file have been fixed, there are still
problems in other software system components that make testing difficult and may
affect user experience. The danger of operational disruptions and customer discontent
escalates in the absence of a thorough strategy for system error testing. However, I've
included a table for testing mistakes in the system's constituent parts:

library_item.py

Figure 5: Test table Library_item.py

create_track_list.py

Figure 6: Test table create_track_list.py

Test Table: update_track.py

Figure 7: Test table update_track.py

IV. Conclusions, Further Development, and Reflection

Completing the jukebox simulation project has deepened my understanding of
object-oriented programming (OOP) and its practical applications in software
development. This coursework was not just an academic exercise; it involved
designing, implementing, and validating software systems, encapsulating key OOP
principles such as abstraction, encapsulation, inheritance, and polymorphism, which
are essential for robust software design (Booch, 2005).
The project emphasized creating modular, reusable code, with specific modules like
track_library.py for data handling and separate GUI components for user interaction.
This separation of concerns, as highlighted by Gamma et al. (1994), allowed for easier
maintenance and extension of the system.

Additionally, the coursework reinforced the importance of rigorous testing and

validation in ensuring reliability and user satisfaction. Implementing input validation
and designing unit tests revealed how errors can propagate if not carefully addressed,
aligning with Fowler's (2004) view that software validation involves both preventing
and detecting errors.
The iterative development process highlighted the value of feedback and continuous
improvement, leading to a functional and user-friendly application. Ultimately, this
coursework provided a solid introduction to OOP principles and practices, equipping
me with valuable skills and insights that will benefit my future endeavors in software
 1. What I did well in this assignment
In this assignment, I achieved several notable successes, including:

• Developing the jukebox application: I designed and built a jukebox simulation

application with all the basic functionalities. The application allows users to create
playlists, update song information, and play music. The user interface is designed
to be intuitive and easy to use, enabling users to interact seamlessly with the
application's features.
• Testing and evaluation: I conducted a series of tests to ensure that the application
functions as expected. Clear test cases were established, detailing input, actions,
and expected outcomes. This not only helped me identify errors but also improved
the overall quality of the application's code.

• Code documentation: I provided detailed comments throughout the code, making

it easier for readers to understand the purpose of each section. This not only
supports my own future maintenance of the code but also facilitates other
developers who may review the code in the future.

• Adhering to a development process: I followed an organized software

development process, from design and development to testing. This approach
helped me manage the project more effectively and minimize risks during
development.

2. Areas for improvement in this assignment?

Although I achieved many successes, there are still some areas where I could
improve:
• Code optimization: Some parts of the code could be optimized to enhance
performance. For instance, I noticed that certain functions could be rewritten more
concisely or could utilize more efficient data structures, which would help reduce
execution time and save resources.

• Expanding functionality: I could develop additional engaging features, such as a

search function for songs by title or artist, or allowing users to create and save
personal playlists. These features would make the application more appealing and
convenient for users.

• Improving the user interface: While the interface worked well, I realized that I
could enhance the user experience by creating a more visually appealing layout
with better icons, colors, and a friendlier design. This would not only improve
aesthetics but also help users more easily locate and use the application's
functions.
• Error management and notifications: One area for improvement is handling
errors and notifying users. Instead of just displaying simple error messages, I
could provide more detailed information so users understand the causes and how
to resolve issues.
 3. What I can carry forward to my next assignments?

From this assignment, I have learned valuable lessons that I will apply to future
tasks:
• Enhanced programming skills: I have improved my Python programming skills,
particularly in using GUI libraries and code management. I feel more confident
working with new technologies and will continue to develop these skills in
upcoming projects.

• Effective time management: I learned how to plan and manage my time better
while working on a large project. Breaking the work into clear stages helped me
complete tasks on time and reduce stress.
• Testing and feedback collection: I realized the importance of thorough testing
and gathering user feedback. In future projects, I will place greater emphasis on
establishing a testing process and obtaining feedback to enhance product quality.

• Critical thinking and problem-solving: The development process has helped me

refine my critical thinking and problem-solving skills. I learned to analyze errors
and seek effective solutions, which will be very beneficial for any future projects.

Reference:
Booch, G. (2005). Object-Oriented Analysis and Design with Applications.
Addison-Wesley. Available at: https://dl.acm.org/doi/abs/10.1145/1402521.1413138

Fowler, M. (2004). UML Distilled: A Brief Guide to the Standard Object Modeling
Language. Addison-Wesley. Available at:
https://books.google.com.vn/books?hl=vi&lr=&id=VTdtDwAAQBAJ&oi=fnd&pg=PR2
1&dq=UML+Distilled:+A+Brief+Guide+to+the+Standard+Object+Modeling+Languag
e.+Addison-
Wesley&ots=HIfVo1BMcc&sig=UKTie_IcrW9P9kgYMqFgXbDnNho&redir_esc=y#v=
onepage&q=UML%20Distilled%3A%20A%20Brief%20Guide%20to%20the%20Stan
dard%20Object%20Modeling%20Language.%20Addison-Wesley&f=false

Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design Patterns:
Elements of Reusable Object-Oriented Software. Addison-Wesley. Available at:
https://www.google.com.vn/books/edition/Design_Patterns/6oHuKQe3TjQC?hl=vi&g
bpv=1
 Booch, G. (2005). Object-Oriented Analysis and Design with Applications.
Addison-Wesley. Available at:
https://books.google.com.vn/books?id=8Rg5wxGj818C&newbks=0&printsec=frontco
ver&dq=Object-
Oriented+Analysis+and+Design+with+Applications+2005&hl=vi&source=newbks_fb
&redir_esc=y#v=onepage&q=Object-
Oriented%20Analysis%20and%20Design%20with%20Applications%202005&f=false

Fowler, M. (2004). UML Distilled: A Brief Guide to the Standard Object Modeling
Language. Addison-Wesley. Available at:
https://books.google.com.vn/books?hl=vi&lr=&id=VTdtDwAAQBAJ&oi=fnd&pg=PR2
1&dq=UML+Distilled:+A+Brief+Guide+to+the+Standard+Object+Modeling+Languag
e.+Addison-
Wesley&ots=HIfVo1BPad&sig=WvwubTUw0eE6xXI1F13tvHsss54&redir_esc=y#v=o
nepage&q=UML%20Distilled%3A%20A%20Brief%20Guide%20to%20the%20Stand
ard%20Object%20Modeling%20Language.%20Addison-Wesley&f=false

Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Using Design Patterns:
Elements of Reusable Object-Oriented Software. Addison-Wesley. Available at:
https://dl.acm.org/doi/pdf/10.1145/226239.226255