# CR: COMP 1405/1406 Redesign

## Learning Objectives

Ideas from discussion on Stack I

- Scoping
- globals, stack, heap
- performance issues (stack vs. heap, function call & I/O overhead)
- parameter passing: by value, by reference
- recursion (with stack usage and building up a data structure, e.g. reverse)

## Topic Brainstorming

Add topics here at the end of the section. Please *don't* **remove** anything!

- WHAT IS COMPUTER SCIENCE
- problem solving
- algorithms
- abstraction and problem decomposition
- efficiency ??

- PSEUDO-CODE ??
- SEQUENCING INSTRUCTIONS
- top down coding in sequence (e.g., draw a house)

- VARIABLES
- declaring vs. assigning
- memory usage ??
- constants
- examples:
- compute simple math formulas
- interactive input (e.g., use mouse position)
- motion (if doing graphics)

- Numbers
- integers
- floats

- CONDITIONALS
- simple IF/ELSE
- nested IF
- booleans(AND/OR)
- examples:
- make choices based on runtime input
- basic state machine
- edge cases / error checking

- ITERATION
- repeating X times (REPEAT)
- counting (FOR)
- repeating until condition (WHILE)
- nested loops
- examples
- sum/avg/max/min
- counting matches
- MonteCarlo approximation
- loop until user input
- searching (find first match)

- ARRAYS (1D and 2D)
- initializing and memory usage
- simple 1D (sum.avg/max/min)
- insert/remove
- copy/growing array

- Optimization
- e.g., knapsack
- greedy

- Simulation
- virus clearing
- Roomba

- Abstract data types
- Sorting
- Search
- linear
- binary
- exhaustive

- Divide and conquer
- Dynamic programming
- FORMATTING
- string manipulation
- display in columns (i.e., tabbing)
- display dates/times

- Data structures
- lists
- structures
- tuples
- binary trees
- dictionaries
- sets
- stacks, queues

- Complexity analysis
- informal

- OBJECTS
- instance variables
- initialization (constructors)
- shared references
- static vs. instance

- FUNCTIONS and PROCEDURES
- simple computations and return values
- passing parameters
- passing arrays as parameters
- helper methods

- RECURSION (likely 1406 material?)
- inductive definitions of data and associated recursion patterns.
- direct vs. indirect
- tail recursion
- examples:
- math problems (factorial/sum/avg)
- searching mazes
- iterate a non recursive data structure (array)
- iterate a recursive data structure (e.g., tree)

- PERSISTENCE (likely 1406 material?)
- writing files
- reading files
- parsing files

- WINDOWING
- display text output
- get textfield input
- buttons
- design and layout
- handling events
- menus
- dialog boxes

- GRAPHICS
- drawing with lines/shapes
- grabbing/selecting/moving graphical objects

- User interaction
- PROPER CODING STYLE
- encapsulation
- polymorphism
- private/public/protected data

- INHERITANCE
- class hierarchies
- abstract vs. concrete classes ?
- overriding/inheriting methods
- type-casting (needed if JAVA used) ?

- NETWORKING ?? (1406 ... as interesting examples)
- read internet page
- two applications talk over network

- Event-driven programming
- Model-View-Controller (more for 1406)
- Database APIs
- Allow use of key/value stores as used by standard websites

- Testing and debugging
- design vs. implementation errors
- basic test cases, regression testing?
- basic debugger usage
- strategies for identifying and fixing programming problems

- Software licenses
- open source and commercial
- restrictions on reuse

- How to read code
- editing and building software
- basic IDE usage

- commenting, code formatting guidelines
- revision control
- have students grab class code from this, pull updates
- make commits/push to submit?

- Understanding APIs
- basic idea of contract, side effects

- Concurrency/parallel code
- maybe not standard locking but some clean parallel constructs?

- Relative costs of operations
- memory vs. I/O vs. computation
- very basic benchmarking
- main idea: know that you can't predict what is going to be fast in practice w/o tests

