Your go-to guide for all things assessment-related including project ideas, assessment criteria and submission details.
Welcome to your Python Essentials project assessment guide. The guide provides you with the learning outcomes that need to be evident within your project when you submit it for assessment Before you dive into the learning content, take the time to look at the criteria and expectations needed to build your awesome project.
Don’t worry if it doesn’t all makes sense just yet. The point of reading through this guide is to help you build up knowledge of what is expected of your project. Return to this guide frequently as you go along. As you go through the material, learning outcomes and their associated assessment criteria will begin to make more sense.
In this project, you'll build a command-line application that allows your
users to manage a common dataset about a particular domain.
You can either choose to build the website based on Project Idea 0, or take inspiration from the other example ideas below.
Bring your idea(s) to life based on providing value to users to address a specific factual or imagined need. Use the relevant project assessment criteria as a guide to the minimum required functionality.
External user’s goal:
Site owner's goal:
Potential features to include:
External user’s goal:
Site owner's goal:
Potential features to include:
| Learning Outcome | Description |
|---|---|
| LO1 | Implement a given algorithm as a computer program |
| LO2 | Adapt and combine algorithms to solve a given problem |
| LO3 | Adequately use standard programming constructs: repetition, selection, functions, composition, modules, aggregated data (arrays, lists, etc.) |
| LO4 | Explain what a given program does |
| LO5 | Identify and repair coding errors in a program |
| LO6 | Use library software for building a graphical user interface, or command-line interface, or web application, or mathematical software |
| LO7 | Implement a data model, application features and business logic to manage, query and manipulate data to meet given needs in a particular real-world domain. |
| LO8 | Demonstrate and document the development process through a version control system such as GitHub |
| L09 | Deploy a command-line application to a cloud-based platform |
| Criteria | Description |
|---|---|
| 1.1 | Write Python code that passes through a linter (eg PEP8) with no significant issues. |
| 1.2 | Ensure all intended functionality works as per the critical project objectives |
| 1.3 | Write code that meets minimum standards for readability (comments, indentation, consistent and meaningful naming conventions). |
| Criteria | Description |
|---|---|
| 2.1 | Write code that handles empty or invalid input data. |
| 2.2 | Clearly separate and identify code written for the application and code from external sources (e.g. libraries or tutorials) |
| 2.3 | Ensure a consistent flow of logic and data with well defined granular functions |
| Criteria | Description |
|---|---|
| 3.1 | Implement standard programming constructs such as flow control, iteration, selection, functions, object-oriented programming and data structures - as appropriate - to achieve the project goals. |
| 3.2 | Implement exception/error handling to optimise the user experience |
| Criteria | Description |
|---|---|
| 4.1 | Use consistent and effective markdown formatting that is well-structured, easy to follow, and has few grammatical errors when writing a README file. |
| 4.2 | Write a README.md file in English for the Python application that explains its purpose and the value that it provides to its users. |
| Criteria | Description |
|---|---|
| 5.1 | Implement basic manual testing procedures for code validation |
| Criteria | Description |
|---|---|
| 6.1 | Implement the use of external Python libraries where appropriate to provide the functionality that the project requires. |
| Criteria | Description |
|---|---|
| 7.1 | Implement a working data model that supports the intended project functionality |
| 7.2 | Write code that queries and manipulates data to meet the identified vital project needs. |
| Criteria | Description |
|---|---|
| 8.1 | Use Git & GitHub for version control of the web application up to deployment. |
| Criteria | Description |
|---|---|
| 9.1 | Deploy a final version of the Python Essentials application code to a cloud-based platform. |
| 9.2 | Ensure that the deployed application is free of commented out code. |
To evidence performance at the MERIT level, a learner will, in general, demonstrate characteristics of performance at the MERIT level, as suggested below. However, the learner must achieve ALL listed merit criteria.
The learner has a clear rationale for the development of this project and has produced a fully functioning, documented application for a real-life audience. Data validation and user feedback are all evident in the code and the working application. There are no logic errors in the code, and the application functions as expected.
The finished project has a clear, well-defined purpose addressing the needs of a particular target audience (or multiple related audiences) and a specific data domain. Its purpose would be immediately evident to a new user without having to look at supporting documentation. The user is kept informed of progress and actions through feedback and, where large data sets are being loaded, progress indicators.
Code is well-organised and easy to follow, and the application has been fully tested, following a manual testing procedure, with no apparent errors left in the code.
The development process is evident through commit messages. The project’s documentation provides a clear rationale for the development of this project.
The application is robust and deals with external errors gracefully (user input).
| Criteria | Description |
|---|---|
| 1.1 | Translate the intended logic into efficient code |
| 2.1 | Ensure a consistent flow of logic and data with well defined granular functions |
| 3.1 | Demonstrate a clear understanding of programming fundamental constructs. and their relationships |
| 3.2 | Implement OOP if appropriate to the project needs. |
| 4.1 | Document the work undertaken to plan this project’s logic through flow charts or diagrams |
| 5.1 | Document validation error-based fixes implemented and identify and explain any unsolved validation errors. |
| 5.2 | Document the implementation of manual testing for code validation(using PEP Validators). |
| 6.1 | Separate and identify code written for the application and code from external sources (e.g. libraries or tutorials) |
| 7.1 | Efficiently implement the intended functionality as per the key project goals |
| 8.1 | Document the rationale as to why a particular library/libraries are necessary for the implementation of the project. |
| 8.2 | Commit often for each feature/fix, ensuring that commits are small, well-defined and have clear, descriptive messages. |
| 8.3 | Demonstrate, through screenshots, what the project outcomes are and how they have been met. |
| 8.4 | Present a clear rationale for the development of the project in the README, demonstrating that it has a clear, well-defined purpose addressing the critical goals of the application for a particular target audience (or multiple related audiences). |
| 9.1 | Document the deployment procedure in a section in the README file. |
At this level, a learner will have achieved all pass and merit criteria, as described above, and will demonstrate characteristics of high-level performance as described below:
Characteristics of performance at DISTINCTION level:
The learner has documented a clear, justified rationale for a real-world application
The development of the project has resulted in a fully-functioning Python application with a command-line interface
There are no logic errors in the code. Where there is a clear breach of accepted design/UX principles or accepted good practice in code organisation, these are fully justified, appropriate and acceptable to the target user. It matches the design and demonstrates the characteristics of craftsmanship in the code. The resulting application is original and not a copy of any walkthrough projects encountered in the unit
Amplification (craftsmanship):
Design
The design of the command line application demonstrates the main principles of imperative programming.
User Control
Consistency
Confirmation
Any design decisions that contravene accepted user interaction principles are identified and described (comments in code or a section in the README)
Development and Implementation
Code demonstrates the characteristics of ‘clean code’:
Consistent and appropriate naming conventions within code and in file naming, e.g.
Readability
Defensive design
Comments
Compliant code
Robust code
The entire design is implemented, providing an excellent solution to the users' demands and expectations and security consideration.
Real-world application
Security features and practice are evidenced.
Data is well structured
Configuration and dependencies files are kept up to date.
All noticeable errors have been corrected or documented:
Version control software is used effectively:
The entire application development process is documented:
Recommended structure for a README.md file:
As a mandatory part of the submission, your project must have a readme file named README.md, in markdown format, that will describe all aspects of your project.
The link below provides an official example of an expected structure for your readme file
NOTE: While it is a requirement for your README to be in English, we
also strongly recommend that your site is in English too. The assessment
will be conducted in English so to ensure that the functionality and
navigation can be fully assessed, we recommend that the site is in
English. If the site is in a language other than English, at a very
minimum you should ensure you have correctly set the
lang attribute in the HTML to the character code of the web
apps content language. This will allow the browser to attempt a
translation into English.
Plagiarism, as defined by the Oxford dictionary is “the practice of taking someone else's work
or
ideas and passing them
off as one's own.” It is a serious academic offence for which there are serious
consequences.
It is acceptable to use and reference others' code however it is an academic plagiarism offence if any piece of work which is not entirely the student's own is not correctly referenced or acknowledged. All student projects submitted will be reviewed for plagiarism. This includes checking code comparison tools, plagiarism software, review of git commit history and other mechanisms.
It is the responsibility of each student to ensure that any direct or indirect inclusion of the work of others is fully and adequately acknowledged. We appreciate that plagiarism may be unintentional however it will still be treated as an offence. The Tutoring team can answer any plagiarism related queries, but as a general rule, if in doubt, include attribution of all sources.
Students are encouraged to ask mentors, tutors and their peers for advice about their project work but any submission should not include any code written by others, unless it is explicitly credited to them. Failure to correctly credit code that a student hasn't created themselves will be considered plagiarism and will result in a failing grade. Blatant or repeat offences of plagiarism will not be tolerated and will result in stringent penalties being applied, including removal from the course.