reacted-io/reacted

ReActed is a high-performance, reactive actor framework for Java that manages concurrent message processing through a system of isolated reactors, mailboxes, and dispatchers. It provides a robust infrastructure for local and distributed communication, supporting serialization via custom interfaces, Avro, and Chronicle Queue, along with service discovery through ZooKeeper and Kafka. The system enables complex reactive workflows through a FlowGraph API for computational graphs and offers configurable backpressure, load balancing, and monitoring capabilities for building scalable, fault-tolerant applications.

42 changes.

This period focused on a comprehensive refactoring of the ReActed core, replacing legacy Java serialization with a custom ReActedMessage interface and introducing typed configuration models for drivers, reactors, and services. The changes standardized message delivery semantics, improved dispatcher performance via ring buffers, and enhanced type safety across the framework. These internal shifts were accompanied by extensive updates to examples and tests to align with the new APIs, alongside the introduction of new features like load balancing policies and reactive MongoDB support.

7 changes.

This period focused on establishing the core infrastructure for reactive data processing by introducing the FlowGraph API and a comprehensive operator framework for building computational pipelines. Concurrently, the project implemented new serialization interfaces and message types in the core module to support structured data handling. These foundational features were complemented by extensive benchmarking examples and consistency tests to validate performance and reliability.

A new example application, MessageStormApp, has been added to the communication examples to demonstrate high-volume asynchronous message publishing. The app sets up a client-server architecture using ZooKeeper for service discovery and gRPC for communication, where the client repeatedly sends messages to a remote server service to measure and display the total time taken for a specified number of cycles.

examples/src/main/java/io/reacted/examples/communication/apublish · high confidence

Added a new example demonstrating a flow graph that maps input integers to strings, reduces them by joining the strings, and prints the result.

examples/src/main/java/io/reacted/examples/flow · high confidence

The spawning example directory now includes a new ReActorRelationsApp that demonstrates how to create and manage relationships between actors, including spawning child actors and handling inter-actor communication through messages like BreedRequest, Greetings, and ThankYouFather.

examples/src/main/java/io/reacted/examples/spawning · high confidence

The core serialization module now includes new \Serializer\ and \Deserializer\ interfaces that define methods for reading and writing primitive types (int, long, byte, string), arrays, enums, and generic serializable objects. Additionally, a \ReActedMessage\ interface is introduced with several concrete message implementations (\StringMessage\, \IntMessage\, \LongMessage\, \ByteArrayMessage\, \EnumMessage\, etc.) that provide default encoding and decoding logic using the new interfaces, enabling structured message serialization.

core/src/main/java/io/reacted/core/serialization · high confidence

This change introduces a new \FlowOperator\ base class and configuration system in the \flow\ module, enabling the construction of reactive data processing pipelines. It adds specific operator implementations: \MapOperator\ for transforming messages, \ReduceOperator\ (including \ZipOperator\) for aggregating messages based on configurable reduction rules, and \ServiceOperator\ for routing requests to external services and mapping responses. The operators support backpressuring, dynamic service discovery for output routing, and configurable refresh periods for operator gates.

flow/src/main/java/io/reacted/flow/operators · high confidence

The flow module now exposes a new \FlowGraph\ API that allows users to define, configure, and execute computational graphs of reactive operators. This change introduces \ReActedGraph\ as the primary builder for these graphs, enabling the addition of operator configurations via a fluent builder pattern. The \GraphController\ manages the lifecycle of the graph, including spawning operator services, initializing input streams, and handling backpressuring mailboxes. Users can now start a graph using the \run\ method, which returns a \CompletionStage\ containing the initialized operator references, and stop it via the \stop\ method. This provides a structured way to compose and run complex reactive workflows within the ReActed system.

flow/src/main/java/io/reacted/flow · high confidence

Added new handler classes (Get.java and Post.java) to the webapp backend examples. The GET handler retrieves data from a database service using service discovery and returns the result via HTTP. The POST handler implements backpressured reading of incoming request bodies, stores the payload in the database, and handles store success or error responses. Both handlers integrate with the ReActor system for asynchronous processing and service communication.

examples/src/main/java/io/reacted/examples/webappbackend/handlers · high confidence

Added a new example HTTP server that serves files via GET requests and automatically applies backpressure to handle arbitrarily large files. The implementation uses the ReActor system to manage concurrent file reading and response writing, ensuring stable performance under load.

