BIT 143:Programming - Data Structures (2008 Fall)

Lessons

(there are more dates listed in The Huge Due Date List, at the bottom of this page)

Assignment 1 (DUE: Weds, Oct 8)

Individual Pre-Class Exercises:
<Due: Sept 29, noon PST (MONDAY of the SECOND week of the class) >

TODO: Do generics right, or else ditch them?
TODO: Emphasize that videos should be watched before doing exercises, for those exercises that have them?
NUNit todo: (1) make the test-runner project the first one, so it'll run by default, and (2) have the test-runner also handle the file copying?  Double-check that the copy is really happening????

1. Orient yourself to BIT 143
    
2. Get Visual Studio
3. Install the software for XNA
   The XNA-based PCEs and assignments will be optional.
   You can install this software later, if you don't want to install it right now
    
4. Join the class newsgroup ; (Required)
   Send the professor your email address
    
5. Create a simple console application 
   (Ch 3.3 (walkthrough),
   3.2 (explanation of the program) )  
   There is a Demo Video that walks you through this, too
    
6. Downloading and using a simple console application
    
7. 'Starter' project for the lesson 01 PCEs (DOWNLOAD THIS!!)
   
   Review Exercises:
8. Console I/O, Operators (Chapter 3) (Hand-In)
9. Fibonacci numbers in an array (Hand-In)
   
   OOP Basics:
   (Demo Video   Example Project)
   OOP Encapsulation:
   (Demo Video   Example Project)
    
10. Review: Variable Scope (class, instance, local/param vars) (Hand-In)
     
