All appendices
Appendix C

Glossary

Terms, alphabetical and by chapter

Appendix C — Glossary

Look it up. Then go back to the reps.

This glossary is a fast reference, not a study guide. Each entry gets one to three sentences and a chapter pointer. If a term confuses you here, the chapter is where you actually learn it.

The glossary has two parts:

  1. Alphabetical — terms in A–Z order, technical and theological mixed together. Use this when you remember the word but not where it lives.
  2. By Chapter — terms grouped by the chapter that introduces them. Use this when you remember roughly when a concept showed up but not its name.

Part 1 — Alphabetical

abstract class — A class that cannot be instantiated directly because it contains at least one method left unimplemented. Subclasses must implement those methods before they can be instantiated. In Java the class itself is marked abstract; in C++ the same effect comes from declaring at least one pure virtual method. (Ch 12, Ch 15)

abstract method — A method declared in an abstract class with no body — only a signature. Subclasses must override it before they can be instantiated. Java spells it abstract void foo();; C++ spells it virtual void foo() = 0; (pure virtual). (Ch 12, Ch 15)

accessor — A method whose only job is to return the value of a private field. Often spelled get plus the field name, e.g. getBalance(). Pairs with mutator (a set method). (Ch 10)

accumulator pattern — The loop pattern where you initialize a variable outside the loop and add to it (or otherwise combine into it) on every iteration. The canonical shape of “sum these numbers” or “build this string”. (Ch 4)

address-of operator — The unary & in C++, which produces the memory address of its operand. &x is a value of type “pointer to whatever x is.” Different from the & in a parameter list, which means reference. (Ch 11)

alignment — The rule that certain types prefer to start at memory addresses that are multiples of their size. The compiler may add invisible padding inside structs to keep fields aligned, which is why sizeof(MyStruct) is sometimes larger than the sum of its field sizes. (Ch 7)

alphabetical order vs lexicographic order — Two ways of comparing strings. Alphabetical is the human-language ordering (“apple” before “Banana”). Lexicographic is character-by-character comparison using each character’s numeric code — which makes “Banana” come before “apple” because uppercase letters have smaller ASCII values. std::string::operator< is lexicographic. (Ch 6)

apologetics — In the broad sense, giving a reasoned account of why one believes what one believes (1 Peter 3:15). In the narrow sense, the academic discipline of defending the Christian faith against intellectual objections. This course’s projects engage the narrow sense in code; the broad sense is everyone’s job. (Ch 1)

apostolic succession — The historical claim that the public Christian faith has been continuously professed from the Apostles to today. The LCMS view: Lutherans affirm the historical continuity of public testimony but reject the Roman Catholic sacramental claim that authority is mechanically transferred by the laying-on of hands. Project 11 models the former, not the latter. (Ch 11)

argument — The actual value passed into a function or method when it’s called. Distinct from parameter, which is the name the function uses for the value internally. “Argument is what you send; parameter is what gets received.” (Ch 5)

ArrayList — Java’s resizable-array class, in java.util. Holds objects (not primitives), grows on .add(), supports .get(i), .size(), .remove(). The Java analog to std::vector. (Ch 13)

array — A fixed-size contiguous block of memory holding multiple values of the same type. int scores[5] in C++; int[] scores = new int[5] in Java. Random access is O(1); resizing is impossible (use a vector or ArrayList for that). (Ch 6)

array decay — The C++ quirk where an array passed to a function silently becomes a pointer to its first element, losing the size information. This is why C++ array parameters are usually paired with an explicit int size parameter. (Ch 6)

ASCII — A 7-bit character encoding mapping 128 characters (letters, digits, punctuation, control codes) to numeric codes 0–127. The reason 'A' is 65 and '0' is 48. C++‘s char defaults to ASCII for the basic letters. (Ch 6)

autoboxing — Java’s automatic conversion between primitive types and their wrapper classes — int ↔ Integer, double ↔ Double, boolean ↔ Boolean. Lets you write ArrayList<Integer> list; list.add(7); even though 7 is a primitive int. (Ch 13)

