Kaung Khant Lin (MSA)-FDSE0624

Design Report for Tournament Scoring System

1. Introduction
This report outlines the design of a software solution for managing the
scoring system of a college tournament. The tournament will feature both
individual and team events, with participants competing for points based on
their performance. The design will include algorithms, flowcharts, data
structures, and a test plan.

2. Software Development Life Cycle (SDLC) Stages

The software development life cycle consists of several stages, each
critical to the successful development of the scoring system. Below is an
overview of the stages relevant to this project:

2.1Requirements Gathering:
 Identify and document the needs of the college, including
participant management, event types, and scoring systems.
 Conduct meetings with stakeholders to finalize requirements.

2.2Desgin
 Create algorithms and flowcharts to outline the program's
functionality.
 Define data structures and storage requirements.
 Develop a design specification document.
 Kaung Khant Lin (MSA)-FDSE0624

2.3Implementation:
 Write the code based on the design specifications.
 Integrate any pre-defined code or libraries as needed.

2.4Testing:
 Develop a test plan to ensure all functionalities work as
intended.
 Conduct unit testing, integration testing, and user acceptance
testing.

2.5Deployment:
 Deploy the application for use in the tournament.
 Provide training and support to users.

2.6Maintenance:
 Address any issues that arise post-deployment.
 Implement updates based on user feedback.

___________________________________________________________________
___________________________________________________________________
 Kaung Khant Lin (MSA)-FDSE0624
3. Scoring System Requirements
 Participants:
 Maximum of 4 teams (5 members each) and 20 individual
competitors.
 Allow participants to enter for one event only or multiple events.

 Events:
 Each participant (individual or team) will compete in 5 events.
 Events can be categorized as team or individual events.

 Scoring:
 Points will be awarded based on rank in each event.
 The college is open to suggestions for the point distribution
system.

4. System Design

4.1 Tasks the Program Needs to Fulfill

 Register participants (individuals and teams).

 Manage event entries and classifications.

 Calculate and store scores based on performance.

 Display results and rankings after each event.

 Kaung Khant Lin (MSA)-FDSE0624

4.2 Algorithms

1. Participant Registration Algorithm:

 Input participant details (name, type: individual/team).

 Validate input and check for available slots.

 Store participant information in a data structure.

2. Event Scoring Algorithm:

 For each event, input participant results.

 Rank participants based on performance.

 Assign points based on rank and update scores.

 Kaung Khant Lin (MSA)-FDSE0624
4.3 Data Structures

Participant {
ID: Integer,
Name: String,
Type: String (Individual/Team),
Events: List of Event IDs,
TotalPoints: Integer
}

Event Structure:
Event {
ID: Integer,
Name: String,
Type: String (Individual/Team),
Results: List of Participant IDs
}
 Kaung Khant Lin (MSA)-FDSE0624
4.4 Data Storage

 Use a relational database (e.g., MySQL) to store participant and

event data.

 Tables:

 Participants (ID, Name, Type, TotalPoints)

 Events (ID, Name, Type)

 Results (EventID, ParticipantID, Rank)

5.Design Options Analysia

Programming Languages:

 Python: Easy to learn, great for rapid development, but may not be
as performant for large datasets.

 Java: Strongly typed, good for larger applications, but has a steeper
learning curve.

 JavaScript: Ideal for web-based applications, but may require

additional frameworks for backend functionality.
 Kaung Khant Lin (MSA)-FDSE0624
Pre-defined Code and Assets:
 Consider using libraries for database management (e.g.,
SQLAlchemy for Python).

 Utilize frameworks for web development (e.g., Flask or Django for

Python).

6.Review Discussions
Discussion Points:

 Confirmed the need for both individual and team event management.

 Agreed on a flexible scoring system that can be adjusted based on

event type.

 Discussed the importance of user-friendly interfaces for participant

registration and results display.

Decisions Made:
 Use Python for development due to its simplicity and community
support.

 Implement a relational database for data storage.

 Kaung Khant Lin (MSA)-FDSE0624
7. Test Plan
Test Objectives:
 Ensure all functionalities work as intended.

 Validate scoring calculations and participant registrations.

Test Cases:
1.Participant Registration:
 Test registration for individuals and teams.

 Validate input for duplicate entries.

2. Event Scoring:
 Input results for various events and verify that scores are calculated
correctly.

 Check ranking assignments based on performance.

3.Data Storage:
 Ensure data is correctly stored in the database.

 Test retrieval of participant and event data.

 Kaung Khant Lin (MSA)-FDSE0624
4.User Interface:
 Validate that the registration interface is user-friendly.

 Ensure results display correctly after events.

Test Data:
 Sample participant names and types (individual/team).
 Event names and types.
 Mock results for scoring tests.

8.Conclusion
This design report outlines a comprehensive approach to developing
a scoring system for the college tournament. By following the software
development life cycle stages, addressing the requirements, and
implementing a robust design, the application will effectively manage
participant registrations, event scoring, and results display. The next
steps involve coding the application based on this design and executing
the test plan to ensure functionality and reliability.
The flowchart below illustrates the main processes involved in the
tournament scoring system:
 Kaung Khant Lin (MSA)-FDSE0624
9.Flowchart

Explanation of Flowchart Steps

1. Start: The beginning of the application where the system initializes.
2. Register Participants:
 Participants (individuals and teams) are registered for the
