Beginning Programming Students Research Articles

Teaching Condor Grid Computing to Beginning Programming Students

Grid computing is taught at the University of Arkansas, focusing on the development of grid services, the Globus toolkit, and higher-level grid components. An early course, cluster and grid computing, successfully taught Globus materials to advanced undergraduates and beginning graduate students. However, the material assumed advanced knowledge of Java programming and covered networking and basic distributed systems concepts, and was therefore too advanced for beginning programming students. When teaching grid computing to beginners, we must focus on creating and submitting a grid job rather than programming grid services. We also teach grid computing to advanced science and engineering students whose programming skills are similar to those of beginning computer science students

Teaching by analogy

Many beginning programming students have difficulty mastering the C++/Java concept of the switch statement. This paper provides a classroom tested analogy that allows students to map a "real world" concept that they already understand to the switch statement, thus making comprehension much easier.

CMeRun

It is generally known that most, if not all, beginning programming students have difficulty understanding and debugging programs. For many students the primary problem is that when a program executes, it is essentially a "black box". They know what they think they wrote, but their only clues to logic errors come from watching the output of the program. If there are problems, it is difficult for inexperienced programmers to trace the problem back to the source of the error(s). This paper presents CMeRun, a tool that allows the user to see each statement in a program as it executes. This tool will allow beginning students to master coding and debugging skills much faster since it allows them to "look into" a program as it executes. Having this kind of insight into program execution will improve understanding, decrease development time, and reduce student frustration.

Teaching two-dimensional array concepts in Java with image processing examples

Two-dimensional arrays (2d-arrays) are fundamental data structures in many software programs and must be mastered by beginning programming students. Teachers of introductory programming are challenged to devise new and interesting exercises for teaching 2d-array concepts. We believe image processing (IP) examples can provide stimulating, challenging, and fun exercises for students. We describe briefly the new Java2 Image I/O API and show how it can be used to read and write images in GIF, JPEG, and PNG formats. We also provide Java code for an Image class that hides the complexity of this API from the student. We conclude with several sample student exercises that can be used to teach 2d-array programming.

Automated feedback on programs means students need less help from teachers

Many educators believe that the most effective means of teaching is through one-on-one interactions with students. It is not surprising, then, that an effective way to teach programming is to give students immediate feedback on programs that they have just written. Unfortunately, such one-on-one teaching scenarios are becoming increasingly difficult to arrange. We built InSTEP, an online tutoring system for beginning C programmers, to see whether an automated system could provide effective immediate feedback to beginning programming students. In an introductory programming course, we compared two groups of students. One group solved six programming problems with feedback from InSTEP; the second group solved the same six problems without feedback from InSTEP; both groups had access to feedback from teaching assistants. While both groups of students took about the same amount of time to complete the problems and performed about the same on a subsequent test, the students who received feedback from InSTEP spent less than a third of the time asking the teaching assistants questions than did the others.

Teaching C++ to high school students

C++ was used to teach programming to beginning programming students in a summer program for high-ability high school students. We discuss the reasons for choosing C++, how we presented it to this group of students, and the results of this experiment. Some suggestions are presented for others interested in teaching C++ to novice programmers.

Creating pedagogical programming environments

A popular way to introduce program design concepts to beginning programming students is to discuss the solution of familiar, easily decomposed problems involving ordinary situations, such as washing a car or cleaning a room. Extensible languages, such as Smalltalk, make it easy to create pedagogical programming systems on which the solutions of such problems can be implemented.

Interactive graphics: a tool for beginning programming students in discovering solutions to novel problems