examples/src/main/java/io/reacted/examples/httpserver · high confidence

The pattern library introduces new utility classes for asynchronous execution, including AsyncUtils which provides methods for async loops and foreach operations, and ObjectUtils for null-safe operations and property serialization. Additionally, the UnChecked class now supports three-argument consumers (TriConsumer) and checked runnables, broadening the range of checked functional interfaces that can be used without explicit exception handling. The Try class has been refined with improved generic typing for error handling and updated documentation.

pattern/src/main · high confidence

Added a new set of Java examples in the \examples/src/main/java/io/reacted/examples/benchmarking\ package to help users measure system performance. \BenchmarkingUtils\ provides shared utilities for generating backpressure-aware, non-stop, and constant-window message streams, as well as setting up statistics collectors for latency and requests-per-interval metrics. \MessageTsunami\ demonstrates a multi-threaded crunching scenario with dedicated dispatchers and backpressuring mailboxes. \ReactionTime\ measures end-to-end latency percentiles using a Chronicle Queue local driver and a single-threaded dispatcher. \SingleChannel\ benchmarks a single-actor self-communication loop to isolate processing overhead.

examples/src/main/java/io/reacted/examples/benchmarking · high confidence

The core services module now includes configurable load balancing strategies for routing messages to service instances. Users can choose between Round Robin, Lowest Load (selecting the routee with the fewest pending messages), or custom partitioning via the new \LoadBalancingPolicy\ interface. Additionally, a \GateSelectorPolicies\ utility provides First and Random selection strategies for gateways, and a \SelectionType\ enum allows services to be discovered either as a routed load-balanced endpoint or via direct reference to a specific instance.

core/src/main/java/io/reacted/core/services · high confidence

Added a new quickstart example in the \examples/src/main/java/io/reacted/examples/quickstart\ directory that demonstrates a distributed system setup using Kafka for remoting and ZooKeeper for service discovery. The example includes a server (\QuickstartServer\) that spawns a \GreeterService\ with backpressuring mailboxes, a client (\QuickstartClient\) that discovers and invokes the service, and a subscriber (\QuickstartSubscriber\) that uses typed subscriptions to intercept messages. This provides users with a concrete reference implementation for integrating these core Reacted components.

examples/src/main/java/io/reacted/examples/quickstart · high confidence

The example web application backend now includes a new reactive database service that persists data to MongoDB. This change introduces a new actor-based storage component (DatabaseService) along with its associated message definitions (StorageMessages) and reactive MongoDB subscribers (MongoSubscribers), enabling the example app to store and query data using non-blocking MongoDB operations.

examples/src/main/java/io/reacted/examples/webappbackend/db · high confidence

Added a new example backend application that demonstrates a replayable web service architecture. The example includes a main entry point that configures a local driver (switchable between Chronicle Queue and a Replay driver) and spawns a database service alongside an HTTP server gate. The server gate handles incoming POST and GET requests by spawning child reactors to process them, enabling the entire request flow to be recorded and subsequently replayed for testing or debugging purposes.

examples/src/main/java/io/reacted/examples/webappbackend · high confidence

Added ReActedUtils, a new utility class providing helper methods for core operations. It includes resolveServices for aggregating service discovery results based on filters and a gate selector, composeDeliveries and ifNotDelivered for chaining and handling delivery status with error callbacks, and rescheduleIf for conditionally rescheduling messages with error logging.

core/src/main/java/io/reacted/core/utils · high confidence

The ChannelId class now implements ReActedMessage, enabling binary serialization and deserialization via encode/decode methods instead of string parsing. A new NULL\_CHANNEL\_TYPE enum value and a per-type name cache in ChannelType replace the previous string-based identity and construction patterns, optimizing performance and supporting reactive stream compliance.

core/src/main/java/io/reacted/core/config · high confidence

The DispatcherConfig now enforces stricter validation and provides sensible defaults for dispatcher settings. The number of dispatcher threads must now be a power of 2, and the batch size and thread count default to 10 and 1 respectively if not explicitly set. Additionally, a null dispatcher configuration is now available via a dedicated constant, and builder methods are marked final to prevent subclassing.

core/src/main/java/io/reacted/core/config/dispatchers · high confidence

