Ideal Approach to Learning to Code

There are different ways to learn programming. We will consider the different approaches and fit them into the Bloom’s Learning Taxonomy grid.


Producing and Interpreting are the two dimensions of a matrix that can be used to identify a range of different learning trajectories and hence to guide students in how to improve their skills and understanding.

Trial and Error Approach

You learn a new programming concept, you first achieve the knowledge of this concept. If you continue learning by imitating a ready example of a program but without a deep understanding of the concept, you will be trapped in a trial and error approach to learning.

Trial and Error Approach

Practical Approach

You have the ability to apply and create without the ability to analyse or evaluate your own program code. The main problem for practical learners is in not being able to debug their own solutions when they encounter errors.

Practical Approach

Theoretical Approach

You remember and understand the concepts and have the ability to analyse or evaluate but lack the ability to apply the knowledge and write code from scratch.

Theoretical Approach

Ideal Approach

The learning of programming can be seen as an iterative process. In the very beginning, you are taught really simplistic and basic pieces of information and places to apply them. Instead of learning some things here and there, programming is a skill that is learned by building new information on top of earlier information.

So in a way the basic pieces of information you are first struggling with become the bits and pieces you use in subsequent learning of new material. The spiral process can be seen, in that when you are learning a new subject, your prerequisites - the materials to use in building new knowledge - have become your new basic knowledge, although you have perhaps reached the level Create or Evaluate on those earlier subjects.

Ideal Approach

Create could be described as the ability to combine one subject with others in order to build new solutions. This may also be seen when new solutions or subjects are learnt by building upon and integrating previous knowledge. This is easily seen to be true when considering the topics that are difficult and require in depth analyzing by some are mere basic knowledge for expert programmers.

Example of a Learning Spiral

In the beginning a programming newbie is taught how to use a loop structure. He will go through all the levels of Bloom’s taxonomy while learning it. He knows that a loop can be used for iteration. He understands how the loop works. He is able to apply a loop when told etc., eventually learning it thoroughly.

After reaching the highest levels, the loop structure has become a tool for the student to use in subsequent programming. As the student is trying to learn how to sort an array, the loop can be seen as his basis knowledge upon which he is building his new knowledge. Later as the student is trying to implement a top-application to his own operating system, he will use the sorting of an array as a part of his base knowledge.


Bloom's Taxonomy applied to computer science provides a very powerful and effective way to learn how to program.

Applying Bloom’s Taxonomy to Programming: From Trial and Error to Mastery

Bloom’s taxonomy, developed by Benjamin Bloom and others, is a classification system used to describe the levels of cognitive learning. Different skills and competencies fall into six categories: knowledge, comprehension, application, analysis, synthesis, and evaluation. These can be broadly categorized into two groups: ‘Producing’ which involves creating and applying knowledge, and ‘Interpreting’ which involves understanding and evaluating this knowledge.

When learning programming, these categories can be used to characterize different learning approaches:

  1. Trial and Error Approach: This is the most basic level of learning in programming. In this approach, learners gain knowledge of concepts and then try to apply them in writing code by imitating examples. However, without a deeper understanding of these concepts, learners may find themselves stuck in a cycle of trial and error. This approach aligns with the ‘knowledge’ and ‘application’ stages of Bloom’s taxonomy.

    Trial and Error Approach

  2. Practical Approach: This approach focuses on gaining hands-on experience in coding. Learners in this category can create code and apply their knowledge to practical situations. However, they may struggle with understanding the underlying principles of the programming concepts, which could lead to difficulties in debugging their code. This approach aligns with the ‘application’ and ‘creation’ stages of Bloom’s taxonomy.

    Practical Approach

  3. Theoretical Approach: This approach focuses on understanding the theory behind the programming concepts but may lack the practical application skills. Learners can remember and understand programming concepts and can analyze and evaluate them. However, they may struggle when it comes to applying these concepts to write their own code. This approach aligns with the ‘understanding’, ‘analysis’, and ’evaluation’ stages of Bloom’s taxonomy.

    Theoretical Approach

  4. Ideal Approach: This is the most comprehensive approach to learning programming. It involves an iterative process where new knowledge builds upon prior knowledge. This process reflects the spiral nature of learning, where foundational concepts become tools for understanding more complex topics. With this approach, a learner goes through all stages of Bloom’s taxonomy, effectively understanding, applying, analyzing, evaluating, and creating new solutions using the programming concepts. This comprehensive approach can lead to a more in-depth and robust understanding of programming.

    Ideal Approach

To illustrate the ideal approach, consider the example of learning how to use a loop structure in programming. Initially, a learner may struggle to understand and apply this concept. However, as they continue to practice and build upon their knowledge, this concept becomes a tool they can use to learn more complex topics, such as sorting an array. As the learner continues to progress, even more complex concepts, like building applications, become attainable. This process of building upon prior knowledge aligns with the highest level of Bloom’s taxonomy, ‘creation’.

In conclusion, applying Bloom’s taxonomy to programming provides a structured and effective approach to learning. It allows learners to understand where they are in their learning journey and provides direction on what steps to take next. Each level builds upon the previous, providing a clear path to progress from basic knowledge to the creation of complex solutions.

Here’s a table that categorizes various “Solution Activity” terms with their respective descriptions:

Solution ActivityDescription
AdaptModify a solution for other domains/ranges
AnalyseProbe the [time] complexity of a solution
ApplyUse a solution as a component in a larger problem
DebugBoth detect and correct flaws in a design
DesignDevise a solution structure
ImplementPut into lowest level, as in coding a solution, given a completed design
ModelIllustrate or create an abstraction of a solution
PresentExplain a solution to others
RecognizeBase knowledge, vocabulary of the domain
RefactorRedesign a solution (as for optimization)
RelateUnderstand a solution in context of others
TraceDesk-check a solution

