---
title: Eboard 39  Wrap-Up
number: 39
section: eboards
held: 2019-05-08
link: true
---
CSC 151 2019S, Class 39:  Wrap-Up
=================================

_Overview_

* Preliminaries
    * Notes and news
    * Upcoming work
    * Extra credit
    * Questions
* Comments on the final
* The subject matter(s) of the course

Preliminaries
-------------

### News / Etc.

* Sit where you'd like (today and Friday)
   * That's "within reason"
* While we do not have labs or readings for Friday, you are expected 
  to show up.
* I'm working on getting grades to you as soon as I can.  I'll have all
  grades by Monday so that you can decide whether or not to take the final.
* Review sessions for final: This Thursday at 7pm, Sunday at 5pm.
* **DO NOT FILL IN THE END-OF-COURSE EVALUATIONS UNTIL FRIDAY'S CLASS**
    * If you've done so already, please speak with me asap.

### Upcoming work

* No more readings.
* No more lab writeups.
* No more quizzes.
* No more flashcards.
* No more exams (well ...).
* Exam 3 epilogue, if you haven't submitted it already.
* **Now**: Exam 3 cover sheets.
* _Optional_ final, 2:00-5:00 p.m., Tuesday, 14 May 2019.
    * [Sample final](../exams/sample-final) available.

### Extra Credit

_Extra credit is generally supposed to be turned in within three days
of the event._

#### Extra credit (Academic/Artistic)

* **Tonight** Gridshock documentary, 7pm, Wednesday, Strand

#### Extra credit (Peer)

* **Today** Choreography performances: Wednesday, 4:30 p.m. Flanagan Theatre
* Voice Recital, 7:30 pm, May 10, in Sebring Lewis
* Track and Field, Friday and Saturday at St. Norbert
* Women's Golf, May 14-17, Houston, TX

#### Extra credit (Wellness)

#### Extra credit (Wellness, Regular)

* Any organized exercise.
* 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.

#### Extra credit (Misc)

### Other good things 

* **Tonight** Digital Music Making class presentation, 7:30 pm. 
  Sebring-Lewis.  (Rap, noise, pop, more.)

### Questions

Comments on the final
---------------------

* Tuesday at 2pm in this room.
* Different format than most of our exams: 
    * Paper (not computer)
    * 4 problems (not 6)
    * Working Scheme not necessary
    * Kind of "extended quiz"
    * But you do get to bring notes.
* We may include vectors, deep recursion, analysis/efficiency, code reading,
  code writing, lists, sorting, etc.
* In the past, most students who took the final finished in 90 minutes or
  less.
* For most students, the final replaces the lowest exam grade, provided
  it is higher than the lowest exam grade.
* We'll discuss the [Sample Final](../exams/sample-final).
    * You can get to it by selecting **Current** > **Exam**.
   
The subject matter(s) of the course
-----------------------------------

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 "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 151 this semester.  I tend to group them into
categories.  

* I'll describe the categories and give an example for each.
* I'll give you some time to come up with suggestions.  
* We'll then get as many on the board as we can.
* We'll talk through them for a bit.
* I'll probably take photos and record them in the eboard at a later date.

### Problem Solving 

_General strategies for approaching problems, computational and otherwise._

* E.g., We've learned to *decompose* a complex problem into smaller
  problems (subroutines) and then combine those solutions back into
  the broader solution.  For example, in learning how to make some
  kinds of sandwiches, we might also solve the problem of "spread
  stuff on bread".
* Describing a problem helps to find a solution. (Sam says formalizing
  problems helps you think.)
* "Team is better than one" 
* Use pen and paper to think through things
* Pursue better ways to spread stuff on bread
* [Picture of a rubber tree] - It's useful to explain what you are
  doing out loud, even if it's not to another human.
* "Any problem can be solved." (If you stay in CS and take CSC 341, you
  will learn that this is provably false.)
* Understand your resources, mental and physical, before solving a problem.
* Try.
* The Internet can help you solve problems.
* Build upon past solutions.
* Try multiple approaches; don't just stick with your first solution.
* You won't always be given the answer.
* Think step by step.

### The core of CS: Algorithms and data structures

_CS is the study of algorithms and data structures; ways to manipulate
data and ways to organize data._

* E.g., We've learned about the "List" data structure, which organizes
  information in sequential order and which you can visit element by
  element using `car` and `cdr`.
* Using recursion to write algorithms
    * May be dangerous
    * Multiple type
* Hash tables as a way to store information
* You should spend some time understanding the capability of each data
  type.
    * Representation
    * Functions that operate on it
* Lots of data types: Strings, number, list, string, struct, vector, hash, 
  pair, nested list, rock
    * Benefits of each
