Fostering Early Development of Expert-Like Knowledge Structures in Computer Science Students

Paolo Bucci and Timothy J. Long
Department of Computer and Information Science
The Ohio State University
Columbus, OH 43210-1277 USA

bucci@cis.ohio-state.edu, long@cis.ohio-state.edu
Phone: +1 614 292 5813
Fax: +1 614 292 2911
URL: http://www.cis.ohio-state.edu/~bucci/, http://www.cis.ohio-state.edu/~long/

Abstract

We propose that development of initial, expert-like knowledge structures should be an explicit learning objective for introductory programming courses. Such knowledge structures can grow with and direct computer science students as they proceed through their undergraduate training. To realize this objective, students will use a novel programming environment and language, tailored to the 18-year-old mind.
Keywords
CS1, CS2, knowledge structures, models of software
Paper Category: position paper
Emphasis: research in education

1. Introduction/The Problem

In virtually every field of learning, novices and experts differ in how they process information and solve problems. In physics, for example, an interesting study reported that competent novices (undergraduate physics students) categorized sample physics problems based on surface-level considerations, such as spring problems, or inclined-plane problems, whereas physics experts categorized the same problems according to the laws of physics [6]. Differences in the knowledge structures of novices and experts are thought to be central to this phenomenon [2]. The knowledge structures of experts allow processing of information by appeal to fundamental governing principles, as opposed to the more surface-level considerations embodied in the knowledge structures of novices.

We know of no studies documenting the novice/expert knowledge-structure phenomenon in the field of software (computer programming) at the undergraduate level. However, over fifty years of combined experience in teaching software development at all levels of the undergraduate curriculum convinces us that computer science graduates, as a whole, leave academia with woefully inadequate knowledge structures of software. We do not believe that this needs to be the case, and it seems to us that the real pity of this situation is one of lost opportunity. Almost all computer science students take a yearlong introduction to programming (often referred to as CS1 and CS2) beginning in the freshman year. If, during CS1/CS2, students formed initial expert-like knowledge structures of software, then the opportunities this would provide are truly exciting. Undergraduate students could, for example,

deepen these structures and their basis in fundamental principles throughout their studies
develop an ability to think in terms of these structures and thereby abandon, of their own volition, ad-hoc and "hacker" modes of software development
hone recommended software skills and practices within the context of these structures
make deeper connections between concepts appearing across the computer-science curriculum.

When we think in terms of what could be, it appears to us that failure to foster student development of initial, expert-like knowledge structures of software is one of the most serious shortcomings of current CS1/CS2 education. Furthermore, once this failure is identified explicitly, it is quite easy to recognize contributing factors. Regrettably, we hold that most programming languages and programming environments, as well as most textbooks, in popular use in CS1/CS2, are "part of the problem" [5,9,10]. In short, we believe that CS1/CS2 education is in need of a change in culture.

2. Background

Beginning in 1997, and with the support of FIPSE (P116B60717) and NSF (CDA-9634425), we began an ambitious project to revamp CS1/CS2 at Ohio State and West Virginia universities using a component-based software engineering model of software, referred to as the RESOLVE model [12]. Although we believe the new course sequence to be a considerable advancement in CS1/CS2 education, and despite encouraging assessment results [13] and the garnering of local and national awards [15], we have experienced a sense of frustration with the project, almost from the very start. At the surface level, frustration arises in the difficulty of appropriately expressing our model of software using the popular programming languages of the day, namely C++ and Java. In retrospect, this should not be surprising, as both languages are industrial-strength languages designed for industrial use. Bjarne Stroustrup, the inventor of C++, states "From the start, C++ was aimed at programmers engaged in demanding real-world projects. ... The nature of the C++ language is largely determined by my choice to serve the current generation of system programmers solving current problems on current computer systems. ... Trying to seriously constrain programmers to do 'only what is right' is inherently wrongheaded and will fail" [14]. Java white papers describe Java as "A simple, object oriented, distributed, interpreted, robust, secure, architecture neutral, portable, high performance, multithreaded, dynamic language" [7] and state that "The Java programming language is designed to meet the challenges of application development in the context of heterogeneous, network-wide distributed environments" [8]. As suitable as these goals may be when considering experienced programmers, these languages obviously were not designed to convey, simply and elegantly, a clean model of software to the 18-year-old mind. Further, these programming languages appear to impede student learning of such basics as algorithmic thinking. Georgia Tech, for example, has abandoned the use of real programming languages altogether in its CS1 course for engineering students [11].

At a deeper level, our inability to appropriately convey our model of software through popular languages has inhibited student development of the desired knowledge structures. We believe this to be a serious and fundamental failure that must be corrected if our approach, or any approach, to CS1 and CS2 is to fully realize its potential in student learning.

3. Our Proposal

The RESOLVE model of software is based on fundamental and time-invariant principles that both pervade and transcend the field of computer science. Examples include system thinking, mathematical modeling, modular reasoning, information hiding, and abstraction. The RESOLVE model is accompanied by a programming language, called the RESOLVE language, used to express software artifacts according to the model. The model and the language have been painstakingly crafted to "fit together" and to incorporate and reflect fundamental principles as simply and as elegantly as possible. They have not been designed to compete with current trends in programming language fashion. We believe that by combining our current use of the RESOLVE model with use of the RESOLVE language, we can begin to address the fundamental issue of student development of expert-like knowledge structures of software, beginning in CS1/CS2. Thus, we propose to