The core Dispatcher implementation has been refactored to replace Java's BlockingDeque with Agrona's ManyToOneRingBuffer for scheduled queues, significantly reducing memory allocation and garbage collection overhead. This change introduces a claim-based dispatch mechanism with a slowpath fallback (LinkedBlockingQueue) to handle contention, ensuring that reactors are reliably scheduled even under high load. Additionally, the dispatcher loop now accepts a reActorUnregister function, enabling more robust lifecycle management and cleanup of reactors.

core/src/main/java/io/reacted/core/runtime · high confidence

The example application now uses the Chronicle Queue-based local driver (CQLocalDriver) instead of the previous direct communication driver, changing the underlying message transport mechanism. Additionally, a new 'FlowDispatcher' is configured with a batch size of 10 and a single thread, altering how messages are dispatched within the example system. The configuration also removes the explicit ask-timeout cleanup interval setting and disables execution recording by default.

examples/src/main/java/io/reacted/examples · high confidence

The mailbox system has been refactored to remove the asynchronous \asyncDeliver\ method from the \MailBox\ interface, replacing it with a synchronous \deliver\ method that returns a \DeliveryStatus\. This change standardizes delivery outcomes: bounded and unbounded mailboxes now return \NOT\_DELIVERED\ when full instead of \BACKPRESSURED\, and the \NullMailbox\ now returns \DELIVERED\_BUT\_DO\_NO\_RESCHED\ while recycling messages. A new \BackpressuringMbox\ wrapper provides explicit, configurable backpressure control via a builder, replacing the previous \Backpressuring\ implementation. Additionally, new high-performance mailbox implementations (\FastBoundedMbox\, \FastUnboundedMbox\) using Agrona queues and a \TypeCoalescingMailbox\ for message deduplication have been introduced.

core/src/main/java/io/reacted/core/mailboxes · high confidence

The core message system has been refactored to replace the Java \Externalizable\/\Serializable\ approach with a custom \Serializer\/\Deserializer\ interface defined by the new \ReActedMessage\ interface. The \Message\ class now implements \ReActedMessage\, using \encode\ and \decode\ methods instead of \writeExternal\/\readExternal\. The \DataLink\ class has been removed, with its fields (\generatingReActorSystem\ and \ackingPolicy\) moved directly into the \Message\ class as \creatingReactorSystemId\ and \ackingPolicy\. The \AckingPolicy\ enum has been updated to include an \isAckRequired\ flag. A new \Recyclable\ interface with \revalidate\ and \invalidate\ methods has been added, likely to support object pooling or recycling for performance optimization.

core/src/main/java/io/reacted/core/messages · high confidence

The ping example now uses the new ReActedMessage serialization interface instead of Java's Serializable, requiring message classes to implement ReActedMessage. Communication methods have been updated: tell() is replaced by publish() for synchronous delivery checks, and aTell() is replaced by apublish() for asynchronous messaging. The reactor implementation uses ReActedMessage.StringMessage for handling string payloads, logs via the context instead of direct System.out, and configures the mailbox using UnboundedMbox and Dispatcher constants.

examples/src/main/java/io/reacted/examples/communication/tell/ping · high confidence

The ping-pong example has been refactored to align with the latest ReActed framework changes. Message classes (Ping, Pong) now implement ReActedMessage with explicit encode/decode methods instead of Java's Serializable interface. Actor spawning uses the new spawn() method, and message sending switches from tell() to publish() and reply(). Configuration now references Dispatcher.DEFAULT\_DISPATCHER\_NAME and UnboundedMbox, with typed subscriptions using TypedSubscription.NO\_SUBSCRIPTIONS.

examples/src/main/java/io/reacted/examples/communication/tell/pingpong · high confidence

The streams module now uses a new \BackpressuringMbox\ builder and \ReActedMessage\ serialization interface instead of the previous \Backpressuring\ mailbox and \Externalizable\ approach. This change updates the \BackpressureManager\ and \ReactedSubmissionPublisher\ to support configurable backpressure thresholds, improved message handling via new message types (e.g., \PublisherComplete\, \PublisherInterrupt\), and a more robust subscription lifecycle. Users will see a shift in how publishers are configured (requiring a threshold parameter) and how they integrate with the core reactor system's serialization and mailbox infrastructure.

streams/src/main/java/io/reacted/streams · high confidence