base class — In an inheritance hierarchy, the class being inherited from. Also called the parent or superclass. In C++: class Car : public Vehicle — Vehicle is the base. (Ch 12)

Bayes’ theorem — A formula for updating a probability when new evidence arrives. P(H|E) = P(E|H) * P(H) / P(E). The Reasoning Toolkit (Project 5) builds a small Bayesian updater; the Resurrection apologetics literature uses it heavily. (Ch 5)

boolean — A type holding true or false. Spelled bool in C++, boolean in Java. Named for the mathematician George Boole. (Ch 2)

break statement — A keyword that exits the innermost loop (or switch) immediately. Use sparingly — a loop that breaks under five different conditions is usually a loop that wants to be rewritten as a while with a clearer condition. (Ch 4)

bytecode — Java’s intermediate compiled format. javac translates .java source into .class bytecode files; the JVM then interprets (or JIT-compiles) the bytecode at runtime. The bytecode is the same on every platform — that’s how Java achieves “write once, run anywhere.” (Ch 13)

call by reference — Passing an argument so the function can modify the caller’s variable directly. In C++, written void f(int& x). In Java, all object parameters are effectively call-by-reference; primitives are not. (Ch 5)

call by value — The default in C++ — the function receives a copy of the argument, and modifications don’t escape the function. Cheap for small types, expensive for large objects. (Ch 5)

case-insensitive — A comparison that treats uppercase and lowercase as equivalent. C++‘s built-in == on strings is case-sensitive; case-insensitive comparison requires lowercasing both sides first. (Ch 6)

character — A single letter, digit, or symbol, stored in C++ as char (typically one byte). Single-quoted in source: 'A', not "A". (Ch 2)

cin — C++‘s standard input stream (in <iostream>). Reads from the keyboard with the extraction operator >> — e.g., cin >> age;. Pairs with cout. (Ch 1, Ch 2)

class — A user-defined type bundling fields (data) and methods (behavior) together, usually with rules about who can access what. The central tool of object-oriented programming. (Ch 9)

classpath — In Java, the list of directories and JAR files where the JVM searches for .class files when loading classes. For a simple OnlineGDB program, this is invisible; for real projects, it matters. (Ch 13)

compile time — The moment when source code is being translated into a runnable program. Compile-time errors (missing semicolons, undeclared variables) are caught before the program ever runs. The opposite of runtime. (Ch 1)

composition over inheritance — The design principle that having an object as a field is often cleaner than being a subclass of one. A Car that has an Engine is usually more flexible than a Car that inherits from Engine. (Ch 12, Ch 15)

conditional — A code structure that runs different code depending on whether some expression is true. if, else if, else, and switch are all conditionals. Pillar 2 of programming. (Ch 3)

const — The C++ keyword that marks a variable, parameter, or method as not allowed to change. const int MAX = 100; makes MAX a constant. A const method promises not to modify the object. (Ch 5, Ch 9)

constructor — A special method that runs automatically when an object is created, initializing its fields. Same name as the class, no return type. Java and C++ both use them. (Ch 10)

continue statement — A loop keyword that skips the rest of the current iteration and jumps to the next one. Pairs with break. Use as sparingly. (Ch 4)

cout — C++‘s standard output stream (in <iostream>). Writes to the terminal with the insertion operator << — e.g., cout << "Hello, " << name << endl;. Pairs with cin. (Ch 1)

dangling pointer — A pointer whose target has been freed (or otherwise destroyed), so the pointer now points to garbage. Dereferencing it is undefined behavior. The classic cause is delete-ing through one pointer while another pointer still holds the old address. (Ch 11)

default constructor — A constructor that takes no arguments. C++ generates one for you automatically if you don’t define any constructors; once you define any constructor, the default disappears unless you ask for it explicitly with = default;. (Ch 10)

dereference — To follow a pointer to the value it points to. The unary * operator in C++: *p is “the thing p points to.” Dereferencing a null or dangling pointer is undefined behavior. (Ch 11)

