When

October 3-7, 2022.

Scope

Programming Languages as a Field of Study, JavaScript, Python.

Ground Rules

You will take the exam on BrightSpace; it will be multiple choice with a 90 minute time limit. You MAY use books, notes, and web searches to look things up. You will not be spied on: there is no browser lock down and hence no need to hide a mobile device in a bag of potato chips. However, you MAY NOT solicit answers in any way. There is to be no asking for help, no posting on forums, no communication with other humans or intelligent bots in any way; you can only “look things up.” You also MAY NOT post answers or help any other test taker either. You are bound by an honor code to follow these rules.

The exam becomes available at 6pm America/Los Angeles time on October 3 and becomes inaccessible at 10pm on October 7. You may complete the exam within any 90 minute period in that window.

Review of the Course Learning Objectives

Step one of your preparation is to remember the learning objectives from the syllabus. Please review them now.

To meet these objectives throughout the course you must gain an understanding of both big picture and low-level questions about programming language pragmatics. You should be able to answer, for particular languages (and for the exam, JavaScript and Python):

• Must a function be called with a specific number of arguments? What if we pass too few arguments? Too many? Can we roll up many arguments into a single parameter?
• Can we (or must we, or must we not) specify the names of the parameters in the call?
• Can we change the value of a parameter within the function? If so, does this action also change the variable holding the argument (if any)? If it does, is the change made immediately or only at the point the function returns?
• Is a parameter of the called function a distinct variable from its corresponding argument, or just an alias for the argument?
• If a complex expression is used as an argument, is it evaluated once before the call? Or evaluated fresh every time the parameter is used inside the call?
• If all arguments are evaluated before the call, in what order are they evaluated? Left to right? Right to left? Arbitrary order? In parallel?
• How do we arrange for the function to return something? Through a special variable? A return statement? Implicitly as the last expression? Some other way?
• Can a function return zero values? Must it return one? Can it return many?
• Are there any restrictions on the types of things a function is allowed to return?
• How do we distinguish between the function itself as a value, and the value resulting from a call of the function?
• Can the function itself (not just its result) be assigned to a variable? Passed as an argument? Returned as a value from another function?
• Can a function call itself? If so, are its variables shared among all invocations or does each invocation have a distinct set of variables?
• Can a function access variables defined outside of the function? If so, must they be explicitly imported or are they available by default?
• Can “local” variables (defined inside the function) be seen by outside code, or are local variables completely private to the function?
• If a function can access “non-local” variables, does it use variable bindings in effect in its caller, or those in effect in the textually surrounding environment?
• If a function can access non-local variables and is passed somewhere where those (non-local) variable names have different bindings, which bindings are used when the function is eventually called?
• Is it possible to test two functions for equality? If so, what does it mean for two functions to be equal?
• Is a function like a regular object, one that we can attach properties to?
• Do functions have to have names?
• Is there or is there not a distinction made between primitive and reference types?
• Is there exactly one numeric type or multiple numeric types? Are integer types divided across signed and unsigned types? Fixed size and unbounded? Modular and saturated? Are there separate types for 8, 16, 32, 64, and 128-bit fixed-size integers? Are floating- point types so divided? Is there an unbounded floating-point type?
• Can a programmer find ratio or decimal types within the language? In the standard library?
• Are characters differentiated from strings of length one?
• Is the length of a string, or of any kind of collection, part of the type?
• Is there a boolean type?
• Are the basic types like numbers, booleans, and strings, wired so strongly into the language that reserved words define them? Or do they simply live in a standard library like all other user-defined types?
• Can the programmer obtain the type of an expression via a function call, method call, or typeof operator? If so, is the response just a string naming the type, or a first-class type object?
• Are types distinguished from classes?
• Can types have supertypes? If so, more than one? If so, how is the inherited behavior determined in the presence of name conflicts?
• Can we add new types?
• Can we conveniently make both sum and product types? Are there tagged or labeled versions of each (i.e., regular vs. tagged unions, tuples vs. records)?
• Do function objects have types? Is the return type part of the function type? What about the types of the parameters? Is the order of parameters significant in determining the function type? What about the modes of the parameters?
• Can we define parameterized types? If so, are they parameterized only by other types, or by arbitrary values?
• Are types first-class? Are type variables allowed? If so, can they be...assigned?
• If types are objects, are all types instances of a single type (perhaps called Type)? Do type classes exist in the language? If so, can a type belong to more than one type class? Can a programmer define new type classes?

This is just a tiny number of the questions we can ask.

What We Have Learned So Far

We began the course with a look into how one studies programming languages, including how languages are classified and to what extent they support or do not support various programming paradigms.

