SCS Curriculum Reinvention Committee: Difference between revisions

From Soma-notes
← Older edit
No edit summary
 
(81 intermediate revisions by 4 users not shown)
Line 1: Line 1:
This page contains notes and discussions related to the SCS Curriculum Reinvention Committee.
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.
=Requests for more data=


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.
*Why are students leaving SCS?
**What are the grades in SCS-related courses for students who change majors out of SCS?
**What majors do they switch to? After how many terms?
*DFW and A/B rates for 2009/2010 versus past years in 1405, 1406, 1805?


=Courses to be examined=
=Courses to be examined=
Line 11: Line 14:
*COMP 1406 - Design and Implementation of Computer Applications
*COMP 1406 - Design and Implementation of Computer Applications


Introductory Theory
Theory
*COMP 1805 - Discrete Structures
*COMP 1805 - Discrete Structures
*COMP 2805 - Introduction to Theory of Computation
*COMP 2805 - Introduction to Theory of Computation
*COMP 2402 - Abstract Data Types and Algorithms
*COMP 2402 - Abstract Data Types and Algorithms
*COMP 3804 - Design and Analysis of Algorithms I


Intermediate Programming
Intermediate Programming
Line 23: Line 27:
*COMP 2003 - Computer Organization
*COMP 2003 - Computer Organization
*COMP 2405 - Internet Application Programming
*COMP 2405 - Internet Application Programming
*COMP 3000 - Operating Systems
*COMP 3002 - Compiler Construction
*COMP 3004 - Object-Oriented Software Engineering
*COMP 3005 - Database Management Systems
*COMP 3007 - Programming Paradigms
*COMP 3008 - User Interface Architecture
*COMP 3203 - Principles of Computer Networks
*STAT 2507
*STAT 2605


=COMP 1405/1406 Redesign=
=Detailed Discussions=


==Topic Brainstorming==
*[[CR: COMP 1405/1406 Redesign|COMP 1405/1406 Redesign]]
 
*[[CR: Theory course redesign|Theory course redesign]]
Add topics here at the end of the section.  Please ''don't'' '''remove''' anything!
*[[CR: Other CS approaches to Math/Theory]]
 
*[[CR: New course descriptions and rationale|New course descriptions and rationale]]
* WHAT IS COMPUTER SCIENCE
*[[CR: Survey of theory requirements in other Canadian Honours programs|Theory requirements survey]]
** problem solving
*[[CR: Reducing the Core Size|Reducing the Core Size]]
** algorithms
*[[CR: Learning Objectives]]
** abstraction and problem decomposition
*[[CR: Proposal to Faculty May 2011]]
** efficiency ??
*[[CR: stream changes]]
* PSEUDO-CODE ??
*[[CR: Proposal to Faculty September 2011]]
* SEQUENCING INSTRUCTIONS
*[[CR: Third and Fourth Year]]
** top down coding in sequence (e.g., draw a house)
*[[CR: Attracting advanced students]]
* VARIABLES
*[[CR: Curriculum Changes April 2012]]
** declaring vs. assigning
*[[CR: to do list]]
** memory usage ??
*[[CR: Notes Fall 2012]]
** constants
*[[CR: New 3rd year courses]]
** examples:
*[[CR: Curriculum Changes for 2015/2016]]
*** compute simple math formulas
*[[CR: Winter 2014]]
*** interactive input (e.g., use mouse position)
*[[CR: Summer 2014]]
*** 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 [http://ocw.mit.edu/OcwWeb/Electrical-Engineering-and-Computer-Science/6-00Fall-2008/CourseHome/  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, [http://www.cs.princeton.edu/introcs/home/ 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)
[[File:Example.jpg]]
 
Using for loops to augment drawing.
 
Grass:
 
[[File:Example.jpg]]
 
Stars:
 
[[File:Example.jpg]]
- 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
[[File:Example.jpg]]
 
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
 
[[File:Example.jpg]]
 
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
[http://www.artsandscience.utoronto.ca/ofr/calendar/crs_csc.htm]
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
[http://www.ucalendar.uwaterloo.ca/1011/COURSE/course-CS.html]
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
[http://registrar.princeton.edu/course-offerings/course_details.xml?courseid=002051&term=1112]
 
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
[http://cs.ualberta.ca/undergraduate-students/course-directory]
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.

Latest revision as of 20:46, 28 April 2014

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

Requests for more data

  • Why are students leaving SCS?
    • What are the grades in SCS-related courses for students who change majors out of SCS?
    • What majors do they switch to? After how many terms?
  • DFW and A/B rates for 2009/2010 versus past years in 1405, 1406, 1805?

Courses to be examined

Introductory Programming

  • COMP 1405 - Introduction to Object-Oriented Programming
  • COMP 1406 - Design and Implementation of Computer Applications

Theory

  • COMP 1805 - Discrete Structures
  • COMP 2805 - Introduction to Theory of Computation
  • COMP 2402 - Abstract Data Types and Algorithms
  • COMP 3804 - Design and Analysis of Algorithms I

Intermediate Programming

  • COMP 1402 - Introduction to Systems Programming
  • COMP 2404 - Programming in C++

Other Core-ish Courses

  • COMP 2003 - Computer Organization
  • COMP 2405 - Internet Application Programming
  • COMP 3000 - Operating Systems
  • COMP 3002 - Compiler Construction
  • COMP 3004 - Object-Oriented Software Engineering
  • COMP 3005 - Database Management Systems
  • COMP 3007 - Programming Paradigms
  • COMP 3008 - User Interface Architecture
  • COMP 3203 - Principles of Computer Networks
  • STAT 2507
  • STAT 2605

Detailed Discussions

Retrieved from "https://homeostasis.scs.carleton.ca/wiki/index.php?title=SCS_Curriculum_Reinvention_Committee&oldid=19100"