11. Using The Distance Formula (Demo Video   Word Document Used in the Video)
    (There is nothing to hand in for this PCE.  Personally, I'd recommend doing a couple of examples by hand in order to make sure that you understand the formula.  You will be using the formula on homework assignment 2, et al.)
     
12. Review: Class Composition: Circle Class (Hand-In)
    Feedback: Example of what class composition is?
     
13. Review:Circle class: Overlap method
     
14. Review: Arrays of Simple Types (Hand-In)
    (This was added on 9/24)
     
15. How To Use Multi-Project Starter Solutions
    
    (related, optional reading: How to create your own multi-project solutions)
     
16. SmartArray Overview
    (This was added on 9/24)
17. Basic SmartArray Class (Hand-In)
    (This was added on 9/24)
     
18. Web Hand-In for pre-class exercises and homework:
    Go to the StudentTracker web app, and create an account for yourself, and then enroll in the course.
    Once you've created an account/enrolled, you can use this direct link to this, specific class: http://panitzco.com/CCC/StudentTracker/course_students/display/2 

Individual Pre-Class Exercises:
< Due: Wednesday, Oct 1, before the start of class >

1. 'Starter' project for the lesson 02 PCEs
   (Unless otherwise stated, put exercises into the PCE_Starter project)
   Feedback: Array of ints left in here - remove; check for extra enum stuff, too
    
2. How to use a debugger: Intro
   Feedback: Example of correct output?
    

3. Figure out what an enum is  
   (Demo Video   VS Project Used in the Video)
    

4. Define the ErrorCode Enum (Hand-In)
   Feedback: Vague instructions -> did next two all at once.
   Replace enums w/ exception handling?
   Feedback: Emphasize/highlight that no code will be produced
   Feedback: This talks about a stack, which hasn't been covered yet

   
    

5. Using the ErrorCode Enum (Hand-In)
    

6. Review: Big "Oh" Notation  (Hand-In)
   Feedback: Exercise: Give 5 different types of routines, match them to their O(N) notation time
   Feedback: Provide example code that demonstrates each of the classes?
   Feedback: Coments in project out-of-sync with this .DOC?
    

7. Figure out what a stack is  (Hand-In)

   Feedback: Emphasize/highlight that no code will be produced
   Feedback: Just summarize what it is- too many bad explanations on the Internet

    
8. Preview: Using the .Net FCL Stack (Hand-In)
    
9. Post at least 1 question in the Google Group for this class.
   Answer at least 1 question (that someone else has posted) in the Google Group for this class
   (Not doing this will result in a point penalty)
    
10. PCE Feedback (Hand-In)
    
     

Individual Pre-Class Exercises:
<Due:  Wednesday, Oct 8, before the start of class>

1. 'Starter' project for the lesson 03 PCEs
   (Unless otherwise stated, put exercises into the PCE_Starter project)
   
   

2. OOP Inheritance (Specialization):
   (Demo Video   Example Project)
    

3. StackOfInts as specialized SmartArray
   (Hand-In)
    

4. QueueOfIntegers as specialized SmartArray    (Hand-In)
   Feedback: Clarify w/ diagram?
   Feedback: More slides about what a circular queue is
   Feedback:  In the QueueOfInts class there’s comment saying: “topOfQueue will be the index of the NEXT space that will be used So it therefore starts out at 0, meaning that 0 is UNoccupied.“ but there is no variable called topOfQueue, so change topOfQueue to backOfQueues
    

5. Stack / Queue: Annotate with Running Time (Hand-In)
   
   

6. SmartArray: Alloc on demand (Hand-In)
   Feedback: Be clear that this is only the first time, and NOT a fully dynamic array
   Feedback: More detail about the null value for arrays/references
   Feedback: How to add tests to the framework?
    

7. Figure out what Generics are
   
   There's a very (very very) thorough explanation at http://msdn2.microsoft.com/en-us/library/ms379564(VS.80).aspx.  If you read the first couple of sections (up to Applying Generics), that should be enough background for you.
   
   

8. Basic, Generic class (Hand-In)
    

9. PCE Feedback (Hand-In)

In-Class Exercises:
<Class Date: Sept 24 (Wednesday) >

(This class meets from 5:45-10:05pm this first week ;

it meets from 8:00pm -10:05pm thereafter)

1. Create a simple console application
2. Basic Console I/O
3. Single-file Demo for PCE's  
4. Single-Solution Demo for PCE's
   (You need use this (or something similar) as the 'template' for the other PCEs)
    
5. How to use a debugger
    
6. Basic class design

Videos:

1. First day's lecture, Part "1"
2. First day's lecture, Part "2"

In-Class Exercises:
<Class Date: Wednesday, Oct 1 >
 

(This class meets from 8:00pm -10:05pm starting this week)

Videos:

1. Intro & Overhead: Due dates, new assignments, etc, etc
2. The rest of the lecture

Review:

1. Enums in detail
2. Bitwise enums
3. OOP review

Preview:

1. Slideshow: Stack ADT
2. Using A Stack: Detecting Palindromes
    
3. Preview: Using the .Net FCL Stack (running time)
    
4. Specifying the Queue ADT
    
5. Generics (quick overview)
   Example Code
    
6. Inheritance: Specializing a base class

Videos:

1. Intro & Overhead: Due dates, new assignments, etc, etc
2. TDD, Linked List basics, Add To Front
3. Linked List: Print All (Traverse A LL)
4. RemoveFromFront

1. Research Opt-Out Form
   
   
2. Stack of Simple Types vs. Reference Types
    
3. Test-driven development:
   Implementing a stack of circles
    
4. Linked List Of Ints: Add to the Front 
   (Sect. 24.4)
   
5. Linked List Of Ints: Traversing  (Sect. 24.4)
    
6. Preview: Print At Index
    
7. Preview: Interfaces, IEnumerable

Assignment 2 (Due: Weds, Oct 22)

Post A1 Survey
(Due: Friday, Oct 24th, at noon)

Feedback: Maybe have an 'add to end' routine?
Feedback: More info / detail on TDD?
TODO: Include the 'TDD' exercise in grading

1. 'Starter' project for the lesson 04 PCEs
    

2. Reference Types vs. Value (Simple) Types
    

3. SmartArray: Manually resizing
   
   

4. Nested Classes: Basics BST (From PCE07)BST
   Feedback: Remove this!!
    

5. Linked List Of Ints: Add to Front   (Hand-In)
   (Sect. 24.3, 24.4)
   Feedback: return type should be 'void'
   Feedback: A later exercise back-claims that this needs to return an ErrorCode?
    
6. Test-driven development: Testing Your Linked List   (Hand-In)
   Feedback: More detail on HOW to create a test, and WHAT to test for
    
7. Linked List Of Ints: Traversing      (Hand-In)
   (Sect. 24.4 - 'Print' )
    
8. Linked List Of Ints: Remove From Front (Sect. 24.4)                                   (Hand-In)
    
9. LL: Printing at a specific location
   (Try your best on this, but don't worry if you end up getting stuck)
   Feedback: Make this required
    

10. Discovery of Interfaces: IEnumerable & Arrays        (Try your best on this,
    but don't worry if you end up getting stuck)
    Feedback: This was very confusing - video this!!

    Feedback: Explain what a 'helper class' is
     

11. PCE Feedback (Hand-In)

1. 'Starter' project for the lesson 05 PCEs
    
2. Nested Classes: Basics (Hand-In)
   Video From Lecture: Nested Classes
   IDEA: Move this back to PCE03?
    
3. LL: Insert by location/index (Hand-In)
   Video From Lecture: Linked Lists: InsertAt
    
4. LL: Remove by location/index (Hand-In)
   Video From Lecture: Linked Lists: RemoveAt
    
5. LL: Insert by value, in order
    
6. LL: Remove by value, in order
   
   
7. Generic Linked List (Hand-In)
   Feedback: Video for this?
   Feedback: detail the default(T) thing
   
8. Strategies for LL: Traversing A Linked LIst (Print, Find, PrintAllMatching)
   Lecture Video: Linked List Schema: Traversal
   Feedback: Generally well liked; by the time this exercise required a description of the steps, the steps were clear
    
9. Strategies for LL: Clone (Hand-In)
   Feedback: This needs more detail - maybe a picture?
   Observation: People seem to pretty consistently loop through 1 list, and use AddAtLocation to insert into the other list.
   Feedback: Specify that Clone needs to return the list.
    
10. PCE Feedback (Hand-In)
     

11. Video Feedback (Hand-In)

Individual Pre-Class Exercises:

<Due: Wednesday, Oct 29 before the start of class;

no penalty until Nov 5 >
(There is no penalty for handing this lesson's PCEs in until Nov 5- you are still responsible for knowing the material on the midterm exam!)

Feedback: Exercise ideas for recursion: Conway's Game Of Life, 'Ant Walk', making a Mandelbrot set, etc.

Feedback: More detail on coding strategies for recursion

Feedback: Use this to bootstrap a 'recursion as shaving off work, then do rest' pattern (i.e., each iteration through loop does a little bit, leaving a smaller but identical remaining work?)

Feedback: More on the running time of recursive methods?

1. Review for the exam!!! 
   Midterm Exam Topics

   
   

2. 'Starter' project for the lesson 06 PCEs
   
   

3. Recursion
   (Note that this was formerly in Lesson 09 in BIT 142, so if you've taken 142, then this will be review)
   (Video: Recursion Mechanics (Review))
    
4. Recursion By hand: Warm-up #1
   
5. Recursion By hand: Warm-up #2
   
   
6. Recursively Printing Even Numbers (Hand-In)
   Feedback: Start with printing 1-10, instead?

   
   

7. Recursive Multiplication
   (Video: Recursion Coding Strategies)
   Feedback: Do Power fnx in video/class, then required this one
   Feedback: This video is less than a minute long

   NOTE TO SELF: This could be done a lot better. Pick PowR & make MultR an exercise, go through the 'onion' thing, then the 'assume the recursive call works like magic' thing, then finally the clear definition of the base &inductive cases.  Strat - define problem in terms of a smaller version of itself, decide if you're working down or up, then clearly ID the base cases, then write recursive case w/ differently named 'magic' self-call, then replace with recursive call?'
    

8. Recursive Power Function (Hand-In)
   
   
9. Write Factorial
    
10. Fibonacci Numbers (And Arrays!)
    Feedback: Not clear how fib function & filling in the array interacted (used separate function call for each slot)

    
    

11. Print a singly linked list recursively (Hand-In)
    
    
12. PCE Feedback (Hand-In)
     

13. Video Feedback (Hand-In)

Videos:

1. Intro ("What's due when")
2. Nested Classes
3. Linked Lists: InsertAt
4. Linked Lists: RemoveAt
5. Linked List Schema: Traversal

Review:

1. Interfaces, IEnumerable
    
2. Linked List stuff

Preview:

1. LL: Insert by location/index
2. LL: Remove by location/index
    
3. LL: Running time
    
4. LL: Insert by value, in order
5. LL: Remove by value, in order
    
6. Strategies for LL: Clone
    

1. Generics for general-purpose ADTs
   Generic Linked List
    

2. Objectifying the Linked List Code
   • Linked_List_Starter.zip -Starter Project for Add/Remove exercises

3. Memory Management:
   KeyedSmartArray (structs vs. classes)

Videos:

1. Intro ("What's due when")
2. Recursion Mechanics (Review)
3. Recursion Coding Strategies

1. UWB presentation
   
2. Post A1 Survey (this must be done by Friday, Oct 24th, at noon)
    

3. Midterm Exam: Q+A & Review
    

4. Recursion By hand: Warm-up #1
5. Recursion By hand: Warm-up #2
   

6. Recursion By hand: Warm-up (#3)

7. Recursion by Hand: Warm-up (#4)

8. Recursion By hand: More Complicated
    
9. Recursive Multiplication
   
   
   
10. Print a singly linked list recursively
11. Add to a singly linked list, recursively
12. Remove from a singly linked list, recursively
    
    
13. Queue implemented via Linked List
     
14. Doubly-linked list
    

Midterm Exam: Q+A & Review

< MIDTERM EXAM>

Assignment 3 (Due: Weds Nov 5)

Assignment 4 (Due Weds, Nov 19)

1. 'Starter' project for the lesson 07 PCEs
   Feedback: Remove the 'nested BST' project
   
   
2. Link to BIT 142's Recursion Material
    
3. Compare & Contrast Two Pow implementations (Hand-In)
   Video: BigOh Applied To Space & Time
   Feedback: More info on what Pow1 & Pow2 are?
     
4. Binary Search Tree preview (Required) (Textbook: Chapter 24, Section 7)
   Video: BST Overview
   Feedback: There's a section in the book on this - find those sections & list them here.
   Feedback: Idea that tree is different based on insertion order is interesting
    
5. Binary Search Tree: Class Definitions
   Video: BST Definitions
   Feedback: This exercise is lame - ditch it?
    
6. BST: Add   (coded in C#) (Hand-In)
   Video: BST.Add
   (You will probably need to watch the video for the 'Find' method (below) first)
   Feedback: Demonstrate both iterative, and recursive solutions for this - especially since most online examples will be recursive?
   IDEA: What about having forced discussions about things like 'what to do about duplicates?"  THis might help them be more independent, but in a way that it's clear they're supposed to be independent.
   Feedback: Mention tree balancing
   Feedback: Offer up (more) advice on duplicates
   BUG: Doesn't handle adding to empty tree
   Feedback: PCE mentions key/data, but video does not
    
7. BST: Find   (coded in C#) (Hand-In)
   Video: BST.Find
   BUG: This really should be covered before Add - maybe hard-code a tree into the starter, to bootstrap Find?
   
   
8. PCE Feedback (Hand-In)

Individual Pre-Class Exercises:
<Due: Wednesday, Nov 12  before the start of class>
IDEA: Provide code to hard-wire a BST, then make them do the searching routine?  Video with iterative & recursive approach?  Variation: Hardcode a bunch of duplicates, make them modify search to find dups?

1. 'Starter' project for the lesson 08 PCEs
   
   
2. BST: Print  (coded in C#, using recursion) (Hand-In)
   Video: BST: Print
   Feedback: Broaden scope - try pre/in/post order traversal?
   
   
3. BST: PrintIterative (coded in C#, using iteration)
   
   
4. BST: Recursive Find
   (Hand-In)
    Video: BST: Patterns
   
   
5. BST: Recursive Add
   (Hand-In)
   Feedback: Pretty easy, despite recursion
   
   
6. BST:Print Beneath Node
   
   
7. BST: Remove preview
   Video: BST: Remove (Overview)
   
   
8. BST: Remove By Hand
   (The lecture 8 quiz will be similar to one of these exercises)
   Feedback: More detail on what needs to be done - maybe a quick demo of a similar exercise?
   
   
9. PCE Feedback (Hand-In)

1. 'Starter' project for the lesson 09 PCEs
   Video: How To Use The Starter Project
   Don't forget to delete bin/obj/DELETETHIS..
   before handing this in!!!
   
   
2. Videos: Remove From A BST (Concepts)
   2008Fall       2008Spring (+Outline)
   
   
3. Video: Explaining code details of BST-Remove
   (+Outline of video)
   
   
4. BST: FindAndRemoveNextSmaller (in C#) (Hand-In)
    
5. BST: Remove (coded in C#) (Hand-In)
   Feedback: RemoveRoot, NonRoot are too similar to really need both
    
6. Sorting & Searching: setup for the class (Hand-In)
   Feedback: Where to put the test code? NUnit?
   Feedback: Too simple for this class - just include it?
   IDEA: Maybe make them redo BubbleSort as a review?
   (If so, make sure to include links to description / 142 lecture?)
   IDEA: BinarySearch / LinearSearch as review?
   IDEA: Also have them do the version that measures the number of comparisons, and then graph those in Excel?
    
7. Preview: QuickSort
   Video: QuickSort (2008 Spring)

   QuickSort SlideShow (this are the same slides used in the above video)

   
   
8. QuickSort: Partition (Hand-In)
   
9. QuickSort: Implementing QuickSort
   (Hand-In)

    

10. PCE Feedback (Hand-In)
    (Please focus your feedback on the NUnit-related aspects of these PCEs)

In-Class Exercises:
<Class Date: Wednesday, Nov 5 >

Videos:

1. Intro ("What's due when")
2. BST: Print
3. BST: Patterns
4. BST: Remove (Overview)

Exercises:

1. Discuss the Pow implementations
2. BST: Find, Add by hand
   
3. BST: Add   (coded in C#)
   

Videos:

1. Intro / Overhead

In-Class Activities:

1. Quiz
   
2. JigSaw: 
   Break into groups of four.  Pair up within the group, and have 1 pair solve each of:
   PrintIterative
   PrintBeneathNode
   When you're done, share your answer with the other pair.
   
3. BST: ReverseTree
   
4. Extra Super Challenge:
   Flattening A BST

Notes: PrintBeneath was fairly easy, but has a nice 'compose it out of Find+Print' thing going on.  Perhaps do NOT put these into the PCEs?
PrintIterative was WAAAAAAY too difficult.  It also unbalanced the jigsaw.
What about something like "CopyToLinkedList" - all the data from nodes that meet a certain criteria are copied into a LL?

CIEs:
1.      Go to: http://assessment.cascadia.edu or http://assessment.cascadia.edu/cie/default.aspx

2.      *Enter your SID and Pin #

3.      Select the class from the drop down menu

4.      Click on the Start Evaluation button

5.      Fill out and submit the survey

A2, A3 Surveys: http://www.panitzco.com/CCC/Survey/

Q+A: BST.Remove (also A4)

1. <No exercises for this section>

QuickSort

1. Partition: By Hand

2. QuickSort: By Hand

3. QuickSort: Running Times

4. QuickSort variation: Random pivot
   IDEA: QS by hand: do partition, then circle the side you're working with, then only copy that side into the next row down?
   

MergeSort

1. MergeSort: Merging Arrays By Hand

2. Implementing MergeSort

Videos:

1. Intro / Overheat (Part 1)
2. Intro / Overheat (Part 2)

QS IDEA: Find a couple different implementations, inject errors & get them to find the errors?

OBSER: Very few people caught/fixed the error with left starting 1 too high.

1. 'Starter' project for the lesson 10 PCEs
   
   Slides (using in the following NUnit videos)
   Video: Unit Testing: Overview of Unit Testing, Quick Run-Through of Basic NUnit features
   Video: Using a normal, console project (NOTE: The starter solution has now been fixed, so you no longer need to change the project type to Console App)
   Video: Details of how the NUnit tests are set up
   Video: How to run the tests in the GUI
   Video: How to run the tests under the debugger ; quick introduction to using a debugger
   Video: Generating a gradesheet
   Video: How to submit your (NUnit) based homework
   Video: How to work with the NUnit based starter projects; how your instructor will grade these
   All NUnit video files, .ZIPped into a single file
   
   

2. Preview: MergeSort
   
   

3. Implementing Merge (Hand-In)
   Video: Merge Intuition
   Video: Merge (as typically used in MergeSort)    
   Feedback: Merge can correctly merge into the working array multiple ways (fill from zero, fill from .Length-1, fill a slice that's parallel to the merging slice) - add a 'Check for matching subsection' routine & use that, rather than an exact match.
   IDEA: OSS .Net array utils, a-la PHP?
   
   

4. Implementing MergeSort (Hand-In)
   Video: MergeSort
   Feedback: Wikipedia entry has a nice animation (June 6, 2008)
   IDEA: Also have them do the version that measures the number of comparisons, and then graph those in Excel?
   
   .ZIP OF ALL THREE MERGESORT VIDEOS
    

5. PCE Feedback (Hand-In)

1. Final Exam: Q+A & Review

1. Quiz
   
   

2. Final Exam: Q+A & Review
    

3. MergeSort: PseudoCode  (the Print-Out Version)
    

4. Jeff & Joe's  Mergesort Slides
    

5. MergeSort: By Hand (Time Diagram)
         Time Diagram Example (Excel)
    

6. MergeSort: Western Kentuckey U Sample

1. Post-Course Evaluation

   (Required - this is an online survey, so you won't 'hand in' anything) (You will do this BEFORE you start the final)
   

2. <Final Exam>

The Huge Due Date List

Note: This list is an attempt to collect up in a single spot all the due dates for the term.  These dates may change.  There may be more items added.  It is your responsibility to make sure that you know what's due when, to make sure that you don't miss anything.

In particular, the homework revisions may be moved to a week earlier, if the instructor can return the initial version within 24 hours of the due date.

Due on: (For items due on a Wednesday, the time which they are due by is the start of class, unless otherwise stated)	Activity
Wednesday, Sept 24 (No later than midnight)	Email the professor, so that the professor has your email address
Monday, Sept 29, by NOON	PCE 01
Wednesday, Oct 1	Google Group: Sign yourself up, post a question, answer someone else's question:
Wednesday, Oct 1	PCE 02
Wednesday, Oct 8	A1 (initial version)
Wednesday, Oct 8	PCE 03
Wednesday, Oct 15	PCE 04
Wednesday, Oct 22	A1 (final, revised version)
Wednesday, Oct 22	A2 (initial version)
Wednesday, Oct 22	PCE 05
Wednesday, Oct 29	MIDTERM  EXAM
Wednesday, Oct 29 (no penalty until Nov 5)	PCE 06
Wednesday, Nov 5	A3 (initial version)
Wednesday, Nov 5	PCE 07
Wednesday, Nov 12	A2 (final, revised version)
Wednesday, Nov 12	PCE 08
Wednesday, Nov 19	A4 (initial version)
Wednesday, Nov 19	A3 (final, revised version)
Wednesday, Nov 19	PCE 09
Wednesday, Nov 26	A4 (final, revised version)
Wednesday, Nov 26	PCE 10
Wednesday, Nov 26	Final Date To Hand In Any PCEs, Homeworks (or revisions to homeworks)
Wednesday, Dec 3	PCE 11
Wednesday, Dec 3	FINAL  EXAM

Back to BIT 143's homepage

Unused Lecture Material

BIT 142's Lessons Page

Optional XNA Exercises

    The following tutorials are provided to help you understand the basics of XNA, and the custom XGA1 library that this class will use on top of XNA.  Each tutorial should have a completed, fully functional Visual Studio project that you can download and run, in order to see the final result of that tutorial, plus a detailed explanation of the code in that project.

    Note that NONE of these are required, but you may want to work through them before attempting the XNA/video-game based homework assignment(s) (#3 and maybe #4). Each tutorial has several exercises at the end, and you're welcome to do as many of those as you'd like.  Tutorials that the instructor strongly recommends are marked "Do this", while tutorials that

    Please feel free to discuss these on the Google Group!

1. Do this: Understanding all the parts of a Visual Studio XNA/XGC1 project & seeing the 'Big Picture' of how XGC1 games work
2. If you're curious: How to create a blank XNA project in Visual Studio
   (This walks you through the process of creating a completely blank XNA project in Visual Studio.  Not really needed (since you'll get starter projects for the game-based stuff), but it's always nice to understand "how the magic happens")
3. Do this: Putting messages at the top/bottom of the screen
4. Do this: How to get your game to react to the controller/keyboard
5. If you're curious: Local & Instance variables in XGC1 games
   (This talks about the difference between local variables & instance variables, as used in the video games that you'll see.)
6. Do this: drawing a rectangle on the screen
7. Do this: drawing a circle on the screen
8. Do this: How XGC1 uses constants
9. If you're curious: A good start at a real game: SoccerPong!
   (This tutorial is the 'capstone' for Topic 4 (Decision Structures)  ).  If you're interested in how to put together a game, this will get you started!

If you're curious, there are many more tutorials, designed to teach most the topics that you'll see in this class.  The tutorials were written with a different book in mind, but there is still a page that maps the tutorials to your C# textbook.  That map, and links to the tutorials themselves, can be found at : http://depts.washington.edu/cmmr/Research/XNA_Games/2.XNA_GTC1/Releases/Pre-Release/TextbookMapping.htm