destructor — A special method that runs automatically when an object is destroyed, doing cleanup (freeing memory, closing files). In C++ written ~ClassName(). Java has no destructors — the garbage collector handles cleanup. (Ch 10, Ch 11)

double — A 64-bit floating-point type. Holds real numbers with about 15 decimal digits of precision. The name is short for “double-precision floating point”; you do not have to care about the history. (Ch 2)

double-free — Calling delete (or free) on the same pointer twice. Causes undefined behavior — often a crash, sometimes silent corruption. Setting the pointer to nullptr after delete makes a second delete a no-op. (Ch 11)

dynamic memory — Memory allocated at runtime with new (and freed with delete), as opposed to stack memory whose size and lifetime are fixed at compile time. Lives in the heap. (Ch 11)

encapsulation — The OOP principle of keeping data private and exposing only the methods that should be allowed to read or modify it. The first big win of using a class instead of a struct. (Ch 9, Ch 10)

enhanced-for loop — Java’s “for-each” syntax: for (Combatant c : party) { ... }. Iterates over every element of a collection or array without an explicit index. Cleaner than the indexed for when you don’t need the index. (Ch 14)

endl — A C++ stream manipulator that writes a newline and flushes the buffer. Equivalent to "\n" followed by a flush. For most beginner code, the performance difference doesn’t matter — use whichever reads cleanly. (Ch 1)

enum — A user-defined type whose values are a small named set. enum class Suit { Hearts, Diamonds, Clubs, Spades }; lets you write Suit::Hearts instead of an opaque 2. (Ch 7)

equals method — In Java, the .equals(Object other) method that compares object contents. Override it whenever you write a class whose instances should be comparable by value. == on objects compares references, not contents. (Ch 13)

evidentialism — In Christian apologetics, the approach that emphasizes presenting historical and empirical evidence (manuscripts, archaeology, witnesses) for the truth claims of Christianity. The Resurrection-evidence and manuscript-database projects sit in this tradition. (Ch 7)

exception — A runtime signal that something has gone wrong (file not found, null reference, divide-by-zero). Java has formal exception handling with try/catch; this course only meets it lightly. (Ch 13)

field — A variable that belongs to an object — a piece of the object’s state. Also called a member variable or instance variable. (Ch 7, Ch 9)

final — The Java keyword that marks something as immutable. A final variable can’t be reassigned. A final method can’t be overridden. A final class can’t be subclassed. (Ch 13, Ch 14)

fine-tuning argument — The apologetics argument that a small set of physical constants of the universe (cosmological constant, strong nuclear force coupling, etc.) sit in narrow life-permitting ranges, and that this is evidence for design. Project 2 builds a small calculator that helps the user see the numbers; it does not claim to settle the debate. (Ch 2)

floating point — The way computers store real numbers — a sign, a mantissa, and an exponent. Approximations, not exact. The reason 0.1 + 0.2 is 0.30000000000000004. (Ch 2)

for loop — The C++/Java loop that bundles initialization, condition, and increment in one header: for (int i = 0; i < n; i++). Best for “do this exactly N times.” (Ch 4)

garbage collection — Automatic memory management. The runtime keeps track of which objects are still reachable from your program; objects that aren’t get freed automatically. Java has it; C++ does not. The single biggest convenience Java provides over C++. (Ch 13)

generic type — A type parameterized by another type, written with angle brackets. ArrayList<String> is “ArrayList of String”; Comparable<Witness> is “Comparable to Witness.” Java’s generics are roughly the equivalent of C++ templates, but simpler (and erased at runtime). (Ch 13, Ch 15)

getline — A function (C++ std::getline(cin, s), Java Scanner::nextLine()) that reads a whole line of input, including spaces, up to the next newline. Use it whenever cin >> s or nextInt() would stop at the first space and leave the rest in the buffer. (Ch 6, Ch 13)

getter — Another name for accessor. A get-style method that returns a private field’s value. (Ch 10)

global variable — A variable declared outside any function, accessible from everywhere in the program. Avoid them. They make code hard to reason about. There is almost always a better design. (Ch 5)

