CPSC 217: Pre-Mini-Assignment 1

Due at 4 PM. For assignment due dates see the main schedule on the course webpage.

New Concepts to be applied for the assignment

• Learning how to create a complete Python program from the ground up using: variables, getting input, displaying output, formatting output using escape codes & format specifiers, using common operators. These things were covered in the "introduction to programming lectures" and the respective tutorials so you need to go through this material before starting the assignment.
• If you want credit for your work: Do not use any pre-created functions/methods unless you are given explicit permission to do so. [Generic list of allowable library functions]

Synopsis:

Write a python program that will perform calculations similar to how your term grade with be determined for this class. To reduce the need for implementing similar features over and over your assignment won't include as many grading components. Although it's not identical to what's used this term but similar enough to give you a good idea how your term grade point will be calculated as well as allow you to apply many basic programming tools. Similar to determining your actual term grade, grade points and not percentages are used in the calculation of your term grade (which is also a grade point and not a percentage). In the actual calculation of your grade for this class the term grade point will be converted to a letter grade using the cut off scales [covered at the start of the term] although you don't have to do the mapping of grade point to letter grade for this assignment.

Creating and running your program

Creating your program

• Use the IDLE editor (it comes with the python install by default) to create and run your program. If you use another program and you run into problems then you will be on your own.
• Windows users: DO NOT try to open or run your program by clicking on it because the [default action] is to run the program in a new window and close the window when the program runs.

Running your program

• Regardless of the program editor or computer used to create/run your program: submissions must run using Python 3.x or else it won't be awarded credit.

Functional requirements (working features of your program):

• The program starts by prompting for the grade point for each of these components (assignments and examinations) one-at-a-time (refer to Figure 1).
  • Error checking that inputs are within range is not needed in this program because you haven't been taught 'branching' yet. (This means that you may assume that the user enters a value with the correct range)
  • Error prevention: However it would be a good idea to specify in the prompts to the user what is the valid range of values (0 - 4.0 for assignments, 0 - 4.3 for the examinations).
  • Also your program doesn't have to check for invalid types of information being entered (e.g. the user enters a string instead of numbers for a grade point) because you won't have learned how to employ tools such "exception handling" until much later in the term.
    • Implementing this form of error handling using exceptions won't be a violation of using pre-created code because the exception handling model in python does not employ pre-created functions.
• Next the program calculates and displays output: the weighted grade points for each the assignments, examinations along with the original grades and the term grade point (refer to Figure 2).
• Calculating a weighted grade: The general formula for calculating a weighted term grade was covered in the first set of lecture notes dealing with administrative issues such as grading but the basics are simple. The weighted grade for a component (whether that grade is a GPA, percentage or raw score) = (grade for the component) * (weight of that component). This product is calculated for each component and the weighted component grades are summed to yield a term grade.
  • Grade point example:. You score 3.7 on a grading component worth 70% and 4.1 on the other grading component worth 30%, the term GPA = (3.7* 0.7)+(4.1*0.3) = 2.59 + 1.23 = 3.82 (should be a letter grade of at least an A-).
  • Percent score example (percentages aren't used in the assignment nor in the calculation of your actual term grade but it's included to help you understand how to calculate a weighted term grade): You score 80% on a grading component worth 70% and 100% on the other grading component worth 30%, the term percent = (80* 0.7)+(100*0.3) = 56 + 30 = 86% (to determine your letter grade you have to look at instructor's specific cut off scale which is one reason why this instructor uses grade points rather than percentages - it's not self evident what the term letter will be if percentages are used - contrary to what some students may believe this university does not impose a required set of cut offs for percentage to letter grade mapping).
  • Components of the term grade for the program you are to write for this assignment:

    Component	Proportion of term grade point (weight)
    A1	15%
    A2	15
    A3	20
    Midterm exam	20
    Final exam	30
    Total	100%

  • Normally you should test your program by hand tracing different inputs and comparing the results with the output of your program. Since that might be time consuming for this assignment you can check your results by entering sample results with the grade calculator spreadsheet that I've customized for this assignment: [Pre-mini-assignment1 grade calculator]
• Formatting your output
  • Each grade point will be display with one place of precision (specified by the correct use of the format specifier, although there are other ways to do this in python this approach is standard with many languages so you need to do it this way in order to get credit), precision is the number of digits right of the decimal point. (If you still don't know what this means here's [an article] explaining the term).
  • Tabs (each one must specified with the appropriate escape code) will separate each piece of information (label or individual grade). Figure3 includes an annotated version of the output of my solution specifying the location of the escape codes.
    • <Assignments:> <tab> <GPA for A1> <tab> <GPA for A2> <tab> <GPA for A3>
    • <Examinations:> <tab> <GPA for the midterm> <tab> <GPA for the final exam>
    • <Weighted assignments/exams> <tab> <Weighted assignment GPA> <tab> <Weighted exam GPA>
    • <Term GPA:> <tab> <Actual GPA for the term>
    • The angled brackets do not actually appear in the output, they are only used to separate different pieces of information. The spaces between the fields shown above are only included for readability and do not appear in the final output (e.g. there is only a tab between A1 & A2 not a space and a tab).
  • The column for the labels ("Full assignments", "Examinations" etc. must be right aligned using a correct format specifier (field width) so that the colons line up on top of each other). Alternative approaches (e.g. typing a bunch of spaces between the quotes in the print function) will be awarded no credit. See the lecture material covering format specifiers on how to align a column of output ("Introduction to programming Part 2"). Figure 4 includes an annotated output of the my sample solution specifying where the format specifiers are used to align the output.

Figure 1: Getting input

Figure 2: Output of the original grades, the weighted grades and the term grade point.

Figure 3: Output of a sample solution annotated with the location of where escape codes format the output.

Figure 4: Format specifiers used to align a column

Non-functional assignment requirements (style and documentation).

Although it won't affect your grade for mini-assignments you should still practice applying good style in your solution as well as writing documentation. It will keep your skills for the full assignments (when you will be graded on these things) and get you used to having good habits.

• Naming conventions: You should employ good naming conventions for identifiers (variables and constants) as covered in the "Introduction to programming" section of the course.
• Defining and using named constants. Although this assignment does not specifically require the use of named constants later assignments will do so and it would be good practice to start employing this practice now.
• Python documentation: This should be specified in the header of the program (very top of your program in the form of Python documentation). The basics of documentation were covered in the "Intro to programming" section of the course. Later sections may include additional details.
  • Identifying information: All assignments should include contact information (full name, student ID number and tutorial section [Here's a Link if you don't know how to find this information]) at the very top of your program.
  • Program version. (version date or version number).
    • Under the version you should specify which assignment features were implemented in that version. An example covering the use of program versioning and documentation was covered in the "Introduction to programming" lectures.
  • Any program limitations or weaknesses.
• [As mentioned] your prompts to the user to enter the required information must be clear to the user as to what should and should not be entered.
• In general: The program output and the program code itself (python program) must be properly aligned and formatted including whitespace as needed to group related parts and separate sections (which again was covered in the "Intro to programming" lectures of the course. Additional requirements in the formatting of output may be included in the "Functional requirements" section of the assignment.