Learning Goals for 214

The following gives an overview of the (high-level) learning goals of 214. All learning goals are roughly written in a form “after taking this class, the student should be able to ...”. The learning goals are ordered loosely following the course’s current structure.

214 Object Oriented Software Construction

• Basic fluency in Java programming (including equals&hashcode, exceptions, static methods, visibility, generics, overloading, mutation, collections, IO)
• Use modern development tools, including version control systems, development environments, build and test automation, debugger, unit testing, test coverage, and static analysis tools
• Understand the basics concepts of Object Oriented Programming

• Understand subtype polymorphism/dynamic dispatch and design software exploiting it
• Reuse code with inheritance and delegation, explain the differences and tradeoffs between the two
• Distinguish between object identity and object equality
• Use collections; understand their importance, generality, and design

• Reason about functional correctness of a program; select a suitable quality assurance strategy

• Specify expected behavior; choosing suitable formality
• Understand how to modularly verify a program (using pre/post conditions and behavioral subtyping)
• Apply unit testing to test functional correctness and basic reasoning about test suite quality in terms of coverage
• Use coverage analysis tools and interpret the results
• Use static analysis tools and interpret their results
• Understand the tradeoffs between verification and testing (and static analysis)

• Design object-oriented software systems at medium scale

• Understand the benefits and costs of designing software (at different levels) before coding
• Identify and model the key entities and their relationships in the domain of interest (conceptual modeling)
• Discuss tradeoffs between designs; evaluate object-oriented designs based on design goals
• Fluency with design patterns to facilitate communication and discussions about design
• Apply design patterns to achieve quality attributes such as decoupling, extensibility and reusability
• Design software for reuse (domain analysis, design patterns, libraries, components, frameworks, and product lines)
• Follow a design process from conceptual model, to object model, to implementation
• Communicate effectively with UML (class) diagrams

• Understand common design paradigms in object-oriented languages, including event-based programming, GUIs, and the design patterns associated with these paradigms
• Concurrency

• Understand the tradeoffs between immutable and mutable data structures
• Understand concurrency as a source of complexity in software

• Be able to discuss the historical context and the need for concurrency
• Uses of concurrency in software design merely as a convenient abstraction
• Know basic problems of concurrency related to functional correctness, performance, and software design

• Know common abstractions for parallelism and concurrency, and the trade-offs among them

• Understand explicit concurrency

• Be able to write thread-safe concurrent programs in Java, using both Java concurrency primitives and higher-level services of the Java concurrency framework
• Recognize data race conditions in concurrent programs

• Understand common thread-safe data structures, including high-level details of their implementation

• Be able to use the Java API’s concurrent data structures in a thread-safe program

• Know transactions and their implementation, and serializability
• Understand common uses of concurrency in software design

• Know the relationship between language design and abstractions of concurrency and parallelism

• Be aware of tools and techniques for testing and verifying concurrent programs

• Understand fundamentals of distributed systems

• Understand scale, concurrency, geography, and failures as sources of software complexity
• Be able to explain high-level distributed systems design goals such as the end-to-end principle, robustness principle, incremental benefits, use of redundancy
• Know high-level details of common communications protocols

• Be able to write network programs using the java.net API

• Know common abstractions for distributed processing and their trade-offs

• Be able to discuss RPC/RMI
• Be able to write simple MapReduce programs

• Know some common components in distributed software design

• Understand primary-backup replication, caching, partitioning, general techniques for replication