See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/2511205

Introducing Computer Science Fundamentals Before Programming

Article · July 1997

Source: CiteSeer

CITATIONS READS
23 3,750

2 authors, including:

Richard J. Leblanc
Seattle University
129 PUBLICATIONS 2,335 CITATIONS

SEE PROFILE

All content following this page was uploaded by Richard J. Leblanc on 15 July 2014.

The user has requested enhancement of the downloaded file.

 Introducing Computer Science Fundamentals Before Programming

Russell L. Shackelford and Richard J. LeBlanc, Jr.

College of Computing
Georgia Institute of Technology
Atlanta, GA 30332-0280

Abstract The traditional approach to introducing Introduction

students to Computer Science has been through a course
built around the development of programming skills. While In 1992, Georgia Tech's College of Computing restructured
many textbooks intended for such courses include the words its lower division curriculum to correct historical flaws and
"Problem Solving" in their titles, the primary focus of most better respond to modern demands. The restructuring was
such courses is the skill of programming in a particular motivated by the recognition that computing has ceased to
programming language. be an arcane technical discipline of interest primarily to CS
Computer scientists will quickly proclaim that the majors and instead has become a core element of a proper
discipline is more than just programming, but our typical university-level education for a broad population of
introductory courses fail to provide students with any students. The restructuring acknowledged the need to
conceptual foundation of computer science as a domain of provide an appropriate foundation in the conceptual and
study. In addition, the "programming-first" approach intellectual foundations of computing as well as relevant
ignores the practical reality that increasing powerful skills, to improve access for non-CS majors to the important
application-oriented software packages have become the ideas that computing offers, and to better exploit
tools of choice for solving many computation problems. computing's numerous opportunities to provide students
In this paper, we describe a two course sequence that with rich and challenging experiences.
has been taught to majors in computer science and a In the two years subsequent to the restructuring,
variety of other disciplines for the last four years. The first enrollments in the first course skyrocketed from ~100 per
course is called "Introduction to Computing"; the second year to ~1400, and computing became a de facto component
course is "Introduction to Programming." The of Georgia Tech's engineering curricula. This fact was
"Computing" course is a ten-week course that includes recently formalized: computing is joining the more-
material on the following: the "computing perspective" (the traditional disciplines as part of the university's core
algorithmic model as a way of thinking); foundational curriculum. This change will occur concurrently with the
concepts underlying program design and implementation, University System of Georgia's shift from a quarter-based to
including: algorithmic methods, static and dynamic data a semester-based calendar, and we believe this calendar
structures, and design using abstraction; fundamental change provides us with yet another opportunity to improve
notions of algorithm analysis and computability; and use of the teaching-and-learning value of our lower division
application tools such as e-mail, Web browsers, word structure.
processors, spreadsheets, databases, and equation solvers. We summarize, below, the rationale and the specific
Building on this foundational pre-programming goals of our restructured curriculum, and the lessons
material, students in the "Programming" course are able to learned from our four years of experience with it.
learn rapidly the skills in program design, implementation,
and debugging necessary to solve computational problems Goals
in a high-level programming language. We emphasize
effective use of abstraction and the acquisition of software Our curricular restructuring was informed by the
development skills that are language independent, though observation that the traditional CS curriculum is an
obviously we use a particular programming language. aberration that lacks a basic feature of time-honored
Our experience with these courses has convinced us curricular structure. While most curricula present
that it is possible to introduce the conceptual foundations of fundamental ideas and principles early, CS curricula have
Computer Science to beginning students in a way that both traditionally presented two years of work focused on applied
engages them and gives them a basis for learning advanced programming skills, effectively withholding key
ways to solve problems using computing, either via foundational material until upper division courses. We
programming or through use of modern, highly- believe that this curricular tradition is residue of the fact
programmable commercial applications. that CS courses originated as "programming skills add-ons"
to Mathematics and/or Electrical Engineering curricula. As
CS matured into a substantive discipline unto itself, it Introducing students to computing by way of a
simply "grew upward" in the curriculum, adding more traditional programming course ignores the practical reality
advanced courses on top of the traditional skills-oriented that standard application programs (such as spreadsheets,
lower division. As a result, students who are not CS-majors Matlab, Maple, etc.) have become the tools of choice for
are effectively denied access to foundational material. In solving many computing-related problems. Engineers can
recent years, numerous efforts have been made to repair the bring to bear a tremendous amount of computing power on
specific courses in the traditional structure without, in our a wide range of problems without ever "writing a computer
view, adequate consideration of the accidental, historical program" in the traditional sense of the phrase. Thus,
design flaws of that course structure itself. introducing students to computing via a course that
emphasizes writing programs effectively bypasses the most
direct means of computer-supported problem solving.
As the power of off-the-shelf application programs has
The Traditional Model grown, so too has their complexity. The boundary between
"programming" and "use of software packages" has become
Freshman