A computer-based, problem-solving exercise was developed, using dynamic graphics to assist beginning programming students in devising and testing solutions to novel problems (problems requiring solution methods with which the students were not already familiar). For evaluation, 103 beginning computer science students at Southeast Missouri State University, were each randomly assigned one of three forms of the exercise containing four array-manipulation problems. The control group worked all four problems without the aid of dynamic graphics; whereas, on Problems 3 and 4, the first experimental group was allowed to test possible solutions by observing graphical execution of attempted code, and the second experimental group was allowed to interactively manipulate the elements of the array by means of arrow keys in order to devise a solution, in addition to observing the graphical execution of their code. Six measures of improvement in performance on Problem 4 over Problem 2 were made for each subject. The one-tailed Wilcoxon two-sample test was applied, using significance level .05, to compare mean scores between groups. The second experimental group showed significantly more improvement than the control group as measured by four of the six scores, and the first experimental group showed significantly more improvement than the control group as measured by two of the six scores. Although the second experimental group scored slightly higher than the first on all but one measure, no significant difference was observable between the two experimental groups. On a follow-up quiz, each experimental group scored slightly, but not significantly, higher than the control group. Additionally, it was noted that only students who had made a score of 13 or more on the KSW Computer Science Placement Exam were able to work either of the two problems used for evaluation.

A study of an advance organizer as a technique for teaching computer programming concepts

Research on instructional methods has suggested that advance organizers (e.g., metaphors) can be an effective tool in teaching certain types of material in some situations. In many cases, teaching computer programming concepts satisfies these criteria. In our research, beginning programming students were trained on the syntax of arrays. A training session consisted of reading a tutorial manual and entering lines of source code into an interactive system. One group was given a metaphorical organizer prior to training (an advance organizer). A second group received the organizer after training. A control group read a passage on computer history prior to training. The groups did not differ on training task performance or on a test of syntactic knowledge (near transfer). However, the advance organizer group did significantly better on a test of semantic knowledge (far transfer). Factors relating to when to use an advance organizer are discussed.

But My Program Runs! Discourse Rules for Novice Programmers

In this article, we present an approach to critiquing and correcting novice programs that “work” (that is, they have correct I/O behavior for all input from the problem space), but are poorly constructed. Poorly constructed working code is often produced by beginning programming students, and it is important but difficult to teach them why some working code is better than others. Traditional explanations of these problems often rest on some kind of efficiency principle. We shall argue that using efficiency as a guiding principle in critiquing working code is inappropriate for novice programmers. Instead, we develop an approach to critiquing working but poorly constructed novice programs based on the principle of program readability. That is, we base our critique of working code on its ability to communicate to program readers.

An interactive program advising system

This paper describes components of an Interactive Program Advising System (IPAS) for beginning programming students. The system, being unaware of the algorithm being implemented by the student, is unable to direct the student toward writing a correct program. It instead comments on the programming constructs the student has used in the specific implementing language—in this case FORTRAN. Beginning programming students often write poorly structured programs (especially in a non-block-structured language like FORTRAN) with constructs which, while legal, indicate that the student doesn't really understand the operation being performed. Data is currently being collected on “conceptual errors” commonly made by beginning students. This paper describes some of these “errors” and what comments can be presented to the student to help him understand and correct his own “errors.” A subsequent paper will present statistics on frequency of errors and plausible student logic which would produce the errors.

An interactive program advising system

This paper describes components of an Interactive Program Advising System (IPAS) for beginning programming students. The system, being unaware of the algorithm being implemented by the student, is unable to direct the student toward writing a correct program. It instead comments on the programming constructs the student has used in the specific implementing language—in this case FORTRAN. Beginning programming students often write poorly structured programs (especially in a non-block-structured language like FORTRAN) with constructs which, while legal, indicate that the student doesn't really understand the operation being performed. Data is currently being collected on “conceptual errors” commonly made by beginning students. This paper describes some of these “errors” and what comments can be presented to the student to help him understand and correct his own “errors.” A subsequent paper will present statistics on frequency of errors and plausible student logic which would produce the errors.

Interactive visual simulators for beginning programming students

This paper discusses two programs that have been written to be aids to introductory programming students. They both embody the belief that Computer Assisted Instruction can be a worthwhile aid to students when properly used and that one of the best uses is to present visually to the student a process that he has some control over and which he would not otherwise be able to observe. Section 2 of this paper discusses HYCOMP1, an interactive visual computer simulator. Section 3 discusses IVF, the Interactive Visual FORTRAN interpreter. They were both written in SNOBOL4 1 and run under the KRONOS Time Sharing System on a CDC 6600 using an Applied Digital Data Systems, Inc. ADDS Consul 880 terminal, which is an ASCII terminal with a CRT display and an addressable cursor.