\documentclass{article}

\usepackage{../style}

\usepackage{../langs}

\usepackage{../graphics}

\begin{document}

\section*{Homework 8}

%%\HEADER

\begin{enumerate}

\item Write a program in the WHILE-language that calculates

  the factorial function.

\item What optimisations could a compiler perform when

  compiling a WHILE-program?

  \solution{

    \begin{itemize}

    \item peephole optimisations (more specific instructions)

    \item common sub-expression elimination %, for example

%\begin{lstlisting}

%x := 3 + a

%y := 3 + a

%\end{lstlisting}

    %can be optimised to

    %\begin{lstlisting}[numbers=none,language={}]

    %  z := 3 + a

    %  x := z

    %  y := z

    %\end{lstlisting}

    \item constant folding / constant propagation (that is calculate the result of 3 + 4 already during

      compilation)

    \item tail-recursion optimisation cannot be applied to the WHILE language

      because there are no recursive functions

    \end{itemize}

  }

\item What is the main difference between the Java assembler

      (as processed by Jasmin) and Java Byte Code?

      \solution{ The main difference is that the j-files have symbols

        for places where to jump, while class files have this resolved

        to concrete addresses (or relative jumps). That is what the

        assembler has to generate.  }

\item Remember symbolic labels in the Jasmin-assembler are meant to

      be used for jumps (like in loops or if-conditions). Assume

      you generated a Jasmin-file with some redundant

      labels, that is some labels are not used in your code for any jumps. For

      example \texttt{L\_begin} and \texttt{L\_end} are not used

      in the following code-snippet:

\begin{lstlisting}[language=JVMIS,numbers=none]

L_begin:        

ldc 1

ldc 2

ldc 3

imul

ldc 4

ldc 3

isub

iadd

iadd

L_end:

\end{lstlisting}

      Do these redundant labels affect the size of the generated

      JVM-code? (Hint: What are the labels translated to by

      the Jasmin-assembler?).      

      \solution{The answer is no. The reason is that assemblers

        calculate for labels either relative or explicit adresses,

        which are then used in the JVM-byte-code. Relative addresses

        are like ``jump 10 bytes forward'' or ``12 bytes backward''. So

      additional labels do not increase the size of the generated code.}

\item Consider the following Scala snippet. Are the two functions

\texttt{is\_even} and \texttt{is\_odd} tail-recursive?     

\begin{lstlisting}[numbers=none]

def is_even(n: Int) : Boolean = {

    if (n == 0) true else is_odd(n - 1)

}

def is_odd(n: Int) : Boolean = {

    if (n == 0) false 

    else if (n == 1) true else is_even(n - 1)

}

\end{lstlisting}

Do they cause stack-overflows when compiled to the JVM (for example by Scala)?

\solution{

Scala cannot generate jumps in between different methods (to which functions are compiled to). So cannot eliminate the tail-calls. Haskell for example can do this because it compiles the code in a big ``blob'' inside a main-method (similar to the WHILE language).

}  

\item Explain what is meant by the terms lazy evaluation and eager

  evaluation.

  \solution{ Lazy evaluation only evaluates expressions when they are

    needed and if they are needed twice, the results will be

    re-used. Eager evaluation immediately evaluates expressions, for

    example if they are arguments to function calls or allocated to

    variables.}

\item \POSTSCRIPT    

\end{enumerate}

\end{document}

%%% Local Variables: 

%%% mode: latex

%%% TeX-master: t

%%% End: