Eugene W. Stark

Second part of a two-semester sequence, CSE 160 and CSE 260. Applies object-oriented programming methodology to data storage and manipulation on complex data sets, such as, binary trees, heaps, priority queues, balanced trees and graphs. Recursive programming is heavily utilized. Fundamental sorting and searching algorithms are examined along with informal efficiency comparisons. Intermediate-level programming language concepts and paradigms, including functional programming, basics of type systems, program and data abstractions, and modularity.

Bulletin Link

• An ability to define and use complex object-oriented data structures and use them in the context of large-scale software development.
• An understanding of the importance of time and memory efficiency in algorithm design.
• An understanding of programming language paradigms and tradeoffs.
• An understanding of functional techniques to identify, formulate and solve problems.

• Y. Daniel Liang, Introduction To Java Programming, Comprehensive Version. Pearson, 11th ed., 2017.
• Michael Scott, Programming Language Pragmatics, 4th ed., Morgan Kaufmann, 2015.

• The software lifecycle: requirements and specifications, use cases, object-oriented design
• UML: use case diagrams, class diagrams, sequence diagrams
• Guidelines for class design, encapsulation, programming by contract, preconditions, postconditions, invariants, and assertions
• Mutability and immutability, side effects and aliasing
• The Java object model: primitive and object types, subtypes, wrapper classes, object identity versus equality, hashing and equality, cloning objects: shallow and deep copy, object serialization
• Application frameworks, model/view/controller architecture, design patterns
• Packages, using refactoring tools
• Threads and synchronization, using threads with Swing
• Running time analysis, big-O notation, using execution profiling tools to measure time and memory use
• Abstract data types: specification and implementation
• Collections: lists, bags, sets, and maps
• Indexed collections, sorted collections, binary search
• Sorting: mergesort, heapsort, quicksort
• Stacks, queues, and their applications: depth-first and breadth-first search, Dijkstra's algorithm
• Trees: binary heaps, binary search trees, balanced trees
• Linked implementation of lists and trees, skip lists
• Recursion
• Hash tables and their implementation

• Software development process, specifications and requirements, object-oriented design, version management, using threads with Swing.
• Graphical user interfaces.
• Design Patterns, Threads and synchronization.
• Abstract data types, collection types, mapping types.
• Linked lists, iterators.
• Stacks and applications.
• Queues and applications.
• Recursion.
• Trees, binary search trees, heaps and balanced trees.
• Searching, binary search, hash tables, complexity, big-O notation, using profiling tools to assess program performance.
• Sorting, mergesort, heapsort, quicksort.

CSE260