Skills

This course will teach the following skills, repeated assessment of which will form the primary source of final grades.

Each skill will be assessed as "Doesn't meet expectations", "Approaching expectations", and "Meets expectations", and students may attempt any skill assessment up to five times (four independently, and once via the bulk assessments, see below), with the best result being used for their grade.

1. Design Basic Functions (Pyret)

   Meets Expectations	• Correct type annotation • Docstring that describes behavior, doesn't repeat type annotation. • A few (2+) correct, meaningfully different tests • Well-formatted, correct implementation:     • may include numbers, strings, if (NOT images)     • minor typos are okay
   Approaching Expectations	• Missing docstring, or long, includes redundant type information, etc. • 1+ correct tests. • Correct implementation.

fun nm-square(n :: Number) -> Number:
  doc: "Multiplies the input by itself"
  n * n
where:
  nm-square(-1) is 1
  nm-square(0) is 0
  nm-square(2) is 4
end

fun nm-square(n :: Number) -> Number:
  doc: "Takes a number as an argument and returns a number. The result is what you get when multiplying the first number by itself."
  n * n
where:
  nm-square(1) is 1
end

2. Construct / Transform Tables (Pyret)

   Meets Expectations	• Function designed has signature, docstring, and at least one test • Function uses correct table function (filter-with, build-column, etc) • Row helper does what is expected, whether defined with lam or named
   Approaching Expectations	• Function uses correct table function (filter-with, build-column, etc) • Row helper accesses fields from row, but not in a way that solves the problem

fun find-scholars(t :: Table) -> Table:
  doc: "Find students not in Boston"

  fun is-scholar(r :: Row) -> Boolean:
    r["campus"] <> "Boston"
  end

  filter-with(t, is-scholar)
where:
  students = table: name, campus
    row: "Ajay", "Oakland"
    row: "Jason", "Boston"
    row: "Lauren", "London"
  end

  result = table: name, campus
    row: "Ajay", "Oakland"
    row: "Lauren", "London"
  end

  find-scholars(students) is result
end

fun find-scholars(t :: Table) -> Table:
  fun is-scholar(r :: Row) -> Boolean:
    r["campus"] <> "Boston"
  end
  
  filter-with(t, is-scholar)
end

3. Iteration: Lists (Pyret)

   Meets Expectations	• Uses for each properly, drawing elements from the list • Mutates a single variable within the loop to correctly accumulate the result • Returns the final result after the loop
   Approaching Expectations	• Uses for each, drawing elements from the list • Either: Mutates within the loop, but in such a way that doesn't produce the correct accumulated answer, or doesn't use the final result properly at the end of the loop

fun list-of-squares(numbers :: List<Number>) -> List<Number> block:
  doc: "produce the squares of the numbers in the input"

  var result = [list: ]
  
  for each(n from numbers):
    result := result + [list: n * n]
  end
  
  result
where:
  list-of-squares([list: ]) is [list: ]
  list-of-squares([list: 5, 6]) is [list: 25, 36]
  list-of-squares([list: -1, 0, 1]) is [list: 1, 0, 1]
end

fun list-of-squares(numbers :: List<Number>) -> List<Number> block:
  doc: "produce the squares of the numbers in the input"

  var result = [list: ]
  
  for each(n from numbers):
    result := result + [list: n * n]
  end
  
  numbers
where:
  list-of-squares([list: ]) is [list: ]
  list-of-squares([list: 5, 6]) is [list: 25, 36]
  list-of-squares([list: -1, 0, 1]) is [list: 1, 0, 1]
end

4. Structured & Conditional Data (Pyret)

   Meets Expectations	• Uses data with variants as needed, fields with appropriate type annotations • Function uses either field projection or cases as needed • Function has signature, doc string, and tests
   Approaching Expectations	• Uses data with variants as needed, fields if needed (possibly missing or incorrect annotations) • Function should use either field projection or cases, but may not do it correctly, or to match the problem

