Show description
Final Exam Study Guide - Concept Refresh
Final Exam: Concept-Only Refresh
Exam Strategy & Structure
Coverage and Weight
Modules Covered: Modules 8 to 13, with some concepts from Module 7.
Topic Weighting: C++ (~20%), Scheme (~40%), and Prolog (~40%). Budget study time accordingly.
Structure and Timing
Format: Approximately 30 questions over 110 minutes, totaling 50 points.
Pacing Heuristic: Aim for about 2 minutes per point to leave a buffer for challenging questions.
Question Types: Around 30 points are autograded (like midterm quizzes), with the remaining 20 points being written responses (subject to change).
Approach and Materials
Key Mental Models:
C++: Focus on objects, lifetimes, and ownership.
Scheme: Focus on expressions, lists, and recursion styles.
Prolog: Focus on facts, rules, unification, and search order.
Allowed Materials: One 3x5 inch notecard (double-sided, handwritten or printed). No separate scratch paper. A virtual scratchbox may be provided.
Important Tip: Attempt all questions. Partial credit may be awarded for demonstrating logical thinking, even if the final answer isn't perfect.
Scheme Concepts
Lists and Recursion Styles
Proper vs. Improper Lists: A proper list is a chain of pairs that ends in an empty list '(). An improper list ends in a non-list value. Functions like cadr are only safe on proper lists of sufficient length.
Non-Tail Recursion: Defers work until after the recursive call, which grows the call stack.
Tail Recursion: The recursive call is the final action, allowing the compiler to reuse the stack frame (an optimization). Often preferred for clarity and efficiency in aggregation tasks.
Common Pitfalls: Forgetting to quote data (e.g., '(1 2 3)), confusing symbols with numbers (pi vs.…
Final Exam Study Guide - Concept Refresh
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Final Exam Study Guide - Concept Refresh</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;700&display=swap" rel="stylesheet">
<style>
:root {
--bg-color: #0D1117;
--container-bg: #161B22;
--text-color: #C9D1D9;
--header-color: #F97316; /* Orange */
--accent-color: #EA580C; /* Deeper Orange */
--border-color: #30363D;
}
body {
font-family: 'Inter', sans-serif;
background-color: var(--bg-color);
color: var(--text-color);
line-height: 1.7;
margin: 0;
padding: 2rem;
}
.container {
max-width: 900px;
margin: 0 auto;
background-color: var(--container-bg);
border: 1px solid var(--border-color);
border-radius: 8px;
padding: 2rem;
box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
}
h1, h2, h3 {
color: var(--header-color);
border-bottom: 2px solid var(--border-color);
padding-bottom: 0.5rem;
margin-top: 2rem;
}
h1 {
text-align: center;
font-size: 2.5rem;
margin-top: 0;
}
h2 {
font-size: 1.8rem;
}
h3 {
font-size: 1.4rem;
border-bottom: 1px solid var(--border-color);
}
ul {
list-style-type: none;
padding-left: 0;
}
li {
background-color: rgba(234, 88, 12, 0.1); /* Orange tint */
border-left: 4px solid var(--accent-color);
padding: 1rem;
margin-bottom: 0.75rem;
border-radius: 4px;
}
code {
background-color: var(--bg-color);
color: var(--header-color);
padding: 0.2rem 0.5rem;
border-radius: 4px;
font-family: 'Courier New', Courier, monospace;
font-size: 0.95rem;
}
strong {
color: var(--header-color);
font-weight: 700;
}
</style>
</head>
<body>
<div class="container">
<h1>Final Exam: Concept-Only Refresh</h1>
<!-- Exam Strategy Section -->
<section id="strategy">
<h2>Exam Strategy & Structure</h2>
<h3>Coverage and Weight</h3>
<ul>
<li><strong>Modules Covered:</strong> Modules 8 to 13, with some concepts from Module 7.</li>
<li><strong>Topic Weighting:</strong> C++ (~20%), Scheme (~40%), and Prolog (~40%). Budget study time accordingly.</li>
</ul>
<h3>Structure and Timing</h3>
<ul>
<li><strong>Format:</strong> Approximately 30 questions over 110 minutes, totaling 50 points.</li>
<li><strong>Pacing Heuristic:</strong> Aim for about 2 minutes per point to leave a buffer for challenging questions.</li>
<li><strong>Question Types:</strong> Around 30 points are autograded (like midterm quizzes), with the remaining 20 points being written responses (subject to change).</li>
</ul>
<h3>Approach and Materials</h3>
<ul>
<li><strong>Key Mental Models:</strong>
<ul>
<li><strong>C++:</strong> Focus on objects, lifetimes, and ownership.</li>
<li><strong>Scheme:</strong> Focus on expressions, lists, and recursion styles.</li>
<li><strong>Prolog:</strong> Focus on facts, rules, unification, and search order.</li>
</ul>
</li>
<li><strong>Allowed Materials:</strong> One 3x5 inch notecard (double-sided, handwritten or printed). No separate scratch paper. A virtual scratchbox may be provided.</li>
<li><strong>Important Tip:</strong> Attempt all questions. Partial credit may be awarded for demonstrating logical thinking, even if the final answer isn't perfect.</li>
</ul>
</section>
<!-- Scheme Section -->
<section id="scheme">
<h2>Scheme Concepts</h2>
<h3>Lists and Recursion Styles</h3>
<ul>
<li><strong>Proper vs. Improper Lists:</strong> A proper list is a chain of pairs that ends in an empty list <code>'()</code>. An improper list ends in a non-list value. Functions like <code>cadr</code> are only safe on proper lists of sufficient length.</li>
<li><strong>Non-Tail Recursion:</strong> Defers work until after the recursive call, which grows the call stack.</li>
<li><strong>Tail Recursion:</strong> The recursive call is the final action, allowing the compiler to reuse the stack frame (an optimization). Often preferred for clarity and efficiency in aggregation tasks.</li>
<li><strong>Common Pitfalls:</strong> Forgetting to quote data (e.g., <code>'(1 2 3)</code>), confusing symbols with numbers (<code>pi</code> vs. <code>'pi</code>), and incorrectly assuming tail recursion is happening.</li>
</ul>
<h3>Higher-Order Functions</h3>
<ul>
<li><strong>Functions as Values:</strong> In Scheme, functions can be passed as arguments, returned from other functions, and stored in variables.</li>
<li><strong>Closures:</strong> A closure is a function that "remembers" the environment in which it was created, capturing variables from its surrounding scope.</li>
<li><strong>Key Patterns:</strong> Use higher-order functions like <code>map</code>, <code>filter</code>, and <code>fold</code> (reduce) for clean, declarative patterns that avoid manual recursion.</li>
</ul>
</section>
<!-- Prolog Section -->
<section id="prolog">
<h2>Prolog Concepts</h2>
<h3>Core Mental Model</h3>
<ul>
<li><strong>Declarative Nature:</strong> You state facts (what is true) and rules (relationships), then ask queries. Prolog's engine searches for variable bindings that make the query true.</li>
<li><strong>Unification:</strong> The core mechanism. It's a powerful form of pattern matching that binds variables. A goal unifies with a fact/rule if their predicate name, arity, and arguments can all be matched.</li>
<li><strong>Search Strategy:</strong> Prolog uses a depth-first, left-to-right search. It backtracks automatically when a path fails to find a solution.</li>
</ul>
<h3>Execution Control</h3>
<ul>
<li><strong>The Cut (<code>!</code>):</strong> An operator that commits Prolog to all choices made so far in a rule and prunes other branches from the search tree. It prevents backtracking past the cut, making a rule deterministic.</li>
<li><strong>Negation as Failure (<code>\+</code>):</strong> A goal <code>\+ G</code> succeeds if Prolog fails to prove <code>G</code>. It's about provability, not mathematical negation.</li>
</ul>
</section>
<!-- C++ Section -->
<section id="cpp">
<h2>C++ Concepts</h2>
<h3>Ownership and Polymorphism</h3>
<ul>
<li><strong>Smart Pointers:</strong> Prefer smart pointers (like <code>std::unique_ptr</code>) over raw pointers to manage memory automatically and prevent leaks. They enforce clear ownership semantics.</li>
<li><strong>The Rule of Zero/Three/Five:</strong> If you manage a resource, you may need to define a destructor, copy constructor, and copy assignment operator (Rule of Three), plus move equivalents (Rule of Five). The Rule of Zero aims to use smart pointers and standard containers so that no manual resource management is needed.</li>
<li><strong>Composition vs. Inheritance:</strong> Use composition ("has-a") for ownership and inheritance ("is-a") for polymorphism.</li>
<li><strong>Virtual Functions:</strong> Dynamic dispatch (polymorphism) only occurs through base class pointers or references. Use a virtual destructor in a base class if it will be deleted through a base class pointer.</li>
</ul>
<h3>Constructors and Destructors</h3>
<ul>
<li><strong>Initialization Lists:</strong> Use constructor initialization lists to initialize members. This is more efficient and necessary for const members and references.</li>
<li><strong>Calling Base Constructors:</strong> A derived class constructor must call a base class constructor. The base class is always constructed before the derived class members are initialized.</li>
<li><strong>RAII (Resource Acquisition Is Initialization):</strong> A core C++ principle where resource lifetime is tied to object lifetime. Resources are acquired in the constructor and released in the destructor (e.g., <code>std::unique_ptr</code>).</li>
</ul>
</section>
</div>
</body>
</html>