CSC 180: textbook coverage
Especially with the first midterm looming, people want an analysis of the
coverage of the textbook in terms of what material from the textbook is and is
not "in the course".
While you're definitely encouraged to read all parts of the textbook which
catch your interest,
right now
you might choose to focus on the ones
I've decided to include in the course, which is why I present this web page.
- Preface: Seems to be directed more at me than at you.
- Chapter 1: Some interesting background. You might not have been
in a
position to follow much of this at the beginning of the course, but you
probably are now. Worth reading now I think, although not really
the subject of the midterm.
NOTE: This last statement does NOT mean that if you see something in
chapter 1, then it is not on the midterm. For a silly
example, the word "the" appears
in chapter 1 several times, but will appear on the midterm. You can skip
chapter 1 if you like, but you can't take it as a list of things you are
not
responsible for, because they may occur elsewhere too. This applies to all of
my exclusions below.
- Chapter 2: All of this material is in the course.
(I feel I need to
comment on the second "Q&A" on page 29: I've heard of studies about
optimum amount of indentation, and as far as I know the answer is four,
not three spaces. In any case, I and the textbook author agree that the two
spaces used in the textbook is too small.)
- Chapter 3: All of this material is in the course except that
the printf modifiers which control the spacing of the output are not going to
be the subject of tests or exams. Basically, the printf modifiers are
something you'll really want to know about
for future reference, but I don't want to focus on them too much for this
course. They're not profound (just useful sometimes).
- Chapter 4: All of this material is in the course.
This chapter is a pretty big one, even though it's not many more
pages. I've covered all this material by now, but I stretched it out over
most of the course so far.
- Chapter 5: All of this material is in the course.
(I'd like to take the
opportunity to disagree with his comment on page 73 that the use of Bool and
TRUE and FALSE contribute to a C program. For TRUE and FALSE it's arguable,
but I think you want to set a sharp limit on how much playing around like
this you want to do. The reader of your program knows C, so they know that
"int" can store a boolean value; but they don't know what strange definition
you may have given "Bool" or TRUE or FALSE, so when they see these things
(especially Bool; TRUE and FALSE are fairly common and invariably defined as
1 and 0 respectively),
they have to look elsewhere in your program
to find the definitions to find out what's going on. It's not helpful.)
- Chapter 6: At the time of writing (Oct 11), we've done all but
discuss infinite loops (bottom of page 87) and
break
and
continue
(section 6.4). Those are coming next week or so.
Note:
Don't use goto
.
Period.
The rationale was discussed in some detail in class.
The goto statement isn't even available in more recently-designed similar
programming languages (e.g. java).
The original C programming language book (Kernighan & Ritchie, 1978)
doesn't use goto and points out that it doesn't. It's obsolete (and already
was in 1978); we know how to write programs better than that now.
- Chapter 7: We've mostly done all but 7.4 (sizeof) and 7.6 (typedef),
but often not with the same emphasis.
In particular, you don't need to know all the different weirder types such as
"unsigned short", etc.
- Chapter 8: All of this material is in the course, but we're in the
middle of it now, and none of it will be on the midterm.
- Chapter 9, sections 9.1 through 9.4: We did this first,
because functions are needed to write the
smallest program in C.
Your textbook author has put this material at about the usual point
for an introductory programming course, but I think that the C programming
language suggests a different sequence, which I followed.
I should comment about the terminology in section 9.3. As far as I know this
is idiosyncratic. The usual terms are "formal parameter" and "actual
parameter", as I discussed in class. He mentions this on page 177. You
should know the standard terms: formal and actual.
- Chapter 9, sections 9.5 and 9.6: Section 9.5 is coming in a couple of
weeks,
when we discuss some more convoluted control-flow structures (also including
the loop stuff mentioned above as having been omitted from chapter 6 so far).
Section 9.6 is much trickier material and will be later in the course.
This is, approximately, where we are now. Arrays and pointers will not be on
the first midterm, but will be on the second.
[main course page]