Course To Do List Submit a question for class

Useful Information
Recommended Reading
If you want to be successful in this class or any, find a learning method that matches your needs. I always recommend reading from a variety of sources. Find the chapters that match the module topics for the week and read through them. If you are unsure what would be useful, ask me in class and I'll gladly point out specific chapters for the week.

At this level most Java books will be similar, but here are some suggestions from the O'Reilly learning platform. Use your Northeastern email address and credentials. Log in here first to access the things listed below: Safari Online If you find other resources that were useful to you, please let me know and I'll add them here.

----- Getting Started -----

Module 0 : Tools and Infrastructure
In this module we'll introduce terms and establish the foundational information needed to understand future modules. We'll also make sure you are familiar with a variety or programming environments.
Module Concepts: IDE, cloud, and command line compiling; test driven development, design principles of object oriented programming
Supporting Material:
Module 1 : Data Definitions, Classes, and Unit Testing in Java

Unlike Python Java is a strongly typed language and everything in Java must be encapsulated in a class object. In this module we explore what this means and get some practice programming in Java.

Module Concepts: Parts of a Java program; primitive data types; static vs dynamic typing, Unit testing in Java, private vs. public access; commenting and JavaDoc documentation; UML diagraming

Supporting Material:
Module 2 : Simple Classes and Exception Handling

Ok, we are getting there. You should have mastered basic Java programming, but let's take one more week to practice. Here we'll explore built in and custom methods and get some practice with more complex Java code.

Module Concepts: Methods built in and custom, objects as arguments, pass by value and pass by reference, exception handling

Supporting Material:
Module 3 : More Complex Forms of Data

It's time to start ramping up. In this module we will explore class composition, inheritance, and abstraction.

Module Concepts: Types vs protocols; dynamic dispatching(polymorphism), composition, inheritance, abstraction

Supporting Material:

----- Organization and Using Objects Wisely -----

Module 4 : Inheritance and Composition

Now that you know how to use inheritance, let's take session to explore how to use it wisely and how composition can replace it when it makes more sense for the design.

Supporting Material:
Module 5 : Linked Lists as a Recursive Data Structures

This is one of my favorite modules. I love it so much we usually take two weeks on it. We not only have to think about how we want to use objects but also how we want to organize them. In this module we'll explore how to create our own linked list structure and use recursion to navigate through it.

Module Concepts: Static data structures; linked lists; applied recursion; function abstraction; predicate abstraction; higher order abstraction; Java generics; for loops and foreach loops; arrays and arrayList; lambda expressions

Supporting Material:
Module 6 : Equality and Comparison

Whew! You made it through module 4. Let's take it a little easier this week. When you create your own objects you have to consider what happens whenever someone wants to compare your objects to each other or determine if two objects are equal. In this module, we'll explore those issues.

Module Concepts: Equality with objects; implementing comparison to facilitate sorting; method overloading from Object

Supporting Material:
Module 7 : Hierarchical Data Structure

Let's get back to it. You've seen how objects can be stored as a linked list. Let's now explore how objects can be stored as a hierarchy. This will give you more practice with object oriented design as well as prepare you for future CS courses.

Module Concepts: Hierarchical storage; abstracting data; higher order functions

Supporting Material:

----- Design -----

Module 8 - 11 : Creating a More Complex Program with MVC Design

Let's move away from storage now and start thinking more about design. In this module we'll introduce some design principles, talk about design patterns, and then create a more complex application using the Model, View, Controller design pattern. We'll take two weeks on this section. First, we'll introduce the concept and explore the model and controller, and then we'll spend a class on the view.

Module Concepts: Design principles, design patterns, MVC design

Supporting Material:
Module 12 - 15 : Inheritance vs Composition and Design Patterns

These last sections focus on design and design patterns. We'll talk about it conceptually, and then I've got some code for us to go over.

Module Concepts: Inheritance vs composition, the iterator design pattern, the strategy design pattern, and the adapter design pattern

Supporting Material:
Demo Code:

----- Other -----

Multi-Module Assignments