OFFERS!
Get Expert-crafted assignments
Get Expert-crafted assignments
Save 51%
Get Expert-crafted assignments
| Category | Assignment | Subject | Programming |
|---|---|---|---|
| University | Cardiff Metropolition University | Module Title | CMP7001 Advanced Programming |
| Word Count | 3000 Words |
|---|---|
| Assessment Type | PRAC1 |
| Assessment Title | Practical implementation of a software system prototype. |
| Academic Year | 2025/26 |
|
Assessment title |
Abr. |
Weighting |
|
Practical implementation of a software system prototype. |
PRAC1 |
75% |
|
Pass marks are 40% for undergraduate work and 50% for postgraduate work unless stated otherwise. |
||
To demonstrate the system design skills you have developed in CMP7001 you are required to work in teams of two or three to design, build, and test a software system to meet the scenario below.
You may choose who to work with.
Myriad Medical Services (MMS) Ltd. is a private medical centre offering its patients a wide range of services. The centre relies on multiple Airtable databases to book in patients, assign patients to clinicians, record treatments and charges, and record when patients pay the charges in full. MMS would like to replace its current system as it is obsolete and no longer supports its key business processes.
The company has approached you to develop a new system with the following requirements:
Non-Functional Requirements
Deliverable
For this part of the project, you are required to produce and submit the following:
1.A written project report containing the following design elements:
2.An implementation, in Java, of your software prototype based on the above description and requirements. It is recommended that you use appropriate source control (GitHub for example) to manage the development of your solution. Note that as part of your implementation, you are required to also implement the unit tests outlined in your test plan.
It is up to you how you choose to divide the tasks between the team members, but each team member must contribute an equivalent of approximately 3,000 words of work (including written content, diagrams, and code). An identical copy of the report must be submitted by each member, with a contributions page immediately following the cover page with the name and student ID of each member, detailing their specific contributions.
Word count (or equivalent): 3000 (per student in the group)
This a reflection of the effort required for the assessment. Word counts will normally include any text, tables, calculations, figures, subtitles and citations. Reference lists and contents of appendices are excluded from the word count. Contents of appendices are not usually considered when determining your final assessment grade.
|
Submission Deadline: |
This will be provided on the Moodle submission point. |
Estimated Feedback Return Date |
This will normally be 20 working days after initial submission. |
|
Submission Time: |
By 4.00pm on the deadline day. |
|
|
|
Moodle/Turnitin: |
Any assessments submitted after the deadline will not be marked and will be recorded as a non-attempt unless you have had an extension request agreed or have approved mitigating circumstances. See the School Moodle pages for more information on extensions and mitigating circumstances. |
||
|
File Format: |
A PDF of your project report should be submitted to Moodle. You can include a link to an unlisted repository containing your code, or include the code files as a zip file. Your assessment should be titled with your: student ID number, module code and assessment ID, e.g. st12345678-CMP7001-PRAC1.pdf |
||
|
Late Submission Window Eligibility |
Where submissions are eligible for the late-submission window this will be communicated in the relevant assessment submission point within Moodle. |
||
|
Feedback |
Feedback for the assessment will be provided electronically via Moodle. Feedback will be provided with comments on your strengths and the areas which you can improve. View the guidance on how to access your feedback. All marks are provisional and are subject to quality assurance processes and confirmation at the programme Examination Board. |
||
Stuck Your CMP7001 PRAC1 Assignment? Deadlines Are Near?
Hire Assignment Helper Now!On successful completion of this module, students will be able to:
1.Critically evaluate the utility of object-oriented principles such as abstraction, reusability, inheritance, and encapsulation.
2.Adapt to the advanced concepts in programming with polymorphic constructs through generics and collections.
3.Apply best practices to write secure software through exception handling.
4.Solve real life problems by using object-oriented constructs and design patterns. Develop proficiency in a high-level programming language at an advanced stage.
5.Develop proficiency in a high-level programming language at an advanced stage.
Other skills/attributes developed
This includes elements of the Cardiff Met EDGE (Ethical, Digital, Global and Entrepreneurial skills) and other attributes developed in students through the completion of the module and assessment. These will also be highlighted in the module guidance, which should be read by all students completing the module. Assessments are not just a way of auditing student knowledge. They are a process which provides additional learning and development through the preparation for and completion of the assessment.
This module assessment provides opportunities for students to demonstrate development of
the following EDGE Competencies:
|
Allocation of marks |
Marks |
|
Report |
(70%) |
|
Use Case Diagram (LO1) |
10 |
|
Use Case Documentation (LO1) |
10 |
|
Behavioural Diagrams (Sequence / Collaboration) (LO1) |
15 |
|
Class Diagram / class dictionary (LO1, LO2, LO4) |
20 |
|
Unit Test Plan & Documentation (LO1) |
15 |
|
Implementation |
(30%) |
|
Object Oriented Implementation (correct alignment with your class diagram and implementation of the required functionality) (LO4, LO5) |
10 |
|
Polymorphic features (LO2, LO5) |
5 |
|
Design Pattern Implementation (LO4, LO5) |
5 |
|
Exception Handling (LO3, LO5) |
5 |
|
Unit Test Implementation (LO1) |
5 |
|
Total |
100 |
|
Grade |
Criteria |
|
70 – 100% (Distinction) |
An excellent report / design document is given. The Use-Case diagram shows all key Use-Cases and Actors, as well as the relevant associations. The Use-Case documentation is very detailed and shows clearly the main and alternate scenarios. The behavioural diagrams are very detailed and correctly show the relevant classes and interactions between them to accomplish the given scenario. The class diagram contains all key classes, with correct associations given, showing excellent understanding of UML notation and design pattern structures. The class dictionary lists all relevant attributes, including references matching associations in the class diagram, as well as all relevant methods. An excellent range of unit tests has been documented that test all aspects of the system and exception handling capability. An excellent implementation is given that demonstrates a deep understanding of object-oriented design principles. The implemented classes and resulting object graphs match the class model given in the documentation. Excellent use of polymorphic features as well as creational, structural and behavioural design pattern structures is evident to accomplish the requirements of the system. An extensive exception handling system is given showing an excellent understanding of error handling code. An excellent range of unit tests have been correctly implemented and match those tests documented in the test plan. |
|
60 - 69% (Merit) |
A very good report / design document is given. The Use-Case diagram shows all key Use-Cases and Actors, as well as most of the relevant associations. The Use-Case documentation is detailed and shows the main and alternate scenarios, though some aspects could be expanded upon. The behavioural diagrams are detailed and correctly show the relevant classes and interactions between them to accomplish the given scenario. The class diagram contains most of the key classes and correct associations between them, showing very good understanding of UML notation and design pattern structures. The class dictionary lists most relevant attributes, including references matching associations in the class diagram, as well as most relevant methods. A very good range of unit tests has been documented that test most aspects of the system and exception handling capability. A very good implementation is given that includes most of the needed object-oriented principles. The implemented classes and resulting object graphs mostly match the class model given in the documentation. Very good use of polymorphic features as well as creational, structural and behavioural design pattern structures is evident to accomplish the requirements of the system. A very good exception handling system is given that captures most relevant errors that can occur. A very good range of unit tests have been correctly implemented where most of the documented tests have been implemented. |
|
50 - 59% (Pass) |
A good report / design document is given. The Use-Case diagram shows many Use-Cases and Actors, as well as most of the relevant associations, but this could be expanded upon. The Use-Case documentation shows most the main scenario and some attempt has been made to document the alternate scenarios, though this needs to be expanded upon. The behavioural diagrams show the relevant classes and interactions between them to accomplish the given scenario, but more detail is needed and a number of minor errors are evident. The class diagram contains most key classes and associations between them, showing a good understanding of UML notation and design pattern structures. However, some minor errors and omissions are evident. The class dictionary lists most relevant attributes, including references matching associations in the class diagram, as well as most relevant methods. A good range of unit tests has been documented but these need to be expanded. A good implementation is given that includes some of the needed object-oriented principles. The implemented classes and resulting object graphs partially match the class model given in the documentation, but the implementation lacks documented / needed functionality. Some use of polymorphic features as well as creational, structural and behavioural design pattern structures is evident, but a number of errors exist throughout the implementation. Some exception handling is evident but needs to be expanded – a number of errors remain uncaught in the given implementation. A good range of unit tests have been correctly implemented but not all relevant aspects of the system are tested. |
|
40 - 49% (Narrow Fail) |
A basic report / design document is given. The Use-Case diagram shows only a few relevant Use-Cases, Actors and associations, but this needs much more detail. The Use-Case documentation shows most aspects of the main scenario, but no attempt has been made to document the alternate scenarios. The behavioural diagrams show some of the relevant classes and interactions between them but much more detail is needed, and a number of errors are evident throughout. The class diagram contains some classes and associations, but a number of errors are evident showing only a basic understanding of UML notation and design pattern structures. The class dictionary lists some relevant attributes, including references matching associations in the class diagram, as well as some relevant methods. However, the class documentation does not match the class diagram – key discrepancies are evident. A limited range of unit tests have been documented and these need to be expanded upon. A basic implementation is given that includes only a few of the relevant object-oriented principles. The implemented classes and resulting object graphs lack key functionality and need to be expanded and do not fully match the class model given in the documentation. An attempt has been made to implement polymorphic features as well as creational, structural and behavioural design pattern structures, but a number of key errors are evident. Very basic exception handling is evident but needs to be expanded – a number of potential errors remain uncaught in the given implementation. A basic range of unit tests have been implemented but not all relevant aspects of the system are tested. |
|
35 - 39% (Fail) |
A very basic report / design document is given. The Use-Case diagram shows only a few Use-Cases, Actors and associations but a number of significant errors exist. The Use-Case documentation shows little to no elements of the main scenario, and no attempt has been made to document the alternate scenarios. The behavioural diagrams show few classes and interactions and contains a number of significant errors so that building a system from this design would not be possible. The class diagram contains few to no relevant classes and associations, showing little to no understanding of UML notation and design pattern structures. The class dictionary lists few relevant attributes, with few to no references matching associations in the class diagram evident. The class documentation does not match the class diagram – key discrepancies are evident throughout. Few to no meaningful unit tests have been documented. A very basic implementation is given that includes few relevant object-oriented principles. The functionality is bare-bones and does not need to requirements of the system given above. An attempt has been made to implement polymorphic features as well as creational, structural and behavioural design pattern structures, but these are incorrect and do not work. Little to no exception handling is evident but needs to be expanded – a large number of potential errors remain uncaught in the given implementation. A very basic range of unit tests have been implemented and little of the actual system is tested. |
|
<35% (Low Fail) |
A very poor submission. The Use-case documentation does not capture the requirements of the system. The class model does not adequately model the system, with little to no understanding of Object-Oriented principles evident. No meaningful test plan is given. The implementation includes little to no relevant design elements and little to no functionality required by the system is evident. Polymorphism and design pattern structures are either not implemented or do not function at all. Little to no error handling or testing is evident. |
Order Custom Answers for CMP7001 PRAC1 Assignment
Order Non Plagiarized AssignmentStruggling with your CMP7001 Advanced Programming PRAC1 Assignment? Let us help! We offer professional, affordable assignment writing services that are AI-free, plagiarism-free, and delivered on time. Our team of PhD experts understands what universities expect and creates high-quality content tailored to your needs. We also offer free assignment samples so you can check our quality before booking. Our expert team provides Programming Assignment Help that has been designed for the students. We’re available 24/7 to support you. Don’t wait until the last minute—contact us now and make your academic life easier with trusted expert assignment help!
Let's Book Your Work with Our Expert and Get High-Quality Content
