Hello!
I have been pursuing Cognitive Load Theory (CL) as an approach to studying how best to
teach programming. Some of you may recall my talk from the 2003 Workshop where I
reviewed CL and where it stood at that time in relation to programming. Since then, I
have been attempting to apply CL more closely to the process of learning programming.
I have hit a stumbling block, and I am seeking help in how to handle it.
I have been impressed with the worked examples approach, and even more so with fading.
Fading has been proposed as an approach to implement worked examples, and has been
the focus of work by Atkinson at Arizona State and Renkl at University of Freiburg.
Their approach is discussed in, among others, the following:
Atkinson, R., Renkl, A., and Merrill, M. (2003). "Transitioning from Studying
Examples to Solving Problems: Effects of Self-Explanation Prompts and Fading
Worked-out Steps" Journal of Educational Psychology, 95(4), December 2003.
This study proposes the use of fading. Students work through a series of worked
examples, the first being completely worked, and successive one have more details
missing. This continues until students are simply given a problem and asked to solve
it. The process is what is being learnt, and the process varies very little for each
successive faded step.
I feel that this work (and much other non-computing CL research) is difficult to
transfer to problem solving in programming for two reasons. First is that the domain
they have chosen involves a different sort of problem-solving. Subjects were
psychology students learning to apply probability of successive events. For example,
if there is a 70% chance of finding a specific traffic signal green on your way to
work, and a second signal 50% for green, what is the probability of finding both
lights green? From initial instruction to testing, students are dealing with two
events, sometimes independent (as above) and sometimes dependent (probability of
pulling 2 red balls from a bag initially containing 5 red and 6 green balls).
Problem-solving in programming involves applying a topic to widely different domains.
The second is the idea of a bag of tools. We teach a tool (the looping structure or
arrays, for example), then encourage students to add this tool to their collection of
tools, and solve problems with the new tool in conjunction with previously-learnt
tools.
There is room for fading in learning programming. But I contend that situations where
fading can assist problem-solving in learning programming does not represent the
biggest stumbling block for students. The process of acquiring a new tool (arrays, for
example), adding it to the set of acquired tools, then applying the whole tool set to
problem-solving is a bigger need in learning programming.
The idea behind fading - successively more challenging steps - greatly interests me,
however. Therefore I am considering another approach to fading. For example,
consider the process of learning single-dimension arrays, and assume students have had
an initial lesson in them in lecture. The laboratory would ask students to work
towards building a program that accomplishes a specified goal, with portions of the
program supplied. Students might initially design a simnple loop that initializes an
array to 0. Next would be a slightly harder task, and each subsequent task is more
challenging and involves an increasing number of other tools (loops, selection, etc)
until students have finished the entire program.
Prior to a student beginning each subsequent step, a check of the current step would
occur. For example, the instructor could supply a data set to apply to the code
developed and check the resultant data. But the important point is that a student
would need to demonstrate success at the current step prior to moving on to the next
step. The final step would be a homework assignment where they start from scratch and
apply arrays to a different problem domain.
If you have any thoughts, ideas, or suggestions on where CL fits into learning
programming, and especially on my proposed approach, I would appreciate hearing from
you. Or if you know of someone doing work along these lines or a theoretic basis for
what I propose, I would appreciate hearing about that as well.
Dale
_____________________________
Dale Shaffer, Ph.D.
Professor of Computer Science
Lander University
Greenwood, SC, USA
----------------------------------------------------------------------
PPIG Discuss List ([EMAIL PROTECTED])
Discuss admin: http://limitlessmail.net/mailman/listinfo/discuss
Announce admin: http://limitlessmail.net/mailman/listinfo/announce
PPIG Discuss archive: http://www.mail-archive.com/discuss%40ppig.org/