hash — A function that maps arbitrary input to a fixed-size numeric “fingerprint.” Used internally by HashMap/HashSet to organize data for O(1) lookup. Out of scope for this course; you’ll meet it in Coding 2. (Ch 13)

header — In C++, a .h file containing declarations (class layouts, function prototypes) that’s #included by other files. The compiler reads the header to learn what’s available; the implementation lives in the .cpp. Java has no headers — the class definition lives in one file. (Ch 5, Ch 9)

heap — The region of memory used for dynamic allocations (new in C++). Distinct from the stack (function-local variables). Heap memory persists until you explicitly free it (or until GC collects it, in Java). (Ch 11)

if/else — The basic conditional. Run this code if the condition is true; otherwise run that code. Pillar 2 in concrete form. (Ch 3)

immutable — A value that cannot be changed once created. Java’s String is immutable: name = name + "!" doesn’t modify the old string; it creates a new one. (Ch 13)

include — In C++, the #include directive that pastes the contents of another file into yours at compile time. #include <iostream> brings in standard I/O; #include "Account.h" brings in your own header. (Ch 1)

inheritance — The OOP mechanism by which one class (the derived or subclass) automatically gets all the fields and methods of another (the base or superclass), and can add or override behavior. The third pillar of OOP after encapsulation and polymorphism. (Ch 12)

initializer list — In C++, the colon-prefixed list after a constructor’s signature that initializes fields before the constructor body runs: Account(string n) : name(n), balance(0) {}. Preferred over assigning in the body. (Ch 10)

instanceof — Java’s runtime type-check operator. if (c instanceof Healable) asks “is c a Healable?” at runtime. Useful when you have a base-class reference and need to know if the actual object supports an optional interface. (Ch 14, Ch 15)

instance variable — Another name for field. A variable that belongs to a particular object (instance), as opposed to a static variable that belongs to the class. (Ch 9)

integer division — Division between two ints that throws away the fractional part. 7 / 2 is 3, not 3.5. The single most common “my math is broken” bug in beginning C++. (Ch 2)

interface — In Java, a named contract listing method signatures that any implementing class must provide. Pure specification — no fields, no constructors. A class can implement many interfaces but extend only one class. (Ch 15)

iterator — A general object that walks through a collection one element at a time. C++‘s std::vector::iterator and Java’s Iterator<T> are both examples. For this course, for loops and enhanced-for usually do the job. (Ch 6, Ch 13)

Java — A statically-typed, garbage-collected, class-based language designed at Sun in the mid-1990s. Runs on the JVM. Used heavily in industry (Android, enterprise backends, scientific computing). The second half of this book. (Ch 13)

JDK — Java Development Kit. The installation that includes javac (the compiler), java (the runtime), and the standard library. OnlineGDB has one built in. (Ch 13)

JVM — Java Virtual Machine. The runtime that executes Java’s bytecode. The JVM is why “compile once, run anywhere” works — the bytecode is the same; the JVM is platform-specific. (Ch 13)

lexicographic order — See alphabetical order vs lexicographic order. The character-code-by-character ordering used by default for string comparison. (Ch 6)

linked list — A data structure where each node holds a value and a pointer to the next node, with the last next being nullptr. Grows without bound; lookup is O(n). The data structure for Project 11. (Ch 11)

literal — A value written directly in source code: 42, 3.14, 'A', "hello", true, nullptr. The compiler reads it and bakes the value in. (Ch 2)

main — The function the runtime calls to start your program. In C++: int main(). In Java: public static void main(String[] args). The line you’ll type more than any other. (Ch 1, Ch 13)

memory leak — Heap memory that’s been allocated with new but never freed, and to which no pointer remains. The memory stays reserved until the program exits. Long-running leaks eventually exhaust available memory. (Ch 11)

method — A function attached to a class — it operates on a specific object. account.deposit(50) calls the deposit method on the account object. (Ch 9)

