Perceptions displayed by novice programmers when exploring the relationship between modularization ability and performance in the C++ programming language.

         The primary purpose of this study was to analyze different
         perceptions displayed by novice programmers in the C++
         programming language, and determine if modularization ability
         could be improved by an instructional treatment that
         concentrated on solving computer programs from previously
         existing modules. This study attempted to answer the following
         questions: (1) Did the treatment emphasizing practice in
         building programs from previously written modules improve the
         decomposition processes of novice programmers and, hence,
         programming performance? (2) Did low- and high-performing
         groups display any significant differences in perceptions?
         Three classes were selected at random from six classes over
         two semesters: two classes for the treatment group, and the
         third for the control group. Students were divided into a
         low-performing group and a high-performing group, based upon
         total scores in the first C++ programming language course as
         well as on calculus. A comparison of 65 perception-responses
         from the questionnaires of the two groups indicated several
         statistical differences. Low-performing students improved
         their ability to divide problem into sub-problems. Pearson
         correlation calculations indicated that excitement and
         satisfaction were highly correlated (75.2%); patience and
         persistence were necessary factors for improvement; and logical
         thinking and problem solving were also strongly correlated
         (87.7%). Although statistical tests reported significance
         between pretest and posttest, meta-cognitive factors played a
         role in the problem-solving activities and different
         perceptions that low-and high-performing students displayed.

**********

The literature commonly cites the frequent incapacity of conventional teaching methods to fully develop students' programming knowledge (Oliver, 1993). Researchers developed Object-Oriented Programming (OOP) in the late 1960s. This concept has entered the mainstream computing and modern computing curriculum. Bjarne Stroustrup's seminal work at Bell Labs in C++ is basically the C programming language with OOP extensions. OOP concepts and design are now integral in developing many modern information systems.

Because of the high interest in computers and the seemingly endless possibilities for growth in the field, the number of novice programmers is at an all-time high. Over the last several years, institutions of higher education have increasingly acknowledged the significance of student retention. Numerous students who enter university do not remain after the first year; in fact, more students leave without receiving a degree than stay, and 75% of those who leave do so because of academic failure. Greater understanding of planning and other strategies can aid students in acquiring computer skills and make programming instruction more effective.

This study examines perceptions displayed by low-performing and high-performing programmers when modularization was used as a teaching technique in the C++ programming language. It also focused on the perceptions of novice programmers exploring the possible relationship between their performance and semantic knowledge, with emphasis on the modularization and planning processes involved in the C++ programming language.

Background

Ross, Drysdale, and Schulz (2001) investigated the effects of cognitive learning style on academic performance in two university-level computer applications courses offered by the Faculty of Education and the Department of Computer Science at the University of Calgary. The Gregorc Style Delineator was used to collect learning-style information from a sample of 974 students over a four-year period from 1993 to 1997. The effect of learning style on academic performance was found to be significant in both courses. Results indicated that sequential learners performed significantly better than random learners in both courses.

Oliver (1993) examined an instrument to measure the achievement of semantic programming knowledge among novice programmers. Results indicated strong evidence of developmental levels among the three knowledge components of the Algorithmic Process Test (APT). Although strong achievement in the lower levels of semantic programming knowledge was also revealed, few students demonstrated achievement at the highest levels, despite its critical importance for programming success.

Bailie (1990) investigated students' modularization ability for solving computer programs in Introductory Pascal Programming from previously existing modules. Pretest and posttest programming were administered to measure performance. Results indicated a significant difference between pretest and posttest means. However, tests to determine if improvement varied according to student ability or problem difficulty were not significant.

Barry (1988) examined the relationship between particular programming skills and task characteristics. A group of novice programmers was given two programs at different levels of difficulty and wrote the programs as they thought aloud; no terminals were used. The proceedings were taped, transcribed, and merged with the written work, and 24 separate strategies were postulated. Two raters established five meaningful and reliable categories with 94% agreement.

Three levels of programmer proficiency were identified for the easier program. The most capable group used abstract thought, emphasized structure and design, and reviewed their work. The middle group gave little evidence of structure or design, connected subparts poorly, and was concerned with details. The least capable group seemed overwhelmed and attempted to translate the program directly into code. Four levels of proficiency were identified for the more difficult program. The top and bottom groups had planning strategies similar to their efforts on the easier program, but two middle groups emerged: the more capable had facility with subparts, yet had difficulty connecting them, while the less capable seemed careless, used partial solutions, and often left the program incomplete. With the more difficult problem, the poorest group was forced to spend greater effort constructing a problem representation at the expense of planning. General planning was a minor part of the protocols, but was the greatest for the capable groups even with an easy program. Less proficient novices focused on details; capable novices used planful approaches with less concern for details. The groupings differed significantly from each other in average SAT Math scores and first-semester course grades. This study demonstrated that changing a program's difficulty level resulted in a shift in strategies, suggesting training novices in representation and general planning. Restricting activities to one cognitive strategy could be used to observe changes in strategy development.

