39 Repos
Design patterns for implementing publish-subscribe relationships between components.
Distinguishing note: Focuses on the structural pattern of notification rather than stream processing.
Explore 39 awesome GitHub repositories matching software engineering & architecture · Observer Patterns. Refine with filters or upvote what's useful.
This project is a comprehensive educational resource designed to help developers master object-oriented design and architectural patterns. It serves as a structured reference for understanding how to organize classes and objects to improve code maintainability, resolve recurring development challenges, and prepare for technical engineering assessments. The guide covers the three primary categories of design patterns: creational, structural, and behavioral. Each pattern is explained through practical examples that demonstrate how to manage object instantiation, simplify complex interfaces, and
Implements the Observer pattern to establish subscription mechanisms for state change notifications.
This project is a comprehensive collection of software design patterns implemented in Python. It serves as a reference for architectural, behavioral, creational, and structural patterns to guide the organization of Python applications. The collection covers behavioral strategies for managing object communication and state, creational techniques for controlling object instantiation, and structural methods for composing classes and objects into flexible hierarchies. It also includes architectural references for system-wide structuring, such as multi-tier architectures and blackboard models. Th
Implements the observer pattern to notify dependent objects automatically when a subject state changes.
RxJS is a library for reactive programming that provides a framework for composing asynchronous and event-based programs. It utilizes observable sequences to model data flows, allowing developers to manage complex sequences of events through a declarative programming interface. The library implements the observer pattern to facilitate decoupled communication between data producers and subscribers. By employing a lazy execution model, streams remain dormant until a consumer explicitly subscribes, at which point data production is triggered. This approach enables the construction of predictable
Implements the observer pattern to facilitate decoupled communication between data producers and subscribers.
DesignPatternsPHP is a reference collection of software architecture patterns implemented in PHP 8. It provides a guide for object-oriented programming through sample code demonstrating creational, structural, and behavioral design patterns. The project includes reference implementations for common patterns such as factories, builders, singletons, adapters, bridges, and proxies. Each implementation is accompanied by a PHPUnit test suite to verify that the patterns behave correctly and produce expected logical outcomes. The codebase covers a broad range of architecture capabilities, including
Implements observer patterns to maintain lists of dependents that are notified of state changes through a communication interface.
DesignPatternsPHP is a reference collection of sample code implementations for common software design patterns using PHP 8.x. It provides a set of examples for implementing creational, structural, and behavioral patterns to organize object-oriented design. The project includes reference implementations for creational patterns that decouple systems from object instantiation, structural patterns that define how classes organize into complex components, and behavioral patterns that manage algorithms and responsibilities between objects.
Implements mechanisms allowing objects to subscribe to state changes in other objects via a notification system.
This project is a comprehensive technical interview preparation resource and computer science interview guide. It serves as an educational reference for developers to study core software engineering fundamentals and common coding patterns required for employment screenings. The repository provides detailed guides and references covering data structures and algorithms, networking and security, operating systems, and web development. It specifically focuses on the implementation and complexity analysis of sorting, searching, and graph algorithms. The material encompasses a wide breadth of comp
Implements the Observer pattern to demonstrate one-to-many dependency and notification systems.
SwifterSwift is a collection of Swift extensions designed to reduce boilerplate code during the development of iOS and macOS applications. It provides a library of pre-made utilities that extend the standard library and system frameworks to streamline data manipulation, system integration, and user interface optimization. The project provides specialized tools for a wide range of development tasks. This includes image processing and binary translation, text string manipulation, and complex data management for arrays, strings, and dictionaries. It also offers utilities for network request mana
Wraps system notification observers in a disposable pattern that automatically unregisters after a single execution.
This project is a curated educational guide and instructional resource for the Node.js runtime environment. It serves as a comprehensive introduction to core concepts, including asynchronous programming tutorials, network application primers, and guides on the module system and stream API. The material focuses on the fundamental building blocks of server-side development, specifically how to create reusable code packages and manage project dependencies via a module manifest. It provides detailed instruction on building programs that communicate over HTTP and TCP protocols to exchange data acr
Implements the publish-subscribe pattern via the EventEmitter for component communication.
RIBs is a mobile architecture framework that structures applications around isolated, lifecycle-managed units of business logic called RIBs. Each RIB separates routing, business logic, and construction into distinct classes through the Router-Interactor-Builder pattern, with hierarchical dependency injection scoping dependencies per node and static analysis enforcing architectural rules at build time. The framework enforces automatic disposal of Rx subscriptions scoped to interactor lifecycles, blocking compilation when subscriptions lack proper disposal to prevent memory leaks. It supports v
Disposes Rx subscriptions automatically when a child component detaches from its parent, preventing memory leaks.
RxLifecycle is a lifecycle management library for RxJava that binds observable streams to Android component lifecycles. It functions as a reactive stream lifecycle wrapper and a memory leak prevention tool by automatically terminating asynchronous sequences when activities or fragments are destroyed. The library integrates RxJava with Android lifecycle states to ensure that resource management is handled automatically. It prevents memory leaks by disconnecting streams and disposing of subscriptions when a component reaches a specific lifecycle state. The project covers the domain of Android
Provides automatic disposal of RxJava subscriptions when Android components are destroyed to prevent memory leaks.
This project is a sample library and implementation guide for using RxJava to manage asynchronous data streams and concurrent tasks in Android applications. It provides a collection of reference implementations for reactive programming, focusing on functional operators to transform and combine asynchronous data flows. The library demonstrates specific Android architectural patterns, such as implementing decoupled event buses for component communication and coordinating parallel network requests. It includes concrete examples of mobile-specific patterns including search input debouncing, list
Provides mechanisms to automatically dispose of RxJava subscriptions to prevent memory leaks during Android component destruction.
Riverpod is a reactive state management framework for Dart that manages application state through providers which automatically track dependencies and rebuild dependents when values change. It functions as an asynchronous data caching library, caching results of async operations and exposing loading, error, and data states to widgets without manual future handling. The framework includes a provider composition system that combines multiple providers into derived values that recompute automatically when any dependency changes, along with code generation for state providers that reduces boilerpl
Registers callbacks via ref.onDispose that run when a provider's state is destroyed, enabling cleanup of resources.
KVOController ist eine threadsichere Objective-C-Bibliothek, die als Wrapper für Cocoa Key-Value Observing dient. Sie verwaltet die Überwachung von Objekt-Eigenschaftsänderungen und automatisiert die Registrierung und Entfernung von Beobachtern. Das Projekt konzentriert sich auf Speichersicherheit, indem die Lebenszyklen der Beobachter an den Controller gebunden werden, wodurch sichergestellt wird, dass Beobachter bei der Deallokation entfernt werden, um Lecks und Abstürze zu verhindern. Es enthält einen threadsicheren Beobachtungsschutz, um Race Conditions und die Wiederbelebung von Beobachtern bei der Überwachung von Eigenschaften über mehrere Threads hinweg zu verhindern. Die Bibliothek bildet Objekt-Eigenschaftspfade auf Handler-Methoden ab und löst Benachrichtigungen durch Blöcke oder benutzerdefinierte Aktionen aus. Diese Koordination ermöglicht die Synchronisierung von Datenmodellen mit Benutzeroberflächen.
Automatically manages observer registration and removal by tying them to the controller lifecycle to prevent memory leaks.
Flutter Boost is a hybrid integration framework that embeds Flutter screens inside existing native iOS, Android, and OHOS applications. It provides a cross-platform page router that navigates between native and Flutter pages using a unified page-name scheme, along with lifecycle-aware engine binding that ties the Flutter engine to native platform lifecycle events for proper start, pause, and resume behavior. The framework also includes multi-engine instance management, allowing separate Flutter engine instances per tab to maintain independent page state. The framework distinguishes itself thr
Attaches a visibility observer to a single page to track show, hide, foreground, and background events.
Rx.NET is a reactive programming framework and library for the .NET ecosystem used to compose asynchronous and event-based programs. It provides an observable data stream API that treats live sequences of information as collections, allowing developers to coordinate asynchronous event workflows using a declarative syntax. The project functions as an extension of language integrated query patterns to asynchronous streams. This allows for the filtering and transformation of asynchronous notifications and event sequences through the application of query operators. The framework covers asynchron
Implements a unified interface to track and clean up active subscriptions, preventing memory leaks in asynchronous streams.
The .NET Reactive Extensions Library is a framework for composing, querying, and transforming asynchronous data streams. It provides a non-blocking implementation of the observer pattern to manage notifications and data flows between producers and consumers, functioning as an event stream processing library. The project applies LINQ-style querying and filtering operators to asynchronous sequences. This allows for the handling of event-driven programming patterns by utilizing composable operators to process notifications as they occur. The library covers asynchronous data streaming and non-bl
Implements a non-blocking observer pattern to manage data flows and notifications between producers and consumers.
Bacon.js is a JavaScript functional reactive programming library used for coordinating complex asynchronous data flows. It functions as an observable event stream framework and an asynchronous data flow orchestrator, allowing developers to model events as declarative streams and properties. The library distinguishes itself through its ability to manage reactive state and synchronize timing across multiple sources. It provides specialized mechanisms for atomic state synchronization to prevent glitches in derived properties and offers advanced coordination strategies such as asynchronous stream
Distributes discrete events from a single source to multiple subscribers through callback registration.
Vue Apollo is a GraphQL client library for Vue.js that integrates Apollo GraphQL queries and mutations into Vue components with reactive data binding. It provides a reactive data layer that automatically updates Vue component state when GraphQL query results change, and supports server-side rendering by prefetching queries during SSR to deliver fully populated HTML on initial page load. The library allows GraphQL queries and mutations to be declared directly inside Vue component options using the apollo property, keeping data dependencies co-located with the UI. It wraps Apollo Client's nor
Automatically subscribes to GraphQL subscriptions for active queries and unsubscribes on component unmount to prevent memory leaks.
AndroidX is the official collection of Android Jetpack libraries for building Android applications. It provides a suite of backward-compatible APIs that expose modern platform features on older Android versions, ensuring consistent functionality across devices. The project is built around lifecycle-aware component architecture, with tools like ViewModel for preserving UI data across configuration changes, LiveData for lifecycle-aware data observation, and WorkManager for constraint-based background task scheduling. The project distinguishes itself through compile-time code generation and type
Emits data updates to observers while automatically respecting lifecycle states.
Dieses Projekt ist eine Referenzsammlung praktischer Beispiele, die die Implementierung gängiger Software-Design-Patterns in Kotlin demonstrieren. Es dient als Leitfaden für architektonische Best Practices und objektorientierte Prinzipien durch die Anwendung von Verhaltens-, Erzeugungs- und Strukturmustern. Die Sammlung bietet konkrete Implementierungen, um zu zeigen, wie die Objektinstanziierung entkoppelt, die Kommunikation und Verantwortung zwischen Objekten verwaltet und komplexe Klassen- und Objektbeziehungen organisiert werden können. Die Referenz deckt Erzeugungsmuster wie Factories und Builder, Strukturmuster wie Adapter und Composites sowie Verhaltensmuster wie Observer und Strategies ab.
Implements the observer pattern to enable subjects to notify multiple subscribers of state changes.