minimal facts approach — In Resurrection apologetics (Habermas, Licona), the strategy of arguing from a small set of facts that even skeptical historians accept (e.g., Jesus’s death by crucifixion, the disciples’ experiences of the risen Jesus, Paul’s conversion). Project 7’s Evidence Inventory engages this style. (Ch 7)

modulo — The remainder of integer division, written % in C++ and Java. 15 % 4 is 3. Useful for “is this even?” (n % 2 == 0) and “every Nth time” patterns. (Ch 2)

multiple inheritance — A class inheriting from more than one base class. Legal in C++ (with caveats — see the diamond problem). Forbidden in Java for classes, but allowed for interfaces. (Ch 12, Ch 15)

namespace — A C++ scope for grouping names so they don’t collide. std::cout means “the cout inside the std namespace.” using namespace std; lets you drop the std:: prefix at the cost of polluting your scope. (Ch 1)

new — In C++, the operator that allocates an object on the heap, calls its constructor, and returns a pointer. In Java, the operator that allocates and constructs, returning a reference. Java’s new is always paired with the constructor; C++‘s new must be paired with delete. (Ch 11, Ch 13)

nullptr — The C++ keyword for “no valid address.” A pointer set to nullptr deliberately points nowhere. Dereferencing it is undefined behavior. Prefer over the older macro NULL. (Ch 11)

null pointer — A pointer with the value nullptr — points to nothing. Used as a sentinel (“end of list”, “not found”, “not yet assigned”). (Ch 11)

NullPointerException — Java’s runtime error when you call a method on or access a field of a reference that’s null. The Java analog to a C++ null-pointer crash. (Ch 13)

object — An instance of a class — a chunk of memory holding the class’s fields, paired with the class’s methods. “Class is the type; object is the value.” (Ch 9)

OnlineGDB — The browser-based IDE this course uses for both C++ and Java. No local installs. Free account. Compiles, runs, and lets you share a link to your code. (Ch 1, Appendix D)

override — To replace a base class’s method in a derived class. In C++, marked with the override keyword (recommended). In Java, marked with the @Override annotation (also recommended). Both catch the typo bug where you thought you were overriding but actually defined a new method. (Ch 12, Ch 14)

ownership (of memory) — The discipline of being explicit about which part of your code is responsible for freeing a piece of heap memory. Every new belongs to someone. Confusion about ownership is the leading cause of leaks and double-frees. (Ch 11)

parallel arrays — Two (or more) arrays where index i of each refers to the same logical record. names[i] is the name of the person whose age is ages[i]. A pre-struct pattern; once you have structs (Ch 7), use them instead. (Ch 6)

parameter — The named placeholder in a function or method’s signature that receives an argument. void f(int x) has parameter x. (Ch 5)

pass by reference — Passing an argument so the function operates on the caller’s actual variable, not a copy. C++: void f(int& x). Java: any object parameter (implicit). Use when the function needs to modify the caller’s data or when copying would be expensive. (Ch 5)

pass by value — Passing an argument so the function gets a copy. Modifications inside don’t escape. C++‘s default for primitives and objects; Java’s behavior for primitives. (Ch 5)

pointer — A variable whose value is a memory address. C++ syntax: int* p. The asterisk is part of the type in a declaration, and the dereference operator in an expression. Java has no pointers in this sense — its references are pointer-shaped under the hood but with safer rules. (Ch 11)

polymorphism — The OOP mechanism by which a call through a base-class reference dispatches to the derived class’s override at runtime. In C++ this requires virtual; in Java every non-static method is polymorphic by default. (Ch 12, Ch 14)

posterior — In Bayes’ theorem, the probability of a hypothesis after taking the evidence into account: P(H|E). Pairs with prior. (Ch 5)

prior — In Bayes’ theorem, the probability of a hypothesis before the evidence comes in: P(H). The starting point you update from. (Ch 5)

private — An access modifier meaning “only this class can see it.” The default for everything you want to encapsulate. (Ch 9)

protected — An access modifier meaning “this class and its subclasses can see it.” Used for base-class fields that derived classes need but outside code shouldn’t touch. (Ch 12)