* Use helpers [+1 ec]
* How to build data structures using struct.
* Searching
* Sorting

### Functional programming

_CSC 151 uses an approach that we term "functional programming" and that
is somewhat distinct from other approaches._

* E.g., "Functions are first-class values": They can be parameters to
  other functions, they can be returned by other functions.  For
  example, `o` is a function that takes two unary functions as
  parameters and returns a new function that applies the two in sequence.
* Recursion as a program design strategy
* Function as a core unit of thinking (something that takes some inputs/params
  and returns a value/result)
* Anonymous functions: We can write and use functions without naming
  them. (lambda)
* Section
* Immutable values (pure): Once you've built a value, it doens't change.
  (Vectors and hash tables are mutable.)
* In most pure functional languages, a function always gives the same output
  for the same input.

### Program and software design

_We've also learned a bit about how you build software (or at least how
you might build software)._

* E.g., Document your code so that others can understand them.
* Don't make things too complex.
* Think broadly about problem before you start implementation
* Format and document to reduce confusion
* Break into smaller parts / use helpers
* Look for patterns
* How to build GUI
* A strategy for writing documetation: 6Ps
    * Preconditions
    * Postconditions
* Husks and kernels
* Divide team work
* Efficiency matters
* Debugging is important

### Scheme and Racket

_We've grounded most of that learning in the Scheme/Racket programming
language.  Along the way, we've learned a bit about Scheme._

* E.g., Scheme's evaluation strategy: Evaluate the arguments, then
  apply the procedure.
    * Some exceptions: `if`, `and`, `or`, `quote`, `cond`, ...
* Debugging
* How to use DrRacket to automatically indent
* How to make shapes
* Approximately 933 different procedures
* (The (joy (of matching (deeply ((((nested)))) parentheses))))
* DrRacket will crash.  Save.
* There's a benefit to having a simple language design
* Tons of shortcuts

### Digital humanities

_We've seen a bit of how computers can serve as a tool in humanistic
inquiry._

* E.g., gathering simple information about a text, such as the most
  common words and how frequently they appear.
* Techniques for marking up text, particularly XML.
* Text generation using right/left neighbors
    * And the joy it brings
* We can use computers to analyze social issues
* You can do cool stuff with only a semester of CS
* RegExp
* Charts are good
* Approach: Sentiment analysis
* Data visualization
* Sequences of numbers may be pointless by themselves.
* Some examples, such as the guest speaker on Mayan Anthro.
* Counting syllables (some things are hard)
* OCR (some things don't work as advertised)
* Approach: Topic modeling
* Exposure to an upcoming field
* Techniques for processing large datasets and what happens when you write
  inefficient algorithms
* Process holistic info
* The computer result is not the final result; it's only a tool for a broader
  humanistic approach

### General skills

_I would hope that most Grinnell classes teach you things beyond the
basic disciplinary subject matter._

* E.g., Practice thinking on your feet.
* Dividing work beteween a team when folks have different skills.
* Working at detailed and big picture levels
* Working with different people (pair/peer/pear programming)
* Collaborate without dominating
* Self reflection
* What to do when Sam gives you more work than you can physically do
  (time management skills)
* How to listen to and interpret other's ideas
* Patience: Try, try again. 
* Seeing patterns
* Organization (in contrast to how Sam approaches the world)
* Simplify work
* Making charts
* Self care
* Presentation
* How to misinterpret instructions

### And beyond

_When I was about your age, my mother, who was a professor of Psychology,
told me that she planned to conduct a study on how faculty serve as moral
models for their students.  I was a snarky young man, so I said something
like "Mom, don't be silly.  While you serve as a moral model to your
students" (and she did), "most faculty are not moral models"._

_But after a few years of teaching, I started hearing from my students
that the way I approach the class does, in fact, provide some models for
how one might approach the world.  I'm still not sure that I'd call it
"moral modeling", but there are things I hope you take away from the
class that go beyond the subject matter and skills._

* E.g., Support those around you; they are amazing people.
* Value of self care.  (And self care can be a lot of fun)
* It's sometimes okay to ignore Sam's instructions
* Correct spelling is sometimes optional.
* Computers are sentient and malicious; when things go wrong, 
  blame them, not yourself.
* Your faculty will punish you for things you think are appropriate.  Deal.
* Set attainable goals.
* Don't be afraid to ask for help.
* There's more to life than CS (or any academic discpline)
* PSA: Moderation
* PSA: Consent
* Web searches can be your friend (?)
* Support those around you.
* Be open about your care for people.
* Laugh.
* Feed others.

### Summary for think/pair/share

* Problem Solving 
* The core of CS: Algorithms and data structures
* Functional programming
* Program and software design
* Scheme and Racket
* Digital humanities
* General skills
* And beyond