# Programming Activities Mapped to Bloom's Taxonomy

Here are some key programming activities from reading a problem statement to writing optimal code:

Read and comprehend the problem statement and constraints

Come up with clarifying questions to resolve ambiguities

Analyze core requirements and isolate key components

Connect to related patterns, concepts and analogies

Determine optimal data structures for modeling the problem

Break down requirements into smaller modular sub-problems

Explore different algorithms and logic approaches to solve each sub-problem

Analyze time and space complexity tradeoffs to select most efficient algorithms

Design clean interfaces and abstractions to connect components

Write tests cases covering edge cases, invalid inputs, performance constraints

Implement in a modular fashion with separation of concerns

Refactor to improve readability, simplicity, scalability and maintainability

Profile, instrument and debug the code to identify bottlenecks

Optimize critical paths and pain points surfaced through measurements

Add robust error handling, input validation and defensive checks

Evaluate against test cases and fix issues revealed

The end-to-end process spans understanding requirements, modeling the problem, systematic decomposition into modules, optimizing algorithms and data structures, refining architecture, instrumentation and targeted performance tuning.

**Read Problem Statement**: Understand the problem, its constraints, and its requirements.**Identify Inputs/Outputs**: Determine what the inputs and outputs are and their data types.**Analyze Constraints**: Understand any limitations on time and space complexity.**Initial Breakdown**: Divide the problem into subproblems or steps that lead to a solution.**Brainstorm Approaches**: Consider different algorithms or data structures that can be used.**Pseudocode**: Write pseudocode for the most promising approach. This will be your rough draft.**Time Complexity Analysis**: Estimate the time complexity of your algorithm to check if it meets the problem’s constraints.**Code Brute-Force Solution**: If possible, write a brute-force solution to have something to test against.**Test Brute-Force**: Manually or automatically test this solution for correctness on sample inputs.**Optimize**: Look for parts of your algorithm that can be optimized in terms of time or space complexity.**Write Optimal Code**: Implement the optimized solution.**Review Code**: Check for any syntax errors, logical mistakes, or inefficiencies.**Unit Testing**: Write tests to confirm the code works as expected. Include edge cases.**Debug**: If the code fails any tests, identify the issue and resolve it.**Revisit Time Complexity**: After coding, revisit the time complexity analysis to make sure it aligns with your initial estimation.**Documentation**: Add comments to your code explaining key portions.**Peer Review**: Optionally, have a colleague or mentor review your code for mistakes or improvements.**Run on Large Inputs**: Final test to check if it meets time and space constraints.**Submission**: Once all tests pass and you’re satisfied with your solution, submit your code.**Post-Submission Analysis**: After submission, analyze what you’ve learned, what could be improved, and how you can apply these learnings to future problems.

Here is a table mapping the programming activities to levels in Bloom’s Taxonomy:

Bloom’s Taxonomy | Programming Activities |
---|---|

Remember | Reading problem statement |

Understand | Comprehending requirements, connecting to concepts |

Apply | Designing data structures, algorithms and abstractions |

Analyze | Breaking into sub-problems, analyzing complexity tradeoffs |

Evaluate | Writing tests, critiquing and refactoring solution |

Create | Implementing modular solution, optimizing performance |

Remember - Understanding problem statement

Understand - Comprehending core requirements

Apply - Designing data structures and algorithms

Analyze - Decomposing into sub-problems, analyzing complexity

Evaluate - Writing tests, refactoring code

Create - Implementing solution, optimizing performance

This maps the programming tasks to increasing cognitive process categories:

- Remembering and understanding the problem
- Applying algorithms and data structures
- Analyzing to decompose and critique solution
- Creating the modular, optimized implementation

The taxonomy provides a model for structuring critical thinking skills applied during programming.

Bloom’s Taxonomy Level | Programming Activities | Description |
---|---|---|

Knowledge | Read Problem Statement | Understand the basic facts and information about the problem. |

Comprehension | Identify Inputs/Outputs | Interpret the meaning of problem requirements and constraints. |

Application | Code Brute-Force Solution | Apply knowledge to solve the problem in a straightforward manner. |

Analysis | Initial Breakdown, Analyze Constraints | Divide the problem and identify its elements; understand constraints and their implications. |

Analysis | Time Complexity Analysis | Analyze the algorithm’s performance and efficiency. |

Analysis | Debug | Identify the elements causing the failure in the code. |

Synthesis | Brainstorm Approaches, Write Pseudocode | Combine different concepts to form a new whole, plan steps for coding. |

Synthesis | Write Optimal Code | Integrate optimizations to create an efficient solution. |

Synthesis | Documentation, Peer Review | Assemble code and comments in a coherent form, integrate feedback. |

Evaluation | Test Brute-Force, Unit Testing | Make judgments about the validity and reliability of the solution. |

Evaluation | Revisit Time Complexity | Re-evaluate the efficiency of the final code and compare it to initial estimates. |

Evaluation | Post-Submission Analysis | Evaluate the entire process and the solution’s effectiveness, and identify areas for future learning. |

Note: Some activities may overlap between different levels of Bloom’s Taxonomy.