Software Engineering 2 —
Training activity: 3

Details

Implement key aspects of code in a software development project in at least one of the following areas:

• Databases
• Modeling
• Image processing

Type

Entrustable training activity (ETA)

Evidence requirements

Evidence the activity has been undertaken by the trainee repeatedly, consistently, and effectively over time, in a range of situations. This may include occasions where the trainee has not successfully achieved the outcome of the activity themselves. For example, because it was not appropriate to undertake the task in the circumstances or the trainees recognised their own limitations and sought help or advice to ensure the activity reached an appropriate conclusion. ​

Reflection at multiple timepoints on the trainee learning journey for this activity.

Considerations

• Scientific requirements
• Legislation and guidance
• The use of the software application in patient care or service delivery
• Good programming practice including version control system, appropriate software tools etc.

Reflective practice guidance

The guidance below is provided to support reflection at different time points, providing you with questions to aid you to reflect for this training activity. They are provided for guidance and should not be considered as a mandatory checklist. Trainees should not be expected to provide answers to each of the guidance questions listed.

Before action

• What are the intended outcomes of implementing these key aspects of code in the software development project? How will you know that your implementation is successful, meets the project’s requirements, and follows good software design principles?
• What is your prior experience with implementing code, particularly in areas like databases, modelling, or image processing? What do you already know about the specific programming languages, techniques (such as object-oriented programming, exception handling, or container classes), or technologies involved? Consider similar previous experiences you may have had.
• What specific programming skills, software design practices or knowledge related to the chosen implementation area do you want to develop? What insights do you hope to gain about the coding process, debugging, or integrating your code within a larger project?
• Will you review relevant documentation, code libraries, or specific programming concepts needed for the implementation? Will you discuss the implementation plan, technical requirements, and design considerations with your training officer or project team? Consider possible challenges you might face during coding (e.g., complex logic, integrating with existing code, performance issues) and think about how you might handle them.

In action

• As you implement code in the chosen area (Databases, Modelling, or Image processing), does anything feel surprising or different from what you anticipate? For example, does a specific database query perform unexpectedly slowly even after initial optimisation, does a machine learning model produce completely erroneous outputs for a particular data subset, or does an image processing filter introduce unexpected visual artifacts that were not predicted? You might also encounter a complex bug that defies initial debugging attempts, or find that integrating your newly written code with existing project components is far more challenging than foreseen due to unforeseen API incompatibilities.
• Consider how this experience compares with previous experiences of similar coding, implementation, or debugging activities.
• Identify how this impacts upon your actions. Do you respond appropriately in the moment, perhaps by immediately initiating a detailed debugging session, consulting specific API documentation for the problematic library, or searching for relevant solutions on developer forums? Do you adapt or change your coding approach or implementation strategy as a result, perhaps by refactoring a section of code on the fly, deciding to use a different algorithm for a modelling task, or adjusting your data handling for image processing? Does it affect your ability to undertake the activity independently, causing you to consider reaching out for immediate help?
• Do you find it difficult to adapt your coding or debugging strategy when faced with a persistent problem? Does it affect your confidence in your ability to resolve the issue independently? Do you feel positive you can reach a successful conclusion, like a fully functional and integrated code segment?
• Identify how you work within your scope of practice when dealing with the unexpected event during coding. Do you recognise when you might need to seek immediate advice or help from a training officer or colleague, such as when a bug points to a fundamental architectural flaw you cannot resolve, or when a performance issue requires specialist knowledge of database indexing?
• Identify what you learn as a result of the unexpected development during the activity. For instance, do you learn a new debugging technique, a specific workaround for a known library issue, or a more efficient coding pattern for a particular scenario?

On action

• Begin by summarising the key points of the experience, including the specific coding task you undertook in your chosen area (Databases, Modelling, or Image processing), the technologies used, and the outcome of your implementation.
• Consider specific events, actions, or interactions which felt important during the activity, such as encountering a difficult bug, successfully implementing a complex algorithm, or challenges in integrating your code.
• Include any reflect-in-action moments you noted, where you adapted to the situation as it unfolded (e.g., trying a different debugging strategy, changing your implementation approach based on a technical issue).
• Reflect on your own feelings during the experience, such as feeling challenged by the code, satisfied with solving a problem, or frustrated by technical difficulties.
• Identify what learning you can take from the experience5. What strengths did you demonstrate in writing code, using good software design and programming practice, or using programming languages? What skills and/or knowledge gaps were evident (e.g., understanding specific algorithms, debugging techniques, proficiency in a particular language)?
• Compare this experience against previous engagement with similar activities, if any. Were any previously identified actions for development achieved? Has your practice improved?
• Identify any challenges you experienced and how you reacted to these (e.g., dealing with performance issues, integrating with existing code, understanding complex documentation). Did this affect your ability to deal with the situation? Were you able to overcome the challenges?
• Did you need to seek advice or clarification from your training officer or colleagues regarding the implementation, design, or debugging? Did you need to ensure you were working within your scope of practice?
• What will you do differently next time you implement code in this area?
• Has anything changed in terms of what you would do if you were faced with a similar situation again?
• Do you need to practise any aspect of the activity further, such as specific programming techniques, using particular libraries, or refining your debugging process?
• How does this experience relate to successfully writing code, using good design/programming practice, using programming languages, developing applications, or developing testing protocols?

Beyond action

• Have you reviewed your previous reflections (before, in, and on action) from undertaking this activity? What actions did you identify you would need to take to improve your coding practice, software design, language use, application development, or testing protocols? Have you completed these actions? Are you ready to demonstrate this new learning into practice?
• How does your understanding of implementing code in Databases, Modeling, or Image processing now compare to your earlier reflections?
• Did discussing code implementation, design practices, or language use with others provide new technical or problem-solving insights?
• Compare your experiences of undertaking this training activity with experiences from other training activities such as writing software using advanced techniques or developing applications. How have you assimilated observable coding practices, design approaches, or debugging strategies into your own practice?
• How has repeatedly undertaking this activity influenced your ability to write code, use good software design and programming practice, use programming languages effectively, develop applications and develop testing protocols?
• Consider how your learning from this training activity will support you in preparing for assessments on profiling code and testing software.
• How has your practice in coding and software implementation developed and evolved over time? Do you now recognise more readily when a technical challenge is beyond your current skill level, and when you need to seek advice or clarification from your training officer or colleagues?
• Identify the transferable skills you are developing through this activity, such as problem-solving, logical thinking, attention to detail, debugging, and using technical documentation. How have you applied these skills in other training activities or aspects of your work?

Relevant learning outcomes

#	Outcome
# 3	Outcome Write code required for a software engineering project.
# 4	Outcome Use good software design and programming practice.
# 5	Outcome Use programming languages.
# 6	Outcome Develop applications using a web browser as the user interface.
# 7	Outcome Develop a protocol for testing a piece of software.