Week 1

GUI Components

• List at least three types of objects that can be contained in a Parent object
• Design and implement a graphical user interface (GUI) programs using the Label and Button classes from the JavaFX package

Week 2

Event-Driven Programming

• Derive from the Application class and create a simple GUI application
• Create a FlowPane and add multiple components to the pane
• Explain what it means to "register an event handler"
• Write a method reference representing an instance method of a particular object
• Use a method reference to register an event handler to a Button or TextField
• Explain the role of the ActionEvent passed to the method reference
• Determine the source of the event that called an event handler
• Describe the event-delegation model and explain the role of the event source object and the event listener
• List two classes whose instances are the source of events (e.g., Button)
• List two classes whose instances are event objects (e.g., ActionEvent)
• Implement the EventHandler interface as an inner class
• Implement an EventHandler as a lambda expression

GUI Components

• Differentiate between layout panes such as: GridPane, FlowPane, HBox, and VBox
• Use the layout panes listed above to arrange components on a scene

Week 3

FX Markup Language

• Describe the differences between creating JavaFX applications using imperative programming and using FXML with declarative style programming
• Use scene builder to create an FXML file describing a GUI layout
• Implement controller classes and make appropriate modifications to FXML files to provide functionality to UI controls such as Button and TextField classes
• Use Alert and TextInputDialog classes to interact with the user.

Functional Programming

• Describe when it is appropriate to replace code with a lambda expression
• Explain the characteristics of and purpose for a functional interface
• Use lambda expressions to implement the Predicate, Function, Consumer, and Comparator interfaces
• Use a method reference in place of a lambda expression
• Explain how functional programming differs from object oriented programming
• Describe the purpose of the Stream interface
• Make use of the Iterable.forEach() method
• Be familiar with the following methods from the Stream interface: collect(), count(), distinct(), filter(), map(), max(), min(), limit(), skip(), sorted(), and toArray()
• Use Collectors.toList() with the collect() method
• Obtain a Stream<String> from a file

Week 4

Interfaces

• Use the Collection<E> and List<E> interfaces defined in the Java Collection Framework
• Explain when to use Collection<E> instead of List<E> and vice versa
• Demonstrate correct use of generics when declaring Collection<E> and List<E> interfaces
• Describe the implications of an interface extending another interface
• List two classes that implement the Collection<E> interface
• List two classes that implement the List<E> interface

Big-O Notation and Algorithm Efficiency

• Explain the purpose of Big-O notation
• Describe the limitations of Big-O notation
• Be familiar with the formal definition of Big-O
• Using Big-O notation, determine the asymptotic time complexity of an algorithm with a conditional
• Using Big-O notation, determine the asymptotic time complexity of an algorithm with a loop
• Determine the asymptotic time complexity of an algorithm with a nested loop
• Using Big-O notation, determine the asymptotic time complexity of an algorithm that calls other methods with known asymptotic time complexity
• Use time complexity analysis to choose between two competing algorithms
• Describe the meaning of the following symbols: T(n), f(n), and O(f(n))
• Given T(n) expressed as a polynomial, determine the Big-O notation
• Determine the asymptotic time complexity of the following methods from the ArrayList<E> class: add(E), add(int, E), clear(), contains(Object), get(int), indexOf(Object), isEmpty(), remove(int), remove(Object), set(int, E), and size()

Array Based Lists

• Describe key differences between an array and an ArrayList<E> object
• Implement classes and methods that make use of generics
• Write an array-based implementation of the List<E> interface, including the following methods:
  • add(E)
  • add(int, E)
  • clear()
  • contains(Object)
  • get(int)
  • indexOf(Object)
  • isEmpty()
  • remove(int)
  • remove(Object)
  • set(int, E)
  • size()
  • toArray()
• Implement small software systems that use one or more ArrayList<E> objects
• Describe key differences between the in class implementation and the java.util.ArrayList<E> implementation
• Describe differences in the java.util.ArrayList implementation compared to the one created in lecture that affect the asymptotic time complexity of any of the methods

