This page contains notes and discussions related to the SCS Curriculum Reinvention Committee.

The content below has gratuitous markup so as to make it obvious how to add more stuff.

To edit this page, you first need to create an account - click the link in the top-right of the page. Then click on the edit tab just about the page headline. Or, you can edit individual sections.

COMP 1405/1406 Redesign

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 FOR WEEKLY OUTLINE (Mark's Opinion)

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)
- 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)
COMMENTING / CODE FORMATTING GUIDELINES
ARRAYS (1D and 2D)
- initializing and memory usage
- simple 1D (sum.avg/max/min)
- insert/remove
- copy/growing array
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
EVENT-DRIVEN PROGRAMMING (if using Processing)
GRAPHICS (if using Processing)
- drawing with lines/shapes
- grabbing/selecting/moving graphical objects
USER INTERACTION
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
SORTING
SEARCH
- linear
- binary
- exhaustive
SIMULATION
- virus clearing
- Roomba
HOW TO READ CODE ???

Weekly Outline

Here is a list of the topics that I (Mark) think should be in 1406:

EDITING AND BUILDING SOFTWARE
- basic IDE usage
RECURSION
- 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
- writing files
- reading files
- parsing files
WINDOWING
- display text output
- get textfield input
- buttons
- design and layout
- handling events
- menus
- dialog boxes
EVENT-DRIVEN PROGRAMMING (if not using Processing in 1405)
MODEL/VIEW/CONTROLLER
GRAPHICS (if not using Processing in 1405)
- drawing with lines/shapes
- grabbing/selecting/moving graphical objects
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
- read internet page
- two applications talk over network
FORMATTING output nicely
- string manipulation
- display in columns (i.e., tabbing)
- display dates/times
ABSTRACT DATA TYPES / DATA STRUCTURES
- lists
- structures
- tuples
- 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

Weekly Outline

Here is a list of the topics that I (Mark) don't think are necessary but can be added if time permits:

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