public — An access modifier meaning “anyone can see it.” The default for methods you want callable from outside. (Ch 9)

pure virtual — In C++, a virtual method declared with = 0 and no body, making the class abstract. Subclasses must implement it. The C++ counterpart to Java’s abstract method. (Ch 12)

RAII — Resource Acquisition Is Initialization. The C++ idiom that ties resource ownership to object lifetime — when the object goes out of scope, its destructor releases the resource. The pattern behind smart pointers, std::vector, std::string, file handles. (Ch 11)

recursion — A function that calls itself. Useful for problems that decompose naturally (tree walks, divided-and-conquer). Foreshadowed in this course; covered formally in Coding 2. (Ch 5)

reference — In C++, an alias for an existing variable, declared with &: int& r = x;. Cannot be null, cannot be reseated. In Java, every variable of a class type is a reference (the term is used differently in the two languages — pay attention to context). (Ch 5, Ch 13)

return value — The value a function or method hands back to its caller. The function’s return type declares what kind of value it produces; the return statement specifies which one. (Ch 5)

Rule of Three — The C++ guideline that if you write a custom destructor, copy constructor, or copy assignment operator, you should write all three (or explicitly disable the others). They tend to need each other. Modern C++ adds a Rule of Five (move constructor, move assignment); we won’t get that deep this course. (Ch 11)

Scanner — Java’s standard input class (in java.util). Constructed with new Scanner(System.in); and used to read typed input — sc.nextInt(), sc.nextDouble(), sc.nextLine(). The Java analog to C++‘s cin. (Ch 13)

scope — The region of code in which a variable is visible. { ... } blocks usually create scopes. A variable declared in a block disappears when the block ends. (Ch 5)

sentinel value — A specific value used to signal “stop” — like -1 for “end of input” or nullptr for “end of list.” Powerful when the real values can’t include the sentinel. (Ch 4, Ch 11)

setter — Another name for mutator. A set-style method that updates a private field, often after validating the new value. (Ch 10)

short-circuit evaluation — The rule that && and || evaluate left-to-right and stop as soon as the result is determined. false && expensive_check() never calls expensive_check(). Used defensively: if (p != nullptr && p->value > 0) won’t dereference a null pointer. (Ch 3)

sizeof — A C++ operator returning the size, in bytes, of a type or expression. sizeof(int) is typically 4. Useful for understanding memory layout; mostly absent from beginner code. (Ch 2, Ch 7)

slicing — A C++ bug where assigning a derived-class object into a base-class value (not pointer or reference) chops off the derived part. Vehicle v = car; keeps the Vehicle fields and silently loses the Car-specific ones. Use pointers or references to base, not values. (Ch 12)

smart pointer (foreshadowed) — A C++ object that wraps a raw pointer and automatically calls delete when it goes out of scope. std::unique_ptr, std::shared_ptr. Modern C++ uses these instead of bare new/delete. This course teaches the manual version first so the smart pointer feels like the obvious improvement. (Ch 11)

sola scriptura — Latin for “Scripture alone” — the Reformation principle that the Bible is the sole infallible rule of Christian faith and life, above tradition and Church authority. A defining LCMS commitment. Not engaged directly in any project, but shapes how the apologetics projects treat Church history. (Ch 11)

stack — The region of memory where function-local variables live. Allocated and freed automatically as functions enter and exit. Fast; size known at compile time. Contrast with the heap. (Ch 11)

static — In C++ and Java, a keyword with several related meanings; for this course, the important one is static method / static field — belongs to the class, not to any individual instance. Called as ClassName.method() (Java) or ClassName::method() (C++). main is static in Java for exactly this reason. (Ch 13, Ch 14)

std::string — C++‘s standard string class, from <string>. Holds text of any length, supports +, ==, indexing, .length(), .substr(), and more. Used as if it were a primitive throughout this course. (Ch 2)

std::vector — C++‘s resizable array, from <vector>. Holds elements of any one type, grows on .push_back(), supports [i], .size(), iteration. The C++ analog to Java’s ArrayList. (Ch 6)