Introduction to Programming I blurred, such that the very same principles that underlie
effective program design (e.g., modularity, abstraction,
reuse, etc.) also underlie the effective use of increasingly
Introduction to Programming II complex software tools. Thus, reliance on such tools
increasingly requires an adequate foundation in algorithmic
principles.
Sophomore

Introduction to Data Structures In light of these factors, we set out to create a curricular
structure that would support not only CS-majors but also
engineering students and others who require a foundation in
Introduction to File Processing
computing. We also sought to provide non-CS majors with
increased access to advanced computing courses that may be
relevant to their professional goals. The result is a lower
division structure that features:
Upper Division

Virtually all of Computer Science: 1. A freshman level "Introduction to Computing"

Operating Systems, Database,
Programming Languages, Compilers,
course emphasizing the design, construction, and analysis
Networks, Theory, Human/Computer of algorithms, in concert with a software applications lab.
Interaction, Artificial Intelligence, et. al. 2. A freshman level "Introduction to Programming"
course (which assumes the first course as a prerequisite)
emphasizing the effective and efficient implementation of
algorithms in a modern programming language.
3. A set of three sophomore courses, each one serving
As computing plays an ever-growing role for students of as a gateway to clusters of upper division courses. This
other disciplines, the traditional structure has become structure allows non-CS students, who may be interested in
increasingly problematic. Engineering students can be such things as systems software, graphics, simulation, etc.,
expected to confront multiple programming languages to have elective access to such courses without facing a
throughout their careers: the large body of existing prohibitively long chain of prerequisites.
FORTRAN programs, a more recent body of C programs, The resulting structure is shown below. It gives the
and a future that will include Java and other languages. No faculty of various academic disciplines considerable latitude
longer can we teach a particular language and believe that it regarding how much of a computing background they wish
will adequately prepare students for their future. their students to acquire. Some faculty may believe that
Each generation of programming languages is more students in their discipline require only application-use
complex than the last, with increased demands to skills and an appropriate conceptual background. Other
understand and apply foundational algorithmic principles faculty may want their students to take a second course to
such as abstraction and design. Furthermore, the clear obtain a significant foundation in computer programming.
trend is for programmers to adapt and reuse libraries of Still others may want their students to take a sophomore
modular components, with far less emphasis on coding from gateway course and additional upper division computing
scratch. In total, these developments require that we courses beyond it. Indeed, at Georgia Tech we presently
provide students with a core set of fundamental principles have one or more engineering schools choosing each one of
and skills that will allow them to adapt to changing these options.
programming environments and practices.
 In addition, we pull from the engineering tradition of
effective "quick-and-dirty" estimation, and show students
how to predict the cost and complexity of competing
The Georgia Tech Model algorithmic approaches. As a result, students experience
better integration of abstraction, design, implementation,
and evaluation. We believe this to be far preferable to the
Introduction to Computing
traditional approach which emphasizes "button pushing" at
Freshman

the expense of any "big picture" perspective on what they

Introduction to Programming are doing and why.
(was TurboPascal - now Java) The lab component gives students applied experience
with a range of computing resources and applications,
including both the UNIX and Windows environments,
Control and Modeling Knowledge Rep
Sophomore

communications facilities (such as e-mail, ftp, tools for

Concurrency and Design & Processing
Paradigm:Systems Paradigm: OO Paradigm: Func
report and document preparation, Web-based data search,
(C - C++) (Java - Smalltalk) (Lisp) and home page creation), and concrete problem solving
(using spreadsheets, databases, and advanced equation
solvers such as Matlab). Such experience is tied to core
algorithmic principles from lecture, allowing students to
Upper Division Upper Division Upper Division apply those principles in concrete tasks of problem solving
Upper Division

courses in courses in courses in and communication.

