LAST UPDATED: 1 OCT 2024 BY SHEKOUFEH RAHIMI

SOFTWARE DEVELOPMENT 1 COURSEWORK SPECIFICATION

This course starts your software deployment journey by introducing the key programming concepts on which the rest
of the course is built. The focus here is on a solid foundational knowledge of Python’s syntax and semantics. To evaluate
progress and highlight any gaps in understanding, this coursework will provide a set of challenging tasks and
programming requirements, as well as ample time to reach an adequate solution to them.

Coursework 1 Submission date: 25th Oct 2024 via Moodle in Moodle by 17:00 hours GMT.

Coursework 2 Submission date: 8th Nov 2024 via CodeGrade in Moodle by 17:00 hours GMT.

Coursework 3 Submission date: 11th Dec 2024 via CodeGrade in Moodle by 17:00 hours GMT.

Contribution: Coursework 1 accounts for 10%, Coursework 2 for 20%, and Coursework 3 for 30% of the total coursework
mark.

Aim: To gauge understanding on the correct use of variables and objects, data types and the ability to abstract data; as
well as the develop students’ fluency in programming languages and software development.

Learning Outcomes: 1: Design, implement, test, and debug a program that uses each of the following fundamental
programming constructs – basic computation, simple I/O, standard conditional and iterative structures, the definition
of functions, and parameter passing. 2: Analyse and explain the behaviour of simple programs involving the
fundamental programming constructs – variables, expressions, assignments, I/O, control constructs, functions,
parameter passing, and recursion. 3: Identify the relative strengths and weaknesses among multiple designs or
implementations for a problem. 4: Use a programming language to implement, test, and debug algorithms for solving
simple problems.

Grading Advice: While fully functioning programs and its documentation that meet all the requirements are the goal of
the test, the programs and the rationale for their design, implementation, testing and debugging will be assessed for
efficiency, simplicity, creativity and good style. Please read the Grading Rubric and bring any questions you may have to
your tutor.

To complete this coursework, you will design the behaviour of simple programs involving the fundamental programming
constructs – variables, expressions, assignments, I/O, and control constructs.

PROBLEM DESCRIPTION

A university has hired our Software Development company to modernize their student assessment system. As we know,
universities evaluate students based on various components throughout the academic year. There are several aspects
to determining a student's overall performance, such as their attendance, coursework submissions, exam results, and
participation. The university administration wishes to implement a categorical marking system to provide more detailed
and standardized feedback to students. You have been tasked to create a program that automates this calculation and
categorization process.

For the Software Development 1 module, student performance is assessed through the following components:

2. Coursework 1: Flowchart concepts (10%)

 3. Coursework 2: Basic Programming concepts (20%)

3. Coursework 3: Complex program implementation (30%)

4. Test: Theoretical and practical assessment (40%)

You have been tasked to create a program that calculates a student's overall score for this module and assigns a category
based on the university's categorical marking framework. The program should take into account the weighted scores
from each component, calculate the overall score, and then map it to the appropriate category:

- 100 (Aurum Standard)

- 92, 85, 82 (Upper First)
- 78, 75, 72 (First)
- 68, 65, 62 (2:1 Upper Second)
- 58, 55, 52 (2:2 Lower Second)
- 48, 45, 42 (Third)
- 38, 35, 32 (Condonable Fail)
- 25, 15, 5 (Fail)
- 0 (Defecit Opus) - nothing of merit, non-submission, or academic misconduct

Here's a basic outline of how the main calculation could work:

1. Calculate overall weighted score:

Overall_score = (coursework1 * 0.10)+ (coursework2 * 0.20) + (coursework3 * 0.30) + (final_exam * 0.40)

Thus, a categorical marking dataset example is as follows:

No Category Overall rate

Aurum
1 100
Standard
2 Upper First 82-92
3 First 72-78
Upper
4 62-68
Second
Lower
5 52-58
Second
6 Third 42-48
Condonable
7 32-38
Fail
8 Fail 5-25
Defecit
9 0
Opus

Example: If a student scores 58 in coursework 1, 65 in coursework 2, 55 in coursework 3, and 72 in the final exam,
their overall score would be calculated as:

(58 * 0.10) + (65 * 0.20) + (55 * 0.30) + (72 * 0.40) = 5.8 + 13 + 16.5 + 28.8 = 64.1

This would be rounded to the nearest category, which is 65, placing the student in the "Upper Second" category

- If the overall score is equal to 100, the output should be "Aurum Standard".
 - If the overall score is between 82 and 92, the output should be "Upper First".
- If the overall score is between 72 and 78, the output should be "First ".
- If the overall score is between 62 and 68, the output should be "2:1".
- If the overall score is between 52 and 58, the output should be "2:2".
- If the overall score is between 42 and 48, the output should be " Third”.
- If the overall score is between 32 and 38, the output should be " Condonable Fail".
- If the overall score is between 5 and 25, the output should be "Fail".
- If the overall score is 0, the output should be "Defecit Opus".

