Technical Artefact 1 Assessment Task 2

Assessment 2

The program should be implemented in Python. The client has specified the following requirements for the functionality of the program: 

1. The program should be running without errors throughout two Phases: Information Gathering and Information Presenting. 
2. Information Gathering is to gather the information from users such as a valid word (valid inputs: any single word only including letter “r”, “e”, “d”, “b”, “l” and “u”, one letter can appear more than once in the word, case sensitive) and a break-word to break the iteration (valid inputs: “END”, case insensitive).
3. If the user enters nothing or invalid input (e.g., “12”, “5.8” or “abc”), the program should alert an error message by a print function and then ask the user to re-enter. The process should iterate until a valid input is entered.
4. Information Presenting is to present the outcome. Once receiving a new valid word from users, the program should print the word in a n x 6 grid (one word each time, no extra space between different letters. For example, each letter is presented in a 6 x 6 grid. A word with three letters will be in an 18 x 6 grid as Figure 1). 
5. The program will continue to ask the user to enter a word until the break-word “END” is inputted and the program stops. 
6. The word presented in the n x 6 grid should be the same as the letter/word in Figure 1 (pay attention to the index value for each “*”). Do not show the table and index number. Just show the word using “*”. 
7. The code of printing the word should be organized efficiently with iterations and conditionals as the sample solution of Practice 3 question b2. Just printing the word one line by one line using print (“***”) is not acceptable.

Program Integration Test

You need to test the program for all functionality thoroughly before delivering the program to the client. After testing, please remove the testing code in the final version. The program should be running appropriately without any syntax or logic errors.

Suggested Strategy

Plan to complete the assignment on time. Do not write all of the code in one sitting and expect everything to work smoothly like magic.

First step Read the assignment specification carefully; clarify anything unclear by putting a post on the assignment forum; think about how to do it, how to test it, and devise high-level algorithms for each independent part of the assignment. Then, begin to write the program (with comments) in incremental stages. Seek help on the assignment forum if needed.

Second step Re-read the specification carefully. Try to implement the function in one task at a time, test it and make sure it works as expected before moving to the next task. Integrate all functions and finish initial coding.

Assessment Requirements Brief Summary

Assessment 2 required the development of a Python-based interactive program that runs smoothly without syntax or logic errors and follows a clearly defined workflow across two phases: Information Gathering and Information Presenting.

Key Pointers Covered in the Assessment

• The program must be implemented entirely in Python.
• It should operate continuously until the break-word “END” (case-insensitive) is entered.
• Information Gathering Phase:
  • Accept a valid single-word input containing only the letters r, e, d, b, l, u (case-sensitive).
  • Allow repeated letters within the word.
  • Reject empty or invalid inputs (numbers, decimals, unrelated letters).
  • Display an error message and re-prompt the user until valid input is provided.
• Information Presenting Phase:
  • Display each valid word in an n × 6 grid, where each letter is represented using a 6 × 6 star (*) pattern.
  • Ensure no extra spaces between letters and no index or table values are shown.
  • Use loops and conditionals efficiently rather than hardcoded print statements.
• Program Integration Testing:
  • All program functionalities must be tested thoroughly.
  • Testing code must be removed from the final submission.
• The final program must run correctly without errors and follow the suggested incremental development strategy.

Academic Mentor’s Step-by-Step Guidance Approach

The academic mentor guided the student through a structured and incremental development process, ensuring clarity, correctness, and alignment with assessment criteria.

Step 1: Understanding the Specification

The mentor began by helping the student carefully analyze the assignment brief. Each requirement was broken down into smaller, manageable components, such as input validation, loop control, grid formatting, and termination conditions. This ensured no part of the specification was overlooked.

Step 2: Planning the Program Structure

Before writing code, the mentor guided the student in designing a high-level algorithm:

• Separate logic for input validation and output rendering
• Use of loops to manage repeated user input
• Clear conditions to handle invalid input and termination using “END”

This planning stage helped the student visualize program flow and reduced logical errors later.

Step 3: Implementing Information Gathering

The mentor supported the student in coding input validation logic:

• Checking for empty input
• Ensuring only permitted letters were used
• Handling invalid entries with meaningful error messages
• Repeating the input prompt until valid data was received

This step reinforced good practices in user input handling and defensive programming.

Step 4: Implementing Information Presenting

Next, the mentor guided the student in implementing the grid-based word display:

• Creating reusable patterns for each valid letter
• Using nested loops and conditionals to dynamically construct the n × 6 grid
• Ensuring formatting accuracy as per the provided figure
• Avoiding hardcoded print statements to meet efficiency requirements

Step 5: Integration and Testing

The mentor emphasized incremental testing after completing each functional block:

• Verifying correct behavior for valid and invalid inputs
• Testing multiple words and termination conditions
• Checking output alignment and formatting accuracy

Once confirmed, the mentor advised removing all test-related code from the final version.

Outcome Achieved and Learning Objectives Covered

Final Outcome

• A fully functional Python program that runs without errors
• Correct handling of user input and termination conditions
• Accurate star-based grid representation of words
• Clean, efficient, and well-structured code using loops and conditionals

Learning Objectives Achieved

• Understanding and implementing program specifications
• Writing robust input validation logic
• Applying iterative and conditional programming concepts
• Structuring code for readability and efficiency
• Conducting integration testing and debugging
• Developing programs incrementally following best practices

Need Assignment Help? Learn Smartly or Get a Custom Solution You Can Trust

Our sample assignment solution is available to help you understand the correct structure, logic, and academic approach required for this assessment. It is designed to support your learning and give you clarity on how high-quality answers are developed.

Important: This sample is provided for reference purposes only. Submitting it as your own work may lead to plagiarism detection and serious academic consequences. Always use sample solutions responsibly to guide your understanding, not as a final submission.

If you need a solution that you can confidently submit, we offer fresh, plagiarism-free, custom-written assignments created by experienced academic writers. When you order a new solution, you receive:

• 100% original content written from scratch
• Zero plagiarism with proper citations and referencing
• Content tailored exactly to your university guidelines
• On-time delivery with quality assurance checks
• Subject-expert writers who understand grading criteria

Choose the option that fits your needs:

Download Sample Solution                  Order Fresh Assignment