struct — A user-defined type bundling fields together. Same as a class in C++ except defaults to public instead of private. Use when you want a bag of data with no rules; promote to a class when rules show up. (Ch 7)

switch — A conditional structure that compares one value against multiple cases. Cleaner than a long chain of else if when you’re branching on a single value (a char, an int, an enum). Remember break after each case. (Ch 3)

theodicy — The branch of theology that addresses the problem of evil — why does a good, all-powerful God allow suffering? Project 3 (Coffee Shop Conversation) engages this question through a branching dialog with honest endings. The point is not to solve theodicy in code but to articulate the moves carefully. (Ch 3)

theology of the cross — In Lutheran theology (after Luther’s Heidelberg Disputation), the conviction that God reveals himself most clearly in suffering, weakness, and the crucifixion — not in glory, strength, or rational proof. Contrasted with a “theology of glory” that expects God to confirm faith by visible success. Background frame for Project 3 in particular. (Ch 3)

this pointer — Inside a non-static C++ method, this is a pointer to the current object. this->field is one way to access a field; usually unnecessary unless a parameter shadows the field name. In Java, this is a reference (no ->), used the same way. (Ch 9, Ch 11)

toString — The Java convention for a method that returns a string representation of an object. Overriding Object.toString() lets System.out.println(myObj) print something meaningful. (Ch 13, Ch 14)

transmission criterion — In manuscript apologetics, the principle that earlier, more numerous, and more geographically diverse manuscripts give us higher confidence in the original text. Project 6 (Manuscript Database) engages this directly — every manuscript has a date, location, and content fragment, and the Hard tier lets the user rank by transmission strength. (Ch 6)

undefined behavior — The C++ standard’s term for “anything could happen” — a crash, silent corruption, the right answer this time and the wrong one tomorrow. Caused by null dereference, use-after-free, out-of-bounds access, signed integer overflow, and others. Avoid at all costs. Java mostly prevents the worst of it via runtime checks. (Ch 11)

uninitialized variable — A variable declared but not given a starting value. Its content is whatever bits were lying in that memory slot. Reading it is undefined behavior in C++ and a common source of “garbage” output. Always initialize. (Ch 2)

use-after-free — Using a pointer (or reference, in Java’s case, but Java prevents this) after the memory it points to has been freed. Undefined behavior in C++. The classic shape of dangling-pointer bugs. (Ch 11)

UTF-8 — A variable-width character encoding that represents all Unicode characters using one to four bytes per character, and is backward-compatible with ASCII. The default encoding for source code and most files on modern systems. (Ch 6)

valgrind — A Linux/Mac tool that runs your compiled C++ program and reports every memory leak, double-free, and use-after-free it detects. Slow, thorough, the gold standard. Project 11 Hard tier asks you to confirm zero leaks via valgrind or an equivalent. (Ch 11)

virtual destructor — A destructor marked virtual in C++. Required when you delete a derived object through a base-class pointer — without it, only the base’s destructor runs and the derived part leaks. Forgetting this is a classic intermediate-C++ bug. (Ch 12)

virtual method — In C++, a method marked virtual so that calls through a base-class pointer or reference dispatch to the derived class’s override. The keyword that unlocks polymorphism. (Ch 12)

vocation — In Lutheran theology, the conviction that one’s everyday work and relationships — student, employee, parent, neighbor, citizen — are callings (Latin vocatio) through which God serves the world. Programming responsibly is vocation. (Ch 1)

void — A “no value” type, used as a function’s return type when it returns nothing. void println(...) returns nothing — it just prints. (Ch 1, Ch 5)

while loop — A loop that keeps running as long as its condition is true. Best when you don’t know in advance how many iterations you’ll need (e.g., “until the user enters ‘quit’”). The canonical linked-list traversal is a while loop. (Ch 4, Ch 11)

Word and Sacrament — In Lutheran theology, the conviction that God reaches sinners through the preached and written Word (Scripture) and through the Sacraments (Baptism, the Lord’s Supper) — the ordinary, external, public means God has promised to use. Background for the LCMS frame of this course; not engaged in any specific project. (Ch 1)

