Formal Language:
  Regular expressions: 
    operators: concatenation, alteration, Kleene's closure
    finite state automaton (state transition diagram)
    pattern matching --
        given a regular expression, what statements will match (be accepted)
  BNF:
    terminal, non-terminal, start symbol, production
    operators: concatenation, alteration
    expression grammar (for operator precedence,
                        for operator associativity)
                        for binary operators and unary operators
    deriving a legal statement from a grammar, AND checking if a statement is legal
      (parse (or derivation) tree form, sentential form)

Expression tree (especially vis a vis derivation from expression grammar)

Binding times

Variables:
  Meaning of: name
              scope
              lvalue (address)
              rvalue (content)
              lifetime
              type
  (Note, lvalue, rvalue questions may be framed using C syntax)
  
  Lost object, Dangling reference
  
  Static scope, dynamic scope
  Implementing static scope or dynamic scope using the run-time stack and stack frames
  
A compiler:
  The phases: lexer, parser, code generation
  The symbol table and how it is created and how it is used by the compiler
  
Variable types:
  Implementation of floating types
  Composite types (addressing and size):
      record, array
      
Parameter passing protocols:
  call-by-value, call-by-value/result, call-by-reference, call-by-name
  passing subroutines: deep binding, shallow binding
  
Concurrency -- using the Java implementation of threads
  what is a Thread? What is a Runnable?
  the run() method
  sleep()
  join()
  synchronized()
  
  understand the sample thread code given in class from:
    http://www.tutorialspoint.com/java/java_multithreading.htm
    https://www.tutorialspoint.com/java/java_thread_synchronization.htm
    https://www.tutorialspoint.com/java/java_thread_communication.htm
    http://emunix.emich.edu/~haynes/341/fa17/Concurrency/tenthreads.java
  
There will be no Haskell questions.

There may be C questions, but only addressing rvalue/lvalue.
    int x = 0, y = 1;
    int *p = &x, *q = &y;
    int z = *p + y;           // what is rvalue of z
    
    x = 3 * y + *q;           // for 'x' use its (choose one): rvalue, lvalue
                              // for 'y' use its (choose one): rvalue, lvalue 
                              // for 'q' use its (choose one): rvalue, lvalue 
                              
There will be question(s) in Java addressing concurrency.