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 process of compilation and the benefits of statically 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. Visualize the state of the runtime stack in a program involving multiple method calls and/or recursion.
  4. Describe how Java stores and references objects in memory and how references are aliased across method calls.
  5. Use the Java documentation to locate a method for a desired behavior and successfully incorporate that method into a program.
  6. Draw a memory diagram that visualizes instantaneous state of one or more objects.
  7. Write Java programs involving arrays, utilizing correct syntax for indexing and array literals.
  8. Write and execute code in Java that utilizes 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 from their specifications.
  11. Identify and explain errors in buggy Java code both with and without a computer.
Software Development
  1. Identify the pre-conditions, post-conditions, and side effects of a method and use these to write detailed Javadoc specifications.
  2. Incorporate defensive programming practices such as pre-condition checks and invariant assertions into code.
  3. Write comprehensive unit tests for a method given only its specifications and signature.
  4. Evaluate the coverage of a unit test suite on a method or a class.
  5. Explain the process of test-driven development and identify its potential benefits.
  6. Differentiate between black-box and glass-box testing and identify scenarios where each is appropriate.
  7. Identify the loop invariant of an iterative method involving an array and visualize it using an array diagram.
  8. Use an array diagram to develop an iterative method that maintains the visualized invariant.
  9. Write precise specifications for methods involving arrays that use range notation.
  10. Explain exceptions and their relationship to specifications and defensive programming.
  11. 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, discussing aspects such as time/space complexity and pre-conditions.
  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. Write an instance method given its specifications that accesses and/or modifies the values of its object's fields.
  4. Draw memory diagrams that visualize the state of code involving instance method calls.
  5. Determine the scope and lifetime of a variable.
  6. Explain the object-oriented principle of encapsulation and its benefits. Evaluate the appropriateness of encapsulation in provided code.
  7. Compare and contrast interfaces, abstract classes, and (concrete) classes, and determine which is most appropriate for a given use case.
  8. Implement an interface using a given state representation according to its specifications.
  9. Compare and contrast static types and dynamic types.
  10. Identify three scenarios where subtype substitution is permitted.
  11. Explain the benefits of leveraging polymorphism in object-oriented code.
  12. Describe the principle of dynamic dispatch and the compile-time reference rule.
  13. Explain inheritance relationships and their benefits/drawbacks over interfaces.
  14. Given a parent class, use inheritance to develop one or more child subclasses.
  15. Determine the correct visibility modifier (public, protected, or private) for a given field or method and justify your choice.
  16. Suggest and/or carry out a refactoring on a piece of code, and explain how it improves the code's maintainability.
  17. Trace through the execution of a code sample that includes one or more of the following: inheritance, overridden methods, and super calls.
  18. Explain the concept of immutability and its relation to the final keyword in Java.
  19. Contrast the == operator and the equals() method, and determine the appropriate one for a given scenario.
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 the behaviors, memory utilization, and performance of ordinary Java arrays and Lists backed by dynamic arrays and linked chains. Determine which is preferable for a given use case.
  6. Draw node diagrams to visualize linked data structures. Implement methods on linked data structures.
  7. Describe the use cases for the Iterable and Iterator interfaces.
  8. Implement Iterators for a given data structure class and use iterators as a client.
  9. Describe the iteratee pattern and identify a scenario where it may be preferable to using an iterator.
  10. Identify and define functional interfaces and implement them using lambda expressions.
  11. Describe the semantics of Stacks and Queues, and utilize them within programs.
  12. Describe composition relationships and scenarios where they may be preferable to inheritance.
Tree Data Structures
  1. Identify parent, child, root, leaf, ancestor, and descendant nodes in a tree.
  2. Given a tree, identify its size and height along with the depth and arity of its nodes.
  3. Write and analyze 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. Explain the semantics of generic type bounds and write code that incorporates them.
  8. Write modifying methods on a binary search tree that preserve its invariant.
  9. Analyze the time/space complexities of a given method on a binary search tree.
  10. Describe the invariants of a heap and determine whether they are satisfied by a given binary tree.
  11. Translate between the tree and array representations of a heap.
  12. Implement operations on a heap and determine their time/space complexities.
  13. 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, and utilize them in programs.
  2. Compare the efficiency of Set implementations backed by arrays, sorted arrays, (balanced) binary search trees, and hash tables.
  3. Use a Map to implement a dynamic priority queue and analyze the space/time complexities of its operations.
  4. Identify the steps of hashing and describe the properties of a good hash function.
  5. Visualize the state of a hash table after performing a given sequence of operations.
  6. Contrast hash collision resolution by chaining and linear probing. Identify scenarios where each implementation might be preferable.
  7. Implement data structures backed by chaining or probing hash tables.
Graphs
  1. Identify substructures in graphs such as neighborhoods, paths, and cycles both visually and programmatically.
  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 vertex as either undiscovered, discovered, visited, and/or settled.
  5. 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.
  6. 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 observer pattern and use it to write event listeners for graphical applications.
  7. Explain the execution of a Swing application and its use of the event 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 synchronize modifications of a shared resource and incorporate them in concurrent programs.