LMU ☀️ CMSI 3801
LANGUAGES AND AUTOMATA I
Practice

Reinforcement Questions

Do you like spaced repetition learning? Have you used Anki or Quizlet? Whether or not spaced repetition works for you, periodically working on flash-card like questions can be a lot of fun, and just may help you retain information. Here are a few problems tied to the course material. Visit them periodically, and feel free to use them in your own spaced repetition learning practice!

Most of the reinforcement questions here deal with language-independent concepts. You should also practice with the language-dependent questions as well.
  1. Programs are a form of ________________ just like novels, short stories, technical manuals, wikis, screenplays, essays, dialogues, articles, and poetry.
    Literature, writing, or written expression.
  2. “If statements” are a form of ________________ and “while statements” are a form of ________________.
    conditional execution; iteration.
  3. What programming language did Alan Kay demo in his 2013 Video Programming Languages and Programming?
    I’m not telling you. Watch the video. It is worth your time. If you watched the video, you know.
  4. What are three main aspects of the study of programming languages?
    (1) Learning specific languages, (2) Learning language-independent concepts, and (3) Learning mathematical formalisms for the description of languages.
  5. When studying individual languages what we must always keep in mind?
    The reason why the language was designed, which is often a particular problem domain for which it was intended to operate in.
  6. Name at least five conceptual areas in the study of programming languages.
    Possible answers include: Binding, Scope, Evaluation, Control Flow, Typing, Procedural Abstraction, Data Abstraction, Modularity, Concurrency, and Metaprogramming. There may be others.
  7. What are three of the most popular programming languages created in the 1950s? What was the primary domain of each?
    Fortran for scientific computation, Lisp for artificial intelligence, and COBOL for business.
  8. What “revolution” in programming characterized the 1970s?
    Structured Programming.
  9. What programming paradigm started taking over the world in the 1980s?
    Object orientation.
  10. What “movements” brought back interest in functional programming in the early 21st century?
    (1) The rise of multicore processors, and (2) the rise of big data.
  11. In Bret Victor’s The Future of Programming, what are the four “predictions” his 1973 persona predicted for 2013 that never really took hold?
  12. Syntax deals with ________________ and semantics deals with ________________.
    structure; meaning.
  13. What are some concerns of programming language pragmatics?
    Possible answers include:
    • most suitable application areas of a language
    • comparisons between languages
    • idioms
    • performance
    • expressiveness
    • libraries and ecosystems
  14. Name at least five technical criteria on which to evaluate programming languages.
  15. Name at least three non-technical criteria on which to evaluate programming languages.
  16. What are some of the major types of programming languages?
  17. What are ways that we normally distinguish “system languages” from “application languages”?
  18. How do machine languages differ from assembly languages?
  19. What are the “two kinds” of languages identified by Ousterhout? Suggested by Kay? Joked about by Stroustrup?
  20. What is the difference between imperative and declarative programming?
  21. What characterizes the structured programming paradigm?
  22. What characterizes the object-oriented programming paradigm?
  23. What characterizes the functional programming paradigm?
  24. What is a binding? What, specifically is getting bound to what?
  25. What is the difference between a declaration and a definition?
  26. What is an assignable? How does assignment differ from binding?
  27. Distinguish aliasing from polymorphism.
  28. Show how pointers give rise to aliasing.
  29. What are static storage, stack storage, and heap storage, and what goes in each?
  30. What is it called in C if an entity outlives all bindings to it? What happens in Java, Go, or Python when an entity outlives all bindings to it?
  31. What is it called in C if a binding outlives its bound entity?
  32. How does Python prevent a binding from outliving the entity it is bound to? How does Rust prevent this from occurring?
  33. What is a free variable?
  34. What is the difference between deep binding and shallow binding?
  35. What is meant by the scope of a binding?
    The region of the program text in which a binding is in effect.
  36. What is the technical term for a binding hiding a previous binding with the same name?
  37. What is the difference between static and dynamic scope?
  38. What would this program output under (a) static scope rules and (b) under dynamic scope rules? 
    var x = 2;
function f() { print x; }
function g() { var x = 5; f(); print x; }
g();
print x;
  39. What does this script print under (a) static scope rules and (b) dynamic scope rules? 
    var x = 1;
function f() {return x;}
function g() {var x = 2; return f();}
print g() + x;
    (a) 2, (b) 3
  40. What does this script print under (a) static scope rules and (b) dynamic scope rules? 
    var x = 100;
function setX(n) {x = n;}
function printX() {console.log(x);}
function first() {setX(1); printX();}
function second() {var x; setX(2); printX();}
setX(0);
first();
printX();
second();
printX();
    Static scope rules result in an output of 1122, while dynamic rules result in 1121. This is because with static scoping, the second execution of setX changes the global x to 2, so that the last printX in the script prints 2. With dynamic scope, the second setX call changes the local x to 2, leaving the global x unaffected.
  41. Why has no (major) language combined static scope and shallow binding?
  42. What is the temporal dead zone?
  43. Distinguish Python, JavaScript, and Ruby's approaches to updating non-local variables.
  44. What is the difference between the way JavaScript and Rust handle the sequence: 
    let x = 3;