- my first wiki entry ever! - djh

Should we copy the MIT 6.00 outline here?

### Sub categories?

Yes, we can add sub categories here.

## COMP1405 LIST OF TOPICS (UNORDERED) FOR WEEKLY OUTLINE

- WHAT IS COMPUTER SCIENCE
- problem solving
- algorithms
- abstraction and problem decomposition
- divide and conquer
- efficiency (just an intro to the ideas behind it)

- PSEUDO-CODE
- SEQUENCING INSTRUCTIONS
- top down coding in sequence (e.g., draw a house)

- VARIABLES
- declaring vs. assigning
- memory usage (how memory is affected) LATER
- constants LATER
- examples:
- compute simple math formulas
- interactive input (e.g., use mouse position)
- motion (if doing graphics)

- Numbers
- integers
- floats MINIMAL HERE --- MAKE SURE THIS TOPIC IS TAUGHT SOMEWHERE IN CURRICULUM

- CONDITIONALS
- simple IF/ELSE
- nested IF
- booleans(AND/OR)
- examples:
- make choices based on runtime input
- basic state machine
- edge cases / error checking

- ITERATION
- repeating X times (REPEAT)
- counting (FOR)
- repeating until condition (WHILE)
- nested loops
- examples
- sum/avg/max/min
- counting matches
- MonteCarlo approximation
- loop until user input
- searching (find first match)
- Make sure to have examples with non-trivial loop invariants (e.g., gcd, searching)

- COMMENTING / CODE FORMATTING GUIDELINES
- ARRAYS (1D and 2D)
- initializing
- simple 1D (sum.avg/max/min)
- insert/remove
- copying as needed for examples

- OBJECTS
- as mutable data structures only, no methods
- instance variables
- initialization (constructors)
- shared references

- FUNCTIONS and PROCEDURES
- simple computations and return values
- passing parameters
- passing arrays as parameters
- modular programming using functions and procedures
- recursion; possible examples: math problems (factorial/sum/avg); searching mazes

- USER INTERACTION
- input and output interaction with environment (e.g. user)

- RELATIVE COSTS OF OPERATIONS
- memory vs. I/O vs. computation
- very basic benchmarking
- often, but not always, you can't predict what is going to be fast in practice w/o tests

- SORTING
- teach in context of indexing (e.g., search engines)?
- illustration of: algorithms, complexity, recursion, divide-and-conquer

- SEARCH
- linear
- binary
- exhaustive

- SIMULATION
- possible examples: robots, Monte Carlo, virus clearing, Roomba

- Course work should include some code reading

## COMP1406 LIST OF TOPICS (UNORDERED) FOR WEEKLY OUTLINE

Top-level goals - Java - developing a complete OO applications

- EDITING AND BUILDING SOFTWARE
- JAVA language basics (make comparision with Processing)
- explain IDE usage (Eclipse), program creation, etc..

- OBJECTS
- defining classes
- writing methods within classes
- having multiple objects interact with each other

- PROPER CODING STYLE
- encapsulation
- polymorphism
- private/public/protected data
- exception handling (needed for JAVA)

- INHERITANCE
- class hierarchies
- abstract vs. concrete classes
- interfaces (JAVA specific...not "user" interfaces)
- overriding/inheriting methods
- type-casting (needed if JAVA used)

- GRAPHICAL USER INTERFACES
- display text output
- get textfield input
- buttons
- design and layout
- handling events
- menus and dialog boxes
- model view controller
- GRAPHICS -- not here, but it should be somewhere?
- grabbing/selecting/moving graphical objects

- FILE I/O
- writing files
- reading/parsing files

- RECURSION
- programming and recursive data structures

- FORMATTING output nicely
- string manipulation
- display in columns (i.e., tabbing)
- display dates/times

- NETWORKING
- read internet page
- two applications talk over network

- ABSTRACT DATA TYPES / DATA STRUCTURES
- lists (?? ArrayLists already used in 1405)
- structures (?? already done in 1405)
- tuples (?? Points already used in 1405)
- binary trees
- dictionaries
- sets
- stacks, queues