Nelson et al. (1993), who investigated the relationship between learning styles and GPAs, found that students involved in a learning style workshop had higher GPAs than students not involved in such a workshop. The workshop included: (1) completing a learning style instrument, (2) developing a background in individual learning styles, and (3) becoming aware of strategies/study tips to accommodate individual styles. Nelson et al. also reported that students who received learning style instruction were more likely to persist in a university.

Maheshwari (1997) developed a model to deliver a first course in computer programming to large and diverse classes. A group of team teachers, tutors, and lab demonstrators implemented this model, which took advantage of the unique characteristics of lectures, tutorials, laboratories, and readings. To improve the learning environment in large programming classes, instructors in the environment emphasized program design and problem-solving skills, and motivated students to learn by active processes instead of concentrating on language syntactic features.

A series of studies by Perkins and associates (1988) revealed metacognitive influences in programming. The goal of the research by Perkins, Martin, and Farady (1986) was to identify students' difficulties in programming. Their theoretical basis lay in their perceptions of programming as both a "problem-solving intensive" and "precision intensive" domain. As a problem-solving activity, programming requires the ability to decompose a problem into sub-problems and implement solutions in correct programming code. One paradigm used to portray the nature of introductory programming was a "precision intensive" one in which the smallest error invalidates a program. While other paradigms focusing on employed strategies could have been used, the researchers considered coding precision paramount. They argued that these two factors combined made programming extremely demanding for pre-college students.

PROJECT DESIGN

Setting and Subjects

The subjects for the present study were selected from students enrolled in the course Computer Techniques, an Intermediate C++ programming language course required for CIS majors. Three complete classes of 60 students were randomly selected to participate and were informed about the research. A reduced sample of 46 students exhibiting different levels of understanding and various programming competencies were identified on the basis of calculus test scores and scores in the first C++ programming course. The treatment group (n=24) was divided into two groups: 13 high-performing and 11 low-performing; there was one control group (n=22).

Questionnaire Development and Analysis

The aim of this study was twofold. First, it examined different perceptions displayed by low-and high-performing students in the C++ programming language. Second, it sought to systematically describe and analyze the cognitive processes involved in writing a computer programming language in C++, especially knowledge of algorithms, ability to develop functions for the C++ library, and relating performance to semantic knowledge among novice programmers in the C++ programming language.

The researcher developed a questionnaire to better understand the modularization that novice programmers hold for problem-solving activity in C++. Of particular interest was the interaction that two novice programmers could provide in an environment to evaluate possible strategies before pursuing a specific course of action, thus permitting greater monitoring of progress. The researcher designed the questionnaire to elicit information on the understanding, motivations, and experiences of problem-solving activities (see Table 6). It was administered directly after the pretest programming that preceded the treatment. A revised questionnaire was also administered directly after the posttest programming at the end of the treatment period.

In order to relate modularization programming and understanding identified by the questionnaire to programming performance, the students were divided into high-and low-performing groups, based on scores from calculus and first C++ programming courses. Two other sessions taught by the same professor using traditional teaching were used as a control group.

Test Problem Development

The researcher selected test questions for pretest and posttest from various textbooks used in three undergraduate institutions. A panel of five experts from three undergraduate institutions reviewed each of the ten problems for their appropriateness in testing the modularization ability of high-performing versus low-performing students. Each expert rated the difficulty level of each problem on a scale from 1 (very easy) to 5 (very hard).

Pretest

Problems, selected according to the required chapters in the C++ Programming (Control Structures, Functions, Arrays, Pointers, Strings), ranged from easy to complex problems. The pretest was administered to students as a monitored, open-book, open-notes test. The 23 students in the sample were videotaped while solving the pretest problems. The investigator graded the test using the scoring scheme presented in Table 2. Graders reviewed all pretests and re-graded any scores that differed. (See Table 1 for a list of calculus scores and programming test scores, and Table 3 for programming problems and modules.)

Treatment

