Designed for computer science instruction, Turing is simply the easiest, most fun, and most effective way of teaching programming concepts.
Quick Links
|
|
Designed for computer science instruction, Turing is simply the easiest, most fun, and most effective way of teaching programming concepts. |
|
Quick Links |
||
 |
 |
 |
|
 |
|
 |
|
 |
|
 |
|
 |
|
 |
Firstly, the students without whom there would have been no
project :-
Simon Brodie, Chris Cheung, Tim Clarke, Matthew Conderan,
Richard Kermath, Eric Marinko, Andy McInnes, Neil Penny,
Robert Skruch and Paul Tichonczuk of Father Michael Goetz
Secondary School, Ontario, Canada and Perth College of
Further Education, Scotland.
Also to Winston Das, Roy Parteno and Lesia Skira who are teachers at Father Michael Goetz Secondary School, Ontario; Margaret Patterson, Derek Summers and Ian Wilson who are lecturers at Perth College, Scotland and Professor Ric Holt, Professor Diane Horton and Professor Pat Hume who are lecturers at the Department of Computer Science, University of Toronto.
Thanks also to Dr Roger Bailey of Imperial College, London for his comments on the Turing language and to Dr K Anjaneyulu of the National Centre for Software Technology, Bombay, Professor Elliot Solloway, University of Michigan and Professor D Sleeman, University of Aberdeen for kindly sending me articles and references when I was unable to obtain them through the normal channels.
A special thank-you to Chris Stephenson, Vice President, Holt Software, Toronto for her kindness, patience and good humour and to Mr Charles Rattray who supervised my project.
Thanks also to my two children Alan and Catriona for their cups of coffee, excellent posters and musical recitals during moments of stress.
I'd like to give an especially big thanks to my husband Donald for being a tower of strength during the past four years and for holding the fort when I was in Canada.
Last but not least I'd like to thank John Sanderson for his comments during the latter stages of writing this report, and my friend Katie Ross for her loyal support and trays of prize-winning energy and without whom I'd have been lost on several occasions!
The project focuses on the syntax and syntax correcting environments of the two languages and the extent to which these are helpful to students.
Data were collected by the clinical observation of Scottish college students using Turbo Pascal and Canadian high school students using Turing. This was supported by interviews with the students and instructors of both languages, and the developers of the Turing language.
The report concludes that the syntax and programming environment of the Turing language would appear to allow students to make faster progress in programming exercises, and that use of the language would have certain advantages in high school computing courses. CHAPTER ONE
More recently, empirical research has indicated that there is little evidence of students having developed better problem-solving skills as a result of exposure to computer programming, and the focus for research has shifted towards teaching methods and the choice of a first language.
Although Pascal is now almost 30 years old, it continues to be a popular first language because it is highly structured and strongly typed and is therefore believed to encourage good programming habits. Many students and teachers however, find its syntax cumbersome and research has shown that some students can become so enmeshed in correcting syntax errors that they achieve little benefit from programming exercises.
There are many implications that, despite having completed well-structured introductory programming courses, many novice programmers still experience extreme difficulty in writing even the simplest of programs.
In a study of approaches to experiments in program debugging and comprehension, Lukey (1981) remarked that "The programming language used in an experiment may well influence the results". Here, Lukey suggests that a language may have a bearing on the acquisition of debugging skills which consequently, may be instrumental in determining the degree of program comprehension achieved by an individual.
This study will look at the Turing language, a general purpose language which was developed in Canada in the early 1980's. Its developers claim that its easy syntax make it simple to learn, thus allowing its users more freedom to focus on the learning of programming concepts and the subsequent application of these in problem solving.
Given that there is a limited teaching time in the Computing Studies syllabus (40 minutes per week in S1/S2 rising to approximately 160 minutes per week in S3/S4/S5), then any language which helps a student to progress more quickly through programming exercises, would offer considerable benefits to students and teachers alike.
It was agreed with the individuals who were kind enough to take part in this study, that they would not be identified. Therefore, names of individuals and institutions have not been mentioned in the main body of the report.
There are three basic stages in programming :-
Knowledge of a programming language can also be separated into two distinct skills :-
Clearly, opinions differ in whether students should be taught to correct syntax errors. In reality, much will depend on the complexity of the language's syntax and the language's syntax checking environment "The programming environment provided to help the program developer use the language seems to be at least as important as the language itself, and probably more so, as a decent editor and syntax-checker integrated closely with the compiler renders most arguments about actual syntax redundant" (Roger Bailey, Imperial College).
Empirical research has indicated that although learning a programming language is much easier than learning problem solving skills, syntactic difficulties can significantly hamper a student's progress and that this, in turn, may affect the student's ability to produce a logically sound, working program (Walsh [10]). It has also been claimed that syntax errors can outnumber semantic and logical errors 2:1 (Friend [23]).
To acquire these automated lower level skills, a student must develop an ability to :-
The students were found to fall into categories of stoppers and movers. Stoppers gave up when they encountered a problem whereas movers tried out one idea after another until a solution was found. On the opposite end of the spectrum from stoppers however, were extreme movers who made alterations to their code in a manner which was unstructured and frequently haphazard. This haphazard 'tinkering' with their program led to a high incidence of frustration with the students frequently moving farther away from a correct solution in the process.
The languages used in the experiment were BASIC and LOGO. It was agreed however, that 'logical tinkering' did not necessarily have a negative effect and could in fact be instructive if done systematically with the student keeping a close track of the code's behaviour and how it was affected by the various changes. The educational benefits of syntactic 'tinkering' however are doubtful. Perkins et al [13] concluded that excessive 'tinkering', or stopping inhibited progress in any domain. They concluded, not unsurprisingly, that proper instruction in tracking programs and debugging skills might alleviate many of the problems.
If this is seen to be the case, then it is unlikely that these students will have derived any problem solving benefits from the exercise. Unfortunately, experience has shown that assisting with syntax errors can account for much of a Computing Studies teacher's time. Schneider et al [18] estimated that as much as 50-75% of a programmers time is spent debugging although it is unclear how much of that figure can be attributed to logic debugging and how much to syntax.
It is especially important on an introductory course, that the student sees his/herself making progress. Carver ([16] p 263) maintains that "...students who spend large amounts of their computer time waiting for the teacher, rewriting code ..... are unlikely to enjoy programming enough to persist through the hundreds or thousands of hours necessary to develop programming proficiency".
For this reason, we must look towards any tool or method which will alleviate the difficulties experienced with syntax, and allow the student to derive every possible benefit from a course in programming.
In a study of cognitive strategies and looping constructs (Soloway et al [2]), it was concluded that languages which operate closely with an individual's cognitive strategy are easier to use effectively and therefore suitable for novices. For example, Soloway concluded that a language which offers an exit in the middle of a loop, is providing a construct which novices find easier to use, and with greater programming success.
A study carried out by Ledgard et al [6] found that an English based language was preferred by subjects and led to a better performance. This is counter-claimed however, in a report by Pea [14] which found that many novice programmers using high-level languages attribute the computer with human-level understanding e.g. :-
if two variables are called 'odd' and 'even' and an input of, say, '2' and '1' is made in that order, then a novice may have the belief that the computer will assign '1' to 'odd' and '2' to even'.
Many also believe that introductory programming courses should use programming languages which are "industrially relevant" (Roberts [27]). This is an issue which will be examined in more detail at a later stage.
Therefore, although widely used, BASIC is not considered to be a suitable first programming language.
Syntax errors appear one at a time as a highlighted line with a corresponding error message and message number at the bottom of the screen. Further explanation of error messages can be obtained from Turbo Pascal's 'Help' menu. It is necessary to recompile the program each time that a syntax error is corrected. Run-time errors return the program to the editor screen which displays a dialogue box containing an error number, and the memory address where the error occurred. Further explanation of the error can be obtained by looking up the error number on the help screen.
Turing, like Pascal, is a strongly typed, highly structured language but with fewer syntax constraints than Pascal. One of its design goals was to provide "Graceful and diagnostic treatment of errors" because "Too often, the beginner is frustrated by incomprehensible program output or error messages, and cannot proceed without the aid of an expert" (Holt et al [25]). It uses 'natural' English language, is case sensitive to identifiers, and provides the option of an exit in the middle of a loop.
Additionally, it has a wide range of built-in graphics which make it suitable for using in schools where lessons are relatively short and pupils can be encouraged by quick results. There are no 'program' statements or compulsory statement separators. Iteration and selection constructs are terminated with an 'end' - ie 'end if', 'end for' etc.
Turing provides a simple editing environment, and users have the option of mouse or keyboard driven commands. Programs can be compiled and run with a single keystroke (F1). An additional feature of Turing is the F2 key which paragraphs the code.
Syntax errors appear as a highlighted line in the program with a corresponding error message at the bottom of the screen. If there is more than one error (or if Turing thinks there is more than one error), all lines containing these 'errors' will be highlighted. Run-time errors in Turing return the program to the editing screen and the line at which execution was halted is highlighted. There is no trace facility in Turing. Turing software is available for the PC and the MAC. The PC version supports colour, pixel graphics, sound and the MAC version supports colour and pixel graphics but not sound.
Turing would therefore appear to offer several of the features, as proclaimed by experts, which constitute a good first programming language.
This study will compare a group of Turing students and a group of Pascal students in their interactions with their relative software. In particular, the study will focus on the students' responses to syntax error messages and the way in which these either help or hinder the students in their efforts to produce a running program. Conclusions will thereafter be drawn about the impact which a language's syntax might have on the programming learning process.
In Scotland, similar arrangements were made with a Tayside college where Pascal is used as an introductory programming language. Henceforth, all students and lecturers who took part in the study will be referred to as Pascal Student One, Turing Lecturer C etc. These represent the order in which the students and instructors were tested or interviewed and is not a reflection of seniority.
Finally, Imperial College in London were approached and asked about their reasons for selecting Turing as a teaching language, and their thoughts and opinions since doing so.
A qualitative approach was selected for the study since the focus was on the process of correcting syntax and this would involve individual observation of the subjects. Thus, the sample sizes are, by necessity, quite small. The possibility exists therefore, that the findings of the study, may not be entirely representative of Turing and Pascal communities as a whole. It will be seen, however, that patterns emerge from the study which at least make a larger, more quantitative study worthy of consideration.
Programming, is introduced at this particular school, in Grade 10.
The students were closely observed on an individual basis. This made it possible to record many details about the participant's behaviour during the exercises. In this type of study, the participants have an opportunity to explain their thought processes as they correct a program and also, to ask questions. This, to some extent, simulates genuine classroom activity where a student might discuss the problem at hand, and any difficulties which he/she may have, with another student or with the teacher.
A structured observation technique was used to record the subjects' behaviour. This initially involved devising a list of possible behaviour which might be exhibited during programming. This list was then used during the observation sessions, to record in numerical order if, and when, the behaviour was exhibited by each subject. By also making brief notes, it was possible to reconstruct the sessions later. This method was based on one used by Berman & Roderick ([17], p 176). See Appendix F for an example of an observation and reconstruction.
It is also important to follow up this type of observation technique with an interview during which the researcher can quiz the participant about the session and any particular behaviour.
Specifically, the exercise attempted to assess the level of understanding which the students had of a simple program which included assignment, selection and iteration.
Four of the Pascal students successfully completed this exercise. One of those asked several questions to assist in his understanding of the exercise. None recognised the output sequence although no particular significance is being attached to this.
A Compaq 386S/20 laptop computer was used for these exercises and consideration was taken of the student's unfamiliarity with the keyboard.
Please refer to Appendix F for an example of use.
Within the restrictions of their particular language characteristics, an attempt was made to make the two series of programs as similar as possible. (see Appendices A and B).
No student was allowed to spend more than 15 minutes on one syntax error.
In the interests of fairness therefore, it was decided to report the results inclusive and exclusive of bug8. It can be seen however, that exclusion of bug8 makes little difference to the conclusions which can be drawn from the overall results.
Overall, the Turing students corrected 90% of the errors on the first attempt, and 100% of the errors were corrected eventually and without assistance.
On the whole, the Pascal students were more inclined than the Turing students to study the code rather than be led by the error message when correcting syntax. This was despite the fact that the Turbo Pascal syntax checker attempts to be more specific than Turing in locating the probable position of the error.
Two of the Pascal students (Pascal Student Two for Bug6 and Pascal Student Four for bug4 & bug5) altered the logic of the programs after repeated attempts to get rid of syntax error messages
In this exercise, it can be seen that for 13% of the errors (24% if bug8 is included), the Pascal students would have required assistance from colleagues or from a teacher. How much time would have been wasted over these syntax errors would be determined by how quickly the students would have been prepared to seek this assistance.
It was however, for precisely that reason that this exercise was included in the experiment. It was felt that by allowing the subjects to make and correct their own errors, it would portray a more realistic picture of the types of the syntax errors and difficulties encountered by students. The syntax error programs allowed a controlled measurement of the subjects responses to the researcher's idea of 'typical syntax errors' based on a prior discussion with instructors. However, this exercise allowed a real-life situation to be evaluated.
No assistance was given with coding unless the student appeared to be having considerable difficulty. All help was recorded, but not evaluated as explained above.
One conclusion which may be drawn from this is that the students considered the exercise to be simple and therefore not requiring formal planning or design. Two others are that the students had not been taught to plan on paper or that they simply couldn't be bothered. In any case, none of the three older students had any difficulty in writing the program, taking no more than 10 minutes to do so and with little syntactic correction being necessary.
All of the older students made methodical use of the F2 key (paragraph) - especially when working on the loop.
Neither of the two younger students used the F2 key at all and both had difficulties with the logic of the program although not just with the loop. One of these younger students expressed that "..I was getting a little messed up because there was too much on the page I reckon". (referring to the instruction sheet)
One of the younger students had difficulty in developing a strategy which would output only those temperatures whose fahrenheit value was a multiple of 5. It was decided at this point to give all subsequent students a 'hint' by explaining the usefulness of the 'mod' function. The older Turing students were already familiar with 'mod'.
Again there were differences of experience and instruction. The older boys used the F2 key to paragraph their program every couple of lines. Two of them commented during their interviews that they liked it and thought that it helped them with loop constructs. One student remarked that the 'shape' of a program helped him to understand it. Schneiderman [4], [5], suggested that there is a close link between how well one can understand a program and how well one can remember it. His experiment indicated that well-structured programs were easier to remember than badly structured programs. His conclusions can however be questioned from the point of view that measurement of comprehension is somewhat subjective. It is entirely possible to understand a concept and still be unable to put this concept into practice.
The Pascal students are instructed in the use of Jackson Structured Programming (JSP) [7] which involves the design of a diagrammatic representation of the program. The students are then encouraged to use this diagram to design procedure stubs and finally, to write the code itself. In practice, only two of the students used this methodology, but they had least difficulty with this exercise and both produced a working program within 10 minutes.
None of the Pascal students had particular difficulty with logic in this exercise, although one student had problems caused by placing a semi-colon after the 'if...then'. The result was that this statement was ignored by the compiler and the output was erroneous. The student, who was in 2nd year, received considerable assistance with the exercise.
The following is an explanation of the graph in figure 2(b).
There had been a preconception that Turing students would be tempted to run their programs frequently during syntax correcting simply because it is a one key operation to do so. It was however, found not to be the case. Even when there was more than one error in a program, the students were inclined to correct both errors at the same time before running the program.
Nevertheless, it was decided to examine the error reporting on the syntax error programs and to categorise these as above. The results of the syntax correcting sessions were then compared with the categories to see if any patterns emerged. A fourth category was included for the Turing syntax checker. This was 'false diagnosis', where one syntax error produced a side effect of other 'false' errors.
The results can be seen in figure 3(a) and 3(b).
Consider first the categories of the error messages. It is apparent that Pascal has a higher incidence of 'unhelpful' and 'misleading' error messages. Turing has no 'misleading' error messages, although one of the 'unhelpful' messages also produces 'false' messages.
It can be seen that with both syntax checkers, there is a higher incidence of errors where the message is misleading and unhelpful or where 'false' errors are produced. This is not perhaps surprising, but given that the students who took part in the test were not novices, it might be reasonable to suggest that complete beginners would have considerably more difficulty with Pascal than with Turing.
It was concluded from the syntax correcting and programming exercises that the Turing students spent less time and needed less assistance with syntax correcting than Pascal students. They were also more likely to resolve syntax errors on the first attempt and less likely to require assistance in doing so. The Pascal students were more likely to be misled by syntax errors and to alter the logic of the program in the syntax correcting process.
There was no difference in the amount of assistance required with logic. Students in both groups required assistance with logic to roughly the same (minimal) extent.
A comparison of the value of the error messages produced by the two syntax checkers, shows that Pascal produces more unhelpful and misleading messages than Turing although Turing produces some 'false' error messages. Statistically, these were the error messages which caused the students most difficulty and it is felt that complete beginners might have considerably more difficulty with Pascal error messages than with Turing.
On the whole, 'trial and error' appeared to be the main method by which syntax correcting was learned. Most of the teachers stated that they did not 'teach' syntax correcting, but rather 'assisted' with individual problems as and when they occurred. "..it's difficult to pick out which one's you're going to teach them because they'll always find another one !" (Pascal Lecturer C). Interestingly though, several of the students appeared to perceive individual assistance as 'teaching'. In this respect, it seems that some teachers may only regard themselves to be teaching when they are addressing the entire classroom. At the College, there are exercises given in first year, in the form of syntax error programs, to assist the students in becoming proficient at recognising and responding to syntax error messages. Some of these errors were repeated in this study.
Textbooks were only considered to be useful in syntax correcting by the Turing students. This is possibly because Turing has no 'help' screen. One of the Pascal students particularly felt that the 'help' screen was useful. This student was alone in making use of the help facility during the exercises.
All of the students stated that previous experience of the syntax errors in the exercises had enabled them to correct them. Several students claimed to have seen some errors previously, even when they were unable to correct them instinctively.
All of the students were happy with the language which they were learning. A few of the Turing students admitted that at first they were a little suspicious of Turing which they knew was not a mainstream language, but that they now felt that it was a good language with which to learn to program. Those who were now using other languages, felt that Turing had assisted them in making the transition "..if I didn't know basic Turing, I wouldn't have been able to get past the first chapter in my tutorial for C++." (Turing Student Two).
None of the Pascal students felt dissatisfied with learning that particular language. This may be due to the fact that often, "Pascal is erroneously thought to be a language of business.." (Turing Lecturer C). Interestingly, despite the difficulties which were experienced during the exercises, none of the Pascal students felt that they spent an unreasonable amount of time correcting syntax errors. One student (Pascal Student Five) felt that the semi-colons were an irritation, but accepted that "...the errors you get, you've put them in yourself..".
Undoubtedly, the F2 key is one of the more popular features of Turing - "...it sure helps with the organisation of the loops and the if statements - especially when it gets long and it helps even more when we learn procedures" (Turing Student Three). Certainly from a teacher's point of view, it is easier to mark a program which is correctly laid out on the screen. In a comparison of the eight available programs which the students wrote for this exercise (see Appendix I), only the first three Turing programs and the first Pascal program are indented in a manner which makes them easy to read. The others are either not indented at all, or indented in an exaggerated way making them equally difficult to read.
Several students however, felt that Turing was not powerful enough and restricted them in the size of program which they wanted to write "I think Turing is really limited. It has a global data size of 64k or something like that and it isn't necessarily quick when you run it...." (Turing Student One); "It's pretty hard to do something that takes a lot of lines" (Turing Student Five); "[A disadvantage is] just how powerful it is. You can only do so much" (Turing Student Three)
Most of the students gave good answers to the questions aimed at ascertaining their understanding of certain programming constructs (see Appendix G).
Without exception, the teachers agreed that problem solving is the most difficult aspect of programming to teach. Opinions on how a language can help to overcome this varied :-
Turing is popular with those who teach it and it's popularity is accredited to it's easy syntax and graphics capabilities. These are perceived as being useful for teaching beginners and, in particular, to younger students. The teachers agreed that Turing is very easy to learn.
The Turing teachers claimed not to explicitly teach syntax correcting although Turing Teacher C felt that it would be a positive teaching method to do so. The lecturers and the other teachers however, all felt that explicit teaching of syntax errors was unnecessary with Turing because of its clear syntax.
Turing Lecturer B also felt that algorithms translate easily into Turing so that at University level, students can be told "You've got the book, you can look up the syntax, this is basically near enough what it looks like".
Perceived disadvantages of Turing included being unable to import graphics from other applications and having to contend with complaints from students who feel that they should be learning a language which is 'industrially relevant'.
No Turing teacher commented on students being misled by 'false' errors.
The Pascal lecturers like Pascal for "..its clarity, its rigor [and] the constraints it puts on students to model the world correctly" (Pascal Lecturer A); "It's well structured...it's more English oriented even although I think C's not too bad. It follows a JSP and I still think the students pick it up quite easily" (Pascal Lecturer B). Pascal Lecturer B, however also has the opinion that it is "...difficult to teach logic or problem solving through Pascal...".
At present, the college used in the study is in the process of deciding whether to introduce C as it's first taught language. It is felt that there are advantages to teaching a language which is considered to be 'industrially relevant' from the beginning, thus giving the students an opportunity to develop expertise in this language. Feelings are mixed among the staff. It is felt that much depends upon the calibre of the students who are being taught and what their previous experience has been. Pascal Lecturer A feels "Fearful...I think that the teaching of an untyped, poorly constrained language in all its complexity to beginners is bad practice because they have no feeling for how you define objects, what the constraints are when you define them, and what the safety is by defining them safely.....if Pascal does one thing, it does produce safe programs". Pascal Lecturer C on the other hand, does feel that there is a case for "getting right into teaching something that [the students] are going to use outside....you've seen the adverts, people want C, they want Visual Basic...".
For some educators, it would appear that the choice of first language depends on the course. Clearly, in an FE college, the objective of the course is to prepare students for a competitive job market and in this case, it may be felt that there are convincing arguments for "Training students to be marketable commodities, immediately useful to an employer". (Laker [22])
In a school setting however, the syllabus is geared more towards preparing the students for further or higher education and from this point of view, there is perhaps more flexibility in a choice of programming language.
The issue of student calibre was raised and considered to be of significance. Where a class contains students of very mixed abilities, it is more important to "[have] easy to learn and use, basic syntax" (Turing Lecturer C). This is certainly a major consideration in Scottish high schools nowadays.
As was earlier stated, some of the instructors who were interviewed in this study, had experience of teaching with both Pascal and Turing. They, are therefore in the strongest position to make a comparison.
All of them felt that Turing was easier to teach and to learn. Turing's main advantages, they feel, are its uncomplicated syntax and error handling. Imperial College in London selected Turing because it was the cheapest system available which offered most of the features which they considered desirable for an introductory programming course. There, it is felt that "The students certainly learn faster at the beginning using Turing ... we can get on to more advanced ideas more quickly ..." (Roger Bailey, October 1995).
In general however, Dr Bailey feels that "..our students are high-achieving computer geeks who aren't fazed by syntax anyway. Inconvenient syntax is usually only a temporary hurdle, but possibly more for, say, schoolkids....".
It was noted during the study that there were occasions where students who shared the same teacher, displayed distinct similarities in approach to the exercises. This included weaknesses such as failure to make use of the F2 key.
Linn & Dalbey [12] studied over 500 students and concluded that the success of introductory programming classes is strongly influenced by the quality of instruction, reasonable access to computers and curriculum materials - all of which they found largely lacking. In Linn & Dalbey's study, the students who had scored highest in the tests, were those high and average ability students (both made similar progress), whose teachers provided exemplary models and debugging techniques. This is a method whose success is endorsed by Pascal Lecturer B.
Linn & Dalbey [12] identified the chain of programming instruction as having three components :-
They also concluded that quality of teaching was a major factor in the success of a computing course. Husic et al [15] found that teachers of programming, especially in a pre-college setting, may know little more about programming than their students. Often, the teacher has learned to program by attending a few workshops or classes in programming. As a result, there was a perpetuated emphasis on syntax-oriented organisation of computing as a result of the teacher's main or only programming experience having been acquired through attending classes or workshops.
Pascal Lecturer B feels strongly that good teaching is of more significance than any particular software. He noted that his students benefited more from a system of teaching which involved informal tutorial sessions, where he would sit with a group and work through a problem together and to completion. This he felt was a better teaching strategy than giving out handouts with examples and solutions.
This is certainly a common-sensical viewpoint. However, unless a student can reinforce such quality teaching by trying out the ideas quickly, many benefits will be lost. The immediacy of this is essential. The longer it takes a student to compile and test an idea, the weaker will be the understanding of what has been taught.
Others agree that "The truth of the matter is that a good teacher can teach a good student regardless of the quality of the teaching tool" (Chris Stephenson, Vice President of Holt Software).
What must be considered however, is "What happens in the absence of good teaching ?". Holt Software feel that they are providing a solution "...Turing is a good tool for the rest of the teachers and students for whom programming is not always immediately accessible".
In other words for 'ordinary students' and 'ordinary teachers'.
This study considered some benefits which might be derived from reducing the time which students and teachers spend correcting syntax errors. The speed at which the Turing students worked through the programming and syntax correcting exercises, is a clear indication that Turing is a language with which students will quickly become familiar and this is something upon which an astute teacher should be quick to capitalise. The Pascal students took approximately 35% longer than the Turing students to complete the exercises. (This approximation includes an allowance for the fact that they also had two extra programs to correct.)
The fact however, that three, of the five of the Turing students re-adapted to the language with such ease when they hadn't used it for some time, is a strong case in favour of its suitability for beginners. Often, there can be confusion over minor syntactic details when there has been a break from using a language and especially where another language has been learned in the interim.
Obviously, syntax is an issue which many educators consider to be a technicality and often a minor one at that. It certainly should be, but all too often it is not. For many programmers, a language is considered in terms of its capability to produce complex and powerful programs. However, the objective of an introductory programming course is to convey programming style and concepts in ways which are both easy to comprehend and, to reinforce through quality practice.
Comfort must not be taken from reassurances that most students will gradually learn the syntax of a language through time. 'Gradually', can mean 'soon' for some students and 'never' for others. It is the students in the middle of that scale for whom the biggest difference can be made.
Syntactic errors have also been seen to have an impact on the logic of programs. On three occasions, Pascal students altered programs which were previously logically correct in their efforts to get those programs to compile. Similar findings were made by Walsh [10]. This matter raises further questions about the findings of other studies which have looked at novice programmers' semantic miscomprehensions (Spohrer et al [11]). In this study, the researchers selected as their data, a total of 158 'syntactically correct' programs from a group of non- science, humanities oriented students who had completed an introductory Pascal programming course. This data comprised of the first syntactically correct program that a subject generated on the basis that it would contain more bugs than later, partially debugged versions.
It is suggested however, that in many circumstances, these programs would not in fact provide an accurate representation of the subjects' semantic miscomprehensions since their sample might include logical errors which were manufactured during the syntax correcting process. Soloway [2] and Anjaneyulu [1] both conducted research which suggested that many novice programmers' semantic misconceptions are directly related to the Pascal language. The design of the Turing language addresses some of these difficulties such as having an exit in the middle of a loop, and preventing array indexes from going outwith their bounds.
Conceptualisation was high on the list of things which teachers considered to be a problem for students. Concepts such as assignment, iteration and selection are often totally alien to a novice. In this sense, Turing is seen to help by providing a feature which reinforces correct layout for the student. By 'shaping' the program in this way, students can conceptualise loops more easily.
Although it does not have a facility for tracing through programs, the fact that a run-time error will highlight the part of the code at which execution terminated, is considerably more helpful to a novice than an address in memory.
Little has been said about Turing's graphics and nothing has been mentioned about its powerful string handling capabilities. However, these are two features which make Turing an exciting language with which to satisfy the programming requirements of the curriculum. The graphics are easy to use and offer an interactive, fast moving, and interesting introductory programming course to younger children. "... we've turned the focus on graphic and music because very simply, that is a way of motivating the kids. You can teach them a loop with a dry example or you can teach them how to bounce something around the screen and they realise that they are learning it..." (Turing Teacher C).
There was however, no evidence that the Turing students had developed better problem solving skills as a result of the language's easier syntax, only that the students wasted less time in dealing with syntax errors. In order to measure progress in developing problem solving skills, a much larger, more controlled experiment would have to be set up with two 'matched' groups of beginners learning the two languages in parallel, with the same teacher instructing both groups. No such experiment has ever been carried out and Roger Bailey, for one, doubts if anyone ever will.
There remains only the question as to whether there is an argument in favour of using a more suitable, but less well known language in an introductory programming course instead of one which is widely used, but with which less progress may be made. The answer must lie in the programming course itself.
There is a strong argument in favour of using such a language initially in order to convey as many programming ideas in as short a time as possible. Given the relatively short class times on a High School computing course, this benefit must not be underestimated. The school aims to provide a solid foundation of understanding upon which a pupil can build. It is therefore more important at this stage that the language which is used, acts as a means to an end rather than the end in itself.
For the vast majority of school pupils and University undergraduates, an introductory course in Computing serves only to fulfil the partial requirements of a syllabus. It is estimated that less than 10% of these students will go on to take computing as a major subject "For many of these students, the introductory course will be the only computer course they take, and it is important for it to provide a good foundation in the discipline of computing" (Roberts [27]).
For the organisers of computing courses in Colleges of Further Education and at University postgraduate level however, there are different considerations. These courses are intensive and specialised. The students are closer to the job market and therefore, a convincing argument remains in favour of training students entirely in an industrially relevant programming language such as C.
One argument put forward by this school of thought, is that good programming style can get lost in the transition from one language to another and that students are being "...taught to become good programmers only in the context of a language that they will never use again". (Roberts [27]). This is one argument which would certainly require consideration in the planning of more intensive and specialised computing courses.
It is accepted that there may always be potential difficulties in progressing from one language to another, but for more than 90% of the students who take introductory computing courses, this will never be a problem. For this reason, languages such as Turing remain the best possible choice to meet the objectives of such courses.
From the viewpoint of a Computing Studies teacher therefore, there is clearly sufficient evidence to merit at least further investigation into the use of Turing as a teaching language in Scottish schools.
[2] E Soloway, J Bonar, K Ehrlich (1989) Cognitive Strategies and looping constructs : An Empirical Study (in Studying the Novice Programmer, Edited by E Soloway & J Spohrer, Lawrence Erlbaum Associates Inc, NJ
[3] F J Lukey (1981) Comprehending and Debugging Computer programs (in Computing Skills and the User Interface, Ed. Coombs M J & Alty J L, Academic Press
[4] Schneiderman B (1977) Exploratory experiments in programmer behaviour (Int J Computer System Sci., 5, 123- 143)
[5] Schneiderman B and McKay D (1976) Experimental investigations of computer program debugging and modification (Technical Report No 48, Computer Science Dept., Indiana University
[6] Ledgard HF, Whiteside J Singer A and Seymour W (1980) The natural language of interactive systems Commun ACM 23, 10 556-563
[7] Pressman R S (1994) Software Engineering A Practitioner's Guide (MgGraw Hill, Berkshire, England
[8] Weidenbeck S (1985) Novice/Expert differences in Programming Skills International Journal of Man-Machine Studies, 23 383-390
[9] Soloway E , Ehrlich K, Bonar J & Greenspan J (1983) What do Novices Know about Programming ? In Directions in Human- Computer Interactions, B Schneiderman and A Badre (Eds) Ablex Inc
[10] Walsh T, (1989) Rationale for and problems involved in teaching programming. Unpublished M.Ed. Dissertation, University of Stirling, Stirling
[11] Spohrer JC, Pope E, Lipman M, Sack W, Freiman S, Littman D, Johnson L and Soloway E (May 1985) BUG CATALOGUE: II, III, IV Tech Report 386, Dept of Computer Science, Yale University, New Haven, Conn
[12] Linn MC and Dalbey J (1989) Cognitive consequences of programming instruction (in Studying the Novice Programmer, Edited by E Soloway & J Spohrer, Lawrence Erlbaum Associates Inc, NJ)
[13] Perkins DB, Hancock C, Hobbs R, Martin F, Simmons R, (1986) Conditions of Learning in Novice Programmers (in Studying the Novice Programmer, Edited by E Soloway & J Spohrer, Lawrence Erlbaum Associates Inc, NJ, 1989)
[14] Pea RD (1986) Language Independent Preconceptual "Bugs" in Novice Programming J Educational Computing Research, Vol 2 (1)
[15] Husic F, Linn MC and Sloane KD (1989) Adapting instruction to the cognitive demands of learning to program J of Educational Psychology , 81, 4, 570-582
[16] Carver S M (1988) Learning and Transfer of Debugging Skills: Applying Task Analysis to Curriculum Design and Assessment, In Teaching and Learning Computer Programming:Multiple Research Perspectives, (Ed) Mayer RE, Lawrence Erlbaum Assoc, NJ, pp 259-297
[17] Berman LM, Roderick JA (1977) "Curriculum: Teaching the What, How and Why of living" Charles E Merrill Publishing Co., Ohio
[18] Schneider GM, Weingart SW & Perlman DM (1978) An Introduction to Programming and Problem Solving with Pascal John Wiley and Sons, New York
[19] Dalbey & Linn (1985) The Demands and Requirements of Computer Programming: A Literature Review J Educational Computing Research, 1 (3), pp 253-274
[20] du Boulay B, O'Shea T & Monk J (1989) The Black Box within the Glass Box: Presenting Computing Concepts to Novices (in Studying the Novice Programmer, Edited by E Soloway & J Spohrer, Lawrence Erlbaum Associates Inc, NJ)
[21] Holt RC & Cordy JR (1988) The Turing Programming Language, Communications of the ACM, 31 (12), pp 1410-1423
[22] Luker, P A (1989) Never mind the language, What about the Paradigm? SIGSCE Bulletin, 21, pp 252-256
[23] Friend (1975) Programs Students Write Technical Report No 257, Institute for Mathematical Studies in the Social Sciences, Stanfor University
[24] McCracken DD, (1992) Programming Languages in the Computer Science Curriculum SIGSCE Bulletin, 24, pp 1-4
[25] Holt RC, Matthews PA, Rosselet JA, Cordy JR (1987) The Turing Programming Language: Design and Definition Prentice Hall
[26] Pennington N & Grabowski B (1990) The Tasks of Programming in Psychology of Programming, Eds Hoc JM, Green TRG, Samurcay R & Gilmore DJ, Academic Press, London, 1990
[27] Roberts ES (1993) Using C in CS1: Evaluating the Stanford Experience, SIGSCE 25.
Hume JNP (1993) Turing Tutorial Guide, Holt Software Associates Inc, Toronto, Canada. 10 A brief look at Gender Differences