Projects sharing features with RxGo

This project provides a formal specification and a set of standard Java interfaces for asynchronous stream processing. It defines a standardized protocol for passing sequences of elements between publishers and subscribers across different threads, centering on a reactive streams specification for the JVM. The project focuses on interoperability by providing a common API that allows different asynchronous streaming libraries to work together. This is achieved through a standard set of interfaces and bridging mechanisms that translate between incompatible streaming specifications. The specifi

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

Reactor is a reactive streams library and framework for building asynchronous data pipelines. It provides a system for coordinating execution contexts via an asynchronous event-loop manager, alongside a set of reactive abstractions for implementing high-performance TCP, UDP, QUIC, and HTTP services. The project includes a specialized testing tool for verifying the timing and order of asynchronous data flows and a bill of materials to synchronize compatible versions of core reactive libraries and networking add-ons. Its capability surface covers non-blocking network services, demand-based bac

Hazelcast is a distributed data platform that combines an in-memory data grid with a stream processing engine to support real-time analytics and event-driven applications. It functions as a partitioned, distributed key-value store that replicates data across cluster nodes to provide low-latency access and high availability. The platform also serves as a distributed SQL query engine, allowing users to execute standard SQL statements against both in-memory datasets and external data sources. What distinguishes Hazelcast is its use of a distributed consensus subsystem to maintain strongly consis

This project is an educational resource designed to help developers master concurrent execution and synchronization patterns in Go. It provides a structured collection of hands-on coding exercises and test-driven challenges that focus on the practical implementation of multi-threaded software engineering practices. The repository emphasizes the core mechanisms of Go concurrency, including channel-based communication, mutex locking, and lifecycle coordination. It covers essential patterns such as managing background tasks, implementing graceful service shutdowns, and enforcing rate limits or e

Effector is a reactive state management library designed for building complex, event-driven applications. It functions as a data flow engine that models application logic as a directed acyclic graph, ensuring that state updates propagate automatically through interconnected nodes. By utilizing atomic state updates and declarative unit composition, the library maintains data consistency and provides a predictable execution model for managing application state. The project distinguishes itself through its framework-agnostic architecture, which decouples business logic from user interface implem

Ants is a goroutine pool library for Go that functions as a concurrent task orchestrator and resource consumption limiter. Its primary purpose is to manage and reuse a pool of goroutines to limit concurrency and reduce the memory allocation overhead associated with frequent thread creation. The system provides a runtime worker manager capable of adjusting pool capacity dynamically to respond to fluctuating workloads. To maintain stability, it includes panic recovery mechanisms that intercept runtime failures within worker threads to prevent a single failing task from crashing the entire appli

Redux-Observable is a functional middleware for Redux that treats action streams as observables to manage complex asynchronous side effects and timing. It acts as an asynchronous action orchestrator, transforming streams of Redux actions into new actions through pipelines of observable-based side effects to coordinate application state changes. The project allows for the dynamic loading, injection, and replacement of side-effect streams at runtime. This enables the addition of asynchronous task handlers without requiring a full application restart, supporting code splitting and lazy loading o

This repository is a collection of practical implementation patterns and reference samples for using RxJava 2 to manage asynchronous data streams in Android applications. It serves as a reactive programming implementation guide, providing code examples for handling complex event-driven logic and asynchronous patterns within mobile environments. The project distinguishes itself by providing specific reference implementations for common mobile challenges, such as real-time search with debouncing, on-demand list pagination for infinite scrolling, and cache-first data streaming to reduce perceive

conc is a Go concurrency library and structured concurrency framework providing primitives for managing parallel tasks, mapping slices, and collecting results. It implements a system for spawning scoped tasks to ensure all child processes complete before their parent exits. The library includes a goroutine pool manager to limit active concurrent processes and a panic-safe task runner that catches panics in goroutines and propagates stack traces to the parent. It also provides a concurrent map-reduce tool for transforming data slices and processing streams in parallel while maintaining the ori

Tunny is a worker pool library and concurrency manager for Go. It functions as a concurrent task scheduler that limits the number of parallel workers processing jobs to prevent system resource exhaustion. The project enables the maintenance of persistent state within individual worker routines to avoid repeated initialization costs. It also supports dynamic worker scaling, allowing the number of active background workers to be adjusted in real time without interrupting tasks in progress. The library provides mechanisms for task timeout enforcement and worker lifecycle management, including t

Ramda is a functional JavaScript standard library and toolset for immutable data transformation and composition. It provides a comprehensive suite of pure utility functions designed to enable declarative data processing pipelines. The library is distinguished by its use of automatic function currying and a data-last argument order. These design patterns allow multi-argument functions to be partially applied, simplifying the construction of processing chains where data is passed through a sequence of operations. The toolkit covers broad data manipulation capabilities, including list processin

Cats is a Scala functional programming library and type class library designed to implement algebraic patterns and functional abstractions. It provides a standardized set of interfaces and a modular toolkit of functional wrappers and containers to enable ad-hoc polymorphism and generic programming across disparate types. The project serves as a functional abstraction standard, offering a monad transformer suite to compose nested effectful contexts and handle multiple computational side effects within a single pipeline. It further enables the construction of embedded domain-specific languages