The reactor configuration system has been restructured to improve type safety and extensibility. The legacy \SubscriptionPolicy\ enum and its \SniffSubscription\ inner class have been removed and replaced by a new \TypedSubscription\ type, which is now used directly in \ReActiveEntityConfig\ for message subscriptions. The mailbox provider signature has changed from a simple \Supplier\<MailBox\>\ to a \Function\<ReActorContext, MailBox\>\, allowing context-aware mailbox creation. A new \ReActorServiceConfig\ abstract class and concrete \ServiceConfig\ have been introduced to handle service-specific settings such as routee count, load balancing policies, and remote service discovery flags. Additionally, a \ServiceRegistryConfig\ class has been added to manage service registry properties, and \ReActorConfig\ has been updated to use a \fromConfig\ factory method instead of the previous \toBuilder\ pattern.

core/src/main/java/io/reacted/core/config/reactors · high confidence

The core reactor system now uses a unified \ReActedMessage\ interface for all message payloads, replacing the previous \Serializable\ constraint. This change updates \ReActions\ to route messages based on \ReActedMessage\ types and modifies \ReActorId\ to implement \ReActedMessage\ with a new custom \encode\/\decode\ serialization logic, removing the old Java \Externalizable\ implementation. Additionally, new interfaces \GenericReActor\ and \ReActiveEntity\ are introduced to standardize reactor configuration and action access.

core/src/main/java/io/reacted/core/reactors · high confidence

Core reactor message classes (such as DeadMessage, EventExecutionAttempt, ReActorInit, and ReActorStop) have switched from Java's native Externalizable serialization to a custom ReActedMessage interface with encode/decode methods. EventExecutionAttempt now implements Recyclable, adding object-recycling support with validity checks. DeliveryStatusUpdate now carries additional metadata (firstMessageSourceChannelId and ackSourceReActorSystem) and its equality/hashCode include these fields. DeliveryStatus enum values and helper methods were adjusted (e.g., BACKPRESSURED renamed to BACKPRESSURE\_REQUIRED, and isDelivered now includes BACKPRESSURE\_REQUIRED and DELIVERED\_BUT\_DO\_NO\_RESCHED). Logging message types (ReActedDebug, ReActedError) now extend a new LogMessage base class, and ReActedInfo was moved from the service-registry config package to this message package and changed from an enum to a class extending LogMessage.

core/src/main/java/io/reacted/core/messages/reactors · high confidence

The core reactor system messaging API has been refactored to improve type safety and simplify message delivery. The \ReActorRef\ class no longer implements \Externalizable\ but instead implements \ReActedMessage\, and its synchronous \tell\ and asynchronous \aTell\ methods have been replaced by \publish\ and \apublish\ methods that return \DeliveryStatus\ directly rather than \CompletionStage\<Try\<DeliveryStatus\>\>\. Message interception and subscription logic has been migrated from the legacy \SubscriptionPolicy.SniffSubscription\ to a new typed system using \TypedSubscription\ and \TypedSubscriptionsManager\, allowing for more granular control over local versus full (remote) message interception. Additionally, the legacy \ReActorService\ and \ReActorServiceConfig\ classes, which handled routee spawning and load balancing, have been removed, and a centralized \RegistryGatesCentralizedManager\ has been introduced to manage routes and gates for reaching other reactor systems.

core/src/main/java/io/reacted/core/reactorsystem · high confidence

The ReActorSystemConfig class has been refactored to introduce a System Monitor feature, allowing users to configure the refresh interval for system statistics collection via the new setSystemMonitorRefreshInterval method. The configuration model now enforces stricter type safety by parameterizing LocalDriver, RemotingDriver, and ServiceRegistryDriver with their respective configuration builders. Additionally, the system now supports a configurable maximum number of reactors (defaulting to 1,000,000) and uses a default local driver for direct communication, while replacing the previous ask-timeout cleanup interval with the new system monitor refresh interval.

core/src/main/java/io/reacted/core/config/reactorsystem · high confidence

The channel driver configuration system has been restructured by replacing the legacy \ReActedDriverCfg\ abstract class with a new \ChannelDriverConfig\ base class. This change introduces configurable timeouts for automatic message failure detection (\aPublishAutomaticFailureTimeout\), periodic maintenance intervals for the acknowledgment cache (\ackCacheCleanupInterval\), and explicit sizing for the acknowledgment cache (\ackCacheSize\). Existing driver-specific configurations, such as \DirectCommunicationConfig\, \NullDriverConfig\, and various logger configurations, have been updated to extend this new base class, standardizing how channel properties and driver-specific settings are built and managed.