Week 5

Linked Lists

• Describe key differences between an array based list and a linked list
• Describe advantages and disadvantages of a singly linked list verses a doubly linked list
• Write an singly linked list implementation of the List<E> interface, including the following methods:
  • add(E)
  • add(int, E)
  • clear()
  • contains(Object)
  • get(int)
  • indexOf(Object)
  • isEmpty()
  • remove(int)
  • remove(Object)
  • set(int, E)
  • size()
  • toArray()
• Describe key differences between a singly linked list and the LinkedList<E> class
• Determine the asymptotic time complexity of the following methods from a singly linked list class developed in lecture: add(E), add(int, E), clear(), contains(Object), get(int), indexOf(Object), isEmpty(), remove(int), remove(Object), set(int, E), and size()
• Describe differences in the JCF LinkedList implementation compared to the one created in lecture that affect the asymptotic time complexity of any of the methods
• Implement small software systems that use one or more LinkedList<E> objects

Week 6

Iterators

• List the methods declared in the Iterator<E> interface
• List the methods declared in the Iterable<E> interface
• Implement the iterator() method in the ArrayList class (returning a fully functional iterator)
• Implement the iterator() method in the LinkedList class (returning a fully functional iterator)
• Explain why the enhanced for loop only works on classes that implement the Iterable<E> interface
• Be familiar with the ListIterator<E> interface

Week 7

Java Collection Framework and Testing

• Explain the purpose of the Java Collections Framework
• Be familiar with class/interface hierarchy for the Java Collections Framework
• Describe the following levels of testing: unit, integration, system, and acceptance
• Describe the differences between black-box testing and white-box testing
• List advantages and disadvantages of black-box testing verses white-box testing
• Develop tests that test boundary conditions

Stacks

• Enumerate and explain the methods that are part of a pure stack interface
• Define LIFO and explain how it relates to a stack
• Explain how the Stack<E> class is implemented in the Java Collection Framework
• Describe the design flaw found in the Stack<E> implementation found in the Java Collection Framework
• Implement a class that provides an efficient implementation of the pure stack interface using an ArrayList<E>
• Implement a class that provides an efficient implementation of the pure stack interface using a LinkedList<E>
• Define the term adaptor class and be able to implement a simple adaptor class, e.g., stack, queue
• Implement small software systems that use one or more stack data structures
• List at least two examples of when it makes sense to use a Stack

Queues

• Enumerate and explain the methods that are part of a pure queue interface
• Define FIFO and explain how it relates to a queue
• The Queue<E> interface has multiple methods for insertion, removal, and accessing the front element. Describe how these methods differ.
• Describe the design flaw found in the Queue<E> interface found in the Java Collection Framework
• Implement a class that provides an efficient implementation of the pure queue interface using a LinkedList<E>
• Explain why an ArrayList<E> is not an appropriate choice when implementing a pure queue interface
• Explain how a circular queue differs from a standard queue
• Implement a class that provides an efficient implementation of a circular queue using an array
• Implement small software systems that use one or more queue data structures
• List at least two examples of when it makes sense to use a Queue

Week 8

Recursion

• For a given input, determine how many times a recursive method will call itself
• Explain the role of the base case and recursive step in recursive algorithms
• Use recursion to traverse a list
• Use recursion to search a sorted array
• Understand and apply recursion in algorithm development

Week 9

Binary Trees

• Use the following terms to describe nodes in a tree: root, children, parent, sibling, leaf, ancestor, descendent
• Recognize empty trees and contents after any branch to be trees themselves, specifically subtrees
• Define node level recursively, starting with level 1 at the root. Define height as the maximum node level
• Define binary tree (contrasted with a general tree) and explain the use of common types of binary trees: expression trees, Huffman trees, binary search trees
• Explain the criteria for binary trees that are full, perfect, and complete
• Explain preorder, inorder, and postorder traversal of trees using words and figures
• Explain the significance of each of these orders when applied to expression trees