let x = 3;
  45. What programming language feature practically destroys the sole argument in favor in dynamic scope?
  46. What are the two main approaches to implementing dynamic scope, and what are the advantages of each?
    (1) The association list, which is efficient when entering and leaving scopes, and (2) the central reference table, which performs lookup efficiently.
  47. What is the difference between an expression and a statement?
  48. What is operator precedence? What does is mean for operator O1 to have higher precedence than operator O2? Give a precise example.
  49. What is operator associativity? What does is mean for an operator to be left associative? Right associative? Non associative? Give precise examples for each.
  50. Evaluate, if possible, the expression in -2**2 in JavaScript and Python. Explain why the evaluation produced the value it did in each language.
  51. Why would a language define an evaluation order for expressions? Why would it choose to leave the evaluation order undefined?
  52. How can the expressions a+(b-c) and (a+b)-c produce different results?
  53. What is a short-circuit operator?
  54. What are Lvalues and Rvalues?
  55. What does the following script output under lazy evaluation? Under eager evaluation? 
    let x = 5
function f() { x = x * 3 }
function g() { x = x * 5 }
function h(a, b) { return a + x }
print(h(f(), g()))
  56. How is a macro different from a function?
  57. What is an expression-oriented language?
  58. How did Go “fix” the most unintuitive aspect of the C (and inherited by C++, JavaScript, Java) switch-statement?
  59. Why is it that the simple act of doing an operation 10 times so easy in Ruby but so annoyingly complex in C-like languages?
  60. What is tail recursion and why is it useful?
  61. What is the non-deterministic statement of Go? Of Erlang?
  62. What is the algebraic definition of a type?
  63. What does it mean for a type to be extra-lingual?
  64. How does one query the type of an expression at run time in JavaScript? Python? Ruby?
  65. What are the main differences between a type and a class?
  66. What is a mixin?
  67. Why to languages like Ruby have a single type Array but in other languages like Java, Rust, and Swift there exist many parameterized array types?
  68. What is an eqtype? A comparable type? A bounded type?
  69. What is a monoid?
  70. Type checking is often concerned less with whether two types are identical, but rather when elements of one type T1 can be assigned to an Lvalue constrained to be of type T2. In what situations is this check made?
    (1) variable initialization, (2) assignment, (3) passing arguments to parameters, (4) returning from a function.
  71. What are three primary situations in which a type A is compatible with type B?
  72. What is the difference between type conversion and type coercion?
  73. In the conditional expression x ? y : z of a typical statically-typed language, what type checking and inference rules would a compiler be required to enforce?
    Checks: the type of x must be boolean and the types of y and z must be compatible. Inference: the type of the entire expression is the least general type of both y and z.
  74. In what sense is the type inference capabilities of ML and Haskell more powerful that that on Go, Rust, Java, and Swift?
  75. Why (do you think) does Java not infer the types of parameters in normal methods but does infer them for lambdas?
  76. What is the difference between strong typing and weak typing?
  77. What is the difference between static typing and dynamic typing?
  78. Classify the following languages as either Static+Strong, Static+Weak, Dynamic+Strong, or Dynamic+Weak: C, JavaScript, Java, Python.
  79. Why is the combination of static typing plus weak typing the worst of the four possible combinations?
  80. I couldn't find in the definition of C whether the language employs shallow or deep binding. Why?
  81. What are covariance, contravariance, and invariance?
  82. What is a dependent type?
  83. How are rational types different from integers or floats? Why are they needed?
  84. Given the types A = {1, 2, 3} and B = {'a', 'b'}, what are the types A+B and A×B?
  85. Untagged product types are usually called ________________. Tagged product types are usually called ________________. (There are two good answers for the latter; one starting with “s” and one starting with “s”.
  86. Tagged sum types are often called ________________.
  87. What is the most popular language with untagged sum types?
    TypeScript.
  88. Is an option type a kind of sum type? Why or why not?
  89. In what way is a struct like a dictionary? In what why are they different?
  90. What does it mean for a struct or dictionary to be ordered?
  91. What mechanism do many languages use to avoid unions?
  92. What is the difference between an array and a list?
  93. If someone talks about static arrays and dynamic arrays, what are they probably referring to?
  94. What is the difference between a string and a symbol?
  95. How do Go and Rust differ (if at all) in their interpretation of the length of a string?
  96. What are pointers for?
  97. Even though Java and JavaScript don’t have explicit pointers, knowledge about references is crucial, why?
  98. What is a memory leak?
  99. What is a dangling pointer?
  100. How do C++, Rust, and Swift deal with their lack of tracing garbage collection?
  101. What is the difference between a subroutine and a coroutine?
  102. What is the difference between a parameter and an argument?
  103. What are the two main ways of associating an argument with a parameter?
  104. What is a default parameter?
  105. What does it mean for a subroutine to be variadic?
  106. What is a rest parameter?
  107. JavaScript and Erlang functions are defined with something more sophisticated that simple parameters. What is this powerful concept and how is it more sophisticated?
  108. Explain the three semantic mechanisms for argument passing (in, out, and in-out).
  109. Explain the following five pragmatic mechanisms for argument passing (value, value-result, reference, name, pure-aliasing).
  110. Why have some languages created “generic” subroutines? Isn’t this whole concept unnecessary given the more general concept of parameterized and dependent types? Why or why not?
  111. What is a closure?
  112. What does functional programming try to eliminate or at least minimize and completely isolate?
  113. What are the three big advantages to removing side-effects?
    1. Thread safety
    2. More opportunities for compiler optimizations
    3. Ease of proving code correct
  114. Why do languages that try to be as functional as possible not have for-loops? What functions does one use instead?
  115. Where did the original idea of object-oriented programming come from?
  116. Alan Kay said, in a letter to Stefan Ram, “OOP to me means only ________________, local retention and protection and hiding of ________________, and extreme ________________.”
  117. The two major approaches to OOP are characterized by ________________ and ________________. Which of the two is more associated with Plato and why?
  118. What might have caused the proliferation of getter and setter methods in languages like Java and C# that purport to be object oriented? What are the arguments as to why getters and setters are evil?
  119. How does concurrency differ from parallelism?
  120. A coroutines an example of parallel computation? Why or why not?
  121. Explain the difference between the Erlang-style and the Go-style of process communication.
  122. Explain the difference between modeling concurrency with threads and modeling concurrency with an event queue.
  123. What is a race condition?
  124. What are deadlock and starvation?
  125. What do the terms safety and liveness refer to in a concurrent system?
  126. What is it about Ruby that make its metaprogramming facilities among the most powerful and expressive of all major programming languages?

Problems

Here are some problems that require some thinking, and some actual work. They may involve writing little scripts, or making sketches. They aren’t exactly short-answer problems.

Syntax

  1. Translate the following expression into (a) postfix and (b) prefix notation, in both cases without using parentheses: 
    (-b + sqrt(4 × a × c)) / (2 × a)
    Do you need a special symbol for unary negation? Why or why not?
  2. JavaScript's implicit semicolon insertion is often considered to be poorly designed because the following four cases aren't exactly intuitive: 
    function f() {
    return
       { x: 5 }
}

    let b = 8
let a = b + b
(4 + 5).toString(16)

    let place = "mundo"
["Hola", "Ciao"].forEach((command) => {
  console.log(command + ", " + place)
})

    const sayHello = function () {
    console.log("Hello")
}
(function() {
    console.log("Goodbye")
}())
    What is being illustrated in each of the above? Go, Python, Scala, and Ruby all allow line endings to end statements and you don't hear people complaining about them the way they do about JavaScript. Pick one of these four languages and show why they don’t have problems with the four "problematic" cases of JavaScript.

Names, Scopes, and Bindings

  1. Give three examples from C which a variable is live but not in scope. Make sure each example is of a different quality than the others; for example, don't just hide three global variables in a single function and claim you have three examples.
  2. Give an example of a program in C that would not work correctly if local variables were allocated in static storage as opposed to the stack. For the purposes of this question, local variables do not include parameters.
    In C, f(2) should return 2, but if local variables were allocated statically, it would return 3. 
    void f(int x) {
    int a = 2;
    int b;
    if (x < 0) {
        a = 3;
        return 0;
    } else {
        b = f(-x);
        return b + a;
    }
}
  3. This fragment of Java code illustrates something about scope. Or does it? Relate it to other similar problems we've seen regarding scope. (Don't forget to come across as being articulate and intelligent in your discussion.) 
    public void fail() {
    class Failure extends RuntimeException {}
    throw new Failure();
}
  4. Show the output of the following, assuming dynamic scope and (a) deep binding, and (b) shallow binding. 
    function g(h) {
  var x = 2;
  h()
}