core/src/main/java/io/reacted/core/config/drivers · high confidence

The core exception package has been reorganized to improve error handling clarity. A new base exception, DeliveryException, was introduced, and NoRouteToReActorSystem now extends it instead of RuntimeException. ReActorRegistrationException was changed from a checked Exception to an unchecked RuntimeException and now accepts a reactor name in its constructor. Additionally, new specific exceptions ServiceNotFoundException and ChannelUnavailableException were added to the core package, with the latter replacing a previous example class.

core/src/main/java/io/reacted/core/exceptions · high confidence

The drivers module has been restructured to support a more robust and configurable system. The ZooKeeper service registry driver has been completely rewritten with a new builder-based configuration model (ZooKeeperDriverConfig) that exposes granular control over connection timeouts, ping intervals, and reconnection strategies, replacing the previous Properties-based setup. Chronicle Queue drivers now utilize a dedicated serialization layer (CQSerializer/CQDeserializer) and have been split into local and remote configurations, with the remote driver explicitly supporting topic naming. Additionally, the Kafka driver now uses a new Avro schema (Message.avdl) for message serialization, introducing structured records for reactor references and system IDs to improve type safety and interoperability.

drivers · high confidence

The local communication drivers have been refactored to replace the previous anonymous inner-class implementations with dedicated, configurable classes: DirectCommunicationDriver, DirectCommunicationLoggerDriver, and DirectCommunicationSimplifiedLoggerDriver. This change introduces specific configuration objects (DirectCommunicationConfig, DirectCommunicationLoggerConfig, DirectCommunicationSimplifiedLoggerConfig) for each driver, moving away from the generic LocalDriver base class which has been removed. The SystemLocalDrivers utility now instantiates these new typed drivers, allowing for more structured setup of direct local messaging and message logging behaviors within the ReActorSystem.

core/src/main/java/io/reacted/core/drivers/local · high confidence

The replay examples (SystemReplayApp and SystemReplayAskApp) have been updated to reflect internal API changes: driver configuration now uses CQLocalDriverConfig instead of CQDriverConfig, mailboxes are explicitly set to UnboundedMbox, and the dispatcher name defaults to FlowDispatcher/DEFAULT\_DISPATCHER\_NAME. Message sending has shifted from tell/aTell to publish/apublish with ReActedMessage wrappers, and actor spawning uses the new spawn() method. The ask example now handles replies via thenAccept(System.out::println) instead of ifSuccessOrElse, and typed subscriptions use TypedSubscription.NO\_SUBSCRIPTIONS.

examples/src/main/java/io/reacted/examples/replay · high confidence

Service discovery requests have been refactored to support flexible, configurable filtering instead of simple name matching. The \ServiceDiscoveryRequest\ now accepts a \ServiceDiscoverySearchFilter\ (with a new \BasicServiceDiscoverySearchFilter\ implementation) that allows matching services by name, CPU load, IP address, hostname expression, and channel ID. Corresponding message classes like \ServiceDiscoveryReply\ and \FilterItem\ have been updated to implement \ReActedMessage\ and use immutable collections, replacing the previous \Serializable\-based approach and simplifying the API by removing the need to pass \ReActorSystem\ instances during reply construction.

core/src/main/java/io/reacted/core/messages/services · high confidence

The service example has been refactored to align with recent framework changes: service configuration now uses the new \ServiceConfig\ builder instead of \ReActorServiceConfig\, mailbox providers have shifted from \BasicMbox\/\BoundedBasicMbox\ to \BoundedMbox\, and subscription policies now use \TypedSubscription\ instead of the previous \SubscriptionPolicy\. Message handling has also been updated to use the new \ReActedMessage\ interface for \TimeRequest\ and \TimeMessage\, replacing the old \Serializable\ approach, and the reply mechanism now uses \ctx.reply()\ instead of \ctx.getSender().tell()\. Additionally, service discovery now utilizes a \BasicServiceDiscoverySearchFilter\ builder.

examples/src/main/java/io/reacted/examples/remoting/services, examples/src/main/java/io/reacted/examples/services · high confidence

The service registry message classes have been refactored to implement the ReActedMessage interface instead of Java's Serializable interface. This change standardizes how registry events (such as publication requests, cancellations, and synchronization status) are serialized, replacing the previous custom string-based serialization logic found in classes like RegistryServicePublicationRequest. Additionally, several message classes have been renamed to better reflect their specific roles, such as RegistryPublicationRequest becoming ReActorSystemChannelIdPublicationRequest and RegistryUnregisterChannel becoming ReActorSystemChannelIdCancellationRequest.