Binary Tree Implementation

• Develop a BinaryTree<E> class with no-arg, one-arg (root node) and 3-arg (root node as well as left and right subtrees) constructors
• Implement BinaryTree<E> methods: get{Left,Right}Subtree, isLeaf, and preOrderTraverse/toString methods

Binary Search Trees

• Define the ordered relationship between parent and child nodes
• Implement a recursive contains() method
• Implement a recursive size() method
• Implement a recursive height() method
• Describe how elements are added to a binary search tree
• Describe how elements are removed from a binary search tree

Week 10

Sets and Maps

• Use the Set<E> and Map<K, V> interfaces defined in the Java Collection Framework
• Choose the appropriate interface to use from the following choices: Collection<E>, List<E>, Set<E>, and Map<K, V>
• List two classes that implement the Map<K, V> interface
• Interpret and write Java code using the TreeMap and TreeSet classes
• State and explain the asymptotic time complexity of the following methods from a TreeSet: add(E), clear(), contains(Object), isEmpty(), remove(Object), and size()

Week 11

Hash Tables

• Describe how elements are added to a hash table
• Describe how elements are removed from a hash table
• Explain the capacity of a hash table and how it is used
• Define the load factor of a hash table and explain how it is used
• Define a collision as it relates to hash tables and describe ways of coping with collisions
• Describe the open addressing method for dealing with collisions within a hash table
• Describe the chaining method for dealing with collisions within a hash table
• Write a hash table implementation (using chaining) that includes the following methods:
  • add(E)
  • clear()
  • contains(Object)
  • isEmpty()
  • remove(Object)
  • size()
• Explain why the Object.hashCode() method must be overridden if the Object.equals() method is overridden
• Describe the criteria for a good hashCode() implementation
• Interpret and develop simple hashing functions
• Interpret and write Java code using the HashMap and HashSet classes
• State and explain the asymptotic time complexity of the following methods from a HashSet: add(E), clear(), contains(Object), isEmpty(), remove(Object), and size()

Week 12

Sorting

• Determine Big-O performance for multiple selection techniques
• Interpret and implement multiple selection techniques
• Determine Big-O performance for various sorting algorithms such as insertion sort, shell sort, and merge sort
• Interpret and implement various sorting algorthims such as insertion sort, shell sort, and merge sort

Week 13

Big-O Notation and Algorithm Efficiency

• Determine informally the space complexity for simple data structures
• Give examples that illustrate time-space trade-offs of algorithms
• Employ benchmarking to analyze algorithm performance

Week 14

Deep verses Shallow Copies

• Distinguish between copying a reference and copying an object
• Demonstrate proper use of == and .equals()
• Describe approaches to making deep copies, e.g., clone() and copy constructors

Week 15

Big-O Notation and Algorithm Efficiency

• Evaluate trade-offs associated with data structure choices for specific scenarios

CS2013

Basic Analysis

• Explain what is meant by "best", "expected", and "worst" case behavior of an algorithm. [AL|Basic Analysis|1]
• In the context of specific algorithms, identify the characteristics of data and/or other conditions or assumptions that lead to different behaviors. [AL|Basic Analysis|2]
• Determine informally the time and space complexity of simple algorithms. [AL|Basic Analysis|3]
• State the formal definition of big O. [AL|Basic Analysis|4]
• List and contrast standard complexity classes. [AL|Basic Analysis|5]
• Perform empirical studies to validate hypotheses about runtime stemming from mathematical analysis Run algorithms on input of various sizes and compare performance. [AL|Basic Analysis|6]
• Give examples that illustrate time-space trade-offs of algorithms. [AL|Basic Analysis|7]

Fundamental Data Structures and Algorithms

