Albany Programming Course Supplement

CS1 and CS2 Syllabus Design and Explanation

The subjects of courses ... (Introduction to Computer Science) and ... (Data Structures) at ... cover in two courses the Topics of the Introductory Tracks in the 2001 ACM Curriculum. This curriculum report details several approaches to the same learning goals. Our ... and ... sequence provides the introductory track at ... . These courses have traditionally been called CS1 and CS2 in much writing about Computer Science education.

They are a two course sequence that is required for all our variations of undergraduate majors and minors in Computer Science. It is designed primarily for Computer Science Majors to take in their first two semesters when beginning major study. Computer Science minors might take them at the beginning, or a little later, like in their junior year, after taking easier programming courses. Also, some ... students first take easier courses that help them decide to switch to a Computer Science major or may prepare them for an easier time in ... . However, if you are willing to put in the effort, taking an easier course to prepare for ... is probably a waste of time.

At ... as well as most 4-year colleges and universities worldwide, every program that leads to a degree termed "Computer Science", major or minor, requires the equivalent of this two-course sequence in addition to courses in a wider diversity of subject areas plus more advanced courses, especially for majors. The Introductory Track begins the education that leads to the primary capability that employers expect when a job description specifies a 4-year college or university level degree with "Computer Science": You can write computer programs, in some programming language, with the competence of entry level employees. Employers know that Computer Science degrees certify this competence, even for jobs that lead to information using or management careers that do not include particular programming tasks.

The description of programming we wrote below, for people who have never done it themselves, indicates that, besides learning concepts, you must deal with many little details within a very unfamiliar conceptual environment to be successful in computer programming courses.

To make learning of these difficult subjects more fun, engaging, and somewhat less difficult, at ... we have chosen the "Multimedia Computing" curriculum which puts the programming tasks and conceptual environment into a modern and attractive context. You can show off your work to friends and family. It makes the abstract orderings of computation steps visible as tracings of a moving "turtle" that leaves a line trailing its path as it moves on a surface according to the commands that you have programmed. It makes the abstract concepts of location of data and the effects of changing data values easy to see and imagine because much of the data will be visible as colors of pixels in digital images. You can even try out picture album making application you create on digital images you take yourself with your camera or find on the Web. However, the multimedia approach does not remove the need to actually learn the concepts behind programming and actually deal with the little details and frustrating mistakes. (The courses are not about selecting or using the variety of multimedia software many of you know about.)

If you believe that you don't really need to take ... or ... which are designed primarily for Computer Science majors, or the level of detailed work required doesn't seem worth it for your objectives, we of the Computer Science faculty advise that you consult your relevant major or minor advisor or other faculty mentor about any easier and more broad knowledge conveying course alternatives you can use for the same requirements. If ... or ... is required in your major, your advisor can discuss your major department's reason for this, or perhaps tell you about easier courses at 2-year colleges that meet your major's goals but are not primarily designed to serve Computer Science majors at competitive university centers.

So, we summarize the purposes of our ... and ... courses at ... as:

To enable you to

work with
and/or

begin to become one of those

people who invent or build software and maybe ideas (that fit observation, or apply to problems, better and better) about computing.

"Building or inventing software" means, for these courses, programming, which is creating computer programs. Major pieces of software are also composed of documentation, media, built-in data, configuration settings, etc. Often, people who do computer programming are today called "software developers", "software engineers", "software architects" and sometimes system or other "analysts". Also, such professionals today usually spend a lot of time and attention meeting with other people; both programmers and customers or others in an enterprise involved in making or deploying software. The stereotype of a "geeky" programmer spending most of the time alone in a cubicle, just writing and debugging code from "specifications" assigned from the boss, has been obsoleted for two decades or more. Just look on the Web for sites about "agile software development". On the other hand, people in these careers, often highly paid people with leadership roles, really do retain and use every day their skills to deal with writing, testing, debugging and instructing their juniors with nitty-gritty details of program code and the arcane rules of many different programming languages.

"Ideas about computing that fit observation or apply to problems better and better" is an attempt to describe in 13 words what computer science is about. It is not specific about what thing (brand or operating system of computer, etc.) is doing the computing. You will acquire in CS1 and CS2 some very specific ideas of what computing is. Specifically, you will become able to explain the particular computing that (small enough) examples of Java programs make a computer do. The idea of Java computing actually covers the computing done by virtually all of today's computers manufactured by people and programmed with a huge variety of languages. You will learn the details of how this is so if, probably as a computer science major, you take subsequent courses that teach (A) what computing programmed at the hardware level is, in ... (assembly language programming, or programming at the hardware/software interface), (B) common principles of many programming languages ... (principles of programming) and perhaps (C) abstract models like the Turing machine in ... (Formal Language and Automata Theory) which capture the essence of computing so the universality of Turing machines and idealized Java become clear.

Like other sciences, what is known in the computer science expands, changes and sometimes ideas get discredited so the science fits observed reality better and better. In these courses everyone learns and applies some of what computer scientists have discovered, and some of you here might even have begin a journey to discover, and make usable by others, new computer science results.

These courses are designed primarily for students who aspire to become one of those people who invent or build software described above. They have committed themselves to the sometimes hard and frustrating intellectual work it often takes to succeed at a Computer Science major at a university center. The courses also serve students in majors or minors where a CS1 or CS2 course is required or is an option within broader requirements. For many of those majors, the objective is to be familiar enough with computer programming to work effectively with or perhaps eventually manage teams including full-time programmers, software engineers and architects, etc. in a business or other large enterprise. Working effectively with people skilled in programming includes gaining their respect. Having experienced a little of what they can do (as opposed to being clueless about it) can go a long way toward communicating effectively and gaining that respect.

For some majors or minors other than Computer Science at ..., our course ... (Introduction to Computer Science) is one of several options in some requirement to take one or two courses from a specific list. Course ... (Data Structures) is also an option within other specific lists of requirements in some of those majors or minors. The intention of the faculty designing those majors or minors is to include a one or two semester experience that overlaps with the beginning studies of your cohorts who will major or minor in Computer Science.

What it means to program a computer

When you write a computer program, it means that you actually do all of the steps below:

Given the description of a task suitable for a computer to perform, or having conceived a task yourself, you figure out how to make the computer do it. That is hard because the choices of operations available in the computer and the ways it has to store and work with data are limited. You have to make those choices and find some way to combining them into steps and structures so the computer performs the task without human intervention.
You express the choice of operations, structures and sequences of steps in a particular programming language. You type your expressive work into the computer much as you would type any other writing assignment. However, unlike when you write for people, you must practice extremely detailed care in conforming to technical rules about the form of your writing. (That's called syntax.) You must also understand exactly how your writing expresses to the computer the computational steps or creation of variables or other data structures. The relationships between what you write and what steps or creations are done are also specified by programming language rules. (That's called semantics, which is a fancy word for "meanings".) All the rules are similar to rules in mathematics in terms of style, use of numbers and other mathematical concepts, and extreme degree of exactness compared to most rules, principles and experiences in school study and in life. (For example, in Java, if(true) { stuff here } always means do the steps defined by { stuff here }, but in life, a green traffic light often but does not always means go.)
The above two steps are intellectually demanding, and you, like everyone who writes programs, from beginners to professionals, will make mistakes and oversights. A crucial part of finishing the job is to discover and correct the mistakes and oversights by repeatedly testing, reviewing and correcting your work so far.

All these steps can only be done well when you can imagine the structures and changes of the data that exist hidden inside the computer hardware when a program runs. These structures and data are almost completely invisible. Besides, they are conceptually different from what people using the program on the computer can see and be aware of. The multimedia approach is particularly helpful to make you imaging these things you have never imagine before by seeing them in graphics and images.

Topics and Learning Objectives

Topics or Ideas

These are described in conceptual rather than demonstrable terms.

Model computation in terms of data state, control state and program (Turing).
Abstraction to separate interfaces from implementation, and define hierarchies.

Skills

Relate externally testable behavior to internal data processing steps when explaining or designing particular computations.
Given a description or your own conception of some task a computer program might do, and a strategy for doing it, write your own program that does it.
Simulate programs.
Subdivide programming problems.
Retrieve and use information (instructional texts and documentation) about computer language (such as Java) rules and operations, and apply them in programming projects and questions.

Attitudes

Seek and value precise thinking in context: Each precise thought should be a true fact about certain values of variables related to what program step the computer is up to, etc. Distinguish precise from vague thoughts in the writing and speech of yourself and others.
Following directions! (also a skill) (A) You must do it so you can operate information technology used by professionals efficiently and effectively. (B) You must do it to simulate, observe, evaluate and debug what the computer does. When executing programs, the computer follows directions exactly. So, to get the idea of what the program is doing so you might fix or improve it, you must sometime follow the same directions. That is called "tracing the program".
Skepticism about your work being right. Your programming mistakes, not the computer's faults cause your program's failures.
Persistence. Also, acting according to the wisdom of taking breaks and formulating useful questions for getting help.
Intellectual honesty--figure out what the code does, not what you want or think it should do; knowing whether or not you understand things you read or were told, helping others acquire what understanding you have without encouraging them to get credit without learning by cheating.