function main() {
  var x = 5
  function f() {
    print x + 3
  }
  g(f)
}

main()
    (a) 8, (b) 5
  5. Show the output of the following, assuming dynamic scope and (a) deep binding, and (b) shallow binding. 
    function f(a) {
  let x = a - 1
  function g() {
    print x - 17
  }
  h(g)
}
function h(p) {
  let x = 13
  p()
}
f(18)
  6. Explain what would need to be done to make deep binding work with dynamic scoping, assuming that association lists were used to implement the scope rules. (Hint: think of turning the association lists into "A-trees".)
    When you call the passed function, save the existing pointer to the top of the association list and replace it with a pointer to just before the point that the function was defined. Then enter the bindings for the new function as a "branch" in the association list (which is now a tree). When the function finally returns, chop off that branch and restore the pointer.

Types

  1. Is JavaScript 100% weakly typed? About what percentage is it? Why, exactly, is it not?
    No, JavaScript is not 100% weakly typed; The values null and undefined do not get coerced to objects, and non-functions do not get coerced to functions. I would say it's roughly 90% weakly typed. It’s not 100% weakly typed because its designer thought that coercing things to functions and even objects would be going too far, since there is no consensus on the obvious coercion to make.
  2. In the Java programming language, if the class Dog were a subclass of class Animal, then objects of class Dog[] would be compatible with the type Animal[]. Write a fragment of Java code that shows that this means that Java is not completely statically typed. Include in your answer a well-written explanation that shows you truly understand the difference between static and dynamic typing.
    If both Dog and Rat are subclasses of Animal, this code 
      Animal[] pets = new Dog[4];
  pets[0] = new Rat();
    compiles fine but when executed throws an ArrayStoreException, that's right, a run-time typecheck error. This means Java is NOT 100% statically typed because this typecheck occurs at run time. A language can only be called 100% statically typed if all type conflicts are detected at compile time.
  3. Here's a variation of M-J. Dominus' Spectacular Example. 
    local
    fun split [] = ([],[])
      | split [h] = ([h], [])
      | split (x::y::t) = let val (s1,s2) = split t in (x::s1,y::s2) end
    fun merge c ([], x) = x
      | merge c (x, []) = x
      | merge c (h1::t1, h2::t2) =
          if c(h1,h2)<0 then h1::merge c(t1,h2::t2) else h2::merge c(h1::t1,t2);