wrapper class — In Java, an object class that “wraps” a primitive value so it can be used where an object is required (e.g., inside ArrayList, which holds objects, not primitives). Integer wraps int, Double wraps double, Boolean wraps boolean. Autoboxing converts between primitive and wrapper automatically. (Ch 13)

Part 2 — By Chapter

Terms in the order they’re introduced. Definitions live in Part 1.

Chapter 1 — The Sport of Programming

  • main
  • include
  • namespace
  • void
  • endl
  • OnlineGDB
  • apologetics
  • compile time
  • vocation
  • Word and Sacrament

Chapter 2 — Memory: Variables and Types

  • boolean
  • character
  • double
  • integer division
  • floating point
  • literal
  • modulo
  • sizeof
  • std::string
  • uninitialized variable
  • fine-tuning argument

Chapter 3 — Asking Questions: Conditionals

  • conditional
  • if/else
  • switch
  • short-circuit evaluation
  • theodicy
  • theology of the cross

Chapter 4 — Repetition I: Loops

  • accumulator pattern
  • break statement
  • continue statement
  • for loop
  • sentinel value
  • while loop

Chapter 5 — Repetition II: Functions

  • argument
  • call by reference
  • call by value
  • const
  • global variable
  • header
  • parameter
  • pass by reference
  • pass by value
  • recursion
  • reference
  • return value
  • scope
  • Bayes’ theorem
  • posterior
  • prior

Chapter 6 — Collections: Arrays and Strings

  • alphabetical order vs lexicographic order
  • array
  • array decay
  • ASCII
  • case-insensitive
  • iterator
  • lexicographic order
  • parallel arrays
  • std::vector
  • UTF-8
  • transmission criterion

Chapter 7 — Grouping Memory: Structs

  • alignment
  • enum
  • field
  • struct
  • evidentialism
  • minimal facts approach

Chapter 8 — Midterm Review and Exam

  • (no new terms — all prior material consolidated)

Chapter 9 — From Struct to Class

  • class
  • encapsulation
  • header (as applied to classes)
  • instance variable
  • method
  • object
  • private
  • public
  • this pointer

Chapter 10 — Constructors and Encapsulation

  • accessor
  • constructor
  • default constructor
  • destructor
  • getter
  • initializer list
  • setter

Chapter 11 — Pointers, this, and Dynamic Memory

  • address-of operator
  • dangling pointer
  • dereference
  • double-free
  • dynamic memory
  • heap
  • linked list
  • memory leak
  • new
  • null pointer
  • nullptr
  • ownership (of memory)
  • pointer
  • RAII
  • Rule of Three
  • smart pointer (foreshadowed)
  • stack
  • undefined behavior
  • use-after-free
  • valgrind
  • apostolic succession
  • sola scriptura

Chapter 12 — Inheritance in C++

  • base class
  • composition over inheritance
  • inheritance
  • multiple inheritance
  • override
  • polymorphism
  • protected
  • pure virtual
  • slicing
  • virtual destructor
  • virtual method

Chapter 13 — Shifting Gears: Hello, Java

  • ArrayList
  • classpath
  • equals method
  • exception
  • final
  • garbage collection
  • hash
  • immutable
  • Java
  • JDK
  • JVM
  • NullPointerException
  • static
  • toString

Chapter 14 — Polymorphism in Java

  • final (as applied to methods/classes)
  • instanceof
  • override (Java’s @Override)
  • polymorphism (Java’s default dispatch)
  • static (revisited)

Chapter 15 — Abstract Classes and Interfaces

  • abstract class
  • composition over inheritance (revisited)
  • interface
  • multiple inheritance (via interfaces)

Chapter 16 — Final Review and Exam

  • (no new terms — all prior material consolidated)

Coach’s Note — Don’t read this appendix straight through. Open it when a word slips your mind, find the entry, click the chapter pointer, and re-read the section that introduces the term in context. The glossary is the index card; the chapter is the gym.