An in-depth beginner's walk-through, taught by Dr. Dan Grissom, of the Java programming language with a transition into (and intro to) C++. Video tutorials of this code being written from scratch and being explained in-depth can be found at hellodrdan.com (coming soon).

NOTE (November 2019): Video tutorials of this code being created from scratch coming soon! Join my e-mail list to be the first to know when modules are released.

SIGN-UP NOW!

This course is taught in 8 modules and mimics the education you'd obtain if you sat through an entire year of introductory programming at the university level. I've taught intro-level programming for 6+ years and am acutely aware of what beginners need to see and hear. In short, I DON'T SKIP STEPS!.

The 8 modules included in this course are as follows:

1. Basics
2. Functions and Storage
3. Object-Oriented Programming
4. Exceptions and File Input/Output (I/O)
5. Memory Organization, Lambda Expressions and Basic Data Structures
6. Threads, GUIs and APIs
7. Recursion
8. Tranitioning to C++ (from Java)

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 (more details) (video overview)
2. Primitive Data Types (more details) (video overview)
3. Strings and Parsing (more details) (video overview)
4. Boolean Logic (relational operators, unary operators, conditional operators) (more details) (video overview)
5. Conditional Logic and Basic Math (math operators, short-hand operators, incrementers) (more details) (video overview)
6. Loops (for, while, do while) (more details) (video overview)
7. More Loop Practice (String and Character methods, ASCII) (more details) (video overview)
8. Basic Statistics (more loop practice, average, min, max, sum) (more details) (video overview)

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) (more details)
2. Single-Dimension (1D) Arrays and the Random Class (declaring, initializing and iterating) (more details)
3. Counting Arrays (more details)
4. 2D Arrays (declaring, initializing, iterating and processing) (more details)
5. More Array Practice (cards shuffling example) (more details)
6. Functions (pass by reference) (more details)
7. ArrayLists (declaring, methods, iterating, sorting, nesting) (more details)
8. More 2D-Array and ArrayList Practice (cards shuffling example) (more details)

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 (more details)
   • Custom Classes
     • Instance Variables
     • Constructors
     • Getters/Setters
     • Method Overriding (toString(), equals())
     • Class Methods
2. Advanced Object Oriented Programming (more details)
   • 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) (more details)
2. User Defined Exceptions (creating own exceptions, throws) (more details)
3. File Input/Output (plain-text, serialized) (more details)

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) (more details)
2. Performance & Functional Differences: ArrayList vs. LinkedList vs. Set (more details)
3. Lambda Expressions (passing methods as parameters) (more details)
4. Sets (simple example) (more details)
5. Maps (mapping a "primitive" to a "primitive") (more details)
6. Maps (mapping a "primitive" to a list) (more details)
7. Maps (sorting by map key, sorting by map value) (more details)

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) (more details)
2. Hand-coded GUI Creation (components, layouts, event handlers) (more details)
3. APIs, JSON, External Libraries and Maven (making Yelp API calls and parsing response data, adding external libraries) (more details)
4. WindowBuilder GUI and APIs (making a GUI using a GUI-builder) (more details)

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) (more details)
   • Recursive Powers Computation
   • Recursive Factorial Computation
   • Recursive Fibonacci Number Computation
   • Recursive Prime Computation
   • Recursive Decimal-to-Binary Computation
2. Binary Search Example (more details)

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) (more details)
2. Pointers (* and & syntax, pointer arithmetic) (more details)
3. Functions (pass by value, pass by reference) (more details)
4. Basic Classes (define macros, .h header files, .cpp source files, deconstructors) (more details)