CS 2110 Learning Outcomes

The following is a list of skills that you will have after taking this course. This list is not meant to be exhaustive, and some topics may need to be reduced or omitted based on our pacing during the semester. A lot of the outcomes use terminology that we will introduce during the course, so the list is likely most useful in retrospect.

Foundations
  1. Explain the difference between statically and dynamically typed programming languages.
  2. Determine the static type of an expression involving one or more operators, method calls, and/or implicit/explicit type coercions.
  3. Draw memory diagrams that visualize the state of execution of a program involving multiple method calls and/or recursion.
  4. Explain how Java stores and references objects in memory.
  5. Use the Java documentation to locate a method for a desired behavior and successfully incorporate that method into a program.
  6. Draw object diagrams to visualize reference types.
  7. Write Java programs involving arrays that utilize syntax for indexing and array literals.
  8. Write and execute code in Java that uses program arguments.
  9. Develop methods in Java from their specifications that incorporate one or more (possibly nested) control structures such as if-else statements, for loops, and while loops.
  10. Develop recursive methods in Java given their specifications.
  11. Identify and explain errors in buggy Java code both with and without a computer.
Software Development
  1. Write detailed JavaDoc specifications for a method given its signature and an English description of its behavior.
  2. Describe the client and implementer roles in software development.
  3. Identify the pre-conditions, post-conditions, and side-effects of a method given its specifications and signature.
  4. Incorporate defensive programming practices such as pre-condition checks and invariant assertions into code.
  5. Write comprehensive unit tests for a method given only its specifications and signature.
  6. Evaluate the coverage of a unit test suite on a method or a class.
  7. Explain the process of test-driven development and identify its potential benefits.
  8. Describe the differences between black-box and glass-box testing.
  9. Describe the loop invariant of an iterative method involving an array and visualize it using a diagram.
  10. Use an array diagram to develop an iterative method.
  11. Write precise specifications for methods involving arrays that use range notation.
  12. Explain exceptions and their relationship to specifications and defensive programming.
  13. Write code that throws, propagates, and handles exceptions.
Complexity Analysis
  1. Explain the benefits of using asymptotic analysis versus performance testing to evaluate the efficiency of a piece of code.
  2. Determine the asymptotic time and space complexity of a piece of code involving one or more loops and/or method calls.
  3. Determine whether a given (mathematical) function belongs to a given big-O complexity class.
  4. Compare and contrast linear search and binary search.
  5. Determine the number of recursive calls and the maximum depth of the call stack of a recursive method and use these to compute its time and space complexities.
  6. Compare and contrast the insertion sort, merge sort, and quicksort algorithms, discussing aspects such as time/space complexity and stability.
Object-Oriented Programming
  1. Given the description of a class, identify its state and behaviors and use these to sketch its fields and public method signatures.
  2. Identify the invariant of a class and write code that maintains this invariant and/or asserts that it is satisfied.
  3. Compare and contrast static and instance methods.
  4. Write an instance method given its specifications that accesses and/or modifies the values of its object's fields.
  5. Draw memory diagrams that visualize the state of code involving instance method calls.
  6. Determine the scope and lifetime of a variable.
  7. Explain the object-oriented principle of encapsulation and its benefits. Identify examples of proper and improper encapsulation in provided code.
  8. Compare and contrast interfaces, abstract classes, and (concrete) classes.
  9. Implement an interface using a given state representation according to its specifications.
  10. Compare and contrast static types and dynamic types.
  11. Identify three scenarios where subtype substitution is permitted.
  12. Explain the benefits of leveraging polymorphism in object-oriented code.
  13. Describe the principle of dynamic dispatch and the compile-time reference rule.
  14. Explain inheritance relationships and their benefits/drawbacks over interfaces.
  15. Given a parent class, use inheritance to develop one or more child subclasses.
  16. Determine the correct visibility modifier (public, protected, or private) for a given field or method and justify your choice.
  17. Trace through the execution of a code sample that includes one or more of the following: inheritance, overridden methods, and super calls.
  18. Determine whether a class is mutable or immutable.
  19. Explain the semantics of the final keyword.
  20. Describe the semantic differences between the == operator and the equals() method, and determine the appropriate one for a given scenario.
  21. Identify the requirements of the equals() method specified in the Object class and override this method in user-defined classes.