core/src/main/java/io/reacted/core/messages/serviceregistry · high confidence

The ServiceRegistryDriver interface has been converted into an abstract class that implements GenericReActor, replacing the previous loose coupling with a strongly-typed configuration model. This change removes the generic ReActions and Properties-based configuration in favor of a specific ServiceRegistryConfig type, ensuring that service registry drivers now receive and expose their configuration through a structured, type-safe builder pattern rather than untyped properties.

core/src/main/java/io/reacted/core/drivers/serviceregistries · high confidence

The stream example applications (SlowdownProducerApp and StreamToMultipleSubscribersApp) have been refactored to use the new ReActedMessage.IntMessage type instead of raw Integers, requiring subscribers to handle the message wrapper. The SlowdownProducerApp now demonstrates explicit backpressure management by checking submit() return values and dynamically adjusting delay, while the StreamToMultipleSubscribersApp removes the best-effort subscription model in favor of reliable subscriptions for all consumers. Both examples also simplify the TestSubscriber implementation by removing manual comparator-based ordering checks in favor of the message's built-in comparator.

examples/src/main/java/io/reacted/examples/streams · high confidence

The message classes in the streams package (PublisherComplete, PublisherInterrupt, PublisherShutdown, SubscriberError, SubscriptionReply, SubscriptionRequest, and UnsubscriptionRequest) now implement the ReActedMessage interface instead of Java's Serializable interface. SubscriptionRequest and UnsubscriptionRequest have been converted to Java records, simplifying their structure while maintaining immutability via the @Immutable annotation. All message classes now include proper toString() implementations for better debugging and logging.

streams/src/main/java/io/reacted/streams/messages · high confidence

The system now includes a SystemMonitor reactor that periodically broadcasts local CPU and memory statistics to subscribers. The Ask protocol has been refactored to use ScheduledExecutorService instead of Timer, enforce strict reply type checking (failing on unexpected types), and improve timeout handling. Service discovery in RemotingRoot now supports filter-based service discovery, handles duplicated system publication errors by shutting down the conflicting driver, and manages registry connection loss by flushing remote gates. DeadLetter handling now logs message types and sender information, and SystemLogger now supports Info-level logging.

core/src/main/java/io/reacted/core/reactors/systemreactors · high confidence

The typed subscription examples have been updated to reflect recent framework changes. The \Update\ message class now implements \ReActedMessage\ instead of \Serializable\ and uses a Java record. The \UpdateGeneratorApp\ demonstrates the new \spawn\ API, uses \UnboundedMbox\ instead of \BasicMbox\, references \Dispatcher.DEFAULT\_DISPATCHER\_NAME\ instead of the system default, and uses \setTypedSubscriptions\ with \TypedSubscription.LOCAL\ instead of the older \setTypedSniffSubscriptions\ with \SubscriptionPolicy\. Additionally, message sending now uses \publish\ instead of \tell\, and a new \RemoteBroadcastingApp\ example shows how to broadcast messages to remote subscribers using gRPC and ZooKeeper.

examples/src/main/java/io/reacted/examples/typedsubscription · high confidence

The local driver system has been refactored to use a unified, generic interface for message delivery, replacing the previous \Message\-centric approach with \ReActedMessage\ and explicit \ReActorRef\ types. This change introduces a new \LocalDriver\ base class and specific implementations like \NullLocalDriver\ and \LoopbackDriver\, standardizing how messages are published, told, and acknowledged within the same reactor system. Users will experience more consistent behavior for stream publishers and asynchronous tell operations, with improved handling of dead letters and subscriber propagation logic that now dynamically switches between synchronous and asynchronous fan-out based on subscriber count.

core/src/main/java/io/reacted/core/drivers/system · high confidence

The ask communication example has been updated to use a new typed reply pattern: TimeRequest and TimeReply are now Java records implementing ReActedMessage, replacing the previous Serializable-based request and raw Instant response. The ReactiveClockApp now sends a TimeReply object via publish instead of telling an Instant, and the BrokenClockApp handles errors using a handle callback instead of a Try wrapper. Additionally, the examples now use the updated BoundedMbox API and the spawn method on ReActorSystem, reflecting internal API changes in the core library.