The purpose of the treatment was to analyze different perceptions displayed by low- and high-performing programmers, and to determine if modularization skills could be improved by an instructional treatment that concentrated on solving problems from previously existing modules. The treatment was integrated into the regular classroom lecture schedule. The modules and programs used in the treatment were drawn from programming texts and former assignments developed by the instructor. The treatment period following the pretest occurred during the programming course, which met twice a week in two 65-minute lecture periods and one weekly, 65-minute computer laboratory. Individual modules were solved together in class and students were assigned individual procedures and functions as lab assignments and programming projects. After the modules were written and tested, programs were assigned that utilized the previously written procedures and functions. The pre-written modules were intended to facilitate program solutions and help students become aware of the advantages of the modularization process.

Posttest

Five weeks after the Pretest Data Structures, such topics as Classes, Friend Functions, Operator Overloading, Inheritance, Virtual Functions, and Polymorphism were tested using modules. The investigator and three raters graded each test, and differences were reconciled during consultation.

ANALYSIS OF RESULTS

Prior to analyzing the treatment results, 23 students were divided into high- and low-ability groups, based upon total scores in the first C++ programming course as well as on calculus. Students scoring above a mean of 75 were placed in the high-performing group, while those scoring below 75were placed in the low-performing group. A control group of 22 students was also obtained from two classes, which did not emphasize modularization. This study attempted to answer the following two research questions: (1) Did the treatment emphasizing practice in building programs from previously written modules improve the decomposition processes of novice programmers and, hence, programming performance? (2) Did low- and high-performing groups display any significant differences in perceptions (see Table 4)?

The means and standard deviations of the pretest and posttest for high-and low-ability students and the control group as a whole were also compared (see Table 5). The high-performing group mean was (75.6 [+ or -] 16.1) for the pretest while the low-performing group mean was (68.8 [+ or -] 8.8). During the posttest, the high-performing group mean was (75.0 [+ or -] 11.7) while the low-performing unit had a mean of (76.5 [+ or -] 13.8). The difference in scores of 7.67 for low-performing students suggested a gain in performance. However, with the high-performing group, the difference of -.625 suggested that little progress was made, even though the mean score was above average, compared to that of the control group. Overall, the mean scores of low- and high-performing students were greater than the mean score of 63.5 of the control group, suggesting improvement of the modularization strategy for the two groups. But how strong was the improvement?

Pearson correlation calculations were used to find how the nine qualities found in programmers, such as ability to think logically, ability to divide a program into sub-problems, ability to identify algorithms, patience, persistence, sense of humor, and luck, were related.

Frustration and boredom were strongly correlated (70.7%) at. = 0.05 level with the high-performing students, whereas excitement and satisfaction were significantly correlated (75.2%) with the low-performing students. With the high-performing students the vast knowledge of programming techniques was highly correlated with the ability to divide a program into sub-problems (82.6%). Patience was an important cognitive factor that the high-performing students displayed as a part of success in the knowledge of programming techniques. This factor was highly correlated with knowledge (77.4%).

Patience and persistence were necessary factors for improvement in the ability to divide a program into sub-problems. The low-performing students were likely to perform better if they became more persistent in their ability to divide a program into sub-problems. Other cognitive factors of learning, such as problem solving, logical thinking in mathematics, natural sciences, social sciences, and business, might be related as well.

Of the low-performing students, 87.7% thought that logical thinking benefits problem solving. The low-performing students had higher expectations that the high-performing students for the statement "breaking problems into smaller problems that can be solved more easily." The low-performing students scored higher than the high-performing students on item #10 of the perception questionnaire because they scored 3.66 while the high-performing students scored 2.33, (i.e., -3.66 is less than -2.33). The results indicated that there was an improvement of the modularization strategy for the two groups, especially for the low-performing students that became more proficient with the time (see Table 7).

Multiple regression analysis tests were also run in each group to determine the best predictor among persistence, ability to think logically, patience, sense of humor, ability to divide a problem into sub-problems, and a dependent variable: the vast knowledge of programming techniques (see Table 8). The results indicated that these attributes were important factors for improvement of the modularization techniques, and the order in which these qualities were exercised, was equally important. The order of significance was as follows: 1) sense of humor, 2) ability to identify algorithms, 3) patience, 4) ability to think logically, 5) persistence, 6) ability to divide a program into sub-problems, which was the order displayed by the low-performing group in the study. When comparing the results for the scatter plot, the low-performing students showed a positive steeper slope, indicating a strong relationship among the predictors (see Table 9).

DISCUSSION