This table should give a quick overview of various activities involved in problem-solving and their meanings.

Solution ActivityDescriptionMapped Term
Problem UnderstandingRead the problem statement carefully. Identify input and output formats.Recognize
Requirement AnalysisList down constraints and special cases.Analyse
PseudocodeWrite high-level logic in pseudocode.Design
Algorithm SelectionChoose the appropriate data structures and algorithms.Model
CodingTranslate pseudocode into actual code.Implement
Edge Case HandlingImplement code to deal with edge cases.Apply
DebuggingTest individual components for errors.Debug
Complexity AnalysisAnalyze time and space complexity.Trace
Test CasesRun multiple test cases, including edge cases.Relate
Code RefactoringOptimize the code for readability or efficiency.Refactor
Code ReviewDouble-check code for syntax errors, logic flaws, and inefficiencies.Adapt
ExplanationBe prepared to explain your code and reasoning.Present

This provides another layer of understanding when working on a coding interview questions. Mapping “Complexity Analysis” to “Trace” could be seen as a way to indicate that you’re tracing the steps of your code to understand its performance characteristics. However, your point is valid: “Analyse” would also be a very fitting term for this activity, as you are indeed analyzing the time and space complexity of the algorithm. The mapping is not set in stone and different perspectives could lead to different mappings. In this context, assigning it to “Analyse” might indeed be more intuitive.

ChatGPT Explains

Applying Bloom’s Taxonomy to Coding Skills in Computer Science

Bloom’s Taxonomy provides a framework for categorizing educational objectives and skills from the simplest to the most complex. Here’s how you can apply it to breaking down the skills needed for coding:

1. Remember

  • Concept: Basic Syntax and Data Types
  • Activities: Memorizing and recalling the syntax of a programming language, basic data types like integers, floats, and strings.

2. Understand

  • Concept: Control Flow and Functions
  • Activities: Understanding if-else statements, loops, and how functions work. Reading code to describe what it does.

3. Apply

  • Concept: Problem Solving
  • Activities: Use the programming constructs and standard libraries to solve simple problems like finding the maximum number in a list.

4. Analyze

  • Concept: Debugging and Code Review
  • Activities: Identifying issues in existing code, analyzing the flow, and determining where things go wrong or could be improved.

5. Evaluate

  • Concept: Code Optimization and Best Practices
  • Activities: Evaluating different solutions to the same problem based on speed, memory usage, and best practices.

6. Create

  • Concept: Software Development
  • Activities: Building a complete program or software, integrating various components and applying design patterns and architectural principles.

Key Takeaways

  • Bloom’s Taxonomy offers a structured way to think about coding skills, starting from the foundational knowledge and moving up to complex problem solving and software design.
  • Use this framework to identify where you are in your learning journey and what the next steps should be.

By applying Bloom’s Taxonomy, you can develop a comprehensive skillset that covers everything from understanding basic syntax to designing complex software systems.

Claude Explains

Bloom’s taxonomy can provide a useful framework for breaking down the skills required for coding by categorizing them into different cognitive levels:


  • Memorize syntax of programming language
  • Remember semantics of various commands
  • Recall definitions of key concepts like class, object, inheritance


  • Comprehend what certain code snippets and programs do
  • Explain programming concepts in own words
  • Summarize principles of logic and algorithms


  • Implement algorithms to solve a problem
  • Use appropriate data structures for task
  • Modify existing code to add new features
  • Debug errors by applying reasoning skills


  • Break down complex problems into sub-problems
  • Recognize similarities to problems seen before
  • Examine program execution and logic flow


  • Compare and contrast tradeoffs of different algorithms
  • Assess efficiency and optimality of solutions
  • Justify appropriateness of data structures choice


  • Design architecture and interfaces for program components
  • Combine basic constructs into elaborate programs
  • Generate new solutions by adapting known algorithms

This taxonomy provides a hierarchy of coding skills from basic remembering through higher order application, analysis, evaluation and creation. Mastering each level results in proficiency.

Revised ChatGPT

Here are additional items to consider under each category of Bloom’s Taxonomy for coding skills:


  • Recall commonly used design patterns.
  • Memorize standard data types and their properties.
  • Recall common coding syntax such as loops and conditionals.
  • Remember function signatures from standard libraries.


  • Interpret error messages and warnings.
  • Distinguish between local and global variables.
  • Paraphrase the function of built-in libraries or frameworks.
  • Differentiate between value and reference types.
  • Interpret the purpose of different types of loops (for, while, do-while).
  • Explain the role of helper functions in code.


  • Use conditional statements to control program flow.
  • Apply string manipulation techniques.
  • Implement loops for repetitive tasks.
  • Employ recursion for specific problems.
  • Use exception handling to manage errors.
  • Implement functions or methods based on specifications.
  • Use libraries or frameworks to accomplish specific tasks.
  • Use array manipulation techniques to solve problems.
  • Employ mathematical operators to solve equations in code.


  • Classify problems based on time and space complexity.
  • Decompose a problem to identify the data structures required.
  • Trace recursive function calls to understand stack behavior.
  • Identify edge cases that need special handling in code.


  • Assess the time and space complexity of algorithms.
  • Compare different sorting algorithms based on their efficiency.
  • Critique the use of specific data structures for a problem.


  • Develop custom algorithms to solve new or complex problems.
  • Design data models for representing real-world entities.
  • Create reusable code components like modules or libraries.
  • Synthesize different algorithms to solve a composite problem.

This list provides a more code-centric perspective across the cognitive levels defined by Bloom’s taxonomy.