Linear Data Structures
  1. Describe the differences between data structures and abstract data types.
  2. Implement a generic class or method with one or more generic type parameters. Use generic classes in client code.
  3. Describe the semantics of auto-boxing and auto-unboxing and identify where they happen in a code snippet.
  4. Implement abstract test suites for an ADT utilizing the template method pattern.
  5. Compare and contrast the behaviors of ordinary Java arrays and dynamic array types such as Java's ArrayList.
  6. Compare the performance of a List implemented with a dynamic array and a List implemented with a linked chain. Determine which is preferable for a given use case.
  7. Draw object (or node) diagrams to visualize linked data structures. Implement methods on linked data structures.
  8. Describe the use cases for the Iterable and Iterator interfaces.
  9. Implement Iterators for a given data structure class and use iterators as a client.
  10. Describe the iteratee pattern and how it differs from using an iterator.
  11. Identify and define functional interfaces and implement them using lambda expressions.
  12. Identify use cases for the Stack and Queue data structures.
  13. Describe composition relationships and scenarios where they may be preferable to inheritance.
Tree Data Structures
  1. Identify parent, child, root, leaf, ancestor, and descendent nodes in a tree.
  2. Given a tree, identify its size and height along with the depth and arity of its nodes.
  3. Write recursive methods on general and binary trees.
  4. Given an image of a binary tree, write out the pre-order, in-order, and post-order traversals of its nodes, and vice versa.
  5. Implement iterators on trees.
  6. Describe the binary search tree invariant and determine whether it is satisfied by a given tree.
  7. Describe the use cases for the Comparable and Comparator interfaces.
  8. Explain the semantics of generic type bounds and write code that incorporates them.
  9. Write modifying methods on a binary search tree that preserve its invariant.
  10. Analyze the time/space complexities of a given method on a binary search tree.
  11. Describe the invariants of a heap and determine whether they are satisfied by a given binary tree.
  12. Translate between the tree and array representations of a heap.
  13. Implement operations on a heap and determine their time/space complexities.
  14. Use a heap to implement a priority queue and analyze its performance.
Advanced Data Structures
  1. Describe the operations of the Set and Map ADTs.
  2. Write programs utilizing Sets and Maps.
  3. Compare the efficiency of Set implementations backed by arrays, sorted arrays, (balanced) binary search trees, and hash tables.
  4. Use functional interfaces to implement operations on data structures.
  5. Use a Map to implement a dynamic priority queue and analyze the space/time complexities of its operations.
  6. Identify the steps of hashing and describe the properties of a good hash function.
  7. Visualize the state of a hash table after performing a given sequence of operations.
  8. Describe the differences between hash tables that use chaining and probing for handling collisions. Identify scenarios where each implementation might be preferable.
  9. Implement data structures backed by chaining or probing hash tables.
Graphs
  1. Translate between a formal description (list of vertices, edges) and an illustration of a (weighted) graph.
  2. Describe adjacency list and matrix representations of a graph and compare the space/time complexities of operations on each of these representations.
  3. Perform BFS and DFS traversals of a given graph by hand and in code.
  4. Visualize the state of a graph traversal at a given point of its execution, describing each node as either undiscovered, discovered, visited, and/or settled.
  5. Describe the relationship between DFS and topological ordering.
  6. Describe Dijkstra's shortest path invariant and use it to establish properties on the unvisited portions of a graph at a given point in the execution of Dijkstra's algorithm.
  7. Implement Dijkstra's shortest path algorithm and analyze its time/space complexities.
Event-Driven Programming
  1. Categorize aspects of a GUI application as part of its model, view, or controller.
  2. Write code to set up the component hierarchy of a graphical application given a mock-up of its design.
  3. Describe the work performed by a layout manager and its interaction with elements in the component hierarchy.
  4. Use the Java documentation to find and incorporate new GUI widgets into graphical applications.
  5. Write code that performs custom painting on graphical components.
  6. Describe the inversion of control in event driven programs.
  7. Write event listeners in graphical applications.
  8. Explain the execution of a Swing application and its use of the Even Dispatch Thread.
Concurrency
  1. Describe advantages and disadvantages of concurrent code.
  2. Use Java's Thread class to write concurrent code.
  3. Identify race conditions in a given piece of concurrent code and list the possible states the program can be in after it executes.
  4. Explain the semantics of locks in Java and write code involving synchronization.
  5. Describe the conditions that can cause deadlock in a concurrent program and how it can be avoided.
  6. Explain how condition variables can be used to synchronize modifications of a shared resource.