CP1404 – Assignment 2 – Movies to Watch 2.

0
(Part 1 ONLY)

This document contains only part 1 of the assignment, which focuses on the classes
(model) and console version of your full program. Because it is good practice to start with
this part before working on the GUI (view), you are only provided with these requirements
initially.
Part 2 will come later and will include full requirements, including the GUI details.

Task:
Create both a console program and a Graphical User Interface (GUI) program similar to your
first assignment, using Python 3 and the Kivy toolkit, as described in the following
information and accompanying screencast video. This assignment will help you build skills
using classes and GUIs as well as giving you more practice using techniques like selection,
repetition, exceptions, lists, file I/O and functions. Some requirements have in-text help
references, like [0], that refer to the resources list near the bottom. Check these references
to find help on that topic. Everything you need to complete this assignment can be found in
the subject materials.
Start your work by clicking this link to create a new repository in GitHub classroom:

https://classroom.github.com/a/EbcWiXFO
Do not use any other repo or a copy of this one... just use this actual repository!
This will give you a new repo containing starter code files and a README for your project
reflection, all of which you must use. Do not add any other files in this project, and do not
rename anything - just use this as your assignment repo. Do not "download" this repo, but
rather checkout this repo using PyCharm.
Classes:
The most important learning outcome of this assignment is to be able to use classes to
create reusable data types that simplify and modularise your programs. The fact that you can
use these classes in both console and GUI programs highlights this modularity.
It is important that you create these classes first – before any code that requires them.
This is good coding practice. You should write and then test each method of each class –
one at a time – committing as you go (e.g. you might commit each time you complete a
method and its tests).
We will assess your Git commit history to see (and mark) that you do these in an
appropriate order, so make sure you write your classes, with tests, then the console
program, before attempting any functionality for the GUI.

The starter code includes two files (test_movie.py and test_moviecollection.py) with
incomplete code for testing your classes. Complete these files with simple tests, that you
write as you develop your Movie and MovieCollection classes.
Do not change the existing tests… write code that makes these tests pass.
You may use assert as shown in lectures [1], or just very simple tests that print the results
of calling the methods you are testing with expected and actual results [2].
Once you have written and tested your classes, you can then use the Movie class in your
console program.

CP1404/CP1804/CP5632 Assignment 2 – Information Technology @ James Cook University 1/5

  Complete the Movie class in movie.py. This should be a simple class with the
required attributes for a movie and the standard methods: __init__ (constructor),
__str__ (used when displaying movie details in the status message), and:
o two (not one) methods, to mark the movie as watched or unwatched.

 Complete the MovieCollection class in moviecollection.py. It should contain a single

attribute: a list of Movie objects, and at least the following methods:
o add movie – add a single Movie object to the movies attribute
o get number of unwatched movies
o get number of watched movies
o load movies (from csv file into Movie objects in the list)
o save movies (from movie list into csv file)
o sort (by the key passed in, then by title) [3]
Notice that you do not store additional attributes like the number of movies, because
this information is easily derived from what you do store (just the movies) [4].

Console Program:
After you have written and tested your classes, rewrite your first assignment to make use of
your new Movie class. Start by copying the code from your first assignment into the existing
a1_classes.py file and committing that. In the first assignment, each movie was stored as a
list. Modify your code so that each movie is stored as an object of your new Movie class.
You do not need to rewrite your first assignment in any other way, even if it had problems.
We will only evaluate how you use the Movie class in the console program.

Project Reflection:
It is important and beneficial for you to start developing good coding and working practices,
so you will complete a short but thoughtful reflection on this project. Complete the template
provided in the README and reflect on what you learned regarding both coding and your
development process. This is worth significant marks, so allocate significant time to it.
We expect answers that show some detail and thought, not just trivial statements.

Git/GitHub:
You must use Git version control with your project stored in the private repository on GitHub
that will be created when you accept the GitHub Classroom invitation above. You are
assessed on your use of version control including commits and commit messages, using the
imperative voice (like "Add X" not "Added X"). [5]

Submission:
Submit a single zip file by uploading it on LearnJCU under Assessment (click on the title of
the assignment). Your zip file should contain the entire project directory, including the .git
directory (just zip up your project directory). Make sure your GitHub URL is included in
main.py. Please name the zip file like: FirstnameLastnameA2.zip.
Due:
Submit your assignment by the date and time specified on LearnJCU. Submissions received
after this date will incur late penalties as described in the subject outline.
Integrity:
The work you submit for this assignment must be your own. Submissions that are detected
to be too similar to that of another student will be dealt with according to the College
procedures for handling plagiarism and may result in serious penalties.
CP1404/CP1804/CP5632 Assignment 2 – Information Technology @ James Cook University 2/5
The goals of this assignment include helping you gain understanding of fundamental
programming concepts and skills, and future subjects will build on this learning. Therefore, it
is important that you develop these skills to a high level by completing the work and gaining
the understanding yourself. You may discuss the assignment with other students and get
assistance from your peers, but you may not do any part of anyone else’s work for them and
you may not get anyone else to do any part of your work. Note that this means you should
never give a copy of your work to anyone or accept a copy of anyone else’s work,
including looking at another student's work or having a classmate look at your work. If
you require assistance with the assignment, please talk with your lecturer or tutor.

