CSC 207.01 2019S, Class 40: Wrapup
- Notes and news
- Upcoming work
- Extra credit
- Final PSA
- The subject matter(s) of the course
- Course evaluation
- Final notes
- Notes on the final
News / Etc.
- Sit where you would like.
- I’m working on getting grades to you as soon as I can. I’ll try to
have all grades in by Tuesday. (May not include HW8.)
- I’ve finished grading all of the “on time” exam 2’s. I’ll return those
at the end of class. (I don’t want better EOCEs for high grades, or
worse EOCEs for low grades.)
- There are still some people who have not turned in exam 2. Please do
not discuss it with anyone. (If you want to discuss it with someone,
please check with me first to ensure that both of you have turned it
- Review sessions for final: TBD. Tentatively Wednesday.
- Solution to quiz grading issue: 10% of your grade is the largest of
(a) your quiz grade, (b) your average exam grade, (c) your grade on
- Final exam: 9am or 2pm, Thursday or Friday of finals week.
- Let me know which of the four times you plan to take the final.
- Today May 10, 2pm, Science 2022,
An Exploration of Torsion of Elliptic Curves over Cubic and Quartic Fields.
- Tonight May 10, 7:30pm, Voice Recital, Students of N. Miguel
- New May 12, 6:30pm, A Capella Concert in the Rotunda
- Any organized exercise. (See previous eboards for a list.)
- 60 minutes of some solitary self-care activities that are unrelated to
academics or work. Your email reflection must explain how
the activity contributed to your wellness.
- 60 minutes of some shared self-care activity with friends. Your email
reflection must explain how the activity contributed to your wellness.
Other good things
- Tonight Dance MAP, 4:30 pm, Flanagan
Final PSA of the semester
- Don’t let the stress of finals’ week negatively affect you.
- Get enough sleep.
- If you decide to shut off your brain with substances, do so in moderation.
- Don’t let academic honesty become an issue; our decision-making becomes
less good at this time of the semester.
- Consent is essential.
How long did people spend on exam 2?
Here’s the data for those who turned it in on time.
P1 P2 P3 P4 Total (Hours)
Min 30 30 30 30 175 2.9
Max 240 210 360 210 900 15.0
Ave 114 98 119 96 428 7.1
Median 99 98 98 90 368 6
Why the variance?
The person on the low end writes a lot of code for fun. The one on the
high end spent three hours on a bug having to do with
Will there be questions on object-oriented programming and design on the
I’m not inclined to add a sixth question. But I am likely to include
to OOP and design issues in other questions.
The subject matter(s) of the course
I thought it would be useful to get an overview of what we’ve learned
on the board. In part, that will help you study for the final.
In addition, the end-of-course evaluations have five questions that read
“blah blah blah helped me understand the subject matter of the course”.
When we first started using College-wide EOCEs, I asked “How will students
know what the subject matter of the class is? After all, students call
CSC 151 ‘The Scheme Course’, even though our primary focus is functional
problem solving, and CSC 152 ‘The Java Course’, even though its focus
is algorithms and data structures.” The response was “You can tell them.”
But that’s not my style.
So we’re going to collaboratively develop a list of things you may
have learned in CSC 207 this semester. I tend to group them into
- I’ll describe the categories and give an example for each.
- I’ll give you some time to come up with suggestions. (Each group should
come up with a few for each category.)
- We’ll get as many on the board as we can. Each group should make sure to
add at least one to each category.
- We’ll talk through them for a bit.
- I’ll probably take photos and record them in the eboard at a later date.
- E.g., Lists (things you can iterate)
- PUM - Philosophy, Use Case, Methods - A way to think about ADT Design
- (Block chain)?
- Priority Queues
- E.g., ArrayBasedLists (lists stored in arrays)
- LIA - Layout, Implementation, Analysis
- Ways to organize info in a DS: Linked structures and array-based structures
- Heap (binary heap)
- Hash tables (probing and chained)
- Linked lists (singly, doubly, circularly, blockchainy)
- Binary search treees
- Implementations of graphs (adjacency matrices, edge lists)
- Sorted lists / arrays
- Array based implementations of basic linear structures
- Linked implementations of basic linear structures
v1 v2 v3 v4 v4
- E.g., Quicksort
- Merge sort (bottom up and top-down)
- Bubble sort (in some cases)
- Heap sort
- Selection sort
- Graph algorithms
- Traversal (tree and graph)
- Dutch national flag
- Some related to individual data structures
- E.g., remove from BSTs, add/remove from probed hash tables
- Algorithm techniques
- Deep recursion (tree recursion)
- Simulating recursion with stacks
- Brute force
- Approach one (top-down): Divide into two halves, sort halves, merge together
- Approach two (bottom-up): Merge neighboring values into sorted pairs,
merge sorted pairs into sorted four-tuples, merge sorted quadruples into
sorted octuples, … (Iterative, rather than recursive.)
- If Sam remembers correctly, a variant of this is part of the legendary
- E.g., Big-O notation, formalized
- Loop invariants
- Modeling costs of operations
- Recurrence relations
- Really hand-wavy proof by induction
- Some important sums
- (1 + 2 + 3 + … n) = n(n+1)/2
- (1 + 2 + 4 + 8 + … 2^n) = 2^(n+1) - 1
- (1 + 1/2 + 1/4 + 1/8 + …) = 2, more or less
- Rules of big O
- E.g., The Iterator pattern
- Inheritance - Code reuse through “A is a B”
- Parameteric polymorphism - Code reuse through parameterized types
- Subtype polymorphism - Code reuse through functions
- Patterns: Wrappers
- E.g., Git basics
- Debugging in Eclipse & “sometimes print statements are better”
- Dealing with crappy software (e.g., “String is not visible”)
- Packages and project structure
- Testing & experimenting
- Putting stuff in tarballs
- Code reading
- Standard styles
- E.g., Anonymous inner classes
- Generics - An implementation of parametric polymorphism
- “Java is your nanny” - Dealing with a language that doesn’t trust you.
- Functional programming in Java
- Testing with JUnit
- Thinking with references (yay state)
- Flush your output
- E.g., “Thinking on your feet”
- E.g., Working with others
- E.g., Coping with too much stress and work (i.e., time management)
- How to collaborate on stupid tasks when the instructor tells you
to do so.
- Reinforcement of general problem solving skills.
- Ways to explain complex things (or at least practice doing so) (or
“how not to” from Sam’s examples)
- Reading academic papers and extracting key issues
- Some faculty are softies and will give almost arbitrary extnesions
- E.g., Drawing can help you understand structures and state
- Diagramming data structures
- Diagramming stack and heap
- Real-world applications of computing
- Oxymorons (Sam’s jokes)
- It’s not enough to understand the big picture; you have to get the
Evaluation forms may be found at https://grinnell.smartevals.com.
End-of-course ratings enable you to give responsible feedback for your
professors, and the information you provide enters into future contract
reviews. The agree/disagree responses will be tallied to produce frequency
reports. The instructor will be able to review your unidentified comments
within the electronic course evaluation system. Please note that the
scale starts with “Strongly Disagree” at the top. Be careful not
to inadvertently reverse your responses. Please provide comments
but do not write your name in the comment boxes. Instructors receive the
unidentified, completed forms only after grades have been submitted to
Notes on the final (if time)