One of the most challenging and frustrating parts of learning how to program is setting up the development tools on your own machine. Dr. Grissom "skips no steps" and show how to setup all necessary tools from scratch on both the Windows and macOS operating systems. This pre-module is broken down into the following lessons:

1. Setting Up the Inital Development Environment
   • Installing the Eclipse Integrated Development Environment (IDE)
   • Installing the Java Development Kit (JDK)
   • Creating Your First "Hello World" Program
2. Downloading the Course's Source Code Using Git
   • Source Code for Executing Completed Programs
   • Source Code Templates for Coding alongside Dr. Dan
3. Installing Special Java Tools
   • Maven
   • WindowBuilder
4. Installing Tools for C++
   • C++ Compiler
   • Eclipse CDT (C++ Development Tools)

Module 1 covers the basics of programming, specifically with the Java programming language. The content in this section is almost always taught in a "101"-style intro programming course. A wide variety of concepts are covered, but the high-level topics and goals of this module are broken down into the following lessons:

1. Printing to Console & Basic Variables
2. Primitive Data Types
3. Strings and Parsing
4. Boolean Logic (relational operators, unary operators, conditional operators)
5. Conditional Logic and Basic Math (math operators, short-hand operators, incrementers)
6. Loops (for, while, do while)
7. More Loop Practice (String and Character methods, ASCII)
8. Basic Statistics (more loop practice, average, min, max, sum)

Module 2 covers the intermediate topics of programming (in Java), specifically focusing on functions (methods) and storage (arrays and ArrayLists). The content in this section is almost always taught in a "101"-style intro programming course, although ArrayLists are sometimes taught at the beginning of a "102"-style intro programming course. A wide variety of concepts are covered, but the high-level topics and goals of this module are broken down into the following lessons:

1. Functions (pass by value and static functions)
2. Single-Dimension (1D) Arrays and the Random Class (declaring, initializing and iterating)
3. Counting Arrays
4. 2D Arrays (declaring, initializing, iterating and processing)
5. More Array Practice (cards shuffling example)
6. Functions (pass by reference)
7. ArrayLists (declaring, methods, iterating, sorting, nesting)
8. More 2D-Array and ArrayList Practice (cards shuffling example)

Module 3 covers the beginner, intermediate and advanced topics of programming (in Java), specifically focusing on object oriented programming. The portion of this module covering basic classes, is typically taught in a "101"-style intro programming course, while the rest is usually taught in a "102"-style intro programming course. A wide variety of concepts are covered, but the high-level topics and goals of this module are broken down in one monolithic lesson/program:

1. Basic Object Oriented Programming
   • Custom Classes
     • Instance Variables
     • Constructors
     • Getters/Setters
     • Method Overriding (toString(), equals())
     • Class Methods
2. Advanced Object Oriented Programming
   • Inheritance
   • Polymorphism
   • Abstract Methods and Classes
   • Interfaces

Module 4 covers intermediate to advanced topics of programming (in Java), specifically focusing on exceptions and file I/O. The content in this section is almost always taught in a "102"-style intro programming course, if it is covered at all. A wide variety of concepts are covered, but the high-level topics and goals of this module are broken down into the following lessons:

1. Basic Exception Handling (exceptions, try/catch/finally)
2. User Defined Exceptions (creating own exceptions, throws)
3. File Input/Output (plain-text, serialized)

Module 5 covers advanced topics of programming (in Java), specifically focusing on memory organization, lambda expressions and an intro to basic data structures. While memory organization may be taught in a "102"-style intro programming course, most of these topics are not covered at all in a "101" or "102"-level course. Topics in this course are taught to expose students to advanced topics so that they are more prepared for a course like Data Structures (typically comes after a "102"-style course). A number of high-quality slides are provided with this module since the concepts covered are more conceptual than previous content. A wide variety of concepts are covered, but the high-level topics and goals of this module are broken down into the following lessons:

1. Memory Organization (Stack vs. Heap)
2. Performance & Functional Differences: ArrayList vs. LinkedList vs. Set
3. Lambda Expressions (passing methods as parameters)
4. Sets (simple example)
5. Maps (mapping a "primitive" to a "primitive")
6. Maps (mapping a "primitive" to a list)
7. Maps (sorting by map key, sorting by map value)

Module 6 covers advanced topics of programming (in Java), specifically focusing on threads, GUIs and APIs. While this module may prove to be the most fun for students, these topics are typically not covered in a "101"- or "102"-style intro programming course. These are essential topics that most students are forced to teach themselves. Understanding these topics well, even in the context of Java, will prepare students to jump into web-app or mobile-app platforms much more easily.A wide variety of concepts are covered, but the high-level topics and goals of this module are broken down into the following lessons:

1. Theads (breaking up tasks to increase performance)
2. Hand-coded GUI Creation (components, layouts, event handlers)
3. APIs, JSON, External Libraries and Maven (making Yelp API calls and parsing response data, adding external libraries)
4. WindowBuilder GUI and APIs (making a GUI using a GUI-builder)

Module 7 covers advanced topics of programming (in Java), specifically focusing on recursion. Recursion is taught in some "102"-style programming courses or not until a Data Structures course. Lessons in this course are taught to expose students to recursion so that they are more prepared for a course like Data Structures (typically comes after a "102"-style course) and are not meant to provide mastery. A wide variety of concepts are covered, but the high-level topics and goals of this module are broken down into the following lessons:

1. Recursive Math Examples (base cases, recursive cases)
   • Recursive Powers Computation
   • Recursive Factorial Computation
   • Recursive Fibonacci Number Computation
2. Binary Search Example

Module 8 covers beginner and intermediate topics of C++, taught toward students who are well-trained in Java (like the students who completed Modules 1-7 of this course). A quick comparison is provided of syntax (Java vs. C++) and lessons demonstrate the differences of C++ when compared to the Java content covered in Modules 1, 2 and the portion of Module 3 covering basic classes. Lessons in this course are taught to jump start students into C++ so they have a solid foundation to confidently learn advanced C++ topics on their own. A wide variety of concepts are covered, but the high-level topics and goals of this module are broken down into the following lessons:

1. Basics (includes, console I/O, loops, conditional statements, arrays, vectors)
2. Pointers (* and & syntax, pointer arithmetic)
3. Functions (pass by value, pass by reference)
4. Basic Classes (define macros, .h header files, .cpp source files, destructors)