What CS1 is about

Imagining, carrying out by hand on paper, designing, and finally programming into computers, using one programming language (Java), many computations. Each consists of recording, reading and changing particular data values that are written or stored on individual note cards or other data storage units such as Java variables and objects, according to precise, written step-by-step, repetitive and conditional instructions.
Learning and deploying in programs a selection of things the computer might do, using (a) Java built-in features, (b) the Application Programming Interface (API) provided with the textbook for media computing, and (c) Java library APIs. Some of the things will be drawing figures by commanding an animated "turtle" to trace straight lines, and modifying and combining numbers stored in an array to represent colors in digital images.
Demonstrate skill in computer programming, with the following strategic steps:

Problem conception.
Planning. For example, plan a sequence of moves that will make the "turtle" trace out a particular letter of the alphabet.
Choosing features and API elements.
Coding (logic design, plus following and correcting syntax).
Incremental development cycle:

Testing
Debugging
Building by coding more functionality.

Final testing and submitting Java source files for grading.
Complete project work and and remember lessons learned from it by exercising effective pacing, patience and persistence.

Intellectual Work: Reusing facts, sometimes hard to learn at first plus new facts, over and over, so you actually demonstrate success in developing solutions for and explaining more and more intricate programming problems and questions about them.

Observable Learning Goals from CC2008

(Unmarked text was copied from CC2008, not in order. Text bracked [like this] was added. Text bracketted, marked OMITTED and crossed out was copied from CC2008 but deemed removed for our CS1 or CS2). This survey of CC2008 material must be completed by adding a selection from the lists of "Topics" given there preceeding each list of observable "Learning Goals".

CS1

Analyze and explain the behavior of simple programs involving the fundamental programming constructs covered by this unit.
Design, implement, test, and debug simple programs in an object-oriented programming language.
Modify and expand short programs that use standard conditional and iterative control structures and functions.
Design, implement, test, and debug a program that uses each of the following fundamental programming constructs: basic computation, simple I/O, standard conditional and iterative structures, and the definition of functions.
Choose appropriate conditional and iteration constructs for a given programming task.
Apply the techniques of structured (functional) decomposition to break a program into smaller pieces.
Describe the mechanics of parameter passing.
Create algorithms for solving simple problems.
Use pseudocode or a programming language to implement, test, and debug algorithms for solving simple problems.
Describe [and demonstrate] strategies that are useful in debugging.
[OMIT: ~~Justify the philosophy of object-oriented design and the concepts of~~] [Recognize, use and extend examples of ] encapsulation, abstraction, inheritance, and polymorphism.

CS2

Describe the representation of numeric and character data. [Demonstrate and explain effects of representation on observable calculations.]
Understand [and demonstrate] how precision and round-off can affect numeric calculations.
Discuss [and demonstrate] the use of primitive data types and built-in data structures.
Describe [,demonstrate and implement] common applications for each data structure in the topic list.
Implement the user-defined data structures in a high-level language.
Compare alternative implementations of data structures with respect to performance. [Demonstrate such performance differences.]
Write programs that use each of the following data structures: arrays, strings, linked lists, stacks, queues, and hash tables [omit hash for CSI310].
[Demonstrate and] [c]ompare and contrast the costs and benefits of dynamic and static data structure implementations.
Choose the appropriate data structure for modeling a given problem
Demonstrate different traversal methods for trees and graphs.
Relate graphs and trees to data structures, algorithms, and counting.
Describe the concept of recursion and give examples of its use.
Identify the base case and the general case of a recursively defined problem.
Compare iterative and recursive solutions for elementary problems such as factorial.
Describe [and demonstrate] the divide-and-conquer approach.
Implement, [trace,] test, and debug simple recursive functions and procedures.
Determine when a recursive solution is appropriate for a problem.
Describe how the class mechanism supports encapsulation and information hiding.
[OMIT: ~~Design, implement, and~~] [Use, extend and] test the implementation of “is-a” [and “has-a”] relationships among objects using a class hierarchy and inheritance.
Demonstrate the difference between call-by-value and call-by-reference parameter passing.
Describe how the computer system uses activation records to manage program modules and their data. [Trace program execution in terms of activation records and "activation trees"]