ITEC 320 - Final Exam topics - Fall 2019

• Updates:
• 2019 Dec 10 11:05:18 AM: Updated percentages and removed draft
• 2019 Dec 10 11:05:18 AM: Noted that variant records were on exam 2
• 2019 Dec 10 11:05:18 AM: Struck through Functionality Oriented Programming (which is not on the exam)

1. Material
1. Rough Percentages of material from each previous test:
• Material from test 1 topics list: about 18% (but many of the basic concepts are used everywhere)
• Material from test 2 topics list: about 24%
• Material since tests 1 and 2: about 58%
2. This breakdown of percentages does not include the complete program that you are to write.
3. Material from (or very similar to) previous exams will be on the final.
4. Pointers are covered heavily.


5. Material from lectures and web pages
6. From the text: chapters related to topics discussed in class


7. Example programs
8. Assignments


2. Pointers
   • Memory model
     • List and define 3 kinds of variable found in modern programming languages
     • Describe when allocation occurs for each of the 3 kinds of variables
     • Describe how subroutine calls follow a stack protocol
     • Indicate whether each kind of allocation is static or dynamic
     • List and describe three areas of memory (static, stack, heap), including the kind of variable found and type of allocation used in each area
     • Draw a diagram showing the three areas of memory and the variables allocated in each as a program executes
     • Describe how actual memory organization differs from conceptual diagram
   
   
   • Access types - Pointers
   • new: be able to use new to dynamically allocate variables
   • Dereferencing pointer variables: know what it means and be able to do it
   • .all: know what it does and be able to use it
   • Define: anonymous variables (ie no name because it's allocated with new)
   • Pointers to records and their fields: be able to access fields of linked structures
   • Null: you should know what this is
   • Describe why it's incorrect to use the phrase "pointing to null"
   • Recognize and describe the similarity between Java primitive and reference types and Ada primitive and pointer types
   • Memory diagrams: be able to draw to illustrate pointers during program execution
   
   
   • Pointer problems - define and describe these problems and Ada's approaches to avoiding them:
   • Null reference
   • Dangling reference
   • Garbage
   
   
   • Unchecked deallocation/dispose/free
   • Describe what it does and be able to use appropriately
   • Recognize that it is generic procedure and know what that means
   • You don't have to memorize the syntax.
   
   
   • Recursively defined data structures: Declare each of the following data structures and give implementation of related procedures and functions
   • Linked list (ie stack) implementation
   • Dynamic stack and queue implementation
   • Dynamic tree implementation
   • Example list procedures using pointers: size, print, equal, copy, reverse
   • Example tree procedures using pointers: size, print, copy, reverse
   • Simple recursive routines with lists and stacks , and trees
   • Deep copy and shallow copy
   
   
3. Variant records [actually, these were on exam 2]
• Define what they are
• Describe the motivation for them
• Describe their relation to OO
• Define and use one


• Security issues and their solutions
• Compile and run time checks
• Basic implementation in other languages (concepts, not syntax)
• C unions
4. Functionality oriented (ie procedural) programming (FOP)
• Describe how variant records are used in FOP
• Describe how FOP and OOP differ in Distributed vs Centralized code and data
• Describe when to use FOP vs OOP:
• One reason: Expected functionality changes vs expected data changes


• Other reasons for FOP vs OOP:
• To avoid time and memory performance penalties
• To gain better access to hardware (eg memory addresses, device drivers)
• To meet reliability needs (ie no pointers)
• To use existing code
• To use existing libraries

1. The following will not be on the Fall 2019 exam:
• Tasks:
• Basic concepts (eg what happens when one is created)
• Entry and accept statement (what happens when one executes)
• You won't have to write one, but you might have to read and interpret one


• Protected object
• Basic concepts (ie what one is and what it provides)
• You won't have to write one, but you might have to read and interpret one



• Topics on procedural application areas and Ada design goals
• Procedural Goals and features needed to support them
• Language goals: reliability, efficiency, concern for programmer, programming in the large
• List and define goals and list and explain how various features support the goals


• Define variable allocation
• Compare and contrast Ada and Java in terms of the kinds of variables that are allocated in each area


• Functional decomposition
1. Problem solving process
2. Structure charts: modules, data and control information
3. Top down and bottom up approaches


• Initialization of memory on heap


• Abstract objects: declare data in package
1. Data declared in package
2. Object not needed as a parameter
3. vs ADT in implementation and usage


• OO Characteristics
1. State, behavior, identity
2. OO is easy as PIE
3. Abstraction
4. Inheritance: add fields and routines
5. Polymorphism and dynamic dispatch


• Object oriented programming in Ada
1. Tagged type
2. Adding methods and fields
3. Types Parent vs Parent'Class (ie class wide type)
4. Dynamic dispatch: requires variable of class wide type as actual parameter
5. Role of pointers with class wide types: if we want polymorphic assignment, we have to use a pointer so that we can know the size
6. Dynamic dispatch in Ada, C++, Java


• Reliable programming
• Pre and post condition
• Invariant


• Reliable programming
1. OO errors and issues
• Overriding
• Dynamic dispatch
• Redefining fields
2. Role syntax and reliable programming
3. Proof of properties


• Other topics on variant records:
2. Comparison with Java
• Describe what Java language feature is closely related to generic packages
• Explain the type checking problems that occur with Java arrays and other containers of Objects and how this problem is solved with Java generic types
3. Define the term template as it relates to generic procedures and functions. [Generic in C++]