in
    fun sort c [] = []
      | sort c x = let val (p, q) = split x
                     in merge c(sort c p, sort c q)
                   end;
   end;
    1. During type inference, give the types assigned to
      • the parameter c within sort
      • the function split
      • the function merge
      • the y in the third clause of split?
    2. Give the type of sort and explain why it is not what you would expect.
    3. How do you rewrite the function to make it actually do a mergesort?
  4. Here's some code in some language that looks exactly like C++. It is defining two mutually recursive types, A and B. 
    struct A {B* x; int y;};
struct B {A* x; int y;};
    Suppose the rules for this language stated that this language used structural equivalence for types. How would you feel if you were a compiler and had to typecheck an expression in which an A was used as a B? What problem might you run into?
  5. Consider the following C declaration, compiled on a 32-bit little endian machine: 
    struct {
    int n;
    char c;
} A[10][10];
    If the address of A[0][0] is 1000 (decimal), what is the address of A[3][7]?
  6. Explain the meaning of the following C declarations: 
    double *a[n];
double (*b)[n];
double (*c[n])();
double (*d())[n];
  7. Translate each of the following declarations in C to Go: 
    double *a[n];
double (*b)[n];
double (*c[n])();
double (*d())[n];
  8. Consider the following declaration in C: 
    double (*foo(double (*)(double, double[]), double)) (double, ...);
    Describe rigorously, in English, the type of foo.

Pointers and References

  1. If possible, write a program in Go that makes a variable point to itself. That is, for some variable x, make it so that *x == x. If this is not possible, state why it is not possible.
  2. If possible, write a program in Rust that makes a variable point to itself. That is, for some variable x, make it so that *x == x. If this is not possible, state why it is not possible.
  3. If possible, give C++ type and object declarations to make a variable point to itself, that is, make it so that p == *p. If it is not possible to do so, state why no such variable can be defined.
  4. In C++ you can say (x += 7) *= z but you can't say this in C. Explain the reason why, using precise, technical terminology. See if this same phenomenon holds for conditional expressions, too. What other languages behave like C++ in this respect?

Expressions

  1. The expression a–f(b)–c*d can produce different values depending on how a compiler decides to order, or even parallelize operations. Give a small program in the language of your choice (or even one of your own design) that would produce different values for this expression for different evaluation orders. Please note that by "different evaluation orders" we do not mean that the compiler can violate the precedence and associativity rules of the language.

Control Flow

  1. The following pseudocode shows a mid-test loop exit: 
    while (true)
    line := readLine();
    if isAllBlanks(line) then exit end;
    consumeLine(line);
end;
    Show how you might accomplish the same task using a while or repeat loop, if mid-test loops were not available. (Hint: one alternative duplicates part of the code; another introduces a Boolean flag variable.) How do these alternatives compare to the mid-test version?
  2. Assume we wanted to write a function called If in Java or C or JavaScript, such that the call If(c, e1, e2) would return e1 if c evaluated to true, and e2 if it evaluated to false. Show why, in these languages, such a function is absolutely not the same as the conditional expression c?e1:e2. You can show a code fragment that would return different results based on whether the function were called versus the conditional expression were evaluated.

    In Java, C, and JavaScript, all function arguments are evaluated before they are called. The evaluation of (p==null ? null : p.value) is null-safe, whereas the call If(p==null, null, p.value) is not: it throws a NullPointerException if p is null. A more blatant example can be seen in the difference between (true ? 1 : formatMyHardDrive()) and If(true, 1, formatMyHardDrive()).
  3. Frank Rubin used the following example (rewritten here in C) to argue in favor of a goto statement: 
    int first_zero_row = -1;              /* assume no such row */
int i, j;
for (i = 0; i < n; i++) {             /* for each row */
    for (j = 0; j < n; j++) {         /* for each entry in the row */
        if (A[i][j]) goto next;       /* if non-zero go on to the next row */
    }
    first_zero_row = i;               /* went all through the row, you got it! */
    break;                            /* get out of the whole thing */
    next: ;
}                                     /* first_zero_row is now set */
    The intent of the code is to set first_zero_row to the index of the first all-zero row, if any, of an n × n matrix, or -1 if no such row exists. Do you find the example convincing? Is there a good structured alternative in C? In any language? Give answers in the form of a short essay. Include a good introductory section, a background section describing views on the goto statement throughout history, a beefy section analyzing alternatives to Rubin's problem, and a good concluding section. Talk about solutions in at least three languages.

