BOTTOM LINE
Bloom's Taxonomy applied to computer science provides a very powerful and effective way to learn how to program.
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.
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.
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.
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.
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.
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.
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, 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:
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.
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.
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.
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.
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 Activity | Description |
---|---|
Adapt | Modify a solution for other domains/ranges |
Analyse | Probe the [time] complexity of a solution |
Apply | Use a solution as a component in a larger problem |
Debug | Both detect and correct flaws in a design |
Design | Devise a solution structure |
Implement | Put into lowest level, as in coding a solution, given a completed design |
Model | Illustrate or create an abstraction of a solution |
Present | Explain a solution to others |
Recognize | Base knowledge, vocabulary of the domain |
Refactor | Redesign a solution (as for optimization) |
Relate | Understand a solution in context of others |
Trace | Desk-check a solution |
This table should give a quick overview of various activities involved in problem-solving and their meanings.
Solution Activity | Description | Mapped Term |
---|---|---|
Problem Understanding | Read the problem statement carefully. Identify input and output formats. | Recognize |
Requirement Analysis | List down constraints and special cases. | Analyse |
Pseudocode | Write high-level logic in pseudocode. | Design |
Algorithm Selection | Choose the appropriate data structures and algorithms. | Model |
Coding | Translate pseudocode into actual code. | Implement |
Edge Case Handling | Implement code to deal with edge cases. | Apply |
Debugging | Test individual components for errors. | Debug |
Complexity Analysis | Analyze time and space complexity. | Trace |
Test Cases | Run multiple test cases, including edge cases. | Relate |
Code Refactoring | Optimize the code for readability or efficiency. | Refactor |
Code Review | Double-check code for syntax errors, logic flaws, and inefficiencies. | Adapt |
Explanation | Be 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.
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:
By applying Bloom’s Taxonomy, you can develop a comprehensive skillset that covers everything from understanding basic syntax to designing complex software systems.
Bloom’s taxonomy can provide a useful framework for breaking down the skills required for coding by categorizing them into different cognitive levels:
Remembering:
Understanding:
Applying:
Analyzing:
Evaluating:
Creating:
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.
Here are additional items to consider under each category of Bloom’s Taxonomy for coding skills:
for
, while
, do-while
).This list provides a more code-centric perspective across the cognitive levels defined by Bloom’s taxonomy.