See

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

Programming and mathematical thinking

Article in ACM Inroads · March 2014

DOI: 10.1145/2568195.2568207

CITATIONS READS

3 75

2 authors, including:

Peter B. Henderson
Butler University
145 PUBLICATIONS 599 CITATIONS

SEE PROFILE

Some of the authors of this publication are also working on these related projects:

Math in CS Education View project

software engineering education View project

All content following this page was uploaded by Peter B. Henderson on 22 February 2017.

The user has requested enhancement of the downloaded file.


MATH COUNTS
Peter B.
Henderson
Programming and
Mathematical Thinking
Editor’s Note:
Peter B. Henderson and
Allan M. Stavely
co-authored this column
OUR GUEST CONTRIBUTOR for this
Math CountS column is Allan Stavely, who
recently wrote Programming and Math-
ematical Thinking: A Gentle Introduction
Featuring Python [2], which will be avail-
able in early 2014. In this column, Allan
gives his motivation for writing this book,
shares his insights on the role mathemat-
ics can play in the curricula, and provides
some guidelines for achieving these goals.
I’d like to second a statement that the
editor of this column made previously,
but push it farther. In his September 2013
column Dr. Henderson, speaking of the
current state of mathematics in under-
graduate computer science, said:
The mathematical foundation
concepts are not used or reinforced
effectively in most computer sci-
ence courses, the relevant connec-
tions between these mathematical
concepts and the fundamental
concepts of computer science are
not made, and the importance of
mathematics as a tool for reason-
ing, problem solving and analysis,
and solution verification are lost for
many students.
To the last point, I would add: the
importance of discrete-mathematics struc-
tures in day-to-day programming is lost
for many students.
The courses in my department have
long followed a familiar pattern: introduc-
tory programming in the first semester,
data structures and algorithms in the sec-
ond semester, and a discrete mathematics
course in the second year as a prerequisite
to several courses in the third and fourth
year. Many of my students never saw the
point of the discrete math course at the
time they were taking it; students call
the course “Weird Math.” Courses like
the third-year analysis-of-algorithms and
formal-languages-and-automata courses
would use discrete-math structures, of
course, so that when the students hit my
fourth-year compiler-writing course they
could cope with the sets and trees and
directed graphs used in compiler writing.
However, I suspect that many of the stu-
dents left the course thinking that discrete
structures are used only in such advanced
and exotic computer science topics.
On the contrary, I claim that concepts
of discrete mathematics are enormously
useful in even the most basic kinds of
programming. Let me quote from a forth-
coming textbook of mine. The example
is adapted from my book Toward Zero-
Defect Programming [3].
Many experienced programmers
approach the design of a program by
describing its input, output, and internal
data objects in the vocabulary of discrete
mathematics: sets, sequences, mappings,
relations, and so on. This is a useful habit
2014 March  •  Vol. 5  •  No. 1  acm Inroads  35
INSI G HTS
for us, as programmers, to cultivate. It can
help to clarify our thinking about design
problems; in fact, solutions often become
obvious. And we inherit a well-understood
vocabulary for specifying and document-
ing our programs and for discussing them
with other programmers.
For example, consider this simple pro-
gramming problem. Suppose that we are
writing software to analyze web pages,
and we want some code that will read
two web pages and find all of the URLs
that appear in both. Some programmers
might approach the problem like this:
First I’ll read the first web page and
store all the URLs I find in a list.
Then I’ll read the second web page
and, every time I find a URL, search
the list for it. But wait: I don’t want
to include the same URL in my result
more than once. I’ll keep a second
list of the URLs that I’ve already
found in both web pages, and
search that before I search the list of
URLs from the first web page.
But a programmer who is accustomed
to thinking in terms of discrete-mathemat-
ical structures might immediately think of
a different approach:
The URLs in a web page are a set.
I’ll read each web page and build
up the set of URLs in each using set
insertion. Then I can get the URLs
common to both web pages by us-
ing set intersection.
Either approach will work, but the
second is conceptually simpler and it will
probably be more straightforward to
implement. In fact, once the problem is
described in mathematical terms, most of
the design work is already done.
Programmers can exploit the properties
of sets and relations and other discrete
structures in their work even before they
study those structures formally and learn
how to construct proofs using them.
Beginning computer science students can
often do their work more skillfully and
professionally, as in the example above,
if they think in terms of the discrete
structures when formulating designs. So
can programming students who aren’t
computer science majors.
INSI G H TS
Programming and Mathematical Thinking
As an analogy: most people in our soci-
ety don’t do geometry proofs in their daily
work. They may not remember how from
their high-school geometry course; some
may have never taken a geometry course.
But everyone knows what a circle and
a rectangle are, and can draw examples
without a moment’s thought when draw-
ing (for example) a poster for a bake sale.
Most know how to construct a precise
circle using a compass and a precise rect-
angle using a drafting square and a ruler,
using the fundamental properties of circles
and rectangles informally, and perhaps
unconsciously, but effectively.
Shouldn’t every programming student
be just as familiar with sets and relations,
directed graphs, and the other basic
concepts of discrete mathematics? And
shouldn’t programming students use
these concepts just as spontaneously in
program design?
Following the proposed Curriculum
2013 [1], we can distinguish three levels
of mastery of concepts:
■ Familiarity: basic awareness of a con-
cept; for example, the concept of a set.
■ Usage: ability to use the concept in a
concrete way; for example, ability to
use sets in a program.
■ Assessment: ability to select an ap-
propriate approach from understood
alternatives; for example, ability to
select the best data structure and algo-
rithms to implement sets in a particular
situation.
There is no reason that discrete
structures at the familiarity level cannot
be taught very early in the curriculum,
perhaps in or in parallel with the first pro-
gramming course. Students should learn,
for example, that a collection of data can
very often be thought of as a set. Then
a student, in thinking of approaches to
a programming problem, should learn to
notice when a particular collection of data
is conceptually a set. Knowing the most
basic properties of sets, to keep in mind
“I don’t need to keep the data in order”
or “I can’t assume that the data is in any
particular order,” and “I can assume that
there are no duplicates” or “I must make
sure that there are never any duplicates,”
while developing the program.
36  acm Inroads  2014 March  •  Vol. 5  •  No. 1
View publication stats
Mastery at the usage level can be
taught very early too. How this is done
will depend on, among other things, the
programming language used in the first
course or two. In Python, for example, set
notation is built into the language and
“set” is a predefined data type, imple-
mented with hashing so that membership
testing is fast. Then mastery at the usage
level simply requires learning the syntax
for sets and set operations and completing
a programming assignment or two using
sets. If the language is C or something
similar, students can be given a set library
to use in a programming assignment,
but it might be better to ask students to
implement sets using arrays or linked lists
or whatever data structure they already
know. A toy problem and a toy implemen-
tation may be good enough at this level.
Mastery at the assessment level can
wait until later, typically until the first
data-structures-and-algorithms course,
when students will learn the efficient data
structures and algorithms for implement-
ing sets and how to compare different
implementations using mathematical
arguments. But this doesn’t need to be
the first time a student hears about sets in
programs.
Think of how we teach programming in
general. We don’t teach everything a stu-
dent needs to know about programming all
in one course, once and only once. We give
a simple introduction in the first course,
then build on this introduction step-by-step
in all the courses that follow. Everything
that the student learns about programming
early is reinforced many times throughout
the rest of the curriculum.
So should we teach everything that
the student needs to know about discrete
mathematics once and only once, in the
first discrete-math course or in the first
data-structures-and-algorithms course?
Certainly not. Students should hear about
discrete-math concepts starting as early
as the first course and the vocabulary of
discrete math should be part of everyday
language throughout the curriculum.
The new book mentioned above [2]
introduces discrete-mathematical struc-
tures at the familiarity and usage levels to
programming students, applying the ideas
expressed here. It was written to be used
in a first university course for students
with some experience with programming.
It could even be used in a pre-university
course. For students with no programming
experience at all, the book can be used in
the first course along with other materials
that teach introductory programming, or
in a second course. The only mathematics
prerequisites are algebra and logarithms. If
you would like to see the table of contents
and preface, please send me email.
I have one more suggestion to make to
computer science departments. Mathemat-
ics departments have often taught the first
rigorous course in discrete mathematics.
Some computer science departments, to
gain more control over the course and to
make sure that topics relevant to CS are in-
cluded, have taught a version of the course
themselves. But, even so, the course
has often been taught by someone with
limited experience and involvement with
programming, either a teaching assistant
or a theoretically-oriented faculty mem-
ber. Consider assigning a real software
person to the course, someone with real
involvement with programming, who can
reinforce the relevance of the mathematics
not only to advanced topics in computer
science, but to all programming. Ir
References
[1] The Joint Task Force on Computing Curricula, Associa-
tion for Computing Machinery, IEEE-Computer Society.
“Computer Science Curricula 2013, Final Report 0.9 (Pre-
release version)” (October 2013): 34. http://ai.stanford.
edu/users/sahami/CS2013/final-draft/CS2013-Final-v0.9-
prerelease.pdf Accessed 2013 November 4.
[2] Stavely, A. Programming and Mathematical Thinking: A
Gentle Introduction to Discrete Mathematics Featuring
Python. To be published by The New Mexico Tech Press in
early 2014.
[3] Stavely, A. Toward Zero-Defect Programming (Reading,
MA: Addison Wesley Longman, 1999): 142-143.
Peter B. Henderson
Emeritus, Department of Computer
Science & Software Engineering
Butler University
Indianapolis, Indiana 46208 USA
phenders@butler.edu
Allan M. Stavely
Emeritus, Computer Science Department
New Mexico Tech
Socorro, New Mexico 87801 USA
al@nmt.edu
DOI: 10.1145/2568195.2568207
Copyright held by author.