examples/src/main/java/io/reacted/examples/communication/ask · high confidence

Added benchmarking and consistency test utilities; Added tests for distributed publishing and updated Reactive Streams TCK validation; Test suite migrated to new core APIs and typed message model; Updated copyright header in UncheckedTests.java.

This release introduces a new 'reacted-flow' module and a 'reacted-framework' meta-package to simplify dependency management via a new BOM. The framework now supports Apache Avro serialization, adding the Kafka Avro serializer and Avro libraries to the drivers module. Under the hood, the project upgrades to Java 17, bumps Chronicle Queue and Wire to version 5.25ea1, updates JUnit to 5.7.2, Mockito to 5.3.1, and Jackson Databind to 2.13.4.2, while also adding commons-io and JMH as dependencies.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 55 → 56 (+1.8)
• Rubric changed (rubric-2026.08.17 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 95 → 97 (+2.0)
• Architecture 98 → 96 (-2.0)
• Maturity 46 → 46 (+0.0)
• Readiness 50 → 55 (+4.7)
• Security 56 → 60 (+3.9)

• Change coupling: FlowGraph.java ↔ FlowOperatorConfig.java (flow/src/main/java/io/reacted/flow/FlowGraph.java)
• Change coupling: FlowGraph.java ↔ GraphController.java (flow/src/main/java/io/reacted/flow/FlowGraph.java)
• Change coupling: SystemLogger.java ↔ ReactedSubmissionPublisher.java (core/src/main/java/io/reacted/core/reactors/systemreactors/SystemLogger.java)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — no supported dependency manifest was read
• Duplicated block (12 lines × 2) (examples/src/main/java/io/reacted/examples/quickstart/QuickstartClient.java)
• Duplicated block (12 lines × 2) (examples/src/main/java/io/reacted/examples/typedsubscription/RemoteBroadcastingApp.java)
• Duplicated block (6 lines × 2) (drivers/src/main/java/io/reacted/drivers/channels/grpc/GrpcDriver.java)
• Duplicated block (7 lines × 2) (examples/src/main/java/io/reacted/examples/remoting/services/ServicePublicationApp.java)
• Duplicated block (8–9 lines × 2) (examples/src/main/java/io/reacted/examples/replay/SystemReplayApp.java)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No exposed public API
• Test reliability not included
• The replay showoff is described but there is no guidance on how to run it locally or what output one can expect. (examples/src/main/java/io/reacted/examples/replay/README.txt)
• The webapp backend example requires a running MongoDB instance but the README states it 'requires a running mongodb instance' without specifying how to obtain one or where to connect in code. (examples/src/main/java/io/reacted/examples/webappbackend/README.txt)
• dormant codebase — no living knowledge left to concentrate

• Change coupling: Ask.java ↔ ReActorSystem.java (core/src/main/java/io/reacted/core/reactors/systemreactors/Ask.java)
• Change coupling: RemotingDriver.java ↔ RegistryGatesCentralizedManager.java (core/src/main/java/io/reacted/core/drivers/system/RemotingDriver.java)
• ClassTooLong: ReActorSystem (core/src/main/java/io/reacted/core/reactorsystem/ReActorSystem.java)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (11 lines × 2) (examples/src/main/java/io/reacted/examples/quickstart/QuickstartClient.java)
• Duplicated block (11 lines × 2) (examples/src/main/java/io/reacted/examples/typedsubscription/RemoteBroadcastingApp.java)
• Duplicated block (5 lines × 2) (core/src/main/java/io/reacted/core/mailboxes/BoundedMbox.java)
• Duplicated block (5 lines × 2) (drivers/src/main/java/io/reacted/drivers/channels/grpc/GrpcDriver.java)
• Duplicated block (7 lines × 2) (examples/src/main/java/io/reacted/examples/remoting/services/ServicePublicationApp.java)
• Duplicated block (7–8 lines × 2) (examples/src/main/java/io/reacted/examples/replay/SystemReplayApp.java)
• FileTooLong: reactorsystem/ReActorSystem.java (core/src/main/java/io/reacted/core/reactorsystem/ReActorSystem.java)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Most significant orphaned file (core/src/main/java/io/reacted/core/reactorsystem/ReActorSystem.java)
• Most significant orphaned file (drivers/src/main/java/io/reacted/drivers/serviceregistries/zookeeper/ZooKeeperDriver.java)
• …and 10 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

reacted-io/reacted was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.