You can find out more about categorical marking at:

https://moodle.roehampton.ac.uk/pluginfile.php/4731975/mod_resource/content/1/LTQC%2088.19%20Categorical%
20Marking%20Frameworks%20UG%20PG%20.pdf

COURSEWORK 1

Draw a flowchart that you will use for your program design (the detailed program description is specified in Coursework
2). You can write it down/draw it by hand and take a picture or choose any software you prefer.

Submission Requirements: Please submit a PDF file containing your flowchart on Moodle.

COURSEWORK 2

There are two tasks you need to complete for this coursework:

Task 1. Following the flowchart you designed for Coursework 1, craft a program in Python which has the features listed
below:

a. You program should use the input() function that includes message text to instruct the user to enter each
student’s data.
b. Use an appropriate data structure to create and store this dataset, which contains the student’s ID, and
overall score.
c. Your program calculates the overall rate for each player, using the four main criteria described above
(coursework 1, coursework 2, coursework 3 and final test)
d. Your program should estimate the suitable category for each student by using the category dataset provided.
For instance, if the overall score of the player is between 72 and 78, the output should be:

72- First

e. The computed score should be printed out as an integer (no decimals).

Task 2: Write a brief reflection on your code (~500 words), which may include but not limited to the discussions about
topics below.

• How did you decompose the problem and why?

• Do you think flowchart helpful when you write a program and why?
• Have you met any difficulties/bugs during this coursework, and how did you tackle it?
• What did you think is the most difficult part in this coursework?
• What have you learnt from investigating this problem?
• Which part(s) in your code design is your favourite and why?
• If you had no time limit, how would you improve your program?

Resources on reflection can be found at: https://libguides.hull.ac.uk/reflectivewriting/reflection1a

Submission Requirements: Please submit your code as a Python file.py (instructions will be provided during lab sessions)
or directly in CodeGrade’s editor. You must submit a python file (*.py) containing the code for your program and
personal reflection on your code (Task 1 and Task 2) to CodeGrade on Moodle. Your program should contain full
documentation explaining your implementation (comment your code). Submitted files should have your name, ID
number and date of last update.

Feedback: Your code will be automatically graded by CodeGrade.

Marking Scheme: A short video explaining the assessment criteria can be found at:
https://www.youtube.com/watch?v=JrA0Dotq1p8

The following rubric will be used to assess your work:

Criteria Excellent Satisfactory Not Satisfactory Not Attempted

Solution A completed solution A completed solution A completed Solution doesn’t run

meeting all the that does not quite solution is or does not meet the
the completeness of specifications. meet all the implemented and specifications defined.
the code,
specifications. runs but lacks much
documentation and of the specification.
reflection to meet
the specification
given.

Design The solution design The solution design Not all of the Few if any of the
decomposes the generally uses selected structures selected structures
ability to decompose problem by using appropriate are appropriate. are appropriate, or
a problem into appropriate structures. Program Some of the the problem is
coherent and structures. The elements and elements are decomposed in ways
reusable parts. overall design is documentation both appropriately that make little sense.
appropriate, and exhibit good design. designed.
with a consideration
of reusability.

Correctness Solution produces Solution produces Solution approaches Solution does not
correct answers or correct answers or correct answers or produce correct
ability to create appropriate results appropriate results appropriate results answers or
solution that reliably
for all inputs tested. for most inputs. for most inputs but appropriate results for
produces correct
can contain most inputs.
answers or
miscalculations.
appropriate results.

Logic Solution logic is Solution logic is Solution logic is on Solution contains

correct with no mostly correct but the right track but some conditions that
ability to use correct known boundary may contain an shows no specify the opposite of
program structures errors, and no occasional boundary recognition of what is required (less
appropriate to the redundant or error or redundant boundary conditions than vs. greater than),
problem domain. contradictory or contradictory (such as < vs. <=). confuse Boolean
conditions. condition. AND/OR operators, or
lead to infinite loops.

Clarity Program contains Program contains Program contains Program contains no

appropriate some some documentation, or
ability to format and documentation for documentation on documentation (at grossly misleading
document code for all major functions, major functions, least the student’s indentation.
human consumption variables, or non- variables, or non- name and program’s
(Good Style) and trivial algorithms. trivial algorithms. purpose) but has
reflection. Formatting, Indentation and occasionally
indentation, and other formatting are misleading
other white space appropriate. indentation.
aids readability.

Robustness Solution handles All obvious error Some obvious error Solution often fails or
erroneous or conditions are conditions are fails completely.
ability of the solution
unexpected input checked for and checked for and Boundary conditions
to handle gracefully; action is appropriate action is some sort of action are not tested for.
unexpected input taken without taken. Nearly all is taken. Most
and error conditions surprising the user. boundary cases are boundary cases are
correctly as Boundary cases are considered and considered and
evidenced via considered and tested. tested.
testing. tested.
COURSEWORK 3