tournament.
 The system checks for the maximum limits (20 individuals and 4
teams of 5 members each).
 Kaung Khant Lin (MSA)-FDSE0624
3. Input Event Results:
 After each event, results are inputted into the system.
 This includes the performance metrics for each participant/team.

4. Rank Participants:
 The system ranks participants based on their performance in the
event.
 This step involves sorting the results to determine the order of
finish.

5. Assign Points:
 Points are assigned based on the ranks achieved in the event.
 A predefined points system is applied (e.g., 1st place = 5 points,
2nd = 3 points, 3rd = 1 point).

6. Update Scores:
 The total scores for each participant/team are updated based on
the points assigned from the events.

7. Generate Reports:
 The system generates reports summarizing the scores and
rankings of all participants.
 This can include individual event results and overall tournament
standings.

8. Display Results:
 The final scores and rankings are displayed to the participants
and organizers.
 This can be done through a user interface or printed reports.

9. End: The application concludes its operations, ready for the next event
or tournament.

Next Steps
 Kaung Khant Lin (MSA)-FDSE0624
With the flowchart and design specifications in place, the next steps in the
development process include:

1. Coding the Application:

 Implement the design using the chosen programming language.
 Ensure that all functionalities outlined in the flowchart are coded
accurately.

2. Testing the Application:

 Execute the test plan to verify that the application functions as
intended.
 Conduct unit tests, integration tests, and user acceptance tests to
ensure reliability and performance.

3. Deployment:
 Deploy the application for use during the tournament.
 Provide training or documentation for users if necessary.

4. Feedback and Iteration:

 Gather feedback from users after the tournament.
 Make necessary adjustments and improvements based on user
experiences.

By following these steps, the scoring system will be effectively developed and
implemented, ensuring a smooth and efficient tournament experience for all
participants. ### Implementation Plan

The implementation plan outlines the steps necessary to bring the tournament
scoring system from design to a fully functional application.

1. Environment Setup

 Development Environment: Set up the development environment with

the chosen programming language and necessary libraries.
 Version Control: Initialize a Git repository to manage code changes
and collaborate with team members.
 Kaung Khant Lin (MSA)-FDSE0624
2. Coding the Application

 Participant Registration Module:

 Create functions to handle participant registration, including
validation of input data.
 Implement data structures to store participant information.

 Event Management Module:

 Develop functionality to create and manage events, including
defining event types and recording results.

 Scoring Module:
 Implement the scoring algorithm to calculate points based on
ranks.
 Ensure that the scoring system is flexible to accommodate
changes in point allocation.

 Reporting Module:
 Create functions to generate reports of scores and rankings.
 Design the output format for easy readability.

3. User Interface Development

 UI Design:
 Design a user-friendly interface for participants and organizers to
interact with the system.
 Ensure that the UI allows for easy navigation and access to all
functionalities.

 Input Forms:
 Develop forms for participant registration and event result input.
 Implement validation checks to ensure data integrity.

4. Testing

 Unit Testing:
 Kaung Khant Lin (MSA)-FDSE0624
 Write unit tests for each module to verify that individual
components function correctly.

 Integration Testing:
 Test the interaction between different modules to ensure they
work together seamlessly.

 User Acceptance Testing:

 Conduct testing with actual users to gather feedback on usability
and functionality.

5. Deployment

 Deployment Strategy:
 Plan for deployment on a suitable platform, whether it be a local
server or cloud-based solution.
 User Training:
 Provide training sessions or documentation for users to familiarize
them with the system.

6. Post-Deployment Support

 Feedback Collection:
 After the tournament, collect feedback from users regarding their
experience with the system.
 Maintenance and Updates:
 Address any issues or bugs reported by users and implement
updates as necessary.
 Future Enhancements:
 Consider additional features or improvements based on user
feedback for future tournaments.

Conclusion
The implementation plan provides a structured approach to developing the
tournament scoring system. By following these steps, the application will be
built efficiently, ensuring that it meets the needs of the college and provides a
 Kaung Khant Lin (MSA)-FDSE0624
smooth experience for all participants. The focus on testing and user feedback
will help refine the system and enhance its functionality for future events.
Bookmark messageCopy message

10.Pseudo-Code

10.Implementation Plan
1.Set Up Development Environment:
 Install necessary software (Python, database management system).
 Kaung Khant Lin (MSA)-FDSE0624
 Set up version control (e.g., Git).

2.Database Design:
 Create database schema based on data structures defined.

 Implement tables for participants, events, and results.

3.Code Development:
 Develop functions for participant registration, event entry, scoring,
and results display.

 Ensure modular coding practices for maintainability.

4.User Interface Development:

 Create a simple user interface for participant registration and results
display.

 Ensure the interface is intuitive and accessible.

5.Testing:
 Kaung Khant Lin (MSA)-FDSE0624
 Execute the test plan developed earlier.

 Document any issues and resolve them before deployment.

12.Future Enhancements
 Mobile Application: Develop a mobile version of the application for
easier access during events.

 Real-time Scoring Updates: Implement a feature for real-time

updates of scores during events.

 Advanced Analytics: Provide analytics on participant performance

over time to help improve future tournaments.

13.References
 Software Development Life Cycle (SDLC) methodologies.

 Best practices in algorithm design and data structure implementation.

 User interface design principles for software applications.