Subroutines

  1. Some languages do not require the parameters to a subroutine call to be evaluated in any particular order. Is it possible that different evaluation orders can lead to different arguments being passed? If so, give an example to illustrate this point, and if not, prove that no such event could occur.
  2. In C++ it is not permitted to have two functions that differ only in return type overload each other. In Ada it is allowed. What is the reason for this situation? Even though other languages do allow this flexibility in overloading, the compiler needs some sophistication. What exactly is involved? Be very precise in your explanation and illustrate it with code fragments.
  3. Write a function that takes in a function f and a list [a0, a1, ..., an-1] and returns the list [a0, f(a1), f(f(a2)), f(f(f(a3))), ...].

    For example, if you pass as arguments the function that doubles its inputs, and the list [4, 3, 1, 2, 2], then the return value would be [4, 6, 4, 16, 32].

    Hint: Do the f(f(f...)) as a separate function. Also you do not have to make your function tail recursive.

  4. Write a tail-recursive JavaScript function that produces the sum of squares in an array. This is just to give you practice with tail-recursion; I know there are better ways to compute the sum-of-squares. 

    function ss(a) {
  function s(i, acc) {
    return i == a.length ? acc : s(i+1, a[i]*a[i]+acc)
  }
  return s(0, 0);
}
  5. Write a tail-recursive Ruby method that produces the sum of squares in an array. This is just to give you practice with tail-recursion; I know there are better ways to compute the sum-of-squares. 

    def ss(a)
  s = Proc.new{|i,acc| i==a.length ? acc : s[i+1, a[i]*a[i]+acc]}
  s[0, 0]
end
  6. Write a tail-recursive function to compute the minimum value of an array or list in Python, C, JavaScript, Go, and perhaps a few other languages. Obviously these languages probably already have a min-value-in-array function in a standard library, but the purpose of this problem is for you to demonstrate your understanding of tail recursion. Your solution must be in the classic functional programming style, that is, it must be stateless. Use parameters, not nonlocal variables, to accumulate values.
  7. In as many languages as you can (but include C, Java, JavaScript, and Python for sure), write a pair of functions, f and g, such that every time you call f, you get back 5 less than the result of the previous call to f or g, and every time you call g, you get back double the absolute value of the result of the last call to f or g. The initial value is 0. It is possible to do this in one line of Perl.
  8. Write the following function in Standard ML, where your implementation must be tail recursive.

    Given: a list [a0, a1, ..., an-1],
    Return: a0*a1 + a2*a3 + a4*a5 + ....

    For example, if given [3, 5, 0, 28, 4, 7] we return 15 + 0 + 28 = 43. If there are an odd number of elements in the list, assume there is an extra 1 for padding.

    Here is, by the way, a non-tail-recursive formulation:

    fun sum_of_prods [] = 0
  | sum_of_prods (x::nil) = x
  | sum_of_prods (x::y::t) = x * y + sum_of_prods t;
  9. Write a JavaScript function, without using eval, that accepts an array of integers a, and a function f, and returns an array of functions, each of which, when called, invokes f on the corresponding element of a.

    For example, if your function was called g, then calling g([6,3,1,8,7,9], dog) would return an array of functions p such that, for example, calling p[3]() would invoke dog(8).

    function g(a, f) {
    var b = [];
    for (var i = 0; i < a.length; i++) {
        b[i] = function(i){return function(){f(a[i])};}(i);
    }
    return b;
}
  10. Write some JavaScript that adds a new method to arrays so that if I call this method on an array with two parameters f and g, I get back a new function which, when called with one argument k, returns the composition of f and g applied to the kth element of the original array. Hint: If we defined the functions square and addSix the obvious way, and we called this new method weird, then: 
    [4, 6, 7, 3, 5, 2, 4].weird(addSix, square)
    would return the function z such that 
    z(2) == 55
    because the element at index 2 within the array is 7 and $7^2 + 6 = 55$.
  11. In Go, Rust, Swift, C, and C++ arrays and records can be allocated on the stack, not just on the heap. When making assignments of aggregates to variables, compilers usually generate code to deposit the values in temporary storage. Why is this necessary in general? After all, in 
    Weekdays := Day_Set(False, True, True, True, True, True, False);

    we could construct the aggregate directly in the variable Weekdays. Give an example of an assignment statement that illustrates the necessity of constructing an aggregate in temporary storage (before copying to the target variable).

  12. In Java, you generally implement callbacks via registration of listeners that implement a known interface, rather than using method pointers. Create a Swing component called AngleReader which displays a picture of a circle and notifies all its listeners of the angle, in degrees, that the mouse cursor makes with the horizontal axis of the circle as the mouse moves over it.
  13. Complete the following definition of a dot product function in ML: 
    val dot =
    let
        fun transpose ... =
    in
        ....
    end;
    The transpose function should work like this 
    transpose ([x1,...,xn],[y1,..,yn]) = [(x1,y1),...,(xn,yn)]
    raising Domain if the arrays have different lengths. The body of the definition of dot (between the in and end) should contain only instances of the functions transpose, o, foldr, map, op*, op+, and the value 0.
  14. Explain what is printed under (a) call by value, (b) call by value-result, (c) call by reference, (d) call by name. 
    x = 1;
y = [2, 3, 4];
function f(a, b) {b++; a = x + 1;}
f(y[x], x);
print x, y[0], y[1], y[2];
    1. Under call by value, the arguments do not change; so the script prints 1 2 3 4.
    2. Under call by value/result, the increment of x does not take place until after the subroutine returns. It prints 2 2 2 4.
    3. Under call by reference, the increment of b changes x immediately, so the new value of x, namely 2, is used to update a, which is still y[1], and that becomes 2 + 1 = 3, so it prints 2 2 3 4.
    4. Under call by name, b++ changes x immediately so x becomes 2. Then, since a refers to the expression {y[x]}, it will need to compute y[2] which is 3. The script prints 2 2 3 3.
  15. Explain what is printed under (a) call by value, (b) call by value-result, (c) call by reference, (d) call by name. 
    x = 1;