- TESTING AND DEBUGGING
- design vs. implementation errors
- basic test cases, regression testing?
- basic debugger usage
- strategies for identifying and fixing programming problems

- OPTIMIZATION
- e.g., knapsack
- greedy

- DYNAMIC PROGRAMMING

## EXTRA LIST OF TOPICS TO ADD IF TIME PERMITS (Mark's Opinion)

- UNDERSTANDING APIs
- basic idea of contract, side effects

- DATABASE APIs ???
- Allow use of key/value stores as used by standard websites

- SOFTWARE LICENSES
- open source and commercial
- restrictions on reuse

- REVISION CONTROL
- have students grab class code from this, pull updates
- make commits/push to submit?

- CONCURRENCY/PARALLEL CODE
- maybe not standard locking but some clean parallel constructs?

## Sample weekly outline (Fall 2006)

1. Introduction Sept 7-8

- intro to CS - class stuff

2. Algorithms Sept 11-15

- what are they - intro to problem solving - statements - pseudocode

3. Variables Sept 18-22

- concept - identifiers - assignment - expressions, arithmetic

4. Conditionals Sept 25-29

- Decision statements - boolean operators - if / then / else - case / switch - going from problem description to conditional statement

5. Iteration Oct 2-6

- idea of looping - starting / stopping / stepping - loop bodies - top and bottom loops - for loops - while loops - going from problem to loop statements

6. Subprograms Oct 9-13

- idea of modularization - functions and procedures - parameter passing - variable scope - when to modularize (problem solving)

7. Computer architecture Oct 16-20

- basic von Neumann architecture - linear memory organization - possibly midterm post-mortem in this week

8. Data structures 1: Arrays Oct 23-27

- idea of data structures & collections - arrays & linear memory - array operations, initialization - relation to loops - 2D arrays - going from problem to array specification

9. Data structures 2: Structs Oct 30-Nov 3

- idea of user-defined structures - why and when to use - examples

10. Searching Nov 6-10

- a larger problem domain - linear and binary search - 'putting it all together' (arrays, loops, variables, etc) - introduction to algorithm analysis (just the idea that different

algorithms can take different time)

11. Sorting Nov 13-17

- same basic structure as searching week - bubble sort and selection sort

12. Recursion Nov 20-24

- introduction to the idea - base cases & recursive cases - composition steps (returning a value)

13. Review Nov 27-Dec 4

- lab exam postmortem - review for the final

## Textbooks

- Sedgewick and Wayne, Introduction to Programming in Java

## Assignment problems

Please list your ideas for assignment problems below in your own subsection. Note that we are currently focusing on smaller problems that can be assembled into weekly assignments.

### David's Processing Problems

Draw a face, draw a house, draw a robot. (basic straight-line code)

Logical drawing (draw simple forms based on mouse position)

Using for loops to augment drawing.

Grass:

Stars:

- change the size, color distribution of stars - draw stars only above the horizon - draw stars only inside a circle (telescope view)

- add freckles to the face, hair

Skyscraper: - drawing location based on loop variable

variants: some windows dark, some lit

draw entire city (collection of buildings)

base sky color and window distribution on mouse pointer (windows get dark as it gets later)

Simple image processing:

Convert colored image to greyscale

Convert image to black and white; variant: base proportion of blackness on mouse position

Convert image to red and white -- only keep red pixels (problem: how to define?)

Robot behaviour:

Move small robot image or drawing primitive based on obstacles, mouse pointer - e.g., flee from mouse - e.g., attracted to mouse - e.g., want to maintain certain distance from mouse

### David's Paper problem solving examples

- Suppose you have two jugs, one with a capacity of three liters and the other with a capacity of five liters. Write an algorithm that uses these two jugs, and no other measuring devices, to get exactly one liter of water in the five-gallon jug.