Systems Software Graphics, Intelligent
(Operating Sys, Visualization, Systems
Database, Usability, and
Results
Networks, and Software Cognitive
Compilers, etc.) Engineering Science With any curricular enterprise, it is extremely difficult to
perform adequately rigorous studies of teaching-and-
learning effectiveness. The fact that we lack reasonable data
about student competence under the old structure has lead
We report here on our four years of experience with the two us to develop prototype "teaching information systems" to
freshman courses. help us better track student competence in the future. In the
meantime, we are left with informal impressions and
The "Introduction to Computing" Course subjective questionnaire data to inform us about the results
of our approach.
The first course has two related goals: Faculty and instructional staff observe that students
(1) provide a foundation in computing and algorithmic prove themselves quite capable of mastering and applying
principles, and key algorithmic principles rapidly, given the opportunity.
(2) establish concrete skills in effective use of software In fact, some of the learning problems that we had come to
packages. accept as normal have virtually disappeared. For example,
We do this by way of a lecture-and-homework agenda it had been quite normal to find that students at every level
that emphasizes the design, construction, and analysis of of computing study preferred to manage repetition by
algorithms, coupled to a lab-and-project agenda focused on iteration rather than recursion, and many preferred to use
the application of those principles in the use of software static, linear data structures rather than dynamic, non-linear
packages. structures. This is inconsistent with the desired learning
The former is based on a pseudo-language for outcome to produce students who do not have such
designing and constructing algorithms. We purposely use a arbitrary, fixed biases. We want to produce students who
pseudo-language to free students from the myriad of make informed design choices based on the properties of the
programming language details that annoy and distract problem at hand and on the cost and complexity
attention from the core issue of algorithmic problem implications of such choices, given the parameters of the
solving. Students do a great deal of algorithm construction problem.
focused on essential elements of abstraction, design, data By the end of the first course, objective measures show
structures and control, and reuse of code. Because students that students can and do routinely make reasonable, well-
are liberated from non-essential syntax and compilation informed algorithmic design decisions. In retrospect, we
requirements, we can present them with a complete range of now view the former "normal student bias" as having been
constructs and algorithmic methods. an artifact of the traditional curricular structure in which
one set of approaches is typically ingrained in the first
course, leaving important alternatives for the second course. (After several years of resisting market pressure to
It would appear that this has significant long-term effects teach C or C++ at the introductory level, we are now
on programmer preferences. We suspect that novice transitioning from Turbo Pascal to Java. We believe Java
students were effectively imprinted on certain approaches presents reasonable pedagogical opportunities, and our
such that many remain forever biased. While we cannot initial experience with it has not dissuaded us from this
presently prove this, we do see quite clearly that students belief. We hope to have more to say on this issue soon)
leave the first course more willing and more capable of The second goal is a new one. We are no longer
making informed and unbiased design decisions than was satisfied if students can implement reasonably designed
the case under the old structure. programs and get them to work. Far too often, students do
Students report far less confusion under the new so by such a painful and laborious trail-and-error process
structure. Under the old structure, it was a normal that they learn to hate programming. We want students to
occurrence to have bright students informally report that, achieve effective computational solutions in reasonable time
despite having earned good grades, they really did not know and effort. Rather than expecting them to produce working
"what they were doing or why." Extensive use of weekly on- programs, we now want them to evidence effective
line surveys since the inception of the new curriculum programmer practices. Thus, we emphasize the two core
shows that students sometimes report that they do not know activities of design (for error prevention and avoidance) and
"how" to do something. Remarkable by their absence are debugging (strategies for diagnosis and repair).
student complaints about not understanding "what" or
"why." We simply do not hear those kinds of complaints Results
nearly as often as we once did; we interpret this difference
as confirmation that our new curriculum is on the right Again, our ability to assert significant results is
track.. inhibited by the difficulty of rigorously measuring curricular
Many students report that their experience in the first effectiveness. Nonetheless, it is abundantly clear to us that
course helps them in practical ways that we did not foresee, the fact that students now enter the programming course
i.e., helping them obtain preferred co-op jobs, because they already familiar with the basics of algorithms and data
now can present themselves to employers as having both structures has provided an unforeseen benefit. It has
applied software experience and a foundation in algorithmic unmasked a problem that we now believe had been there all
principles. It is clear that the first course better prepares along.
students for employment than did the first course of the old Under the traditional curriculum, the first two courses
structure. were focused on introducing both a particular programming
At present, the majority of engineering students have language and foundational constructs. In practice, students
this course as a degree requirement. All undergraduates at were left to develop their personal programming methods
Georgia Tech will soon have this course as part of their core on their own in a very ad hoc way, generally while
degree requirements. struggling with the compiler.
Under the new structure, we need not consume lecture
The "Introduction to Programming" Course in the programming course covering the ideas and
mechanisms of parameters, modularity, static and dynamic
The second course has two related goals: (1) to introduce data, etc., because students are well practiced in such things
students to problem solving via a modern, full-featured from the prerequisite course. Instead, we have the
programming language, and (2) to establish professional opportunity to focus explicitly on the myriad of important
software development skills and practices that allow ideas and skills concerning the activity of programming that
students to construct well-designed and tested programs were either completely ignored or barely touched on in our
quickly. old, traditional introductory programming course.
The first goal is enabled by first course. Students report This has led us to recognize that our old curriculum
that they enter the second course "knowing what they are mis-titled the introductory course. We called it
trying to do." We observe that they are able to learn rapidly "introduction to programming," but it would have been
the skills in program design, implementation, and more accurately described as an "introduction to program
debugging necessary to solve computational problems in a components in the syntax of a specific language." By
complex programming language. We emphasize effective moving coverage of algorithmic concepts and skills to a
use of abstraction and the acquisition of software non-programming course, we not only enable students to
development skills that are language independent, though progress with programming at a much faster pace, we also
obviously we use a particular programming language. allow ourselves to focus on key questions of programming
skill that have traditionally been ignored.
 We now have the opportunity to focus on effective working with people. These are precisely the skills that
