usingc.txt

c语言开发方面的经典问题,包括源代码.c语言开发所要注意的问题,以及在嵌入式等各方面的应用

                             Using C in CS1
                   Evaluating the Stanford Experience


                            Eric S. Roberts

                     Department of Computer Science
                          Stanford University

Permission to copy without fee all or part of this material is granted
provided that the copies are not made or distributed for direct
commercial advantage, the ACM copyright notice and the title of the
publication and its date appear, and notice is given that copying is by
permission of the Association for Computing Machinery.  To copy
otherwise, or to republish, requires a fee and/or specific permission.
ACM-24thCSE-2/93-IN,USA
(c) 1993 by ACM.

ABSTRACT

In 1991, the Stanford Department of Computer Science decided to abandon
Pascal in its introductory computer science courses and to adopt ANSI C
as the language of instruction.  We based this decision on several
factors: the inadequacy of standard Pascal as a base for teaching modern
programming concepts, the need to prepare our students for more advanced
courses in which they will be expected to use C for programming
projects, and increasing pressure from students and faculty throughout
the School of Engineering for instruction in a language that has become
the industry standard.  We also believe that it is not reasonable to
expect students to learn C on their own; students must receive
instruction in C in order to become good C programmers.  C has several
known deficiencies that make it a challenging language to teach.  Based
on our experience at Stanford, we believe that it is possible to
minimize the problems associated with teaching C at the introductory
level by applying standard software engineering strategies -- procedural
abstraction, modular decomposition, and information hiding -- to good
pedagogical effect.  This paper expands on the reasons behind Stanford's
decision to adopt C and summarizes the pedagogical approach.

1.  INTRODUCTION

Any introductory course in computer science has one overriding mission:
to teach students the basic programming concepts and methodologies that
make more advanced work possible.  To a large extent, these concepts and
methodologies are independent of any particular programming language.
However, since most of these concepts are best mastered through use, the
introductory course must choose some programming language as its medium
of instruction.

For many years, most universities in the United States used Pascal to
introduce programming concepts.  Compared with many other programming
languages, Pascal is conceptually simple and easy to learn.  Pascal is
also highly constrained, in the sense that it does not include certain
powerful features that are easy to abuse.  Such features tend to confuse
students at the introductory level, even though they may be extremely
useful to more experienced programmers.

Over the last five years, however, many schools have begun to move away
from Pascal.  The reasons behind this shift include:

   o  Pascal is getting old.  There are several modern programming
      concepts, such as separate compilation, string manipulation,
      and the use of functions as first-class objects, that are not
      supported by standard Pascal and that are therefore difficult
      to teach.

   o  The restrictiveness of Pascal's design occasionally forces its
      users to "program around the language." Doing so means that
      students develop certain bad habits -- habits that they must
      later unlearn when they begin to work with more modern
      languages.

   o  Pascal is not widely used beyond the introductory sequence,
      and students are therefore being taught programming style and
      the discipline of software engineering in the context of a
      language that they will never again use.  The first course
      must provide an introduction to good programming practice.
      Unfortunately, the effectiveness of that instruction is
      compromised when the linguistic tools used to illustrate the
      underlying concepts are so quickly abandoned.

Even though a consensus seems to be emerging among educators that Pascal
is becoming increasingly obsolete, there is no corresponding consensus
on what language should replace it.  Various informal surveys of
colleges and universities indicate that the first course in computer
science is moving in several competing directions.  Many schools have
shifted their curriculum to a language that adheres to the general
philosophy and tradition of Pascal, but includes more modern concepts.
In this category, the principal contenders are Ada [Winslow89, Frank90]
and Modula-2 [Gabrini86, Koffman88].  Other schools have begun to use a
Lisp-like language, the favorite being Scheme as it is presented in the
textbook Structure and Interpretation of Computer Programs [Abelson85].

A growing number of institutions, however, are choosing to adopt ANSI C,
in light of its status as the language most often used for systems
programming applications.  Each of these approaches has merit, and it is
not clear that there is a single answer that fits all academic
institutions.  At Stanford, we have decided to adopt ANSI C as our
instructional language in the introductory sequence, for reasons which
are developed in the next section.

2.  THE REASONS FOR STANFORD'S CHOICE

In 1990-91, the faculty in Stanford's Computer Science department held
several meetings to address the question of what language should be used
in the first course.  Since our introductory course serves a large
population of non-majors from other engineering departments, that
discussion was broadened to include the Engineering School Undergraduate
Council, which has curricular authority over courses, like introductory
computer science, that are considered to be "engineering fundamentals."
As the various options were discussed, the systems faculty in the
Computer Science Department and the representatives from other
departments in the Engineering School argued strongly for using C in the
introductory course.  There was also general support for the proposal
from the department as a whole.  As one of the major proponents of C, I
had been prepared to encounter opposition, but the decision turned out
to be almost entirely without controversy.  With the support of the
department, I developed an experimental course using ANSI C, and in
1991-92 offered that course as an alternative to the Pascal-based
course.  Based on the success of that experience, the department has
decided to revise the curriculum so that, starting in 1992-93, all
introductory programming courses will be taught in C.

