Spring 2026
CISC-1600-E01
is CRN (course reference number) 27620, 3 credits.
Spring 2026
CISC-1610-E01
is CRN (course reference number) 27621, 1 credit.
The home page for these two courses is
https://markmeretzky.com/fordham/1600/
A computer is a machine that follows instructions. The list of instructions we put into the computer is called a program. In the near future, we will write programs in English. But that day isn’t quite here yet, so for the time being we write programs in simpler languages such as C++. This is a course in reading, writing, executing, and debugging programs in C++.
CISC-1600 will cover the parts of C++ that it has in common with the earlier language C, except for pointers. (A pointer is a variable that contains the memory address of another variable.) The rest of the C++ language, including pointers and the features for object-oriented programming, will be covered in CISC-2000.
CISC-1610 is the hands-on lab that goes with CISC-1600, and CISC-2010 is the hands-on lab that goes with CISC-2000. Both labs are given on a Fedora Linux server.
We have 14 weeks to explore the following topics, in approximately the following order.
We will be creating our C++ programs as files on the
Fedora
Linux
server
storm.cis.fordham.edu,
and will also store our files of input and output there.
We will therefore need to know the basic
Linux
commands for
creating,
editing,
saving, naming,
renaming,
copying,
moving,
and
removing
files.
For example,
to type in the statements (commands) of a C++ program
and save them in a text file,
we will use the
Linux
“visual”
editor
vi.
Our first C++ program must command the computer to produce output. Otherwise we would never know if the program was executed correctly, or even if it was executed at all. Our program will produce three types of output:
\a),
the tab (\t),
and the newline (\n).
In later examples,
our output will be in the form of the
pixels
(i.e., tiny colored dots, as in a magazine photo) of an image,
each with measured amounts of the primary colors red, green, and blue.
If our programs could not accept input, they would be very boring. That’s because they would behave exactly the same way each time we ran them (in the absence of the random numbers coming later in the course). Our programs will draw input from different sources, including
Certain rules are imposed by the C++ language itself.
These include rules about case (uppercase vs. lowercase),
spacing (the places where blanks or tabs are forbidden or required),
and punctuation marks (characters such as
(parentheses),
{curly braces},
and
[square brackets],
which must come in matched pairs).
The computer will reject the program
if these rules are violated.
But other rules are imposed by human convention. For example, in English we indent the first line of each paragraph; in C++ we indent the statements of each block. The human reader will reject the program if these rules are violated. The human also expects to see comments, invisible to the computer, embedded in the program as explanations.
A
variable
is a container in the computer that can contain a number, a word,
a series of characters, or a logical conclusion such as
true
or
false.
A program must be able to create a variable,
store a value into a newborn variable (via
initialization),
and change the value in the variable (via
assignment) unless the variable is a
constant.
A program must also be able to use a value
that has been previously deposited into a variable.
Each variable has a name, and there are rules about what names are permitted, and what happens if two variables have the same name. Each variable has its own scope or habitat, the part of the program in which we are allowed to mention the name of the variable. Each variable also has a well defined lifetime, and is created and destroyed at precise times during the execution of the program. It would be wasteful to create the variable before we need it, or to allow the variable to linger after we no longer need it.
Variables such as
x
and
y,
and
literals
such as
10
and
20,
may be combined with
operators
such as
+
and
−,
to form
expressions
such as
x+y
and
y−10.
These expressions
command the computer to perform arithmetic
(and other operations that are more exotic).
The expressions are made almost unambiguous by
the rules of
precedence
(higher vs. lower)
and
associativity
(left vs. right).
For example, in the expression
1-2-3,
which subtraction should be executed first?
Should the final result of the two subtractions be −4 or +2?
The students will be warned away from the rare expressions
that are ambiguous in C++.
For example,
in the expression
f(x)+g(x),
which of the two functions is executed first?
And when would it matter?
This is a question of
side effects.
This is the most important part of CISC-1600, since control structure is what makes computer programming different from other forms of human endeavor. (The only thing remotely similar to a computer program is knitting instructions, because knitting instructions have control structure.)
A program is a list of instructions;
by default,
the list is executed by the computer from top to bottom.
We can insert special instructions
(called
control structure)
into this list to tell the computer to skip, or to repeat,
other instructions or groups of instructions in the list.
We could even tell the computer to jump around from point to point
in the program,
but that would make the program hard to understand and even harder to debug.
Instead,
we limit ourselves to a very restricted set of stylized control structures,
consisting of the instructions
if,
else,
while,
for,
and
do.
These statements will let the program respond flexibly
to different inputs and different situations,
but only in familiar, conventional ways
whose execution can be traced by a human
when things go wrong.
The topic of control structure
will include the crown jewel of computer programming,
“nested loops”.
Each variable in C++ can hold only one type of data. For example, one variable might be capable of holding a number; another might be capable of holding a word. And even among the numeric variables, there are different types of data. One variable might be capable of holding a number with a fraction (e.g., 2½); another might be capable of holding only a whole number. There are also different types of non-numeric variables. For example, one variable might be capable of holding an entire word or sentence; another might be capable of holding only a single character.
What are the tradeoffs between space and speed when selecting the different types of variables to use in our programs? This question becomes imporant when we have thousands or millions of variables, because our memory or available time might be limited. And what would happen if we take a number with a fraction and try to store it in a variable that can hold only whole numbers? In general, what sorts of things can go wrong when we try to copy a value from one type of variable into another?
An array is a long series of mass produced variables, all of the same data type. An array can also be two-dimensional, consisting of rows and columns of variables instead of a one-dimensional line. When we process the variables in an array, one by one, we always use control structure to repeat the same instructions over and over again. (In other words, we have to write a loop because there are so many variables in the array.)
Let’s assume that all the variables in a given array hold numbers. There are many kinds of tasks that a C++ program might want to do with such an array, including
[The loops that perform the most common array tasks (searching, sorting, copying) have already been written for us once and for all in the “C++ Standard Library”. This topic is outside of the scope of CISC-1600 (it’s covered in CISC-2000), but this topic is the instructor’s vote for what we should do with any extra time we may have left at the end of the course.]
We can package part of a C++ program as a separate function to execute it at more than one time as the program runs. For example, consider a program that outputs the lyrics to a song consisting of verses and a repeated chorus. We can package the chorus as a function to output it at more than one point during the execution of the program. Another reason to package various sections of a larger program as separate functions is to break the program into pieces of manageable size for human convenience.
Often we want to do more than simply execute the instructions
packaged as a function.
We may also need to transmit information to the function
from the rest of the program.
These values passed to the function are called
the
arguments
of the function.
We will explore the tradeoffs between the two mechanisms
for passing arguments to a function,
pass-by-value
and
pass-by-reference.
To make sure that a function has received valid values as arguments,
it can contain
assert
statements.
The rest of the program may want to receive a resulting value,
called the
return value,
from the function.
We have the same two mechanisms for transmitting a return value
that we had for transmitting an argument.
And we can also write an
assert
statement inside the function to make sure that the return value is valid.
To provide a foundation for the concepts of CISC-2000 in Spring 2026, CISC-1600 will emphasize certain distinctions that will become important only later. For example, CISC-1600 will point out the exact limits of the scope and lifetime of a variable, because these boundaries will trigger the “constructor” and “destructor” functions that will play a large role in the object-oriented programming in CISC-2000. CISC-1600 will also recognize the difference between initialization and assignment, in preparation for the “operator overloading” topic in CISC-2000. And CISC-1600 will train students to program in the same style with variables of every data type, in preparation for the C++ “templates” in CISC-2000. See you again in Spring 2027!
Mark Meretzky’s
office is
340 JMH
(John Mulcahy Hall),
but he is never there.
You can Zoom him, or email him at
mmeretzky@fordham.edu.
And he can meet you on the Rose Hill campus an hour before class
for individual help.
Please contact him.
CISC-1600-E01 and
CISC-1610-E01 will meet on the following 15 Thursday nights in Fall 2026.
There is no class
on Thursday, November 26, 2026 (Thanksgiving),
and no class
on Thursday, December 10, 2026.
The midterm examination will be on the eighth night of the course,
Thursday, October 15, 2026.
The final examination will be on Thursday, December 17, 2026.
2026
July August September
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 1 1 2 3 4 5
5 6 7 8 9 10 11 2 3 4 5 6 7 8 6 7 8 9 10 11 12
12 13 14 15 16 17 18 9 10 11 12 13 14 15 13 14 15 16 17 18 19
19 20 21 22 23 24 25 16 17 18 19 20 21 22 20 21 22 23 24 25 26
26 27 28 29 30 31 23 24 25 26 27 28 29 27 28 29 30
30 31
October November December
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 1 2 3 4 5 6 7 1 2 3 4 5
4 5 6 7 8 9 10 8 9 10 11 12 13 14 6 7 8 9 10 11 12
11 12 13 14 15 16 17 15 16 17 18 19 20 21 13 14 15 16 17 18 19
18 19 20 21 22 23 24 22 23 24 25 26 27 28 20 21 22 23 24 25 26
25 26 27 28 29 30 31 29 30 27 28 29 30 31
CISC-1600-E01 and CISC-1610-E01 meet from 6:00 pm to 10:00 pm, with intermissions at 7:30 pm and 9:00 pm.
CISC-1600-E01 and CISC-1610-E01 meet in room [to be announced]
in
Keating Hall,
the architectural centerpiece of the
Rose Hill
(Bronx) campus of
Fordham University.
For personal sanity,
you can also visit the
Blue Chapel
on the west side of the third floor of Keating.
Take the B or D subway
(orange in
this map)
to the
Fordham
Road station
in the Bronx,
and then walk six blocks east on Fordham Road.
Or take the
Metro North
Harlem
or
New Haven
lines
(blue and red in
this map)
to the
Fordham station,
and then walk 20 feet east on Fordham Road.
Each student’s desk in the classroom has a Microsoft Windows PC.
We will use these machines to connect to our
Fedora
Linux
server
storm.cis.fordham.edu,
which is the computer that will actually store and execute our C++ programs.
We will use the
GNU
C++ compiler
/usr/bin/c++
(version 16.1.1 this semester)
on
storm
to translate each C++ program
into terms that
storm
can understand and execute.
If a student has access to a computer
(Windows PC, Macintosh, or Linux) at home or at work
(and nowadays everybody does),
he or she should also connect to
storm.cis.fordham.edu
during the week between classes.
ssh jsmith@storm.cis.fordham.edu
jsmith
is your Fordham ID (the first part of your Fordham email address).
Terminal
application and give the same command,
ssh jsmith@storm.cis.fordham.edu
jsmith
is your Fordham ID (the first part of your Fordham email address).
In fact, if the student’s own computer is portable, he or she can bring it to class and use it instead of the Microsoft Windows PCs in KE room [to be announced]. Most people are more comfortable using their own computer.
The textbook is the many examples of C++ programs on the web at
https://markmeretzky.com/fordham/1600/src/
No loginname or password is required.
There are no programming prerequisites for CISC-1600-E01 and CISC-1610-E01, and it’s okay if the student’s typing skills are at the hunt-and-peck level. But the student should already know how to copy and paste text on a Microsoft Windows PC or Apple Macintosh.
A student has to be able to proofread his or her own work, and to compare their work on a character-by-character basis with the exmples presented in class. In this business, a typographical error of even a single keystroke can kill you.
Each homework will be a C++ program. There will be one or two assignments per week, each one due in six days. Don’t fall behind: you can’t hand in all your overdue homework in one big lump at the end of the semester. A student should expect to spend at least three hours per week outside class on homework.
A student will submit his or her homework by posting it in the
public_html
directory of their account
on our
Fedora
Linux
server
storm.cis.fordham.edu.
This means that every student will be able to
see the work
of every other student.
The midterm and final exam will be presented and answered on paper. If a student has done their own homework reasonably successfully all semester, they will have no trouble with the midterm or final: it will just be more of the same. But if a student has plagiarized their homework all semester, or has been massively late or absent, they will fail the midterm and final. That’s obvious, isn’t it?
Students will get the same grade for CISC-1600-E01 and CISC-1610-E01.
The grade for the these courses will be taken
50% from the homeworks
25% from the midterm
25% from the final exam
In practice,
a student’s grade for the homeworks and the grade for the final exam
will almost always be very similar.
If you’ve been working hard all semester,
and been present in class,
it will show on the final.
Attendance will be taken when the class begins at 6:00 pm. If you are not present at that time, you will be marked “absent” for that week. As per Fordham’s policy on student attendance, you fail the course if you are absent for more than two of the 14 classes.
As per Fordham’s policy on academic integrity and its subsection on standards of academic integrity, “Academic integrity is the pursuit of scholarly activity in an honest, truthful and responsible manner. Fordham students are expected to accept the responsibility to be honest and to respect ethical standards in completing their academic assignments, assessments, and other requirements. Students are expected to adhere to academic integrity by completing all assignments and other requirements on their own without assistance from external resources (including any artificial intelligence or machine-learning tools) unless directly authorized by the instructor. It is the student’s responsibility to give credit to any quotation, idea, or data used from an outside source. Students who fail to meet the responsibility for academic integrity subject themselves to sanctions ranging from a reduction in grade, course failure in the assignment, or expulsion from the University.”
You can’t use AI to write your homework.
Reliable indications that a student has plagiarized their work include
=
instead of with the contemporary
{curly
braces}.
See
variable3.C.
endl
instead outputting a simple
"\n".
0
instead of
EXIT_SUCCESS
from the
main
function.
.cpp
instead of (uppercase)
.C.
Some members of the Fordham community are known by a name
other than their legal name.
Students who wish to be identified by a chosen name can
email the instructor at
mmeretzky@fordham.edu
to request that their chosen name and pronoun be used.
Please also let the instructor know
if he accidentally spelled your name wrong when he created your
computer account on
storm.cis.fordham.edu.
You can check this by copying and pasting the following
Linux
command on
storm.
awk -F: '$1 == "jsmith" {print $5}' /etc/passwd
where
jsmith
is your Fordham ID.
The tutoring center is in room 310 of JMH (John Mulcahy Hall), south of Keating Hall in the Rose Hill (Bronx) campus of Fordham. It is open Monday through Friday, 11:30 am to 3:45 pm. [May change in Fall 2026.] Drop in, no reservations are required.
The Fordham Computer Science Society has been known to give out free pizza.
Please contact the dean of your school if you are unable to attend class or do any work this semester.
Here are links to the
Fordham Emergency
Medical Services
Fordham Counseling and Psychological Services
Fordham
Office of Disability Services
Under the Americans with Disabilities Act,
all members of the campus community are entitled
to equal access to the programs and activities of Fordham University.
If you have (or think that you might have)
a disability that may impact your participation
in the activities, coursework, or assessment of this course,
you may be entitled to accommodations through the
Office
of Disability Services.
You can contact them at 718-817-0655,
disabilityservices@fordham.edu,
or by visiting the lower level of O’Hare Hall on the Rose Hill campus.
Whether or not you have documentation for accommodations,
your success in this class is important to your instructor.
If there are aspects of the course that are not accessible to you,
please let him know as soon as possible
so that we can work together to develop strategies
to meet both your needs and the requirements of the course.