Programming Activities Mapped to Bloom's Taxonomy

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

  1. Read and comprehend the problem statement and constraints

  2. Come up with clarifying questions to resolve ambiguities

  3. Analyze core requirements and isolate key components

  4. Connect to related patterns, concepts and analogies

  5. Determine optimal data structures for modeling the problem

  6. Break down requirements into smaller modular sub-problems

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

  8. Analyze time and space complexity tradeoffs to select most efficient algorithms

  9. Design clean interfaces and abstractions to connect components

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

  11. Implement in a modular fashion with separation of concerns

  12. Refactor to improve readability, simplicity, scalability and maintainability

  13. Profile, instrument and debug the code to identify bottlenecks

  14. Optimize critical paths and pain points surfaced through measurements

  15. Add robust error handling, input validation and defensive checks

  16. 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.

  1. Read Problem Statement: Understand the problem, its constraints, and its requirements.

  2. Identify Inputs/Outputs: Determine what the inputs and outputs are and their data types.

  3. Analyze Constraints: Understand any limitations on time and space complexity.

  4. Initial Breakdown: Divide the problem into subproblems or steps that lead to a solution.

  5. Brainstorm Approaches: Consider different algorithms or data structures that can be used.

  6. Pseudocode: Write pseudocode for the most promising approach. This will be your rough draft.

  7. Time Complexity Analysis: Estimate the time complexity of your algorithm to check if it meets the problem’s constraints.

  8. Code Brute-Force Solution: If possible, write a brute-force solution to have something to test against.

  9. Test Brute-Force: Manually or automatically test this solution for correctness on sample inputs.

  10. Optimize: Look for parts of your algorithm that can be optimized in terms of time or space complexity.

  11. Write Optimal Code: Implement the optimized solution.

  12. Review Code: Check for any syntax errors, logical mistakes, or inefficiencies.

  13. Unit Testing: Write tests to confirm the code works as expected. Include edge cases.

  14. Debug: If the code fails any tests, identify the issue and resolve it.

  15. Revisit Time Complexity: After coding, revisit the time complexity analysis to make sure it aligns with your initial estimation.

  16. Documentation: Add comments to your code explaining key portions.

  17. Peer Review: Optionally, have a colleague or mentor review your code for mistakes or improvements.

  18. Run on Large Inputs: Final test to check if it meets time and space constraints.

  19. Submission: Once all tests pass and you’re satisfied with your solution, submit your code.

  20. 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 TaxonomyProgramming Activities
RememberReading problem statement
UnderstandComprehending requirements, connecting to concepts
ApplyDesigning data structures, algorithms and abstractions
AnalyzeBreaking into sub-problems, analyzing complexity tradeoffs
EvaluateWriting tests, critiquing and refactoring solution
CreateImplementing 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 LevelProgramming ActivitiesDescription
KnowledgeRead Problem StatementUnderstand the basic facts and information about the problem.
ComprehensionIdentify Inputs/OutputsInterpret the meaning of problem requirements and constraints.
ApplicationCode Brute-Force SolutionApply knowledge to solve the problem in a straightforward manner.
AnalysisInitial Breakdown, Analyze ConstraintsDivide the problem and identify its elements; understand constraints and their implications.
AnalysisTime Complexity AnalysisAnalyze the algorithm’s performance and efficiency.
AnalysisDebugIdentify the elements causing the failure in the code.
SynthesisBrainstorm Approaches, Write PseudocodeCombine different concepts to form a new whole, plan steps for coding.
SynthesisWrite Optimal CodeIntegrate optimizations to create an efficient solution.
SynthesisDocumentation, Peer ReviewAssemble code and comments in a coherent form, integrate feedback.
EvaluationTest Brute-Force, Unit TestingMake judgments about the validity and reliability of the solution.
EvaluationRevisit Time ComplexityRe-evaluate the efficiency of the final code and compare it to initial estimates.
EvaluationPost-Submission AnalysisEvaluate 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.