联系我们： 手动添加方式: 微信>添加朋友>企业微信联系人>13262280223 或者 QQ: 1483266981
1
Department of Computer Science
Summative Coursework Set Front Page
Module Title Programming in Python
Module Code CS2PP
Lecturer responsible Dr Todd Jones
Type of Assignment
(e.g., technical report, set exercise, in-class test) Project
Individual or Group Assignment Group
Weighting of the Assignment 60%
Word count/page limit 3000 words (in Markdown files)
Expected hrs spent for the assignment (set by lecturer) 24 hours per group member
Items to be submitted
A single .zip archive of one csgitlab
repository and a link to the repository
submitted to Blackboard.
Required repository contents detailed
below.
Work to be submitted on-line via Blackboard Learn by 2025 May 30th (Friday) 12:00 (noon)
Work will be marked and returned by 2025 June 20th (Friday)
Artificial Intelligence Tools May be used to support work
Note
By submitting this work, you are certifying that you have read the assessment guidelines,
which are displayed in the folder of Assessment on the Blackboard course for this
module, and that you have conformed to and understand the associated policies and
practices, including those on:
Submitting your own work, not that of other people or systems, and the
associated penalties for Academic Misconduct
Submitting by the specified deadline, and the penalties associated with late
submission (if allowed)
The exceptional circumstances system
For students with relevant needs, attaching with a green sticker
Note, any extension granted for the Group Work does not automatically mean that an
extension is appropriate for the whole Group – a case will need to be made. It is
recommended that you contact the lecturer responsible or the Support Centre for advice.
1. Assessment Classifications
This coursework assesses your ability to:
1. implement common computer science algorithms to design solutions to
programming problems with Python scripts and software applications;
2. assemble code that incorporates imperative, functional, and object-oriented
programming paradigms;
3. integrate third-party Python libraries to formulate and construct Python
programs for practical applications; and
4. demonstrate best practices and conventions for writing clean and efficient
code.
In general, you will gain credit for:
preparing and submitting required files as requested;
successful implementation of the specified tasks;
writing efficient, functional code;
providing thoughtful, clear, well-structured written analysis that conveys
complex information understandably.
Your assignment will be marked according to the marking scheme provided below.
The scheme is designed so that the collectively weighted assignment mark will
correspond to the following qualitative degree classification descriptions:
2
3
Classification Range Typically, the work should meet these specifications:
First Class (>= 70%) This work demonstrates coding proficiency with high
efficiency and based on advanced techniques. Evidence of
independent research into the methods used and a thorough
justification of applications of these methods is presented
clearly. Work at this level demonstrates exceptional
understanding, creativity, and application in all aspects of the
project. The code is exemplary in quality, showcasing
exceptional efficiency, organisation, and innovative
techniques; documentation is thorough, enhancing clarity
and understanding.
Upper Second (60-69%) Good work with few mistakes. Some minor tasks have not
been carried out or are not completely correct. Work at this
level exhibits strong comprehension and application of the
project’s objectives. The code demonstrates strong
proficiency, with efficient and well-organised structure; it is
well-documented, facilitating easy readability and
comprehension.
Lower Second (50-59%) Demonstrates knowledge of core concepts but with some
mistakes. Work at this level demonstrates a good grasp of
the project requirements. The code is well-structured and
functional, with a good level of efficiency and readability;
documentation is clear and aids understanding.
Third (40-49%) Some parts of the assignment are missing and/or have
partially correct results. Work at this level shows an
adequate understanding of the project’s scope with
satisfactory data collection and analysis. Technical aspects,
including Python tool usage, are competently executed but
lack sophistication. Individual contributions are notable, and
there is evidence of teamwork, though not fully effective.
The code is functional but simplistic, with some issues in
efficiency and structure; basic documentation is present but
lacks detail.
Pass (35-39%) Work at this level meets a subset of the basic requirements
but lacks depth in these. There is a rudimentary
understanding of the project’s objectives, with elementary
data collection and analysis. Technical execution is basic,
with minimal use of Python tools. Individual contributions
fulfil some basic criteria, and group collaboration is limited
but present. The code meets basic functional requirements
but is rudimentary, often inefficient, and lacks proper
organisation or documentation.
4
Fail (0-34%) Work at this level fails to meet the minimum requirements.
There is a lack of understanding and application of the key
concepts and methodologies related to the project. Data
collection and analysis are either incorrect, superficial, or
missing. Technical implementation is inadequate, with
significant errors or misunderstandings. Group collaboration
is poorly demonstrated or not evident. The code is either
non-functional, severely flawed, or largely absent, showing a
fundamental misunderstanding of basic programming
concepts.
2. Assignment Description
This is a group assessment with individually assessed components. Each element
will be used to assess your implementation of several aspects of Python by
harnessing third-party tools.
A detailed breakdown of the Marking Scheme is provided later in this document.
Group Formation
Groups will have approximately 5 members.
Groups will be available for self-selection via Blackboard, and you can also make
a request to be randomly assigned to a group by emailing
t.r.jones@reading.ac.uk if you have not already requested this from the class
survey in Week 1. Students with registered accommodations have been
contacted about adjustments to this plan.
If you have not selected a group by Monday, 24th March at noon, you will be
randomly assigned to a group.
If your group has fewer than 5 members on Monday, 24th March at noon,
additional members will be assigned to your group, unless the numbers are
uneven, in which case some groups will have 4 members.
Embracing Collaborative Learning and Practical Application
Computer science is a dynamic field where the ability to collaborate effectively
and apply theoretical knowledge to real-world problems is invaluable. This group
coursework is designed not only to assess your technical proficiency in Python
programming but also to enhance your collaborative skills, which are highly
valued in the professional world. Research indicates that employers and
graduates alike place significant importance on teamwork and the ability to work
effectively in diverse groups (Hughes & Jones, 2011; Salas et al., 2005). Through
this project, you will demonstrate your understanding of both functional and
object-oriented programming paradigms in Python. By engaging in this group
task, you will experience firsthand the challenges and rewards of collaborative
problem-solving, a critical skill in today’s interconnected and constantly changing
work environments.
Key Requirements
Your group will collaboratively build a Python application that generates a
functional QR code from user-provided text (e.g., a URL) and displays the
resulting code via a simple interactive GUI or website. In the end, your QR code
should be scannable by a standard QR reader app.
5
The following elements will guide successful completion of the coursework:
1. QR Generation (Version 1 complexity) – See the end of this document for
guideline resource.
Accept an input string (e.g., a short URL or textual message).
Encode the string into byte mode bits.
Integrate Reed-Solomon error correction at level L via the reedsolo
library to generate error correction codewords.
Assemble the bits into the correct 2D matrix.
Include separators, finder, alignment, and timing patterns, the dark
module, and format information.
Apply one masking pattern (pattern 0) to reduce large blocks of the
same-coloured modules.
Ensure the proper QR format is represented in a data array that can be
printed to the screen.
Each of the above steps must be demonstrated to be functional in a
README.md file (specified below) for one stated test string. This can be
done by printing input/output pairs of text or visualisations of
intermediate forms. For example, before and after masking or the dark
module is applied.
2. Display Functional QR via Interactive GUI or Website
Develop an interactive user interface in the form of a GUI or website
based on the tools explored in the module.
The interface should request text from a user to be converted into a QR
code by using the Version 1 implementation developed above.
Ensure the design complies with data protection principles and warns
users of potential risks (e.g., phishing scams) possible from use of QR
codes.
Demonstrate that the interface can display a QR code in its most basic
form (black and white module squares) on a computer screen and be
successfully read by a typical mobile phone-based QR scanner.
3. Project Enhancements
Extend the Version 1 implementation to enable creation of a Version 2
QR code, including automatic determination of the appropriate version
based on the input string and demonstrating failure for a very long string.
Apply all eight masking patterns and evaluate them with all four penalty
scores to determine the best masking pattern.
6
Provide the user with the option to enable explanatory display of the
creation of the QR code in a step-by-step, slideshow-like presentation to
foster digital literacy.
Enable the user to select inclusive, accessible customisation of the QR
display (e.g., colours, module shapes, frames, sizes, image filters).
4. Documentation
The README.md will act as a well-formatted user manual for operating your QR
product and demonstration of functionality, containing the following
elements.
a) A description of the application’s functionality and operation
instructions to promote transparency. What must a user do to get it
running and what options are available to the user You might
support this with a diagram depicting the structure of your application
components.
b) A summary of the ways in which imperative, functional, and object oriented programming were used.
c) A summary of how social (e.g., accessibility, inclusivity, education),
legal (e.g., data protection), and ethical (e.g., transparency, risk
mitigation) concepts have been addressed in this work.
d) Outline the specific weaknesses and flaws in your application. For
example, is it susceptible to misuse or potentially unsafe How
e) Explain how you have modelled information, managed user inputs,
and ensured data integrity and security (e.g., sanitisation, error
handling).
f) Describe the features of your application that would make it suitable
for use in support of real-world functions (e.g., marketing, inventory,
science, tracking).
g) For a stated test string, the intermediate proofs of functionality in the
implementation of a Version 1 QR code generation and enhancement
tasks.
h) A screen-capture animation of the product in action. E.g., as a .gif:
5. Collaborative Coding with Individual Contributions
The project must consist of collaborative coding efforts, accompanied by
implementation of code produced individually.
Each member is responsible for the creation of their own identifiably
labelled Python module file containing at least one function or class that
will be imported into the main project application.
The group code base will reside on csgitlab.reading.ac.uk in a repository
owned by one group member and to which the remaining group
7
8
members will have been added in the Maintainer role. The repository
should be named to correspond to your Blackboard group ID.
In addition to the main branch, all group members will have their own
personal branch, where they will work to develop their contributions.
All developments will be merged into the main branch in the final
version.
6. Individual and Group Reflective Accounts
As a group, provide a Markdown in the main branch containing a written
account of how you worked as a group. In what manner and on which
dates did you meet Which communication strategies did you employ
Who assumed which roles How were tasks planned What was the
intended scope of the individual code contributions
i. Were contributions of effort distributed unequally If so,
express the contributions of effort as a percentage (i.e., 100%
is full effort, assumed by default). See note following Marking
Scheme table.
ii. If a group member did not contribute their own module code
or their contribution performs improperly, please note how
this affected the implementation.
Individually, reflect upon your development of your individual module
file code. Ensure you state which code is your personal work. Describe
the process of designing your code and the way in which it is
instrumental to the functionality of the collective project. What issues
did you face in its development, and how might you approach this
differently if you were to revise this element Each group member
should write this reflection in a separate Markdown file (with a unique
name) of their own, annotated with their name and student ID number.
These should be merged into the main branch for submission.
In the reflective elements, specifics are essential! You can read this
reflection guidance to guide your writing.
9
3. Assignment submission requirements
“Front page” of the Submission
The following are compulsory. Please add these items to at the top of your group
Markdown file.
Module Code:
Assignment report Title:
Student Number (e.g., 25098635):
Actual hrs spent for the assignment:
Which Artificial Intelligence tools used:
Format of the Required Work
You must use Python (version 3.11.7). Where possible, use the packages
consistent with the base conda environment in the Anaconda3 distribution used
in this module (2024.02). Provide instructions to implements any deviations.
In addition to the project code, the files of which you may structure as you see fit,
the following files are expected in your submission (and repository):
1. README.md – See details in Documentation component.
2. reflection_group.md – 300-word limit
3. reflection_12345678.md – one for each group member, formatted with your
8-digit student ID number, 200-word limit
You will find the submission point on the module’s Blackboard page under
Assessment. Here, you can submit repository, as downloaded to a .zip archive,
named to correspond to your Blackboard group ID. For example:
Practical_A_Group_01.zip.
Code Plagiarism
This coursework is expected to be the result of your own group effort, not that of
other people or systems. That said, you should indeed work closely with others
on this coursework. You may employ pair programming techniques, for instance.
Copying whole tutorials, scripts or images from external sources is not permitted.
Any material you borrow from other sources to build upon or to support your
arguments should be clearly referenced (use comments to reference elements
within Python module files and supply formal literature references at the end of
the README.md file); otherwise, use of such material will be treated as
plagiarism, which may lead to investigation and subsequent action. Work
10
inspired by module materials is permitted, but such material should not be used
without significant modification. Artificial intelligence tools may be used to
support development of ideas for this work, but their outputs should not be
copied and submitted; they are also not necessary to complete this work.
11
4. Marking Scheme
Element Marks Available
Group Elements*
Basic QR Data Generation
Data Encoding: Correct handling of Byte Mode. Proper mode
bits, character count bits, and data bit assembly (terminator +
padding). Evidence the group understands how to form
codewords from the input string.
10
Error Correction Integration: Usage of the reedsolo library at
ECC Level L. Correct total data codewords vs. ECC codewords for
Version 1 (e.g., 19 data + 7 ECC = 26 total). Data + ECC
codewords are correctly generated (order and count).
10
Matrix Layout and Patterns: Finder patterns in corners, timing
pattern, dark module, format information area reserved. Zigzag
placement of the data/ECC bits in the right modules (skipping
reserved cells). Application of one masking pattern (any single
pattern is fine). Resulting text-based QR is structurally
consistent with Version 1 (21×21).
12
Basic Interactive QR Data Presentation
Basic GUI/Website Interactivity: A clear way for the user to
enter text/URL and trigger the QR generation. Demonstrated by
README.md screen capture animation.
5
Presentation and Visualisation: The QR code is rendered as an
image on the screen. The interface is reasonably user-friendly
(labels, instructions, layout). Demonstrated by README.md
screen capture animation.
5
Testing and Demonstration: Confirmed scannable by a phone
QR app. Include QR image to test in README.md.
3
Project Enhancements
Version 2 and Automatic Version Selection: If the input string
exceeds Version 1’s capacity, automatically switch to Version 2.
Correctly handle the updated matrix size (25×25) and alignment
pattern.
8
Multiple Mask Patterns and Penalty Scoring: Implement all
eight mask patterns (0–7). Calculate penalty scores and
automatically select the best. Show a clear demonstration or
example of how masks are evaluated.
8
Step-by-Step Display: A user option to display a slideshow
showing how the QR elements are built (finder, data bits, mask)
or other similar advanced explanation. This could be a
8
Continued on next page…
12
specifically visual implementation of the intermediate steps in
the README.md.
Inclusive, Accessible Customisation: Implementation of user
options to modify the QR rendering.
8
Documentation
Documentation: Written elements provided in the
README.md. 8
Group Reflection
Group Reflection: Quality of group reflection on teamwork, role
distribution, and collaborative process; approximately 2-3
paragraphs; additionally include member name/effort weight
5
Individual Elements
Individual Reflection: Depth of individual reflection on your
contribution, challenges faced, and learning outcomes;
approximately 1 paragraph
5
Individual Module Code: Quality and functionality of individual
code contributions, adherence to naming conventions and
intended scope, documentation as evidenced in the module
files, integration into main analysis.
5
Coursework 2 Total 100
* These elements are group marks. By default, marks of this type earned will be
applied equally to all members of the group. All members are entitled to retain 25%
of the group mark. However, 75% of the group mark will be modified by
proportional weighting in the event contributions of effort toward completion were
distributed unequally. Note effort contributions as percentages in the group
reflection Markdown submission within a copy of the leftmost 2 columns below.
For example, for a group mark of 60:
Provide in Group Reflection Marking Calculation Example
Member Name Effort Weight Group
Mark
Weighted
Group
Mark
Individual
Mark
Total
Mark
ABC 80% 60 51 9 60
DEF 50% 60 37.5 8 45.5
GHI 0% 60 15 10 25
JKL 100% 60 60 5 65
MNO 100% 60 60 10 70
13
5. References
Available as PDFs on the Blackboard CW2 Assessment Item
Hughes, R. L., & Jones, S. K. (2011). Developing and assessing college student
teamwork skills. New Directions for Institutional Research, 2011(149), 53–64.
https://doi.org/https://doi.org/10.1002/ir.380
Salas, E., Sims, D. E., & Burke, C. S. (2005). Is there a “Big Five” in Teamwork Small
Group Research, 36(5), 555–599. https://doi.org/10.1177/1046496405277134
14
6. Essential Resources
QR Code Guidelines
Multiple instruction sets are available online. However, you are strongly advised to
follow Thonky.com’s QR Code Tutorial: https://www.thonky.com/qr-code-tutorial/
This will take some time to read and understand. Do this early. Ask questions.
Because we ask you to employ the reedsolo library for error correction, you will not
be asked to implement this encoding manually.
You can rely on reference to character capacity and total codeword tables for Level L
error correction in Versions 1 and 2. These do not need to be calculated.
https://www.thonky.com/qr-code-tutorial/character-capacities
https://www.thonky.com/qr-code-tutorial/error-correction-table
Test early and often:
http://www.thonky.com/qrcode (Advanced options, switch to ISO-859-1)
softwarehouse.au/tool/qr-code-generator (Mode is automatic; ensure byte used)
Encodes the string ‘known’, using Version 1, ECC L, Mask 0, Byte Mode:
Encodes the string ‘known’, using Version 2, ECC L, Mask 4, Byte Mode:
Merge code branches early and often to stay up to date.
https://docs.gitlab.com/ee/user/markdown.html
https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet
发表评论