1

Unit 4: Programming – Programming Development

Student

Institution

Professor

Course

Date
 2

1. Life Cycle Stages of Software Development

The application development for the tournament scoring system will be based on a standard

Software Development Life Cycle (SDLC) model.

a) Planning and Requirements Analysis:

Talk with stakeholders (college and IT department) about their requirements.

Determine features, functionalities, and limitations.

Assess technical and resource feasibility.

Document functional and non-functional requirements.

b) Design:

Specify high-level components and interactions.

User interface (UI) design: Screens and flows for user interaction (prototype).

Model data entities and relationships.

Design algorithms for score recording, ranking, and calculation.

Select suitable programming language, frameworks and tools.

c) Development:

Develop application code from designs and specifications.

Combine different components and test each one separately.

Write test cases for all functions.

d) Testing and Deployment:

Do unit testing, integration testing and system testing.

Improve and refine applications based on test results.

Deploy the application to the selected platform (web or mobile app).

e) Maintenance and Support:

 3

Perform continuous maintenance and support for the application.

Analyze usage and incorporate feedback for future improvements.

2. Assessment of Scoring System Requirements

The critical requirements for the tournament scoring system include:
Participant management: Register people and teams to record chosen events.
Event scheduling: Create a schedule based on the kinds of events and people who can attend.
Scorekeeping: record results and automatically add up the points based on ranking.
Leaderboard: Display individual and team standings in real-time.
Single event entry: Permit participation only in individual events.
Reporting and data export: Create reports and export data for further analysis.
Tie-breaker and penalty systems: Establish rules governing ties and dealing with no-shows.
Security and privacy: Preserve participant data and guarantee user privacy.
3. Design Specification

a) Tasks

Participant registration and event selection.

Event scheduling and management.

Score recording and point calculation.

Maintenance and real-time updates of the leaderboard.

Reporting on individual, team and event performance.

Data export for further analysis.

User authentication and data security.

b) Algorithms:

Point calculation algorithm: According to the points per rank pre-established for each event.

Ranking algorithm: Divide participants/teams based on total points earned.

 4

Tie-breaker algorithm: Resolve ties using rule 1 (head-to-head record) and rule 2 (average

Score).

Scheduling algorithm: Take account of event types, participant availability and resource

considerations.

c) Data Structures:

Participants: Collect participant information (name, team, email address and events).

Events: Store in the store event details (title, type, points per rank, maximum Score).

Results: Store participant performance in each event (rank, points earned).

Reports: Download or analyze store-generated reports.

d) Data Storage:

Stored in a relational database (MySQL, PostgreSQL) for structured data on participants, events

and results. Flexible data storage (reports, logs) in a NoSQL database (MongoDB).

4. Design Options Analysis:

a) Programming Languages:

Python: Both capable and widespread, Libraries are extensive for web development and data

analysis.

Java: Robust, scalable, suitable for large-scale applications.

JavaScript: Suitable for web development, especially front-end apps.

b) Pre-defined Code and Assets:

Review existing libraries and frameworks for UI components, data validation, and security.

For particular functions such as reporting and scheduling, use open-source libraries.

4. Design Review and Feedback:

 5

Find out what needs to be improved in the design through peer reviews and user testing.

Consider feedback to:

Make usability and user interface clarity better.

Enhance system performance and scalability.

Allay any security or privacy concerns.

6. Test Plan:

Develop a comprehensive test plan that includes:

Unit testing of individual program modules.

Integration testing for component interaction.

Testing for overall system function and user experience.

Data to test all kinds of scenarios and edge cases.

7. Final Design Justification:

The chosen design allows the tournament scoring system to be easily and flexibly managed. It

prioritizes:

User-friendliness: Easy-to-use interface registration, event selection and results tracking.

Accuracy and transparency: Scores are automatically calculated, and standings are updated in

real-time so that the scoring is reliable.

Flexibility and customization: Supports various event formats, scoring systems and

participation types.

Scalability and security: Employs robust technologies and methods to deal with large data

volumes and protect user information.

Development Report: Tournament Scoring System Application

1. Development Environment and Programming Language:
 6

a) Development Environment:

Visual Studio Code (IDE for cross-platform development)

Git for version control

b) Programming Language:

Python (selected for its readability, extensive libraries, and applicability to web development)

c) Pre-defined Code and Libraries:

Django web framework (enabling rapid development of Web applications)

SQL Alchemy (ORM for effortless database handling)

Pandas (for data manipulation and analysis)

NumPy (for numerical computations)

2. Testing and Error Correction:

a) Test Plan Execution:

From the design stage, test plans are rigorously executed.

All are comprehensively documented with reasons and suggestions for the repair of all detected

errors.

b) Error Repair:

Accurate records of repair procedures and retest results.

c) Unrepairable Errors:

Documented with reasons and suggestions for future reference.

3. User Feedback and Optimization:

a) Feedback Collection:

During testing and demonstration, gathered feedback from users.

 7

b) Identification of Improvement Areas:

UI streamlining in pursuit of a better user experience.

Performance optimization for large datasets.

Improved reporting functions for in-depth analysis.

c) Prioritization of Improvements:

Prioritized according to user feedback and time constraints.

4. Final Product Evaluation:

a) Fulfillment of College Requirements:

The completed application fully meets all required specifications.

It covers the whole cycle of participant registration, event scheduling, scorekeeping and

calculation of rankings.

b) Decision Impact:

A high-quality, highly functional product was the result of this design and development.

The chosen technologies and libraries helped make development efficient and maintainable.

c) Comparison to Other Solutions:

The selected approach offers advantages in terms of:

Development speed (because of Python's convenience and Django)

Flexible (adaptable to future changes and extensions)

Scalable (can handle larger tournaments and datasets)

5. Individual Responsibility and Management:

a) Time Management:

They properly plan and control time so they can achieve project milestones.

Flexible and changed timelines as circumstances require.

 8

b) Feedback Incorporation:

Actively solicited and incorporated feedback from peers as well as supervisors.

Used this feedback to raise the quality of code and overall project results.

c) Professionalism:

Abided by professional standards in speech and behavior.

Others were respected, responses were timely, and actions were accountable.

d) Evaluation and Decision-Making:

We critically assessed the outcomes and based our recommendations on evidence.

Decisions based on analysis and project requirements.

e) Effective Communication:

Wrote the code.

Communication tailored to the audience to ensure understanding and cooperation.

Pseudocode in Python Syntax

Participant Registration

/*def register_participant(name, team_id=None, email):

"Registers a new participant in the system."""

# Validate input (e.g., check for valid email format)

# Check for duplicate entries (e.g., using a database query)

if participant_exists(name, email):

return "Participant already exists"

else:

# Create a new participant record

 9

with db.session() as session: # Assuming a SQLAlchemy session

new_participant = Participant(name=name, team_id=team_id, email=email)

session.add(new_participant)

session.commit()

return "Participant registered successfully" */

Event Registration

/*def register_for_event(participant_id, event_id):

"Registers a participant for a specific event."

# Validate input

# Check if a participant is already registered for the event

if participant_has_event(participant_id, event_id):

return "Participant already registered for this event."

else:

# Add participant to the event registration table

with db.session() as session:

new_registration = EventRegistration(participant_id=participant_id, event_id=event_id)

session.add(new_registration)

session.commit()

return "Event registration successful" */

Score Recording

/* def record_score(participant_id, event_id, rank):

"Records a participant's Score for an event."

# Validate input
 10

# Calculate points based on rank and event points

points = calculate_points(rank, get_points_for_rank(event_id))

with db.session() as session:

result = session.query(Result).filter_by(participant_id=participant_id,

event_id=event_id).first()

if result:

result.rank = rank

result.points = points

else:

new_result = Result(participant_id=participant_id, event_id=event_id, rank=rank,

points=points)

session.add(new_result)

session.commit()

return "Score recorded successfully"*/

Leaderboard Update

/* def update_leaderboard():

"Calculates and updates the leaderboard standings."

with db.session() as session:

participants = session.query(Participant).all()

for participant in participants:

total_points = 0

results = get_results_for_participant(participant.id)

for result in results:

 11

total_points += result.points

participant.total_points = total_points

session.commit()

# Sort participants/teams based on total points in descending order (e.g., using a sorting

algorithm)

# Display or store the updated leaderboard */

Reporting

/*def generate_report(report_type, filters=None):

"Generates a report based on specified criteria."

# Gather data from the database using queries and filters

# Format data into a presentable report format (using a library like Pandas)

# Display or export the report (as a PDF)*/