Different perceptions displayed by low-performing students during the planning and implementation of problem-solving activities indicated strong correlations among attributes and qualities found in programmers about the modularization process such as sense of humor, ability to think logically, ability to identify algorithms, patience, persistence and ability to divide a program into sub-problems.

Pearson correlation calculations indicated that excitement and satisfaction were significant (75.2%) at alpha level of 0.05 with the low-performing students. Patience and persistence were significant factors for improvement in the ability to divide a program into sub-problems. Statistical tests reported significant results between the pretest and the posttest. The mean score was improved during the posttest with low-performig students. A difference of 7.667 between the pretest score and the posttest score was observed, whereas the high-performing students did not improve their scores, the mean score was different by -.625. The low-performing students were likely to perform better than the high-performing if they became more persistent in their ability to divide a program into sub-problems.

Pearson correlation calculations also indicated that logical thinking and problem solving were strongly correlated (87.7%). Low-performing students thought that logical thinking benefits problem solving, and mathematics learning contributed (77.2%), as well as social sciences learning contributed (77.2%). The low-performing students had higher expectations than the high-performing students for the statements "breaking problems into smaller problem that can be solved more easily."

[GRAPHIC OMITTED]

[GRAPHIC OMITTED]

CONCLUSIONS

The results of this study indicated that there was a significant difference between the pretest and posttest, in which the low-performing students' mean score and the high-performing students' mean score were both higher than the control group's mean score. The low-performing students scored higher than the high-performing students on the posttest.

The analyses of different perceptions displayed by low-performing and high-performing students during the treatment have indicated also that there was improvement of modularization technique. Pearson correlation results have also indicated the strong correlations between attributes and perceptions displayed by the low-performing students. For example, logical thinking is highly correlated with problem solving, and the low-performing students have more expectations than the high-performing students for the statement "breaking problems into smaller problem that can be solved more easily."

Multiple regression tests were run to assess the best predictors among attributes, and the results indicated that sense of humor and persistence were very significant in predicting the improvement of modularization technique.

Although statistical tests and analyses of different perceptions displayed by low-performing students and high-performing students indicated that there was improvement of modularization technique, caution must be exercised in interpreting results. Meta-cognitive factors such as sense of humor, persistence, confidence, and patience were highly rated by low-performing students. Time was another important factor. The videotaping and the exit interview supported and enhanced these findings. The results of the perceptions displayed by each group provided additional insights about meta-cognitive analysis. Confidence displayed by low-performing students seemed to simultaneously dissipate frustration and foster persistence until a solution was found.

INSTRUCTIONAL IMPLICATIONS

The results of this study have certain implications for instructional methodologies employed for novice computer programmers in the C++ programming language. Results show a strong evidence of improvement of the understandings of modularization that novice programmers hold regarding problem-solving activity in C++ programming language. This methodology of planning and designing through modularization seems to advocate guiding students at an early stage to build library and to implement functions, especially for classes, which can be employed in the solutions of larger and more complex problems using modules. The results of this study highlight the importance of meta-cognitive factors such as confidence and persistence in the teaching of modularization as a problem-solving strategy whose value is particularly significant in computer programming education.

Table 1

List of Student's Ability Measures

Students' group      CALCULUS TEST  COMPUTER TEST  #

Low-performing #1         60             70        1
Low-performing #2         57             62        2
Low-performing #3         65             60        3
Low-performing #4         70             65        4
Low-performing #5         65             60        5
Low-performing #6         55             55        6
Low-performing #7         62             67        7
Low-performing #8         59             70        8
Low-performing #9         58             65        9
Low-performing #10        72             68        10
Low-performing #11        68             63        11
High-performing #1        81             76        12
High-performing #2        86             75        13
High-performing #3        79             77        14
High-performing #4        80             76        15
High-performing #5        80             75        16
High-performing #6        82             80        17
High-performing #7        79             85        18
High-performing #8        83             82        19
High-performing #9        85             88        20
High-performing #10       90             95        21
High-performing #11       92             100       22

Table 2

Scoring Scheme

Program Plan  Points  Category

                   0  No overt attempt at modularization

                 1-2  Modularization attempted but major modules
                      missing or too detailed

                 3-4  Modularization good but minor errors

                 5-6  Reasonable modularization but not expressed
                      coherently

                 7-8  Reasonable modularization and coherently
                      expressed

Program Plan       0  No refinement or negligible refinement

                 1-2  Refinement attempted but major errors

                 3-4  No major errors but some details overlooked
                      or incorrect

                 5-6  Accurate solution with minor errors in
                      logic

                 7-8  Complete and accurate solution with no
                      errors in logic

