Creating an object oriented computer program
CITY & GUILDS LIMITED
Vocational
This topic covers implementing, refining, and testing object-oriented programs. Learners must demonstrate proficiency in OOP concepts such as classes, inheritance, polymorphism, and testing.
9
Learning Outcomes
28
Assessment Guidance
29
Key Skills
9
Key Terms
38
Assessment Criteria
Assessment criteria
City & Guilds Level 2 Diploma in ICT Professional Competence
City & Guilds Level 3 Diploma in ICT Systems Support
City & Guilds Level 3 Diploma in ICT Professional Competence
City & Guilds Level 2 Certificate in ICT Systems Support
City & Guilds Level 2 Award in ICT Systems and Principles
City & Guilds Level 2 Diploma in ICT Systems and Principles for IT Professionals
City & Guilds Level 3 Diploma in ICT Systems and Principles for IT Professionals
City & Guilds Level 3 Certificate in ICT Systems and Principles
City & Guilds Level 4 Diploma For ICT Professionals (Systems and Principles)
Topic Overview
The City & Guilds Level 2 Award in ICT Systems and Principles provides a foundational understanding of information and communication technology, covering hardware, software, networking, and the principles of ICT systems. This qualification is designed for students who want to develop practical skills and theoretical knowledge essential for further study or entry-level roles in IT support, digital literacy, or systems administration.
The course explores how computer systems work, from the internal components of a PC to the way data is transmitted across networks. Students learn about operating systems, application software, and the importance of security and data protection. By the end of the award, you will be able to identify system components, troubleshoot common issues, and understand the ethical and legal implications of ICT use.
This qualification fits into the wider subject of Computer Science by bridging the gap between basic digital literacy and more advanced topics like programming or network engineering. It is ideal for students who want a hands-on, practical understanding of ICT systems without delving into complex coding or theoretical computer science. Mastery of these principles is crucial for anyone pursuing a career in IT support, technical sales, or further vocational training.
Key Concepts
Core ideas you must understand for this topic
- →Hardware components: Understand the function of CPU, RAM, storage devices (HDD, SSD), motherboard, and peripherals, and how they interact to process data.
- →Software types: Differentiate between system software (operating systems, drivers) and application software (word processors, spreadsheets), and know their roles in a computer system.
- →Networking basics: Learn about LAN, WAN, IP addresses, protocols (TCP/IP), and network devices (router, switch) to understand how data is transmitted and shared.
- →Data storage and units: Know binary representation, units (bit, byte, KB, MB, GB), and how data is stored and measured in ICT systems.
- →Security and legal issues: Understand threats like malware, phishing, and the importance of passwords, firewalls, and legislation such as the Data Protection Act and Computer Misuse Act.
Learning Objectives
What you need to know and understand
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement a software design using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program, Document an object oriented driven program
Assessment Criteria
Key criteria assessors look for in your portfolio
- Implement a program using classes, objects, and inheritance.
- Refine code to improve quality (e.g., readability, efficiency, maintainability).
- Test the program using appropriate test cases and document results.
- Implement a program using classes and objects.
- Apply inheritance and polymorphism appropriately.
- Refine code to improve efficiency and readability.
- Test the program using a range of test data.
- Document test results and fix identified errors.
- Implement a program using classes and objects.
- Apply inheritance and polymorphism correctly.
- Refine code to improve efficiency and readability.
- Test program functionality using appropriate methods.
- Award credit for demonstrating correct class definition with appropriate attributes and methods, showing encapsulation through private/protected members and public interfaces.
- Award credit for implementing inheritance and polymorphism where relevant, such as superclass/subclass relationships and method overriding, aligned with the program specification.
- Award credit for refining code through iterative improvements, including meaningful variable naming, commenting, and applying DRY (Don't Repeat Yourself) principle.
- Award credit for systematic testing evidence, including a test plan with test cases covering normal, boundary, and erroneous inputs, and documentation of actual results against expected outcomes.
- Award credit for resolving identified defects and providing a final working program that meets all functional requirements of the design brief.
- Implement a program using classes, objects, inheritance, and polymorphism.
- Refine code to improve readability, efficiency, or maintainability.
- Test program operation using appropriate test cases.
- Document code and test results clearly.
- Debug errors systematically.
- Implements a program using classes and objects.
- Applies inheritance and polymorphism appropriately.
- Refines code to improve efficiency and readability.
- Tests the program thoroughly and documents results.
- Implements software using object-oriented principles.
- Refines programs to improve quality and efficiency.
- Tests programs to ensure correct operation.
- Documents code and uses version control appropriately.
- Implement a program using object-oriented concepts.
- Refine code to improve quality (e.g., readability, efficiency).
- Test the program to identify and fix errors.
- Use appropriate data structures and algorithms.
- Implement a software design using OOP.
- Refine an OOP program to improve quality.
- Test the operation of an OOP program.
- Document an OOP program.
Assessment Guidance
Guidance for achieving higher grades
- 💡Use meaningful variable and method names.
- 💡Write unit tests for each method.
- 💡Refactor code iteratively to improve quality.
- 💡Plan your class hierarchy before coding.
- 💡Use meaningful variable and method names.
- 💡Test incrementally as you develop each class.
- 💡Use UML diagrams to plan class structures.
- 💡Write unit tests alongside code to verify functionality.
- 💡Refactor code iteratively to improve quality.
- 💡Start by thoroughly planning your classes with a UML diagram or simple structure outline before coding to ensure you meet all OOP requirements and assessment criteria.
- 💡Demonstrate refinement explicitly by submitting version histories or annotating changes made to improve efficiency, readability, or error handling—assessors value evidence of iterative development.
- 💡For testing, create a test harness or use a simple framework (if permitted) to show automated testing; otherwise, present a structured table with test ID, input, expected output, actual output, and pass/fail status.
- 💡Remember that quality in OOP extends beyond functionality: ensure your code is properly formatted, commented, and avoids duplication. Use static analysis tools if available to evidence refinement.
- 💡Use meaningful names for classes and methods.
- 💡Write unit tests for each method.
- 💡Refactor code incrementally rather than all at once.
- 💡Plan your class hierarchy before coding.
- 💡Use meaningful names for classes and methods.
- 💡Write unit tests for each method.
- 💡Plan class design before coding.
- 💡Write unit tests for each method.
- 💡Refactor code to improve readability and maintainability.
- 💡Use UML diagrams to design classes.
- 💡Write unit tests for each method.
- 💡Refactor code to remove duplication.
- 💡Use design patterns where appropriate.
- 💡Write test cases before coding.
- 💡Comment code clearly.
- 💡When describing hardware components, always link their function to the overall system performance. For example, explain how more RAM allows more applications to run simultaneously without slowing down the computer.
- 💡For networking questions, use the OSI model or TCP/IP layers to structure your answer. Even if not explicitly required, showing you understand the layers demonstrates deeper knowledge.
- 💡In security questions, always mention both technical measures (firewalls, encryption) and human factors (user training, strong passwords) to show a holistic understanding.
Common Mistakes
Common errors to avoid in your coursework
- Misunderstanding inheritance or using it incorrectly.
- Neglecting to handle exceptions or edge cases in testing.
- Poor code structure leading to difficulty in refinement.
- Confusing class and object definitions.
- Not using inheritance correctly leading to code duplication.
- Insufficient testing or not covering edge cases.
- Misusing inheritance leading to tight coupling.
- Neglecting to handle exceptions or edge cases.
- Inadequate testing coverage for all paths.
- Confusing classes and objects: students may try to use a class directly without instantiation, or fail to create multiple instances to demonstrate object independence.
- Overcomplicating OOP design by forcing inheritance where a simple class hierarchy isn't necessary, leading to unnecessary complexity and poor maintainability.
- Neglecting to properly test all methods, especially setter/getter methods, resulting in hidden bugs where state changes are not validated.
- Failing to document test evidence clearly, such as not recording actual outputs alongside expected results, making it impossible for an assessor to verify the testing process.
- Misunderstanding the 'self' or 'this' keyword, causing errors in method definitions and variable scope within class instances.
- Not planning class hierarchy before coding.
- Ignoring encapsulation principles (e.g., public fields).
- Insufficient testing of edge cases.
- Creating classes with too many responsibilities.
- Not using access modifiers correctly.
- Skipping edge cases in testing.
- Overcomplicating class hierarchies unnecessarily.
- Neglecting to test edge cases.
- Failing to use encapsulation properly.
- Not planning class hierarchy before coding.
- Ignoring encapsulation by exposing internal data.
- Insufficient testing leading to undetected bugs.
- Poor class design and lack of encapsulation.
- Insufficient testing, especially unit tests.
- Inadequate documentation.
- Misconception: RAM and storage are the same thing. Correction: RAM is temporary memory used for active processes, while storage (HDD/SSD) holds data permanently even when the computer is off.
- Misconception: The internet and the World Wide Web are identical. Correction: The internet is a global network of computers, while the Web is a service that runs on the internet (using HTTP) to access websites.
- Misconception: More cores always mean faster performance. Correction: Performance depends on software optimisation; some tasks benefit from multiple cores, but clock speed and architecture also matter.
Frequently Asked Questions
Common questions students ask about this topic
Pass / Merit / Distinction Evidence Checklist
How your portfolio evidence is graded for CITY & GUILDS LIMITED Creating an object oriented computer program
Every vocational unit is marked against named criteria rather than an exam percentage. Your tutor's brief lists the exact codes for this unit — here is what each band is asking you to do.
Pass (P)
Demonstrate baseline knowledge, accurate terminology, and core practical application.
Merit (M)
Provide detailed analysis, structured explanations, and clear workplace reasoning.
Distinction (D)
Deliver thorough evaluation, original problem solving, and fully justified recommendations.
Before You Start
Prior knowledge that will help with this topic
- •Basic digital literacy: Ability to use a computer, open applications, and browse the internet confidently.
- •Understanding of simple mathematical concepts like binary numbers and data units (bits, bytes) is helpful but not essential.
- •No prior programming knowledge is required, but an interest in how computers work will make the course more engaging.
Coursework AI Review
Paste your assignment brief and check your draft against its P/M/D criteria
Key Terminology
Essential terms to know
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement software using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program
- Implement a software design using object oriented programming, Refine an object oriented program to improve quality, Test the operation of an object oriented driven program, Document an object oriented driven program
Ready to learn?
AI-powered learning tailored to this unit