Registration Times

• Registration is coming up!

Advising

• Everyone needs an in-major advisor
• Interested in declaring a major in Computer Science or Data Science?!
  • Email registrar@willamette.edu
  • CC myself or whomever you’d like to be your advisor
  • Include your ID #
  • Say which majors you want to declare
    • You can add/drop majors/advisors anytime

Continuing in CS

• If you are interested in continuing with a CS major, in order of urgency, you should be considering:
  • CS 152: Data Structures
    • Two sections
    • Prereq for most other higher CS courses
  • MATH 251W: Foundations of Advanced Math
    • Two sections, but may still fill
    • Has a calculus requirement but can be waived for strong students. Contact the instructor to join in that case.
  • DATA 352W: Data Ethics
    • Not necessary for 3+1 DATA majors

Continuing in DATA

• If you are interested in continuing in or majoring in DATA:
  • DATA 151
  • DATA 152
  • DATA 252: Models and ML
  • DATA 352W: Data Ethics (unless 3+1)
  • MATH 280
    • Talk to instructor about joining if missing calculus

Other Computational Courses

• There are other computational/data courses being offered that you likely meet the pre-reqs for:
  • DATA 275: Data in the Cosmos
  • DATA 399: Topics in Environmental Data Science (Need DATA 151)
  • DATA-199: Lego Robotics at Bush Elementary
  • CS 370: Python for Data Science (Needed for 3+1)
  • PHEAL 214: Epidemiology
  • ENVS 250: GIS

Cryptography

• The science of encoding messages to keep their contents secret–and the symmetric problem of decoding those messages–is called cryptography.
• First recorded cryptographic algorithm attributed to Julius Caesar. The Roman historian Suitonius writes that:

If [Caesar] had anything confidential to say, he wrote it in cipher, that is, by so changing the order of the letters of the alphabet, that not a word could be made out.

• In a Caesar Cipher, each letter is advanced a fixed distance in the alphabet, wrapping around to the start if necessary
  • A +3 Caesar cipher would make the following mappings

Letter Substitution Ciphers

• A letter-substitution cipher (informally called a cryptogram) is a code in which each letter in the original text is replaced with some other letter.
  • The substitution pattern remains the same throughout the message
  • Any letter can be mapped to any other unused letter, no order is necessary
• One of the more famous cryptograms was written by Edgar Allen Poe in his short story “The Gold Bug”
  • Described in his story how the message could be decoded by mapping the most common letters in the message to the most commonly used letters in the English language

World War II

Alan Turing

• One of the most important contributors to computer science is Alan Turing, who made critical contributions in the theory of computation, hardware design, and artificial intelligence
• During WW2, Turing headed the mathematics division at Bletchley Park in England, which broke the German Enigma code
• Tragically, Turing committed suicide in 1954 after being convicted on a charge of “gross indecency” as a homosexual
  • Prime Minister Gordon Brown issued a public apology in 2009

The Enigma Machine

Enigma Rotors

The Enigma Internals

Operation of the Enigma Machine

• Whenever a letter is typed, the following happens:
  1. The force of the key press advances the fast rotor one position. If the rotor wraps from Z to A, this advances the next rotor by one increment as well.
  2. An electric signal is fed into the wire corresponding to the key, which then flows through seven letter-substitution steps
     • Through the fast rotor from right to left
     • Through the medium rotor from right to left
     • Through the slow rotor from right to left
     • Through the reflector, which turns the signal around
     • Through the slow rotor from left to right
     • Through the medium rotor from left to right
     • Through the fast rotor from left to right and on to the lamp

Encoding “A”

Encoding “A” Again

Project 4 Milestones

Model-Controller-View

Modeling

• In the Enigma project, the view and the controller are handled for you
  • Both are actually handled in the same module
  • Both export various methods that you can use to get input or interact with them from within the model
• You are responsible for writing the code that comprises the model
• There is also a constants module, where all of the various constants that you may need are stored

Iterating through a Dictionary

• Frequently we might want to iterate through a dictionary, checking either its values or its keys

• Python supports iteration with the for statement, which has the form of:

  for key in |||dictionary|||:
      value = |||dictionary|||[key]
      |||code to work with that key and value|||

• You can also use the .items method to grab both key and values together:

  • Returns a tuple with both the key and corresponding pair

  for key, value in |||dictionary|||.items():
      |||code to work with that key and value|||

Finding Students by grade

• Suppose we had a file of student ids and corresponding grades on a test

• We want a simple program where we can enter in a target grade and have it tell us all the students who received that grade

  def read_to_dict(filename):
      dictionary = {}
      with open(filename) as f:
        for line in f:
            ID, score = line.strip().split(',')
            dictionary[ID] = score
      return dictionary
  
  def get_students_with_score():
      scores = read_to_dict('SampleGrades.txt')
      done = False
      while not done:
          des_grade = input('Enter a letter grade: ')
          if des_grade == "":
              done = True
          else:
              for st_id, grade in scores.items():
                  if grade == des_grade.strip().upper():
                      print(f"{st_id} got a {grade}")

Common Dictionary Methods

Dictionary Records

• While most commonly used to indicate mappings, dictionaries have seen increased use of late as structures to store records

• Looks surprisingly close to our original template of:

  boss = {
      'name': 'Scrooge',
      'title': 'founder',
      'salary': 1000
      }

• Allows easy access of attributes without worrying about ordering

  print(boss['name'])

• It is still using a mutable data-type to represent something that should be immutable though

Pythonic Sets

• Enclosed within squiggly brackets

• No key-value pairs, just single values separated by commas

  digits = { 0, 1, 2, 3, 4, 6, 7, 8, 9 }
  squares = { 0, 1, 4, 9 }
  primary = { "red", "green", "blue" }

• Set elements must be immutable

• Sets themselves are generally mutable

• Can not create an empty set just using { }!

  • Python assumes this to be an empty dictionary!
  • Must instead use set().

Set Operations

• The fundamental set operation is membership (∈)
  • 3 ∈ primes
  • 3 ∉ evens
  • red ∈ primary
  • -1 ∉ N
• The union of the sets \(A\) and \(B\) (\(A \cup B\)) consists of all elements in either \(A\) or \(B\) or both.
• The intersection of the sets \(A\) and \(B\) (\(A \cap B\)) consists of all elements in both \(A\) and \(B\).
• The set difference of \(A\) and \(B\) (\(A - B\)) consists of all elements in \(A\) but not in \(B\).
• The symmetric set difference of \(A\) and \(B\) (\(A\triangle B\)) consists of all elements in \(A\) or \(B\) but not in both.

Python Implementations

• Python’s built-in implementation of sets supports all these same operations
• Can either use appropriately named methods on sets or operators between sets
• Membership 3 in primes

Venn Diagrams

• A Venn Diagram is a graphical representation of a set which indicates common elements as overlapping areas
• The following Venn diagrams illustrate the effect of the 4 primary set operations

Practice

If we have the following sets from earlier:

What is the value of each of the following:

• evens ∪ squares
• odds ∩ primes
• primes - evens
• odds ∆ squares