y = 2;
function f(a, b) {a = 3; print b, x;}
f(x, x + y);
print x;
  16. Using your favorite language and compiler, write a program that determines the order in which subroutine arguments are evaluated.
  17. Consider the following (erroneous) program in C: 
    void foo() {
    int i;
    printf("%d ", i++);
}
int main() {
    int j;
    for (j = 1; j <= 10; j++) foo();
}
    Local variable i in subroutine foo is never initialized. On many systems, however, the program will display repeatable behavior, printing 0 1 2 3 4 5 6 7 8 9. Suggest an explanation. Also explain why the behavior on other systems might be different, or nondeterministic.
  18. Give an example which shows that default parameters are unnecessary in C++ because you can always get the desired effect with overloading.
  19. What does the following program output? 
    with Ada.Text_IO, Ada.Integer_Text_IO;
use Ada.Text_IO, Ada.Integer_Text_IO;

procedure P is
  A: Integer := 4;
  type T is access Integer;
  B: T := new Integer'(4);
  C: T := new Integer'(4);

  procedure Q (X: in out Integer; Y: T; Z: in out T) is
  begin
    X := 5;
    Y.all := 5;
    Z.all := 5;
  end Q;

begin
  Q (A, B, C);
  Put (A);
  Put (B.all);
  Put (C.all);
end P;
  20. In some implementations of an old language called Fortran IV, the following code would print a 3. Can you suggest an explanation? (Hint: Fortran passes by reference.) More recent versions of the Fortran language don't have this problem. How can it be that two versions of the same language can give different results even though parameters are officially passed "the same way." Note that knowledge of Fortran is not required for this problem. 
          call foo(2)
      print* 2
      stop
      end
      subroutine foo(x)
          x = x + 1
          return
      end

Modules, Classes, and Abstract Data Types

  1. Make a Perl module with a function called nextOdd. The first time you call this subroutine you get the value 1. The next time, you get a 3, then 5, then 7, and so on. Show a snippet of code that uses this subroutine from outside the module. Is it possible to make this module hack-proof? In other words, once you compile this module, can you be sure that malicious code can't do something to disrupt the sequence of values resulting from successive calls to this function?
  2. What can't you do with a Perl package named m, s, or y?
  3. Consider the implementation of a Container class framework with the following abstract base class Container: 
    template <class Item>
class Container {
public:
  unsigned numberOfItems() {return currentSize;}
  bool isEmpty() {return currentSize == 0;};
  virtual void flush() = 0;
  ~Container() {flush();}
private:
  unsigned currentSize;
};

    Here the idea is that each particular (derived) container class shall implement its own flush() operation (which makes sense because different containers are flushed in different ways: there may be arrays, linked lists, rings or hashtables used in the representation), and when a container is destroyed its flush() operation will be automatically invoked. However, the idea is flawed and the code as written causes a terrible thing to happen. What happens?