• Implement basic numerical algorithms. [AL|Fundamental Data Structures and Algorithms|1]
• Implement simple search algorithms and explain the differences in their time complexities. [AL|Fundamental Data Structures and Algorithms|2]
• Be able to implement common quadratic and O(N log N) sorting algorithms. [AL|Fundamental Data Structures and Algorithms|3]
• Describe the implementation of hash tables, including collision avoidance and resolution. [AL|Fundamental Data Structures and Algorithms|4]
• Discuss factors other than computational efficiency that influence the choice of algorithms, such as programming time, maintainability, and the use of application-specific patterns in the input data. [AL|Fundamental Data Structures and Algorithms|6]
• Explain how tree balance affects the efficiency of various binary search tree operations. [AL|Fundamental Data Structures and Algorithms|7]
• Demonstrate the ability to evaluate algorithms, to select from a range of possible options, to provide justification for that selection, and to implement the algorithm in a particular context. [AL|Fundamental Data Structures and Algorithms|9]

Fundamental Concepts

• Construct a simple user interface using a standard API. [GV|Fundamental Concepts|4]
• Describe the differences between lossy and lossless image compression techniques, for example as reflected in common graphics image file formats such as JPG, PNG, MP3, MP4, and GIF. [GV|Fundamental Concepts|5]

Object-Oriented Programming

• Correctly reason about control flow in a program using dynamic dispatch. [PL|Object-Oriented Programming|3]
• Define and use iterators and other operations on aggregates, including operations that take functions as arguments, in multiple programming languages, selecting the most natural idioms for each language. [PL|Object-Oriented Programming|7]

Functional Programming

• Write basic algorithms that avoid assigning to mutable state or considering reference equality. [PL|Functional Programming|1]
• Write useful functions that take and return other functions. [PL|Functional Programming|2]
• Compare and contrast (1) the procedural/functional approach–defining a function for each operation with the function body providing a case for each data variant–and (2) the object-oriented approach–defining a class for each data variant with the class definition providing a method for each operation Understand both as defining a matrix of operations and variants. [PL|Functional Programming|3]
• Define and use iterators and other operations on aggregates, including operations that take functions as arguments, in multiple programming languages, selecting the most natural idioms for each language. [PL|Functional Programming|6]

Event-Driven and Reactive Programming

• Write event handlers for use in reactive systems, such as GUIs. [PL|Event-Driven and Reactive Programming|1]
• Explain why an event-driven programming style is natural in domains where programs react to external events. [PL|Event-Driven and Reactive Programming|2]
• Describe an interactive system in terms of a model, a view, and a controller. [PL|Event-Driven and Reactive Programming|3]

Algorithms and Design

• Implement, test, and debug simple recursive functions and procedures. [SDF|Algorithms and Design|5]
• Determine whether a recursive or iterative solution is most appropriate for a problem. [SDF|Algorithms and Design|6]

Fundamental Programming Concepts

• Describe the concept of recursion and give examples of its use. [SDF|Fundamental Programming Concepts|8]
• Identify the base case and the general case of a recursively-defined problem. [SDF|Fundamental Programming Concepts|9]

Fundamental Data Structures

• Discuss the appropriate use of built-in data structures. [SDF|Fundamental Data Structure|1]
• Describe common applications for each of the following data structures: stack, queue, priority queue, set, and map. [SDF|Fundamental Data Structure|2]
• Write programs that use each of the following data structures: arrays, records/structs, strings, linked lists, stacks, queues, sets, and maps. [SDF|Fundamental Data Structure|3]
• Compare alternative implementations of data structures with respect to performance. [SDF|Fundamental Data Structure|4]
• Describe how references allow for objects to be accessed in multiple ways. [SDF|Fundamental Data Structure|5]
• Compare and contrast the costs and benefits of dynamic and static data structure implementations. [SDF|Fundamental Data Structure|6]
• Choose the appropriate data structure for modeling a given problem. [SDF|Fundamental Data Structure|7]