To complete this coursework, you will design the behaviour of complex programs involving the fundamental
programming constructs – functions, operations, and file reading/writing. A template Jupiter notebook and a text file
are provided to complete the tasks. Time in class can be used to troubleshoot and get feedback on your program.

The university that hired our Software Development company is very pleased with the outcome of Coursework 1 and has
requested an extension. The program that you have crafted for Coursework 1 takes in scores for 4 components of student
assessment in the Software Development 1 module:

2. Coursework 1: Flowchart concepts (10%)

3. Coursework 2: Basic Programming concepts (20%)

3. Coursework 3: Complex program implementation (30%)

4. Test: Theoretical and practical assessment (40%)

The program uses these individual component scores to calculate an overall score out of 100 using the formula:

Overall_score = (coursework1 * 0.10)+ (coursework2 * 0.20) + (coursework3 * 0.30) + (final_exam * 0.40)

The resulting number (should be between 0 and 100) is then used to estimate the category using the categorical marking
dataset:

Category
No Overall rate

Aurum
1 100
Standard
2 Upper First 82-92
3 First 72-78
Upper Second
4 62-68
2:1
Lower Second
5 52-58
2:2
6 Third 42-48
Condonable
7 32-38
Fail
8 Fail 5-25
9 Defecit Opus 0

From the dataset above,

- If the overall score is equal to 100, the output should be "Aurum Standard".
- If the overall score is between 82 and 92, the output should be "Upper First".
- If the overall score is between 72 and 78, the output should be "First ".
- If the overall score is between 62 and 68, the output should be "2:1".
- If the overall score is between 52 and 58, the output should be "2:2".
- If the overall score is between 42 and 48, the output should be " Third”
- If the overall score is between 32 and 38, the output should be " Condonable Fail".
- If the overall score is between 5 and 25, the output should be "Fail".
- If the overall score is 0, the output should be "Defecit Opus".

You are asked to add the following functionality:

1. Functions (8 points): Split and pack up your Coursework 2 code into functions. The program must contain a main() function
and at least two other functions called "calculate_overall_score()" and "determine_category()".

2. Input expansion (8 points): Adjust your program to ask users to enter a student ID (2-digit number), name and date-of-
birth (D.o.B) by sequence, before asking for the 4 component scores from Coursework 1 (Coursework1, Coursework 2,
Coursework 3 and Final Exam). D.o.B should be in ISO format YEAR-MONTH-DAY.

3. Loop your code (8 points): Your program should use a loop to ask for the information of three students, or until the input
for user ID is "end".

4. Calculate the students' overall scores and store them for later use (2 points).

5. Determine the students' categories and store them for later use (2 points).

6. Calculate students' ages (8 points): According to each user's year of birth, your program should calculate the age of the
student and store it for later use. Hint: the library datetime can be used here to make your job easier.

7. Tabulate (8 points): Display a table that summarises the input data (ascending order with user ID) using the tabulate library.
It should look like:

UID Name D.o.B Age Score Category

-- ----------------- ---------- --- ------- --------------

13 Lieke Martens 1992-12-16 29 86.6667 Upper-First
02 Cristiano Ronaldo 1985-02-05 37 73.3333 First
24 Lucy Bronze 1991-10-28 31 50 Third

8. File writing (8 points): Save the table into a new local file named "students.txt"

9. Make sure that you: a. Implement robust input validation for a student's ID, D.o.B., and scores. Your program should give

a. Warning that says "The input you entered was invalid" for any input errors (6 points)

b. Display use of appropriate data structures for storing student information (5 points)

c. Display use of appropriate code structures for implementing the functionality (5 points)

10. Implement a function called `round_to_category(score)` that takes a numerical score and rounds it to the nearest
category. This function should (10 points):

a. Accept a float or integer score as input.

b. Determine the two nearest category boundaries.
c. Round the score to the nearest category based on which boundary it's closer to.
d. Return the rounded score and the corresponding category.

For example:

- If the input score is 73.7, it should return (75, "First") because 73.7 is closer to 75 than to 72.
- If the input score is 69.2, it should return (68, "2:1") because 69.2 is closer to 68 than to 72.

Your implementation should handle edge cases, such as scores exactly halfway between two categories (round up
in these cases), and scores at or beyond the extremes of the scale.
 UID Name D.o.B Age Raw Score Rounded Score Category

-- ------------ -------- ---- ---- ---- ------------

13 Lieke Martens 1992-12-16 29 86.6667 85 Upper-First
02 Cristiano Ronaldo 1985-02-05 37 73.3333 75 First
24 Lucy Bronze 1991-10-28 31 50 52 Third