software development skills, including error avoidance, employers plead for. Many students report that their TA job
prevention and debugging, which allow students to design is the only aspect of their entire undergraduate career that
and implement solutions in less time. In short, we can for allows them to "do something that is real."
the first time provide a course that is a true "introduction to
programming." At present, we have made what we think Summary
are important strides in this direction, but are not yet at our
goal state. Our current work is focused on developing We undertook our curriculum revision with some
effective means for best exploiting this new teaching-and- trepidation, as we were trying to design curricular solutions
learning opportunity, and we hope to have a good deal more without an adequate model or supporting textbooks. After
to say about this in the near future. four years of experience, we have created one textbook [1],
are working on a second one, have learned a good deal
Course Management Issues about what works and what doesn't, and are pleased to see
that our original goals have been largely achieved.
The fact that the new structure has been accepted across We now know that students from a variety of
campus presents both good news and bad news. The good backgrounds can master key computing principles early,
news is that we are having a much broader impact on many that students can quickly achieve competence with both
more students. We have succeeded in having computing software packages and computer programming, and that we
incorporated into the university's core curriculum, and we can achieve much more of a tight coupling of computing
believe that we are doing a far better job of providing a theory and practice at the earliest levels.
broad range of students with a good foundation. In addition, we have been pleased to see that our efforts
The bad news is that we now have thousands of to better serve engineering students have resulted in what
students to teach each year. This presents many logistical we believe is a better education for our own CS-majors.
problems, including a heavy demand for student learning The early, integrated coverage of both principles and skills
support. Rather than use a few graduate students as graders has resulted in: fewer misconceptions among our own
for the large numbers of students, we chose to use many students; less need for subsequent CS courses to correct
undergraduate students as Teaching Assistants. problems which were rooted in the introductory courses;
Because the freshman courses are intended for a broad and a greater focus on explicitly teaching things (such as
audience, we do not wish our TA population to be limited to testing, verification, error avoidance and prevention, and
CS majors. Indeed, we recruit across the board and debugging strategies) that have traditionally been given
routinely employ numerous undergraduate engineering inadequate attention. In sum, by opening up our curriculum
majors, including several who have risen to become "senior to better serve others, we have improved the undergraduate
TAs" who help guide and manage the courses. experience in computing for everybody.
We invite those interested in considering such an
Results approach for their own curriculum to peruse the web pages
for the two freshman courses. The pages for the
Because undergraduates are less expensive to hire than are Introduction to Computing course may be found at
graduate students, we can achieve student/TA ratios that http://www.cc.gatech.edu/classes/cs1501. For the second
support individualized attention, not just massive grading. course, Introduction to Programming, the home page may
While this strategy was initially viewed as risky, we have be found at http://www.cc.gatech.edu/classes/cs1502. We
found that undergraduates as a group are superior to also welcome inquiries by e-mail. Address e-mail to:
graduate students in motivation, energy, initiative, and [email protected].
caring.
The relative affordability of undergraduates means that, References
despite the large numbers of students, we can and do
mandate individual (i.e., one-to-one) student/TA meetings 1) Shackelford, Russell L. Introduction to Computing and
for every student each week (only those students who Algorithms. Addison-Wesley, Reading, Massachusetts,
maintain an "A" average are exempt). In addition, 1997.
underghraduate TAs teach weeklly small-group recitation
sessions which provide the kind of human-scale classroom
experience unattainable in huge lecture halls.
An unforeseen benefit is that our undergraduate TAs
obtain valuable experience in teaching, public speaking, and

View publication stats