- The Greeks of classical Athens assemble to choose a new leader, and they vote by placing voting stones into an urn: a black stone, to vote for Castor, or a white stone, to vote for Pollux. You are put in charge of the election results. Write a specific algorithm for determining which of the candidates (Castor or Pollux) is the winner.

- You are the in charge of the Royal mint, which produces a single type coin, the grote. There are ten machines producing grotes. One machine is producing grotes weighing one gram less than they should (each coin should weigh 10 grams). You have a scale that can be used exactly once before it explodes (don't ask), but will give an accurate reading of the weight of whatever is on the scale. Using only this one weighing, identify the single faulty machine. (Note; no algorithm required, just solve the puzzle if you can).

- The Royal Mint has run out of exploding scales, and now has balances instead. (A balance will tell you whether the items in the left pan or the items in the right pan are heavier, but not how much heavier.) You have nine grote-minting machines, and one of them is producing grotes that are too light. Write an algorithm for using the balance to determine which machine's grotes are too light. (Challenge: do it with only two balance operations.)

- Four travellers are trying to cross an old, rickety bridge, so decrepit that only two can cross at once. They reached the bridge at night, and have only one flashlight among them; there are enough holes in the bridge that it can only be crossed safely by a group carrying a light. Now, the travellers have reached the bridge at different levels of exhaustion: one will take 1 minute to walk across; one will take 2 minutes; one will take 5 minutes to limp across; and one will take 10 minutes to crawl across. A group moves at the speed of its slowest member. Give a general algorithm for getting everyone safely to the far side of the bridge. Using your algorithm, how long does it take the travellers to cross? (There are no tricks, like throwing the flashlight back to the other side.) (Challenge: get the group across in under 20 minutes.) (Challenge #2: get the group across in under 18 minutes.)

- An old story has a grateful king granting a wish to a favored advisor, and the advisor describing the following process. A chess board is to be brought out, and one grain of rice placed on the first square, two grains on the second, four on the third, and so on, doubling for each square. There are 64 squares on the chessboard. Write pseudocode for an algorithm to determine how many pounds of rice the unlucky king has to give to the advisor, assuming 1000 grains per pound.

- Suppose you are trying to pay off credit card debt. You have an initial balance, and the credit card charges 1.5% additional interest each month. Write pseudocode for an algorithm that gets a monthly payment amount from the user and then reports (a) how long it will take to pay off the debt; (b) how much of the payment is for interest (total paid minus initial balance). Make sure not to allow infinite loops! (How would a bank avoid an infinite loop on a credit card?)

- You have a spaceship that runs on gold, consuming 1 ton of gold for each parsec traveled. It can carry a maximum of 1000 tons, but can also eject gold into space and pick it up later. You have 3000 tons of gold and want to get as much as possible to your destination 1000 parsecs away (just at the limits of what you could reach, arriving empty). Describe a general algorithm for getting to your destination with as much gold as you can. (Challenge: reach the destination with more than 425 tons.)

- Consider the following exchange:
- ``My dog is precisely one-third Dalmatian.
- ``How can that be?
- ``Well, his father was one-third Dalmatian, and his mother is one-third Dalmatian, and so he is too.

What is wrong with the reasoning in the last statement? (Note: this is a question about recursion, NOT genetics! Pretend that the amount of Dalmatian in the offspring is the average of the amounts in the parents.)

- The Greek hero Achilles has the ability to stride half the distance to his goal in just a single step. He also has the ability to take a normal step, which will take him at most 1 meter. Write pseudocode for a recursive function that takes a float argument (the initial distance to the goal) and returns the smallest number of steps Achilles has to take to reach his goal. Notice that Achilles's best strategy will be to take giant steps (halving the distance) until the distance remaining is one meter or less, which he can finish with one normal step.

### Anil M's example problems

### Anil S's example problems

- Build an adventure game (2D graphics or text). This can turn into a huge assignment; however it can break down into a number of small tasks. Adventure games are a great way to teach about objects, persistence, conditionals, for example.
- draw fractals: recursion, numerical methods (limits of precision), basic graphics, complexity (fractals can take a while to render)
- find patterns in an image (squares, lines) - specific pixel patterns are easy, but scale and rotation invariant searches are much more challenging.
- spirograph
- file visualization - learn file I/O, basic data visualization, string processing, bit of recursion
- core wars? You just need arrays and a simple bytecode interpreter (bunch of conditionals)

### Doug's example problems

### Michiel's example problems

- Monte-Carlo estimation of pi: Throw N points randomly in the unit-square, and count how many of them are in the unit-circle. Do experiments with larger and larger values of N, and see how the result improves.

- Monte-Carlo estimation of integrals. Take some integrals that students learned in calculus (and that are not completely trivial). Choose random real numbers and count how many of them are underneath the function. Do experiments as for pi.

- Monty Hall problem. First let students guess what is the best strategy. Do a large number of experiments (put the prize behind a random door; choose a random door first, then follow the strategy) and count how many times you win the car. Based on this, students may be convinced that their initial strategy is not correct. In this case, revise the strategy and repeat the experiments.

- In all these problems, students may use different random number generators and see if they give the same results.

### Mark's paper problem solving examples

- Part A - Mary Melody has an apartment building high up in the sky. On her balcony is a ledge with 10 flower pots on it. The ledge is so narrow that it only holds exactly 10 pots. Mary has named each of her 10 flowers by placing a piece of masking tape on the bottom of the pot with the name on it. One day Mary decided to have a maid come and clean. The maid was so thorough and she was a kind of "neat freak". The maid wants to sort the flowers by name from left to right so that the leftmost flower has the name which comes first alphabetically. Assume that the maid can pick up only 1 pot in each hand at a time and that the pots must either be in the maid's hand or on the ledge (that is, she cannot put them down anywhere else). Note that the maid may pick one pot up in her hand and slide another pot along the ledge with her free hand. Explain (i.e. give an algorithm) how the maid can sort the pots properly.
- Part B - Assume now there are exactly two ledges and that the maid can make use of the second ledge to place the pots on. Can you describe a better way of sorting the pots ? Perhaps there is a quicker way or a way that involves the use of only one hand.

- Assume that you want a robot to follow along the walls of a building and that the walls have always 90 degree turns. Explain how to get the robot to follow the walls. Draw a picture of your robot and indicate any kinds of sensors that you would need. Make sure to explain how you use the sensors.

### Mark's programming problems

- Write a program to compute how many balls can be packed into a box. This can be done 2D or 3D. In 2D, the user can draw a rectangle and a circle and then use their dimensions to compute the number of circles that fit into the rectangle and display them packed in there. It can be done in 3D as well without too much difficulty. (This will help students understand the differences between using floats and ints because only WHOLE balls are to be fit into the rectangle, not partial balls).

- Part A - Write a program that determines whether or not cell phone access is continuously available along a planned path between various cities. In this program, the user will click a set of arbitrary locations on the screen that represent city centers. Assume that a cell phone tower is placed at each city center and is represented as a circle with some radius. Assuming that the user then drives from one city center to the others in sequence, the user then needs to compute whether or not there is cell phone access along the whole path. The solution is to make sure that the circles intersect for each consecutive pair of cities.
- Part B - Assume that internet access is available throughout the whole trip. If it costs $0.20 per minute to use the cellphone and the person traveled an average (non-stop) speed of 50km/h ... for the whole trip, staying connected to the internet the whole time ... what will be the maximum cell phone cost from this trip ? (They would calculate the distances between adjacent cities to compute the total distance and will need to determine how many minutes of travel time was made on the trip ... assuming constant speed of 50km/h to keep things simple).

- Simulate Cars parking in ParkingLots over time. Define Car and ParkingLot data structures, where cars maintain the time that they entered the parking lot (if they take a ticket stub) and perhaps whether or not they have a parking pass. As cars enter the lot, their entry time is stored in the Car data structure, based on the current time. When they leave, the cost is computed based on their entry time and current time at some fixed cost (e.g., $1.50 per hour). The ParkingLot maintains the total money made so far as well as its capacity and the number of cars parked there. (The students could draw the parking lot and grab cars with the mouse to place them in the lot (perhaps showing their entry time as well). The cars can then be clicked on to leave the lot (no need to animate it). We could then have two parking lots of different capacities and rates and then have the cars go into each one. This is a nice way to get them used to using data structures)

# Recommendations Summary

- "Objects first" is not working, too many students DFW in first year. Also, we've already moved away from objects first in practice. Some leading CS departments, e.g. Waterloo, UofT, & MIT, do not teach objects first (objects are just one topic among many). We're proposing to do the same.
- Only cover objects as data structures in first year: no inheritance until last few weeks of 1406.
- Inheritance will be covered in 2404 (Programming in C++) - title should change to "Object-Oriented Programming in C++". 2401 covers C and UNIX in the Fall, 2404 covers C++ in the Winter.
- Emphasize problem solving in a general-purpose programming language.
- Teach only basic programming language structures: loops, conditionals, functions, procedures, exceptions.
- No required special applications in 1406.
- 1405 is an introduction to problem solving through programming, 1406 is a second course on the same topic.
- Advanced students would start with 1406 and skip 1405; 1406 shouldn't require knowledge of the specific language syntax used in 1405.
- 3007 becomes Functional and Concurrent programming. (e.g., cover MapReduce)
- 2402 will give students extra experience with Java beyond 1405 and 1406.
- Challenge: where do students get more experience with object-oriented Java? (How much do they need?) Question: could 3004 provide this, or do we need a new course, maybe just for the software engineering stream?

Required Programming Courses

- 1405 and 1406
- 2401, 2402, & 2404
- 3004 and 3007

## Old Course Descriptions

COMP 1405 [0.5 credit] Introduction to Object-Oriented Programming A first course in problem solving and computer programming designed for B.C.S. students. Introduction to object-oriented programming; syntactic constructs, data abstraction, classification and inheritance, typing and polymorphism, testing and debugging. Precludes additional credit for COMP 1005 and SYSC 1100. Prerequisite: Restricted to students registered in the B.C.S. program, combined Honours in Computer Science and Mathematics, Honours Computer Mathematics, and Honours Computer Statistics. Lectures three hours a week, tutorial one and a half hours a week.

COMP 1406 [0.5 credit] Design and Implementation of Computer Applications A continuation of COMP 1405 focusing on the design and implementation of complete applications. Topics covered include persistence, graphical user interface design and implementation, event-driven programming, recursion, drawing and manipulating 2D graphics and networking. Precludes additional credit for COMP 1006 and SYSC 1101. Prerequisite: COMP 1405. Restricted to students registered in the B.C.S. program, combined Honours in Computer Science and Mathematics, Honours Computer Mathematics, and Honours Computer Statistics. Lectures three hours a week, tutorial one and a half hours a week.

## New Course Descriptions

**COMP 1405 [0.5 credit] Introduction to Programming I**

A first course in programming emphasizing problem solving and computational thinking. Topics include an introduction to computer science, pseudocode, variables, conditionals, iteration, arrays, objects, functions, sorting, searching, and simulation.

**COMP 1406 [0.5 credit] Introduction to Programming II**

A second course in programming emphasizing problem solving and computational thinking. Topics include object-oriented programming, abstract data types, linked data structures, testing and debugging, recursion, encapsulation and information-hiding, specification, program efficiency, state machines, and exception handling.

### Links for May 10, 2010

From Doug

Toronto [1] CSC108 and CSC 148 (150 is an accelerated combo)

Topics:

Program structure: elementary data types,statements, control flow, functions, classes, objects, methods, fields. Lists; searching, sorting and complexity.

Abstract data types and data structures for implementing them. Linked data structures. Encapsulation and information-hiding. Object-oriented programming. Specifications. Analyzing the efficiency of programs. Recursion.

Waterloo [2] CS 135 and 136

Topics:

Syntax and semantics of a functional programming language. Tracing via substitution. Design, testing, and documentation. Linear and nonlinear data structures. Recursive data definitions. Abstraction and encapsulation. Generative and structural recursion. Historical context.

It introduces the design and analysis of algorithms, the management of information, and the programming mechanisms and methodologies required in implementations. Topics discussed include iterative and recursive sorting algorithms; lists, stacks, queues, trees, and their application; abstract data types and their implementations.

Princeton [3]

Potential topics from Princeton: hardware and software systems; programming in Java; algorithms and data structures; fundamental principles of computation; and scientific computing, including simulation, optimization, and data analysis.

Alberta [4] CMPUT 174 and 175

Potential topics from Alberta for 1405 and 1406:

- computation, states, events, transitions
- state machines, simple pattern matching
- programming basics (variables, input, output, while, if, etc.)
- search
- lists, arrays, and hashes
- regular expressions and pattern matching
- functions, subroutines, and testing
- recursion
- references and data structures
- expression and binary trees
- abstract data types
- simulation
- sorting
- abstract data types
- objects
- graph algorithms
- exceptions
- little languages
- closures

## Email to Faculty

The "curriculum reinvention" committee (Anil x 2, Michiel, Mark, Doug, Dave) have been discussing revising our curriculum with the goal of improving engagement and retention of our students, i.e. doing a better job of teaching them. Lately, we've been focusing on the first year programming courses, and would like to get your input on a proposal for a substantial change to 1405 and 1406 (leaving 1005 and 1006 aside for now). Below is a summary of the changes followed by a calendar-like description of the courses.

We're interested in any views you might have. Nothing is set in stone at this point.

The key change we are proposing is to change their focus from learning Java to learning how to solve problems using programs. Key programming concepts are to be taught in as language-independent a manner as possible, e.g., through the use of pseudo-code. Object-oriented programming concepts are present in the courses but are not presented first. 1405 will cover objects as simple data structures, but methods, inheritance etc will be postponed until 1406. Instead, a wide range of basic programming skills will be taught.

The new courses will be structured in some ways as a unit; however, the topics are partitioned so that students with substantial programming experience in any language will have a decent chance of going directly to 1406 (via a placement test).

For the initial course delivery, we are tentatively planning on emphasizing weekly assignments structured around multiple small problems rather than fewer, larger assignments. Also, while Java will be used for both courses, 1405 will use Processing, a Java "subset" designed for image creation. We believe Processing will facilitate more engaging assignments.

These changes will have limited impact on the rest of the curriculum. 2402 (Abstract Data Types) will continue to be taught in Java. 2404, our C++ course, will focus more on problem solving using object-oriented programming and design with C++.

Old Course Descriptions (prereqs etc omitted)

COMP 1405 [0.5 credit] Introduction to Object-Oriented Programming

A first course in problem solving and computer programming designed for B.C.S. students. Introduction to object-oriented programming; syntactic constructs, data abstraction, classification and inheritance, typing and polymorphism, testing and debugging.

COMP 1406 [0.5 credit] Design and Implementation of Computer Applications

A continuation of COMP 1405 focusing on the design and implementation of complete applications. Topics covered include persistence, graphical user interface design and implementation, event-driven programming, recursion, drawing and manipulating 2D graphics and networking.

New Course Descriptions

COMP 1405 [0.5 credit] Introduction to Programming I

A first course in programming emphasizing problem solving and computational thinking. Topics include an introduction to computer science, pseudocode, variables, conditionals, iteration, arrays, objects, functions, sorting, searching, and simulation.

COMP 1406 [0.5 credit] Introduction to Programming II

A second course in programming emphasizing problem solving and computational thinking. Topics include object-oriented programming, abstract data types, linked data structures, testing and debugging, recursion, encapsulation and information-hiding, specification, program efficiency, state machines, and exception handling.