CSE 321 Midterm Review

The exam is closed-book, closed-notes, closed-neighbor. We will provide you with a summary sheet of all the kernel operations for the relevant components. If you need to see the specification for any component during the exam, your instructor will have a copy of the full specifications for you to consult.

1. Be able to read and understand component specifications, including convention and correspondence
2. Be able to write code from specifications
3. Representation, Convention, Correspondence: what are they, and why are they necessary?
4. Be able to demonstrate an understanding of the Resolve principles for implementing and using kernel operations, private operations and extensions.
   • kernel operations:
     • are implemented by referring to the fields of the Representation (i.e. must use self[...]).
     • may not call themselves or other kernel operations
   • programmer defined private operations within a kernel:
     • may not directly refer to the Representation (i.e. may not use self[...])
     • if they need access to one or more fields of self, the fields should be passed as arguments to the private operation
     • may call themselves and other private operations
     • may not call any public operations within that kernel
   • extension operations:
     • must be implemented using the (public) kernel operations of the kernel they are extending
     • may not directly refer to the Representation of the kernel they are extending (i.e. may not use self[...])
     • may call themselves and any private operations defined by the implementer of the extension
   • programmer defined private operations within an extension:
     • may not directly refer to self (the object being extended)
     • if they need access to self, self must be passed as one of the arguments to the private operation
5. Be able to visualize, design, and implement recursive algorithms (5 step method)
6. Be able to use the following software components:
• Sorting_Machine
• Tree
• Statement
• Program
7. Sorting_Machine
   • Conceptual model, representation, implementation
   • Be able to describe how the following sorting algorithms work and compare their performance:
     • selection sort
     • insertion sort
     • quicksort
     • mergesort
     • heapsort
8. Statement
   • Conceptual model
   • Know how to draw the model/value of a Statement given a BL statement, and how to derive a BL statement from a given Statement value
   • Know how to represent and implement Statement_Kernel on Tree
9. Program
   • Conceptual model
   • Know how to draw the model/value of a Program given a BL program, and how to derive a BL program from a given Program value
   • Know how to represent and implement Program_Kernel on Partial_Map
10. Context Free Grammars
    • Be able to identify the parts of a cfg: start symbol, terminals, non-terminals, and rewrite rules
    • Given a cfg and a string, be able to show the derivation (parse) tree for the string
    • Understand how cfg's are used to specify syntactic representations of things such as Boolean expressions and arithmetic expressions
    • Be able to write a cfg for a language similar to those discussed in class
11. BugsWorld project
    • High-level architecture of the BugsWorld simulation: Server, Client, Display
    • BL language
    • High-level structure of the Translator