Lecture

Imperative Event Handling: The Observer Pattern

Related lectures (31)

Functional Reactive Programming: Signals and Transformations

Explores functional reactive programming using signals to simplify state changes and event reactions in a more functional and clean approach.

Functional Reactive Programming

Explores functional reactive programming as a cleaner and more functional alternative to the traditional observer pattern, using signals to simplify complex observer hierarchies.

LabVIEW Design Patterns

Explores LabVIEW design patterns, covering local and global variables, race conditions, state machines, and producer-consumer architecture.

LabVIEW: Data Acquisition and Design Patterns

Covers LabVIEW fundamentals, data acquisition, sound acquisition, and design patterns like state machines and producer-consumer.

Design Patterns: Observer

Covers the implementation of the Observer design pattern in Java.

LabVIEW: Display and DAQ

Covers LabVIEW programming, focusing on displaying data and acquiring it.

Design Patterns: Elements of Reusable Object-Oriented Software

Explores the principles of design patterns and their role in creating flexible object-oriented code.

Observer Design Pattern

Explores the Observer design pattern in graphical interfaces using a simple spreadsheet example to demonstrate automatic value updates.

Design Reflection Minute

Focuses on the SWISH principle in instructional design and the orchestration graph.

Design Patterns: Observer/MVC

Explores implementing Observer and MVC design patterns in Java for updating a spreadsheet interface.

Concurrency Control & Recovery in Databases

Delves into transaction management, concurrency control, and recovery in databases to ensure data integrity and system resilience.

LabVIEW Design Patterns

Explores LabVIEW design patterns including local variables, race conditions, state machines, and queues.

Transaction Management & Concurrency Control

Explores transaction management, concurrency control, ACID properties, anomalies, and conflict serializability in database systems.

Asynchronous Programming: Callbacks and Failures

Covers the concept of asynchronous programming and how to handle dependencies and failures.

Good Code: Best Practices

Emphasizes good code practices, including user story specificity, problem-solving, readable code, design patterns, and defensive programming.

Functional Programming: Concepts and History

Explores imperative programming limitations, theories without mutation, functional programming principles, and the history of functional languages.

Transactions: Concepts and Implementations

Explores the significance and challenges of transactions, emphasizing ACID properties and the practical implications of using transactional memory for concurrency control.

Design Patterns for Decentralized Systems

Explores design patterns for decentralized systems, workload management, failure handling, and time management in large-scale systems.

Concurrency with Futures

Explores futures as a structured approach to concurrency, simplifying parallel tasks and input-output operations.

Introduction to Concurrency

Covers the basics of concurrency, its importance, and how to write concurrent programs.