CS52 - Spring 2017 - Class 1

Example code in this lecture


Lecture notes

  • PERM list, etc.

  • CS51, CS52 and CS62: how it all fits together
       - Who should be here?
          - taken CS51
          - taken AP CS
          - something similar and have gotten approval from a CS faculty member

  • course overview
       "The goal of this course is to give you a broad view of Computer Science, including: algorithms and complexity, computer architecture and organization, programming languages with a solid understanding of functional programming and recursion, and finite automata and computability."

  • Course web page: http://www.cs.pomona.edu/~dkauchak/classes/cs52/
       - Use Piazza (I'll have you all registered by the end of the day)
       - Mentor sessions
          - Use them to get help *if* you get stuck
          - These are NOT required
          - Work before coming to the session
          - The earlier sessions will be *much* less crowded and you'll get better support
       - Course readings
          - No official book, but many you can use to supplement (You should find one that you like)
          - Won't be extensive reading, but do read the handouts as I suggest
       - Course schedule

  • Administrative: http://www.cs.pomona.edu/~dkauchak/classes/cs52/administrivia.html

  • Academic honesty and collaboration
       - I take it very seriously!
       - Read the administrative handout
       - Read the CS department policy
       - Understand what is appropriate and what is not!
       - I want you to be able to talk with other students and support each other. I also want the *assignment* work submitted to be your own.
       - Some things to watch out for:
          - Don't procrastinate!
             - One of the common ways I've seen people get into trouble is by not leaving enough time to work on the assignment.
             - If you find yourself in this situation, just turn in what you have and take it from there.
          - Do not give your work to anyone!
             - It doesn't help them.
             - It doesn't help you (and can get you into trouble).
          - Understand what type of collaboration is ok and what type is not.
             - You MAY:
                - Use/copy ANY of the examples covered in class or in the readings (in fact, you're encouraged to!)
                - Look at and work through examples from class with a partner or group
                - Talk about issues raised in the reading with a partner or group
                - Talk at a high-level (i.e. NO CODING) about the assignments with a partner or group
                - Help someone with a syntax problem (i.e. code won't compile)... this is the only time you should look at someone else's code
                - Help someone understand an error message
             - You may NOT:
                - look at anyone else's code to help yourself
                - give or show your code to anyone else (except to help diagnose a syntax problem)
                - search online for answers, solutions, etc.
                - sit next to someone while working that you are talking with about the assignment (ideally, just don't sit next to anyone who's in the class)

  • Assignment 0
       - Posted and due Friday at 5pm
       - If you've never taken a CS class at Pomona, you should have gotten an e-mail with account setup. If not, stop by the office of Corey LeBlanc in the back of Edmunds 227.

  • laptops
       - You have access to all of the CS labs. They have SML, Aquamacs, etc. installed
       - You may also use your laptop for this class, but you'll have to set it up with SML and a few other things installed.
          - This is your responsibility.
          - I'll post some notes on how to do it, though sometimes there are challenges.
          - We'll have a session on Wednesday night to specifically help with this. If you're planning to use your laptop try and set it up before the session. If you can't get it to work, plan to attend the session.

  • Two ways of interacting with SML
       1) the interpreter
          - Type commands and get back results
          - Nice for testing things out and doing simple things
          - I'll use this a lot in class
       2) by editing a file and then running in the interpreter
          - Much more useful when writing actual programs
          - Same as if you'd typed the commands into the interpreter

  • To start SML you first open Terminal, which is a shell
       - What can you do in the shell?
          - almost everything you can do with the GUI (i.e. the windows environment)
          - navigate the file system
          - edit files
          - run programs
          - ...
       - then just type sml and you'll see:
          Standard ML of New Jersey v110.69 [built: Mon Jun 8 23:24:21 2009]

          (The dash is the statement prompt from SML, though I'll often use '>' in my notes)

  • Your first SML function
       > fun add1 x = x + 1;
       val add1 = fn : int -> int

       - The syntax for declaring a function is:
          fun <name_of_function> <arguments> = <function_body>;

          - it looks a bit more like declaring a mathematical function
       - What do you think: "val add1 = fn : int -> int" is?
          - This is the response from SML saying that it has defined a new value
             - The responses can always be broken down as follows:

                val <variable_name> = <value> : <type>
          - The name of the value is add1
          - fn tells us it's a function
          - int -> int is the type of the function
       - This already tells us some interesting things about SML:
          - functions are "first-class entities" in SML. They are treated like any other *value* in the language (ints, strings, etc.)
             - they can be stored to variables
             - they can be passed as arguments to other functions
             - they can be returned from functions
          - int -> int
             - this says that the function takes an integer as a parameter and returns an integer
             - How did SML know this?
                - Everything in SML has a type
                   - this is called a "strongly-typed" language
                   - values have a type
                   - functions, therefore, also have a type
                   - operators (like +, -, *, etc.) have a type as well
                - SML has a *very* good type inference system
                   - + we know is used on numbers
                   - therefore, x must be a number
                   - therefore the function both takes and returns a number
  • Using a function
       - Once we've declared a function, we can use it
       > add1 10;
       val it = 11 : int

       - As before, the response from SML can be broken down:
          - name of the variable: it
             - what do you think "it" is?
                - name for the previous statement when we don't assign it to a value
                   - can actually use it if you'd like in the next statement
          - value is 11
          - type of the value is int
          - get used to looking at the response and understanding it!

       - Anything interesting about how we called the function?
          - no parentheses!
             - we could have added them, but for style reasons we won't put them in
          - like Java, we will terminate all statements with a semi-colon

  • The power function
       - We'd like to write a function called power that takes two numbers, n and k, and produces n^k
       - Write this in Java, recursively:
          public static int power(int n, int k){
             if( n == 0 ){
                return 1
                n * power(n, k-1)
       - look at the power function in power.sml code
          - now I'm using Aquamacs (an Emacs editor) to view the file
          - like before, we use fun to define a new function
          - what's different?
             - we're not using if/else like in Java
          - SML uses "patterns" to match different input cases
             - it can do many things, like match constants (e.g. 0), but not everything (e.g. match all negative numbers)
             - pattern matching starts at the top and works down. When it finds one that matches, it executes that code and only that code
                - for example, the order in the power function *does* matter. If we'd put (n,k) first, the (n,0) case would never be reached

  • Using the function
       - We can type this (or copy and paste this) into the SML window and we get the following response:
          val power = fn : int * int -> int

       - Anything new here?
          - the input type to the function is "int * int"
             - this is called a "tuple"
                - a tuple is a combination of two or more values
                - they are defined by putting comma separated values inside parentheses
                   > (1, 2);
                   val it = (1,2) : int * int
             - the function only has one input
                - in fact, technically, all functions in SML only have one input!
       - to call it we give it a tuple:
          > power (10, 2);
          val it = 100 : int