5. Recursion: Lists (Pyret)

   Meets Expectations	• Function has appropriate type signature, doc string, and tests • Function uses cases to handle empty case and link case • In link case, calls function recursively on rest of list appropriately
   Approaching Expectations	• Uses cases to break apart list, and has recursive call to rest of list

6. Recursion: Trees (Pyret)

   Meets Expectations	• Function has appropriate type signature, doc string, and tests • Function uses cases to handle base case and recursive case • In recursive case, calls function recursively on subtrees appropriately
   Approaching Expectations	• Uses cases to break apart tree, and has recursive call on subtrees

7. Variable Scope (Python)

   Meets Expectations	• Output of given code, that uses variables, defined locally, in functions, globally, etc, is correct • Explanation of behavior, including global keyword if needed, is correct
   Approaching Expectations	• Explanation mentions key idea, but does not use it to correctly characterize behavior

8. Design basic functions (Python)

   Meets Expectations	• Correct type annotation • Docstring that describes behavior, doesn't repeat type annotation • A few (2+) correct, meaningfully different tests • Correct implementation
   Approaching Expectations	• Missing docstring, or long, includes redundant type information, etc. • 1+ correct tests • Correct implementation

9. Iteration: Lists (Python)

   Meets Expectations	• Uses for ... in ... properly, drawing elements from the list • Mutates a single variable within the loop to correctly accumulate the result • Returns the final result after the loop
   Approaching Expectations	• Uses for ... in ..., drawing elements from the list • Either: Mutates within the loop, but in such a way that doesn't produce the correct accumulated answer, or doesn't use the final result properly at the end of the loop

10. Aliasing & Mutation (Python)

    Meets Expectations	• Output of given code that uses mutation of values like lists, aliasing, etc, is correct • Explanation of behavior is correct
    Approaching Expectations	• Explanation mentions key idea, but does not use it to correctly characterize behavior

11. Identifying Privacy Issues in Problem Formulation

    Meets Expectations	• Privacy analysis chart is complete and each entry is correct • Identify named privacy issue in a new context • Proposed mitigation strategy is appropriate given context
    Approaching Expectations	• Chart is complete but at least one entry is not correct • Attempts to identify named privacy issue but mis-identifies, or explanation is unclear • Proposed mitigation of known privacy issue would not address the privacy threat

12. Identifying Stakeholders in Problem Formulation

Skill Introduction​

Skills will be introduced in certain weeks (and may be re-inforced in later weeks), via class, recitation, labs, and HW. Each of these will be marked with what skill is being introduced or reinforced by the material.

Skill Assessment​

Assessment of skills can be done at many different opportunities.

Assessable@Hours​

Every week, there will be several special hours held by instructors, course coordinators, or graduate TAs, that exist solely for the purpose of taking assessments. The skills assessable at these hours are those that were introduced the previous several weeks -- see the table below to see what skill is assessable in any given week via this mechanism.

This is intended to allow you several attempts at the skill after the content is introduced, but require you to keep up with the material -- all assessments cannot be deferred to the end of the semester, since only the last few skills can be attempted at the end of the semester.

Skill Days​

Several class days exist as gaps in our schedule, and some of the class may be used to catch up on material, but 30+ mins of class will be used for skill assessments. Instructors will bring a set of assessments -- students are able to attempt any of those available (likely, due to time, 1-2 of them). See the schedule below to see what weeks these occur in, and what skills are assessable during each one.

• Skill Day 1: 1, 2, 11, 12
• Skill Day 2: 3, 4, 5, 11, 12
• Skill Day 3: 6, 7, 8, 9, 10

Skill Bundles​

Finally, there are two bulk assessment slots, which take place during normal lab time, during the semester. These collectively cover all of the skills for the semester, and students are welcome to attempt all of the assessments available -- every student will be given a packet with a set of assessments when they come to the lab session. If they have already completed a given skill, they can skip that one, and if they have already completed all the skills, they are welcome to skip the bulk assessment entirely. The two bundles are:

• Skill Bundle 1: 1, 2, 3, 4, 11, 12
• Skill Bundle 2: 5, 6, 7, 8, 9, 10

Skill Schedule​