Object-Orientation

  1. What philosophers call a "class" mathematicians call a "set" (i.e., a collection of unordered, unique, values). So, a philosopher says that every member of a subclass is also a member of the superclass. But a C++ programmer says that every member of a superclass is also a member of its subclass! What is going on here?
  2. Write a three-page paper on the nature of identity in object oriented philosophy. Include some code fragments to illustrate your main points.
  3. It is certainly possible to make a Person class, then subclasses of Person for different jobs, like Manager, Employee, Student, Monitor, Advisor, Teacher, Officer and so on. But this is a bad idea, even though the IS-A test passes. Why is this a bad idea and how should this society of classes be built?
  4. One of the most important ways in which object oriented programming helps us to manage complexity is through the ability to group related classes into a hierarchy of subclasses and superclasses. Dynamic binding (run-time polymorphism) allows us to operate on collections of objects from different classes in a hierarchy safely. Furthermore, systems which are programmed using dynamic binding are more easily extendible.
    1. What construct is used in non-object oriented programming languages to simulate class hierarchies, and why do we say that it is unsafe?
    2. Why are inheritance-like structures in non-OOPLs harder to extend?
  5. Why is it said that implementation inheritance is at odds with encapsulation?
  6. Inheritance is not always appropriate. Discuss the reasons why a design with a superclass Person and subclasses for different jobs (e.g., programmer, manager, ticket agent, flight attendant, supervisor, student, etc.) is a lousy design. Give an alternative.
  7. In designing a class hierarchy in C++, when should you make an operation virtual and when should you make an operation non-virtual? Give examples.
  8. Write a Perl "class" for machine parts that have an identification number (a positive integer divisible by 5), a weight (a positive floating-point number) and a name (which must consist entirely and exclusively of alphabetic characters). Provide a "constructor" that takes in a string consisting of the id, weight, and name, respectively in which
    • the string may have leading and trailing spaces
    • the three fields are separated by a vertical bar
    • the weight is not expressed in scientific notation: it can have an integral value, but if it does have a decimal point, then it is followed by a non-empty fractional part. There is no "E" part, ever. It's simple.
    The constructor will check for a valid argument by matching against a regex, and if all is cool, will split the string to assign to its fields.
  9. Find some old "procedural" code you have written and rewrite in an object-oriented fashion. I don't mean that you have to use inheritance or polymorphism; all I am really looking for is that you wrap some functions up in a sensible class.
  10. A common pattern that comes up a lot is the need to assign unique identifiers to objects of a given class, for example: 
    class Item {
    private int id;
    private static int numberOfItemsCreated = 0;
    public Item() {id = numberOfItemsCreated++;}
    // pretend that there are more members here...
};
    As you can see, every item that gets created will get a unique id. Because this pattern occurs frequently, it might be nice to generalize this and make make something reusable out of it so we don't have to write this code inside every class that needs ids. Perhaps we need an interface or abstract class. Tell me why these two suggestions won't work with a detailed, technical answer. Then tell me something that will work. (Note: there is nothing wrong with the access modifiers above; the problems with my two suggestions have to do with the nature of interfaces and abstract classes.)
  11. Given a utility class, can you always rewrite it as a singleton? Given a singleton, can you always rewrite it as a utility class? If so, when would you choose one over the other?
  12. Explain how, in C++, you can get access to, and indeed modify, a protected component of an object that someone else declared. As a concrete example, let's say someone has declared 
        class C {protected: int x; ...};
    C c;

    then your job is to assign a new value to c.x. Assume there are no public operations of C that modify x that you know of. Also, do not use any preprocessor tricks (like #define protected public).

  13. What makes more sense, to inherit a list from a stack or a stack from a list?
  14. Why did the designers of the C++ standard library containers emphatically reject an inheritance hierarchy of containers?
  15. In C++ you can write 
    class C {int x;};
C c;
C* p = &c;
cout << p;
    and there is no compile-time nor link time error, despite the fact that operator<<(C*) is not a member of ostream (since that class was declared before you declared C), nor for that matter did anyone declare the global function 
        ostream& operator<<(ostream&, C*);
    So why does it all work? Explain exactly what gets printed and why.
  16. What happens to the implementation of a class if we "redefine" a field in a subclass? For example, suppose we have: 
    class Foo {
    public int a;
    public String b;
}
...
class Bar extends Foo {
    public float c;
    public int b;
}
    Does the representation of a Bar object contain one b field or two? If two, are both accessible, or only one? Under what circumstances? Answer for C++, Java, Python, and Scala.
  17. If Foo is an abstract class in a C++ program, why is it acceptable to declare variables of type Foo*, but not of type Foo? Does this problem even make sense to ask in Java or Python?

Concurrency

  1. Implement a priority queue data type in Ada, using a server task to provide synchronization.
  2. Implement a priority queue data type in Ada, where each priority queue object is a protected object.
  3. In the example Ada package implementing the Set data type with a guardian task, there is a serious problem with the package design: errors in insertion are not handled well! What happens if we run out of memory? (Answer in terms of the system interfaces.) Show how to add robust error handling to the package and comment on the amount of parallelism permitted with your solution.
  4. Discuss the difficulties of implementing a secure Post Office object in Ada that meets the following requirements. The post office is to maintain a collection of P.O. boxes, each belonging to some task. Any task can put a letter into another task's box, but only the owner of a particular box can open it and read the letters.
  5. A relay is an agent task created by one task to relay a message to another. For example, if a calling task wishes to send a message to another but does not wish to wait for a rendezvous, the caller can create a relay task to send the message. (Note that relays are only appropriate to use when there are no out parameters in the called entry.) Sketch in detail a body for an Ada task T that uses a relay R to call entry E of task U, passing message X.
  6. In Ada, if two tasks are executing a Put procedure at the same time, their outputs may be interleaved. (This could produce amusing and even distasteful results, e.g. writing "sole" in parallel with "ash") Show how to set things up so only one task is writing at a time.
  7. Why do Java programmers not have to worry about the situation in the previous problem (interleaving of text output written to a stream)?
  8. One of the nice features of Quicksort is that it allows a great deal of parallelism in an implementation. After partitioning, the slices on either side of the pivot can be sorted in parallel. It is very easy to set things up to do this in languages such as occam, but tedious in Ada and Java. Code up a parallel version of Quicksort in Ada or Java and explain why it is messy.
  9. In Ada, what happens when you try to call an entry in a task that has terminated? Comment on the following code fragment as a possible approach to calling entry E of task T only if T has not terminated. 
    if not T'Terminated then
    T.E;
end if;
  10. In Java, what happens if you invoke a method on a thread that has completed?
  11. Here's an open-ended question many students hate, especially on exams. Two JavaScript programmers are arguing over the best way to implement a little timer widget. The first programmer prefers: 
    let countDown = function () {
    let i = 10;
    let update = function () {
        document.getElementById("t").innerHTML = i;
        if (i-- > 0) setTimeout(update, 1000);
    }
    update();
}
    The second argues that this is better: 
    let countDown = function () {
    let update = function (i) {
        document.getElementById("t").innerHTML = i;
        if (i-- > 0) setTimeout(function () {update(i)}, 1000);
    }
    update(10);
}
    Your role is to figure out which programmer is right, if any. Make a fairly extensive list of the pros and cons of each approach. Your list will be graded on completeness, neatness, correct usage of terminology (don't forget to mention "anonymous function" and "closure"), and how articulately you express yourself. Bad grammar will impact your grade negatively. You may want to consider readability and (especially) performance.

Programming Problems

Keep sharp by practicing your programming skills.

  1. Write a function or method (in as many languages as you can) that randomly permutes a string.
  2. Write a function or method (in as many languages as you can) that generates powers of some base and sends them to a callback as they are generated, up to some limit.
  3. Write a generator function (in as many languages as you can, provided they support generators) that generates powers of some base up to some limit.
  4. Write a function or method that doubles each item in an array. If your language allows adding methods to an array class (or provides for extensions), use that feature.
  5. Write a command line script that writes successive prefixes of its first input argument, one per line, starting with the first prefix, which is zero characters long.
  6. Write a command line script that reports the number of non-blank, non-commented lines in the file named by the first argument. Blank lines are those that have either no characters or consist entirely of whitespace; commented lines are those that begin with the # character.
  7. Write a function that accepts a number of U.S. cents and returns a tuple containing, respectively, the smallest number of U.S. quarters, dimes, nickels, and pennies that equal the given amount. If your language has adivmod operator, write two solutions, one using the operator and one that does not.
  8. Write a function that takes in a string s and returns the string which is equivalent to s but with all ASCII vowels removed.
  9. Consider the problem of determining whether two trees have the same fringe: the same set of leaves in the same order, regardless of internal structure. An obvious way to solve this problem is to write a function fringe that takes a tree as argument and returns an ordered list of its leaves. Then we can say 
    def same_fringe(t1, t2):
    return fringe(t1) == fringe(t2)
    1. Write a straightforward version of fringe in Python or JavaScript.
    2. Given your straightforward code in part (a), how efficient is same_fringe when the trees differ in their first few leaves?
    3. If you answered part (b) correctly, you know that what you need for efficiency is laziness. Write an efficient (lazy) version of same_fringe in Python.
    4. Write an efficient (lazy) version of same_fringe in JavaScript or Go.
  10. Write a function that interleaves two lists. If the lists do not have the same length, the elements of the longer list should end up at the end of the result list. For C++, write this three ways: using C-style arrays, using std:array, and using std::vector.

Program Analysis

  1. For each of the following code fragments, explain what happens when evaluating them. Make sure you convey in your explanation a thorough understanding of Ruby objects, classes, singleton classes, etc. 
    dog="spike"; class <<dog; def bark; "arf"; end; end; dog.bark
    Evaluates to "arf", since we essentially gave this one dog its own bark method, by attaching it to its own singleton class. 
    class <<"sparky"; def bark; "woof"; end; end; "spraky".bark

    class <<"sparky"; def bark; "woof"; end; end; "sparky".bark

    dog="sparky"; class <<dog; def bark; "woof"; end; end; dog.bark
    Evaluates to "woof", because we attached the bark method to the object referenced by the variable dog, through its metaclass. 
    class <<"sparky"; def bark; "woof"; end; end; "sparky".bark
    Raises a NoMethodError because the object in whose metaclass we added the bark method WAS NOT the same string object we tried to call bark on. 
    class <<:sparky; def bark; "woof"; end; end; :sparky.bark
    Raises a TypeError because Ruby does not allow metaclasses on symbol objects. Maybe this is because Ruby treats symbols in such a super-special way an never puts them in the object pool. It probably holds them as plain old small integers.
    class <<2; def bark; "woof"; end; end; 2.bark
    raises a TypeError for the same reason as for symbols. 
    class Counter
  attr_reader :val; @val = 0; def bump(); @val += 1; end
end
Counter.new.bump; Counter.new.val
  2. One of the freshman tried to write a Ruby dot-product method. It came out like this: 
    def dot(a, b)
  a.zip(b).map{|x,y| x*y}.inject{|x,y| x+y}
end
    1. Her first unit test failed. What was her test, and why did it fail?

      The first unit was assert_equal(dot([], []), 0) and it failed because her method returned nil, not 0.
    2. She fixed that problem with this 
      def dot(a, b)
  a.zip(b).inject(0){|x,y| x+y[0]*y[1]}
end
      Eventually she wrote a unit test with the first array longer than the second and got a TypeError. She fixed that by raising an ArgumentError if the arguments to dot had different lengths. Show her fixed up method. 

      def dot(a, b)
  raise ArgumentError if a.length != b.length
  a.zip(b).inject(0) {|x,y| x+y[0]*y[1]}
end
    3. Then she got fancy and put her method into the array class 
      class Array
  def *(a)
    ..............her code here..............
  end
end
      And the unit tests worked: [3,4,2] * [1,5,0] == 23 for example. But this fancy * definition had a very nasty side effect, which, if she did this in real production code, would have probably broken something big time. What went down with this definition?

      There is already a * operator in the array class; any new definition replaces the old one. Old code using Array * int and Array * string will break badly, because ints and strings can’t be converted to arrays.
  3. What's wrong with this Java code, if anything, and why? 
    class Pair implements Cloneable {
    private Object first, second;

    public Pair(Object x, Object y) {first = x; second = y;}
    public first() {return first;}
    public second() {return second;}
}
Ray Toal • Computer Science Department • College of Science and Engineering • Loyola Marymount University