dimension of the taxonomy, which poses an interesting question, indeed. Actually, we have not found any CS1 approach dealing with this dimension, directly.

As an attempt to elaborate some ideas for this issue, we briefly consider the learning model used in [3]. It serves us as a contrast because the CS1 model is different to[32, 33], and not explictly aligned with Bloom.

Instead, the course model is an implementation of the so-called *early-bird* pattern ([4]). We may interprete it in terms of driving the course by modeling not directly by language function, which in a SE/OOP context appears to be natural. In fact, authors explicitly aim at SE as a student target.

From the point of view of the Bloom's Taxonomy, we claim, the course is driven by the knowledge dimension, the process dimension is subordinated, in such a sense. Moreover, the knowledge dimension is covered iteratively (like a spiral model), so the course consists of several cycles covering a core set of new topics added on the top or extending previously covered material. Using models and **Bluej** apparently help to deal with programming language related details, especially at the beginning. In any case, **Java** plays a central role in this course.

| Knowledge      | Bloom's Level          | Example (Student ...)                                              |            |
|----------------|------------------------|--------------------------------------------------------------------|------------|
| Behavioral     | Factual and Conceptual | Understands a model of geometric figures with different attributes |            |
| Implementation | Procedural             | Understands                                                        | overload            |
| ing            | of                     | constructors                                                       | in         |
| Java           |                        |                                                                    |            |
| Enhancement    | Metacognitive          | Recognize                                                          | redundancy |
| as a maintenance problem                |                        |                                                                    |            |

By taking a look at the material in [3], we have identified a categorization as shown in Table 4.

We have provided some simple examples as clues as seen in the table. It seems to us, under a Table 4: CS1 Proposed Knowledge Model derived from [3]
model-based approach the *Factual* and *Conceptual* knowledge levels naturally merge building a uniform category. Every cycle starts with a specification of a conceptual model which the student has to understand and *play* with before learn how to implement it (procedurally)14. Initially the specification is UML-like, later on can be more informal allowing learning of basic design principles as well. In terms of exercising, we find difficult to describe interactions because of the graphical nature of specifications, we are more interested in textually expressed code. However, [3] provides a lot of exercises at the **Reading and Understanding** level.

Considering the cognitive level of **Writing small code fragments**, we want to present an exercise which is (mini)pattern-oriented and likewise suitable for exercising refactoring. It also requires exercising some basic understanding. It is shown in Figure 515. As we did before, we raise the question about the representation in terms of e-Learning. Although, the example is quite