Table 4

Comparison of Question #2 responses

Question #2: Rank the importance of each choice as a quality for a
successful programmer.

2a.  ability to think logically
2b.  ability to modularize
2c.  ability to identify algorithms
2d.  innate ability
2e.  knowledge of programming techniques
2f.  patience
2g.  persistence
2h.  sense of humor
2i.  luck

items  low-performing  high-performing  control group

2a     87.5%           66.7%            40%
2b     60%             62.5%            50%
2c     70%             37.5%            40%
2d     70%             37.5%            80%
2e     70%             62.5%            50%
2f     40%             25%              60%
2g     50%             37%              60%
2h     80%             75%              80%
2i     90%             87.5%            90%

Table 5

Pretest and Posttest Scores

                        Pretest        Posttest

Group               Mean      SD     Mean     SD

Low-performing LP   68.833   8.833  76.500  13.826
High-performing HP  75.626  16.132  75.000  11.789
Control Group       60.00   13.295  63.500  15.295

Table 6

Questionnaire Outline

I.    Motivations

      A. Reasons to study C++ programming language
         (Question #1)

      B. Expectations from studying C++ programming
         (Question #3)

      C. Success in other areas (Question #4)

II.   Understandings and Modularization

      A.Essence of programming (Question #5)

      B. Essentials for success

                 1. Qualities for success (Question
                    #2)

                 2. Learn by memorizing algorithms
                    (Question #12c)

                 3. Learn by memorizing rules
                    (Question #12d)

      C. Strategy models

                 1. Teacher expectations (Question
                    #6)

                 2. Professional programmers
                    (Question #8)

      D. Opinions

                 Getting program to work is the
                 only important part of activity
                 (Questions #12a)

                 2. Knowing how to solve a problem
                       is as important as getting
                       it to work (Question #12b)

                 3. There is only one correct way
                    to solve a problem (Question
                    #12e)

                 4. No solution mean all time has
                    been wasted (Question #12f)

      E. Personal evaluation of ability (Question
         #13)

III.  Experiences

      A. Personal strategies (Question #7)

      B. Effort expended

                 1. Time spent on problem (Question
                    #9)

                 2. Time spent on problem when
                    cannot solve (Question #10)

      C. Emotional responses

                 1. Frustration or challenge when
                    cannot solve (Question #10)

                 2. Other emotions (Question #11)

Table 8

Multiple Regression Analysis Results

Lower-Performing Students

  Model     Sum of Squares  DF  Mean Square    F    Sig.

Regression      8.811       6      1.468     3.418  0.170
Residual        1.289       3       .430
Total           10.100      9

High-Performing Students

  Model     Sum of Squares  DF  Mean Square    F    Sig.

Regression      38.047      6      6.341     3.575  .092
Residual         8.870      5      1.774
Total           49.917      11

Control Group

  Model     Sum of Squares  DF  Mean Square    F    Sig.

Regression      36.472      6      6.079     7.958  .116
Residual         1.528      2       .764
Total           38.000      8

Acknowledgments

The work described in this article was supported in part by grant PSC-CUNY Award #61404-00-30 that I received from the Professional Staff Congress of the City University of New York Research Awards Program to investigate the relationship between modularization ability and performance in the C++ programming: The case of Novice Programmers and Expert Programmers. However, the views expressed are not those of either the Foundation or the Project.

References

Bailie, F. K. (1990). The relationship between a novice programmer's set of understanding and programming performance. Doctoral dissertation, Columbia University.

Barry, T. K. (1988). Planning levels of novices in introductory computer programming. Doctoral dissertation, Columbia University.

Maheshwari, P. (1997). Improving the learning environment in first-year programming: Integrating lectures, tutorials, and laboratories. International Journal of Computers in Mathematics and Science Teaching, 16, 111-131.

Nelson, B., Dunn, R., Griggs, S., Primavera, L., Fitzpatrick, M., Bacilious, Z., & Miller, R. (1993). Effects of learning style interview on college students' retention and achievement. Journal of College Student Development, 34, 364-369.

Oliver, R. (1993). Measuring hierarchical levels of programming knowledge. Journal of Educational Computing Research, 9, 299-312.

Perkins, D. N., Martin, F., & Farady, M. (1986). Loci of difficulty in learning to program (Technical Report 86-6). Cambridge, MA: Educational Technology Center.

Perkins, D. N., Schwartz, S., & Simmons, R. (1988). Instructional strategies for the problems of novice programmers. In R. E. Mayer (Ed.), Teaching and learning computer programming: Multiple research perspectives (pp. 153-178). Hillsdale, NJ: Lawrence Erlbaum Associates.

Ross, J., Drysdale, M., & Schulz, R. (2001). Cognitive learning styles and academic performance in two postsecondary computer applications courses. Journal of Research on Computing in Education, 33(4), 400-412.

RELATED ARTICLE: Table 3

Summary of Modules

Module #1 Data type

Module #2 Control structures

Module #3 Function prototype 

Module #4 Arrays

Module #5 Pointers

Module #6 Class declaration

Module #7 Functional implementation

Module #8 The use of #ifndef

Module #9 Class object

Module #10 Use of operators new and delete 

Module #11 Use of default constructor 

PRETEST

Problem #1

Define a function hypotenuse that calculates the length of the hypotenuse of a right triangle when the other two sides are given. Use this function in a program to determine the length of the hypotenuse for each of the following triangles. The function should take two arguments of type double and return the hypotenuse as a double.

Triangle  side 1  side 2

      1   3.0     4.0
      2   5.0     12.0
      3   8.0     15.0

(Module 1, 2, 3)

Problems #2

Implement the following integer functions:

a) Function Celsius returns the Celsius equivalent of a Fahrenheit temperature.

b) Function Fahrenheit returns the Fahrenheit equivalent of a Celsius temperature.

c) Use these functions to write a program that prints charts showing the Fahrenheit equivalents of all Celsius temperatures from 0 to 100 degrees, and the Celsius equivalents of all Fahrenheit temperatures from 32 to 212 degrees. Print the outputs in a neat tabular format that minimizes the number of lines of output while remaining readable. (Module 2, 3)

Problem #3

Write a function that takes an integer value and returns the number with its digits reversed. For example, given the number 7631, the function should return 1367. (more difficult, Module 3, 2)

Problem #4

Create a class Rectangle. The class has attributes length and width, each of which defaults to 1. It has member functions that calculate the perimeter and the area of the rectangle. It has set and gets functions for both length and width. The set functions should verify that length and width are each floating-point numbers larger than 0.0 and less than 20.0 (Module 2, 6, 7, 8)

Problem #5

(a) Create a Square object for a class called Rectangle

(b) Create a Checkbook object for a class called Bank Account (Module 9)

Problem #6

Write class declaration for the circle class that requires three public member functions: one to initialize the radius, one to calculate the circumference, and one to calculate the area. The only private member required is the circle radius. (Module 6, 7)

Problem #7

Write an if statement that compares the two dynamic int variables pointed to by variables p and q, puts the smaller into an int variable named smaller, and destroys the original two dynamic variables. (Module 1, 2,5,10)

Problem #8

In a single statement declare a pointer variable named list and initialize it to the base address of a newly created dynamic array of 50 int elements. Then give a section of code that will zero out the array. (Module 4, 5, 10)

Problem #9

Given the variable list of question (above), show how to deallocate the dynamic data pointed to by list. (Module 10)

Problem #10

The C++ compiler will signal a syntax error in the following class declaration. What is the error?

Class SomeClass

{

public:
           void Func1(int n);
           int Func2();
           int SomeClass();

private:
           int privatelnt;

};(Module 1, 6)

RELATED ARTICLE: Table 7

Summary of Statistical Significance

The t-test indicated that there was a significant difference in the means of the following questions:

1. Low-performing students ranked sense of humor, patience, persistence higher as qualities of a successful programmer. (Questions #2h, #2f, #2g)

2. Low-performing students gave a high mark to ability to divide a problem into sub-problems (modularize). (Question #2b)

3. Low-performing students responded that teachers often expected them to use modularization as a strategy. (Question #6d)

4. High-performing students reported that professional programmers more often use modularization as a strategy. (Question #8d)

5. Low-performing students revealed that confidence is a key to success in problem solving. (Question #11f)

6. Low-performing students ranked vast knowledge of programming techniques higher as a quality of a successful programmer. (Question #2e)

7. Low-performing students gave a high mark to luck, sense of humor, and persistence. (Questions #2g, #2h, #2i)

8. High-performing students reported that they are frustrated and give up immediately more often. (Question #10a)

9. High-performing students ranked boredom higher than low-performing students while solving a programming problem. (Question #11g)

10. Low-performing students gave a high mark to satisfaction, excitement, and confidence (Questions #11c, #11e, #11f)

MAURICE A. VODOUNON

John Jay College of Criminal Justice 

The City University of New York

USA

[e-mail]