INDEMNIZACIÓN

Novices and experts develop code in different ways (Palumbo, 1990; Pears, Seidman et al., 2007; Robins et al., 2003). As mentioned previously, it takes about ten years to turn a novice into an expert. Expertise begins with general problem-solving skills and basic knowledge about the field, which grows with repeated practice (Winslow, 1996).

Various studies reviewed by Winslow (1996) concluded that novices – • lack adequate mental models;

• are limited to superficial knowledge;

• have fragile knowledge (knows something but fails to use it when required);

• use general problem-solving strategies instead of strategies dependent on the specific problem; and

Robins et al. (2003) confirm this and add that novices spend little time on both planning and testing code. They attempt small ‘local’ fixes instead of reformulating code. They are often weak at tracking or tracing code and may not understand that programs execute sequentially. Their knowledge is more context-specific than general (Robins et al., 2003), as they tend to work with smaller, less-integrated information units (Palumbo, 1990). As a result, their problem-solving strategies can also be fragile (Robins et al., 2003), since they lack adequate organized, meaningful knowledge patterns in memory (Wiedenbeck, 2005). Furthermore, novices often do not realise their own shortcomings (Ala-Mutka, 2004).

Spohrer and Soloway (1989) provide an overview of the underlying problems novices experience. They identify three types of construct-based problems which hinder novices in learning the correct semantics of programming language constructs, as well as nine types of plan composition problems causing problems with planning and design, respectively entailing the following:

• Construct-based problems:

• Natural-language problem. Novices confuse the semantics of programming-language constructs with the related natural-language words.

• Human interpreter problem. Novices assume that the computer will interpret a construct in the way they intend it to be interpreted.

• Inconsistency problem. When novices understand how a construct works in a certain situation, they may assume that it will do the same in a slightly different situation.

• Plan composition problems:

• Summarisation problem. Only the primary function of a plan is taken into account, while the secondary functions may be overlooked.

• Optimisation problem. Inapplicable optimisation may be attempted.

• Previous-experience problem (Plan-pollution). Inappropriate aspects of previous plans may be used in a related-plan.

• Specialisation problem. Abstract plans may be used inappropriately or instantiated incorrectly.

• Natural-language problem. Mapping from natural language to a programming language may be incorrect.

• Interpretation problem. Implicit problem specifications may be left out or only included when novices can easily retrieve plans for it.

• Boundary problem. Novices find it difficult to specify correct boundary points when adapting a plan to specialised situations.

• Unexpected cases problem. Uncommon, unlikely or boundary cases may be omitted. • Cognitive load problem. Minor but important parts of plans may be omitted, or plan

Soloway and Spohrer (1989) also report on general misconceptions held by novices. Novices frequently assume that the computer will do what they mean, rather than what they say, and do not realise the level of detail that needs to be specified (Du Boulay, 1989). Bonar and Soloway (1989) show that novices’ pre-programming knowledge about standard tasks in step-by-step natural language, plays an important role in relation to the bugs in their programs, especially if their programming knowledge is fragile. Spohrer and Soloway (1989) found that a large percentage of program bugs are caused by a few bug types; and that most bugs are the result of plan composition problems (putting the pieces of a program together) and not of construct-based problems (misconceptions about language constructs).

Experts, in contrast (Winslow, 1996) –

• have many mental models which they select and combine in resourceful ways;

• have a deep, hierarchical, many-layered knowledge of their subject with explicit maps between the layers;

• apply all their knowledge;

• work forward from the givens when processing a task in familiar areas and develop sub-goals hierarchically, but fall back on general problem-solving techniques when faced with unfamiliar problems;

• recognise problems with a similar solutions more easily; • tend to approach programs through data structures or objects; • use abstract algorithms rather than language specific syntax; • work faster and more accurate; and

• have better syntactical and semantic knowledge and better tactical and strategic skills.

Robins et al. (2003) add to the above that experts have efficiently organised and specialised knowledge representations; organise their knowledge based on functional characteristics instead of superficial details; use both general and specialised problem-solving strategies; use specialised plans and a top-down, breadth-first approach to deconstruct and understand programs; and are flexible in their approach to understand programs and willing to discard dubious hypotheses. Wiedenbeck (2005) confirms that efficient programming knowledge organisation distinguishes experts from novices. In contrast to novices, experts spend much of their time on planning. Experts are aware of the advantages of testing their code and have well-developed strategies to design tests to expose all possible problems. Novices frequently test only the obvious and may neglect to test all of their code. Experts consider large-scale as well as minor changes when required to modify their programs, while novices tend to attempt ‘local’ fixes (Linn & Dalbey, 1989).

Experts use sophisticated problem-solving skills such as decomposition, analogical reasoning and systematically plan, code and debug their programs. Novices classify tasks and write programs according to surface characteristics while experts use the general concepts and underlying structures to solve programing problems (Kurland, Pea, Clement & Mawby, 1989).

In summary, while experts use sophisticated knowledge representations and problem-solving strategies, novices experience difficulty in basic program planning, and their programming specific knowledge is often fragile (Pears, Seidman et al., 2007; Robins et al., 2003). Even if they know the syntax and semantics of individual statements, they do not know how to combine these into valid programs (Winslow, 1996). To assist novices in becoming experts, educators should take note of the recommendations in Robins et al. (2003), and pay special attention to assist novices in developing appropriate mental models for programming.