Then we began our tour of programming language concepts with deep dives into JavaScript and Python. In addition to language history we uncovered and practiced many technical linguistic aspects. Here is a small subset of things we learned:

	JavaScript	Python
First Appeared	1995	1991
Designer	Brendan Eich	Guido von Rossum
Versions	ES2015 and later is “modern” JS; we use ES2022 in this class.	Python 2 is no longer supported! We use Python 3.10.
Recognized For	First-class functions, prototypes	Wonderful expressiveness
Notable Uses	Webapp clients, asynchronous servers	Web servers, scripting, data science
Six words or less	The assembly language of the web	Easy to learn and extremely productive
REPL	node	python
Runs command line scripts	Yes	Yes
Can be hosted?	Yes (in browser, usually)	Not designed to be
Typing Systems	Dynamic and Weak	Dynamic and Strong
Dynamic Types	Technically only 8, cannot create more, but “faked” with constructors	Dozens built-in, user can create infinite number of new types
Static Typing	Not exactly, as TypeScript is considered a different language	Yes, but type hints are ignored at run time
Distinguishes primitive and reference Types?	Yes	No, everything is an object (BEAUTIFUL)
Getting the type of an expression	typeof (operator, funky) or .constructor	type
Types are....	just kind of there, they surface as strings with typeof	really objects!
What’s falsy?	undefined, null, false, 0, NaN, empty string	None, False, numeric 0, empty sequences, empty mappings, instances of classes where __nonzero__ or __len__ return 0 or False.
Objects vs. Dictionaries	Kind of conflated, but there is a built-in Map	Very different. Dictionaries have type dict, objects are instances of a class
Objects have	properties, keyed by strings or symbols or numbers	attributes
Object philosophy	Prototypes	Classes
Getters	get	@property
Can properties / attributes be added to existing objects?	Yes	Yes
Syntax Grouping	Curly braces	Indentation
Statement separator	; but language uses weird algorithm to add them if you forget them	; if multiple statements on same line, otherwise newline unless inside of delimiters or triple-quoted string literals.
Local variable declarations	Declare with let or const (legacy var also supported)	Just assign to a variable in function; it will be be local unless a nonlocal or global declaration for the identifier preceded it.
Parallel assignment?	Through array pattern match	Yes (no delimiters needed)
General destructuring	Yes	Only in match statement
Increment and decrement operators?	Yes	No!
Multiline strings	Delimited with backticks	Delimited with triple quotes
Package Ecosystem	npm	pip
Common unit testing framework	mocha	pytest

Interested in more comparisons? Check out the the first two columns of this page. Woah, how useful was THAT?! (Very useful, but be careful because in some areas it might be out of date.)

What other similarities and differences can you think of?

Format of the Exam

An ideal assessment of your understanding of programming language concepts would examine (1) your ability to articulate these concepts as expressed in the design of JavaScript and Python, and (2) your ability to articulate the similarities and differences between JavaScript and Python in their implementation of these concepts, through an oral exam. However, given the the number of students, this assessment will be on your recognition and evaluation of concept expression in the form of multiple choice and similar questions.

At some point during the exam window, find the quiz on BrightSpace and take it. You will have 90 minutes to complete it. Upon submission you should receive feedback and your score will be recorded in the gradebook.

How to Study

Review your answers and my answers to the first two homework assignments.

Do the reinforcement problems relevant to the material within the scope of the exam.

Keep in mind that our (world’s) knowledge culture is far more literary than oral, so read, or reread:

• The Preface, Chapter 0, Chapter 2, and Chapter 4 of the textbook, because fluency in JavaScript and Python is indispensible in being able to express and describe the programming language concepts being assessed on this exam.
• The JavaScript and Python course notes.
• A few of the linked resources mentioned in the course notes.

You have to put in the time for effortful self-study. Although the exam is open resources, you will not have time to look everything up. Those who come in with a strong comfort level with the material will finish on time. I am assessing your fluency and your proficiency with the material, not your Google-Fu.

Sample Problems

What does the following JavaScript function return when called (assuming url is actually a real url that actually returns real data)?

function mystery() {
    return fetch(url).then(r => "woohoo").catch(e => "aw snap")
}

1. A string
2. A promise
3. Nothing, it throws an error
4. undefined

What is the proper Python list comprehension that replaces the code fragment below?

a = []
for x in first_range:
    for y in second_range:
        if x >= y:
            a.append(y // x)

1. [y // x for x in first_range for y in second_range if x >= y]
2. [y // x if x >= y for x in first_range for y in second_range]
3. [y // x for x in second_range for y in first_range if x >= y]
4. [y // x for x in first_range if x >= y for y in second_range]