The most important reason for this decision comes from the fact that it
has become increasingly important to teach C somewhere in the computer
science curriculum.  C is used in most upper-level systems courses, and
students are expected to know how to use the language by the time they
encounter those courses.  In previous years, the only instruction that
students received in C took place in a sophomore-level "Programming
Paradigms" course, which introduced the students to several different
programming languages, including C.  This course teaches the
fundamentals of C syntax and structure, and expects that students will
learn everything else they need to know on their own.

Unfortunately, students are better at picking up the syntax and
structure of a new language than they are at developing discipline in
the use of that language.  The introductory sequence at Stanford
concentrates -- as it should -- on instilling in students the importance
of good programming style.  Unfortunately, at Stanford, and at many
other schools, we have been teaching people to become good programmers
only in the context of a language that they never again use.  Students
learn good programming style and methodologies in the context of Pascal,
but are forced to develop their own styles and methodologies for the
other languages they encounter.  For some students, these critical
software engineering skills transfer well.  For others, however, many of
the concepts seem to get lost in translation, and we are therefore
generating a large number of students who program well in an arguably
useless language and who program poorly in more useful ones.  This is
not an ideal state of affairs.  We believe that it is not enough to
expect students to learn C on their own; they must receive instruction
in C in order to become good C programmers.  Turning out another
generation of mediocre C programmers is not in anyone's best interest.
There is a serious oversupply of such programmers today.

Student demand was also a factor in the decision to adopt ANSI C.  In
today's computing industry, it is clear that C has become the dominant
language for systems development, and our students are not blind to that
fact.  Given the choice last year between an experimental C section and
a well-established Pascal section taught by a popular instructor,
students expressed a two-to-one preference for the C section, most often
citing C's practicality as the reason for their choice.

The importance of student demand is heightened by the fact that the
introductory programming course at Stanford -- as at many
institutions -- must serve the needs of a diverse clientele.
Approximately 700 students enroll in the introductory computer science
course each year; of these, only 60 will go on to become computer
science majors.  Most of the students take the course to fulfill the
requirements of some other major in the School of Engineering, and there
is also a significant enrollment of students from various departments in
the School of Humanities and Sciences.  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.

Finally, it is important to recognize that the value of following
conventional practice has risen in accordance with the increased size of
the computer science community and with the increased complexity of
programs written today.  Twenty years ago, it was easy to have students
in the introductory course write programs that seemed exciting to
them -- programs that seemed as flashy and interesting as the
applications they had previously encountered on their own.  Today's
students have grown up with Macintoshes and fancy graphical interfaces.
To them, a program that averages numbers or even one that plays a
simple, interactive, text-based game will seem like pretty tame stuff.

It is impossible today to construct from scratch a program that meets
the student's heightened sensibility of what a "real" computer program
must be.  To do so, one must make use of sophisticated software
libraries, such as the X11 library or the Macintosh Toolbox.  To use
such libraries, however, one must program in a way that is compatible
with them.  In most cases, this means working with a programming
language, such as C, that is implemented on the vast majority of
platforms and offers a clean interface to those libraries.

3.  AVOIDING THE PITFALLS

For the most part, the advantages of using C discussed in the preceding
section are fundamentally strategic in nature.  We believe that
introducing C at the introductory level will yield long-term advantages
as students apply the knowledge and engineering discipline they have
learned to more advanced courses or projects that require a knowledge of
C.  Viewed from the perspective of the introductory sequence alone, it
is clear that using C presents a variety of tactical problems.  I do not
deny for a moment that it is harder to teach C to beginning students
than it is to teach Pascal; my claim is rather that the long-term
benefits more than compensate for the short-term costs.  I also believe
that it is possible to minimize the problems associated with teaching C
at the introductory level by applying standard software engineering
strategies -- procedural abstraction, modular decomposition, and
information hiding -- to good pedagogical effect.

For example, one of the most common complaints about teaching C is that
certain conceptually simple operations are implemented in conceptually
sophisticated ways [Mody91].  Often, C's design follows an underlying
logic that is only meaningful to the experienced programmer.  To the
novice, that logic is entirely obscure, and the student is given no
conceptual framework for understanding the mechanism.

As an example, consider the operation of reading an integer from the
console and storing it in a variable -- an operation which is likely to
occur in conversational programs very early in the introductory course.
The ANSI libraries include a function for this purpose, and the
experienced programmer would know to code this operation as follows:

          scanf("%d", &value);

Unfortunately, the use of scanf is extremely confusing to new
programmers.  In order to achieve the effect of call-by-reference, scanf
passes a pointer to the variable used to store the input value.
Explaining this mechanism in detail requires students to comprehend
pointers and a great deal more about parameter passing than one wants to
introduce at the beginning of a course.  As it is, the scanf syntax has
to be presented as a linguistic rule: every variable that appears in a
scanf call (except for character arrays, which turn up later and
multiply the confusion) must be preceded with an ampersand.  This
approach might be tolerable if C compilers were able to enforce this
syntactic rule.  Given C's structure and semantics, however, the
compiler cannot detect the extremely common error of leaving out the
ampersand.  The student writes

          scanf("%d", value);

the compiler doesn't complain, the value entered on the console gets
written into deep space, the program gives the wrong answer (assuming