imove is a JavaScript workflow orchestration library and functional pipeline framework. It operates as a graph-based logic engine that executes modular functional units by traversing a directed graph of nodes and edges. The system functions as a visual logic flow mapper, translating graphical flowcharts into executable program sequences to manage business logic visually. It allows for the creation of reusable logic nodes that can be instantiated multiple times with unique parameters. The library provides an environment-agnostic runtime to execute the same orchestrated functional sequences ac

Js-csp is a concurrency library that implements communicating sequential processes with channels and generator-based routines for asynchronous programming in JavaScript. It provides a framework for building data processing pipelines and managing concurrent workflows, bringing Go-style channels and process coordination primitives to applications. The library coordinates message passing through buffered channels, stream mixing, multi-channel selection, and pub-sub broadcasting. Communication pathways support unbuffered rendezvous, fixed buffers, sliding windows, and dropping overflow. Operation

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

Lodash is a JavaScript utility library and data manipulation toolkit. It provides a collection of modular functions for transforming, filtering, and validating arrays, objects, strings, and numbers. The project functions as a functional programming toolkit, offering capabilities for function composition, currying, and lazy evaluation. It includes mechanisms for execution control, such as debouncing and throttling, to manage the timing and frequency of function invocations. The library covers a broad surface of data operations, including deep cloning and merging of complex nested structures,

RxJava is a reactive stream processing framework and JVM reactive extensions library. It serves as an asynchronous dataflow orchestrator used to compose event-based programs by transforming, combining, and consuming real-time data flows on the Java Virtual Machine. The project distinguishes itself through integrated backpressure flow control, which manages the emission rate between producers and consumers to prevent memory exhaustion. It further provides mechanisms for concurrent thread management and parallel data processing to offload blocking operations and maintain application responsiven

Cycle.js is a functional reactive web framework and observable-driven UI library used for building web applications. It employs a reactive stream architecture that treats the document object model and side effects as continuous data streams, coordinating state and logic through a functional cycle. The framework distinguishes itself by isolating side effects from core logic using a system of drivers. This architecture maps external events to internal commands through a symmetric input-output pipeline, ensuring that the application remains a cycle of pure functions. The project provides capabi

r4ds is a data science curriculum and educational resource designed for mastering the R programming language. It provides a structured learning path for the end-to-end process of importing, tidying, transforming, and visualizing data. The project emphasizes a reproducible data science guide and a comprehensive curriculum for data wrangling. It includes specialized tutorials on the grammar of graphics for layered data visualization and technical publications created with Quarto that blend executable code with narrative prose. The material covers a broad range of analytical capabilities, inclu

Redux is a predictable state container designed to manage global application data through a centralized store. It operates on a unidirectional data flow architecture where state transitions are triggered by dispatching action objects, which are then processed by pure reducer functions to produce a new, immutable state tree. This approach ensures that application data remains consistent and traceable across the entire component hierarchy. The library distinguishes itself through a functional pattern that relies on pure functions for state logic and a middleware-based extension system. This mid

This project is a command-line processor designed for the parsing, filtering, and transformation of structured data streams. It functions as a declarative programming environment that treats data as immutable streams, allowing users to perform complex structural modifications through the composition of small, reusable functions. By utilizing a recursive tree traversal engine, the system enables the navigation, inspection, and modification of deeply nested hierarchical data structures. The engine distinguishes itself through a stream-oriented architecture that processes input records one by on

The Reactive Extensions for JavaScript

KotlinMvp is a short-video Android application developed with Kotlin. It utilizes the Model-View-Presenter architectural pattern to maintain a clear separation between business logic and the user interface. The project integrates a short-video playback interface that supports content discovery through category filtering and popularity rankings. It employs a Retrofit REST client for network communication and the RxJava reactive framework to manage asynchronous data streams and background tasks. Image loading and caching are handled via the Glide image loader. The application includes capabili

This project is a reference implementation of the Model-View-Presenter (MVP) architecture for Android applications. It focuses on separating business logic from the user interface by decoupling data logic, UI presentation, and view layers. The implementation distinguishes itself through the inclusion of a boilerplate generator that automatically creates the activity, presenter, and view files required for the MVP pattern. It utilizes a compile-time dependency injection framework to manage object lifetimes and a reactive programming workflow to handle asynchronous data streams and event propag

ReactiveCocoa is a functional reactive programming framework and Cocoa UI binding layer. It provides a library for composing asynchronous data streams and managing application state through signals and functional operators. The framework functions as an Objective-C data binding library that links object properties and method calls to reactive streams using runtime dynamism and swizzling. It includes a utility to convert traditional key-value observation notifications into composable streams for synchronized state tracking. The project covers reactive UI programming by connecting interface el

Azul is a native desktop application builder and UI toolkit for creating high-performance graphical user interfaces. It utilizes a functional and reactive programming model for managing layout and state, enabling the development of native software through a CSS-based toolkit. The framework is distinguished by its use of the WebRender engine to provide GPU-accelerated rendering. This allows the system to display complex user interface elements with high efficiency and speed by leveraging hardware acceleration. The project enables the design of desktop interfaces using a document object model