implement an innovative programming environment, called SCW (Software Composition Workbench), for student use of the RESOLVE language in CS1/CS2
adapt our current CS1/CS2 materials/develop new materials to work in conjunction with SCW
determine, through assessment, the extent to which beginning undergraduate students can develop initial, expert-like knowledge structures of software and the extent to which this can impact learning throughout their undergraduate computer science studies.

The SCW is central to our entire effort. Design of the SCW will be based on the idea of a conceptual editor [4] and will feature just the minimal amount of functionality necessary to develop programs according to the RESOLVE model and language. The self-explanatory interface will use visual structure, such as forms, to present the static elements of programs. This is in contrast to the usual method of keywords and indentation standards and will help students to distinguish between syntax and the elements that syntax is designed to express. Further, the interface will enforce a prescriptive pattern of interaction, through the use of wizards, so that the model of software will be unavoidably embodied in the very process of developing software through the SCW. (Although many programming environments are available already, almost all of them are complicated in their functionality and are not designed to foster student development of knowledge structures of software. DrJava [1], for example, is one effort to provide a more appropriate educational environment for Java.)

To further nurture student development of appropriate knowledge structures, students will be consciously engaged in metacognitive strategies in the classroom [3]. Principles and fundamentals will be introduced in homework readings, and the manifestation of underlying principles in the RESOLVE model and language, and in the SCW, will be reinforced constantly through classroom activities. Our existing course materials will be adapted for this integration of classroom activities with the SCW, and we will package and make available complete materials for in-class and at-home student activities.

Formative evaluation will be especially important for proper development of the SCW. In formative evaluations we will assess the ease of use of the SCW, its suitability for developing software, and its effectiveness in conveying the desired model of software. Summative evaluations will concern student development of expert-like knowledge structures of software. Desired knowledge-structure features will be identified and assessment instruments will focus on the extent to which each such feature is seemingly represented in student knowledge structures. Finally, for longitudinal evaluations, we will select a small number of subsequent courses involving considerable software development. Following each such course, we propose to assess how students' previously acquired knowledge structures of software impacted their performance in the course, and how their knowledge structures evolved.

4. Conclusion

CS1/CS2 is fragmented with respect to programming languages, programming paradigms, and programming environments. This trend may worsen as competing companies aggressively market their technologies to the educational community. Within this context, our goal of fundamentally impacting CS1/CS2 education may appear quixotic, even if the technological elements of our approach are superior, which we believe them to be. Hence, we see evaluation as the key to our ultimate success. For us, development of knowledge structures that can grow with students as they proceed through the computer science curriculum is now an explicit learning objective for CS1/CS2. Through rigorous assessment demonstrating the extent to which this is possible and revealing measurable gains in subsequent student performance, we envision a CS1/CS2 community persuaded to embrace a fundamentals-based approach. At that time, the base of our curriculum will become the place where models are established, principles explained, and fundamentals practiced.

References

[1] Allen, E., R. Cartwright, and B. Stoler, "DrJava: A Lightweight Pedagogic Environment for Java", Proceedings of the 33rd ACM SIGCSE Technical Symposium on Computer Science Education, ACM Press, 2002, 137-141.

[2] Bransford, J., A. Brown, and R. Cocking, eds., How People Learn: Brain, Mind, Experience, and School, National Academy Press, Washington, D.C., 1999.

[3] Bruer, J., Schools for Thought: A Science of Learning in the Classroom, MIT Press, Cambridge, MA, 1993.

[4] Bucci, P., Conceptual Program Editors: Design and Formal Specification, Ph.D. Dissertation, Dept. of Computer and Information Science, Ohio State University, 1997.

[5] Bucci, P., T. Long, and B. Weide, "Do We Really Teach Abstraction?", Proceedings of the 32nd ACM SIGCSE Technical Symposium on Computer Science Education, ACM Press, 2001, 26-30 (http://www.cis.ohio-state.edu/~weide/sce/papers/index.html).

[6] Chi, M.T.H., P. Feltovich, P., and R. Glaser, "Categorization and Representation of Physics Problems by Experts and Novices," Cognitive Science 5, 1981, 121-152.

[7] Gosling, J., The Java Language: an Overview, 1995 (http://java.sun.com/docs/Overviews/java/java-overview-1.html).

[8] Gosling, J. and H. McGilton, The Java Language Environment: A White Paper, 1996 (http://java.sun.com/docs/white/langenv/).

[9] Long, T., B.Weide, P. Bucci, D. Gibson, M. Sitaraman, and S. Edwards, "Providing Intellectual Focus to CS1/CS2," Proceedings of the 29th SIGCSE Technical Symposium on Computer Science Education, ACM Press, 1998, 252-256 (http://www.cis.ohio-state.edu/~weide/sce/papers/index.html).

[10] Long, T., B. Weide, P. Bucci, and M. Sitaraman, "Client View First: An Exodus from Implementation-Biased Teaching", Proceedings of the 30th ACM SIGCSE Technical Symposium on Computer Science Education, ACM Press, 1999, 136-140 (http://www.cis.ohio-state.edu/~weide/sce/papers/index.html).

[11] Shackelford, R., Introduction to Computing and Algorithms, Addison Wesley, 1998.

[12] Sitaraman, M. and B. Weide, eds., Component-based software using RESOLVE, ACM Software Engineering Notes 19, 1994, 21-67.

[13] Sitaraman, M., T. Long, B. Weide, E. Harner, and L. Wang, "A Formal Approach to Component-Based Software Engineering: Education and Evaluation," Computer Science Education, Swets & Zeitlinger Publishers, to appear.

[14] Stroustrup, S., The Design and Evolution of C++, Addison-Wesley, 1994.

[15] http://www.cis.ohio-state.edu/~weide/sce/now/awards.html