The subject materials (lecture notes, practicals, textbook and other guides provided in the
subject) contain all of the information you need for this assignment. You should not use
online resources (e.g. Stack Overflow or other forums) to find resources or assistance as this
would limit your learning and would mean that you would not achieve the goals of the
assignment - mastering fundamental programming concepts and skills.

Assistance: Who can you get help from? Resources: Where can you get code
Use this diagram to determine from whom from? Use this diagram to determine where
you may seek help with your programs. [6] you may find code to use in your programs.

Sample Output:
Study the screencast provided with the complete assignment to see how the GUI program
should work, including what the messages should be and when they occur.
The console program should look identical to the requirements for Assignment 1; only the
implementation has changed.

References – Resources from Subject Materials:

1. Lecture Notes for Chapter 15 - Testing.

2. Practical 06 - Classes. https://github.com/CP1404/Practicals/tree/master/prac_06
3. Lecture Notes for Chapter 11 - Classes
4. Programming Patterns. https://github.com/CP1404/Starter/wiki/Programming-Patterns
5. Lecture Notes for Version Control.

CP1404/CP1804/CP5632 Assignment 2 – Information Technology @ James Cook University 3/5

6. Negotiating the Maze of Academic Integrity in Computing Education.
https://dl.acm.org/citation.cfm?doid=3024906.3024910

CP1404/CP1804/CP5632 Assignment 2 – Information Technology @ James Cook University 4/5

Marking Scheme:
Ensure that you follow the processes and guidelines taught in class in order to produce high quality work. Do not just focus on getting the
program working. This assessment rubric provides you with the characteristics of exemplary down to very limited work in relation to task criteria.

Criteria Exemplary (9, 10) Good (7, 8) Satisfactory (5, 6) Limited (2, 3, 4) Very Limited (0, 1)
Project reflection The project reflection is complete and Project reflection contains some good Many aspects of the project reflection
14% describes development and learning well, content but is insufficient in coverage, are missing or could be improved.
shows careful thought, highlights insights depth or insight.
made during code development.
Use of version control Git/GitHub has been used effectively and Git/GitHub used but several aspects of Git/GitHub not used.
9% the repository contains a good number of the use of version control are poor, e.g.
commits with good messages that not enough commits, or meaningless
demonstrate incremental code messages that don’t represent valuable
development starting with classes and incremental development in an
testing then console before GUI. appropriate order.
Console program Class is used correctly in console Class is used in console program but Class is not used in console
9% program. not correctly. program.
Error handling Errors are handled correctly and robustly Some errors are handled but not all, or No reasonable error handling.
9% as required. errors are not handled properly.
Correctness GUI layout is correct and program works Aspects of the GUI layout are GUI layout is very poor or not done.
14% correctly for all functionality required. incomplete or poorly done or there are Program works incorrectly for all
significant problems with functionality functionality required.
required.
Identifier naming All function, variable and constant names Several function, variable or constant Many function, variable or constant
9% are appropriate, meaningful and Exhibits aspects of names are not appropriate, meaningful Exhibits aspects of names are not appropriate,
consistent. exemplary (left) and or consistent. satisfactory (left) and meaningful or consistent.
Use of code constructs Appropriate and efficient code use, satisfactory (right) Several problems, e.g. unnecessary very limited (right) Many problems with code use.
9% including no unnecessary duplication, duplication, poor control, no use of
good logical choices for control and constants, improper use of global
storage, good use of constants, no global variables, poor use of functions in main
variables, good use of functions in main app.
app, etc.
Use of classes and Classes and methods are used correctly Some aspects of classes and methods Classes and methods used very
methods as required. Method inputs and outputs are not well used, e.g. methods not poorly or not used at all.
9% are well designed. used where they should be, problems
with method/parameter design,
incorrect use of objects.
Commenting Code contains helpful # block comments, Comments are reasonable, but some Commenting is very poor or not
9% all classes and methods have meaningful classes and methods have no done.
docstrings and main module docstring docstrings, and/or there is some noise
contains all details (name, date, basic (too many comments), and/or missing
description, GitHub URL). details in main module docstrings.
Formatting All formatting is appropriate, including Problems with formatting reduces Readability is poor due to formatting
9% indentation, horizontal spacing and readability of code. PyCharm shows problems. PyCharm shows many
vertical line spacing. PyCharm shows no multiple formatting warnings. formatting warnings.
formatting warnings.

CP1404/CP1804/CP5632 Assignment 2 – Information Technology @ James Cook University 5/5