11. Distinction Advanced Function: Once everything in requirements 1-10 has been completed, for a distinction grade, extend
your program with one more function called advanced(). This function should:

a. Be a complimentary main() method that, instead of taking user input, uses the provided file as input.

b. Accepts in its argument (filename) the name of the text file to read.

c. Read the student information record from the provided file "StudentData.txt", which contains student IDs, names,
and date-of-births. The function should then use this data as the input for the program.

d. ll all the other functions used and produces a text file output (requirement 8).

12. Advanced Generalization Function (Distinction level): Implement a function called `setup_module()` that allows the user
to define the assessment criteria for any module. This function should:

a. Ask the user to input the module name.

b. Ask the user how many assessment components the module has.
c. For each component:
- Ask for the component name (e.g., "Coursework 1", "Final Exam")
- Ask for the component's weight as a percentage (ensure all weights sum to 100%)
d. Store this information in an appropriate data structure.
e. Return the module configuration.

Here's an example of how the program flow might look:

Welcome to the Student Grading System First, let's set up the module configuration.

Enter module name: Advanced Programming

How many assessment components does this module have? 3

Component 1 name: Midterm Exam

Component 1 weight (%): 30

Component 2 name: Final Project

Component 2 weight (%): 40

Component 3 name: Participation

Component 3 weight (%): 30

Module configuration complete.

Now, let's enter student information and grades.

Student 1:
ID: 01
Name: John Doe
Date of Birth (YYYY-MM-DD): 1995-05-15
Midterm Exam score: 75
Final Project score: 82
Participation score: 90

Results:
UID | Name | D.o.B | Age | Raw Score | Rounded Score | Category
-----|--------------|----------------|------ |---------------|---------------------|---------
01 | John Doe | 1995-05-15 | 28 |82.6 | 82 | Upper First

Submission Requirements: Submit your code via Codegrade as a Jupyter notebook named:

student_category.ipynb

The program file should contain full documentation explaining your implementation (comment your code). Your file
should have your name, ID number and date of last update.

Feedback: Feedback will be given automatically through Codegrade via Moodle.

Marking Scheme: Grades will be based on number of components completed. You will be assessed on

• Solution: the completeness of the code, documentation, and reflection to meet the specification given.
• Design: ability to decompose a problem into coherent and reusable parts.
• Correctness: ability to create solution that reliably produces correct answers or appropriate results.
• Logic: ability to use correct program structures appropriate to the problem domain.
• Clarity: ability to format and document code for human consumption (PEP-8) and reflection.
• Robustness: ability of the solution to handle unexpected input and error conditions correctly as evidenced via
testing.

The following rubric will be used to assess your work:

Basic Requirements

In order to get full marks for this rubric category your code must:

- Be encapsulated into functions including `main()`, `calculate_overall_score()`, and `determine_category()`. (8)

- Prompt users for an ID, name, D.o.B, and four student components, in that order. (8)
- Accept data for exactly 3 students before stopping or if "end" was entered instead of an ID. (8)
- Calculate the student' overall score. (2)
- Calculate the student' category. (2)
- Calculate the students' ages. (8)
- Display a table of all the data passed to the program using `tabulate` (8)
- Save this table to `students.txt` (8)

Intermediate requirements

In order to get full marks for the rubric category your code must:

- Implement robust input validation for a student's ID, D.o.B., and overall score (6)
- Display use of appropriate data structures for storing student information (5)
- Display use of appropriate code structures for implementing the functionality (5)

Distinction Requirements:

Distinction work in the range of 72-78 should demonstrate:

- Exemplary attainment of learning outcomes

- A high level of insight and critical evaluation of the material
- A comprehensive and up-to-date account of relevant theoretical and empirical material
 - A thorough understanding and integration of material supporting a cogent argument
- Excellent writing of a high academic standard

Distinction work in the range of 82-100 should demonstrate:

- Attainment beyond the intended learning outcomes

- An outstanding level of originality and creativity, providing a significant new perspective on the question or
topic
- A clear, elegant and well supported argument, based on the integration and sophisticated critical evaluation of
a substantial body of knowledge
- Suitability for publication in high quality journal

Academic Misconduct: All submissions will be processed through a code plagiarism tool. If signs of misconduct are
found, all students involved will be contacted to discuss further steps. Please see here for information on academic
integrity at the university https://portal.roehampton.ac.uk/information/Pages/Academic-Integrity.aspx.

Our guiding principle is that academic integrity and honesty are fundamental to the academic work you produce at the
University of Roehampton. You are expected to complete coursework which is your own and which is referenced
appropriately. The university has in place measures to detect academic dishonesty in all its forms. If you are found to
be cheating or attempting to gain an unfair advantage over other students in any way, this is considered academic
misconduct and you will be penalised accordingly. Please don’t do it.