"The question is no longer whether an application is concurrent and distributed, but only to what extent an application is concurrent and distributed."

— Dominik Tornow

resonatehq.io proudly presents:

Distributed

Async Await

— an open specification,

defining a holistic programming model for the cloud

Concurrency

introduces Partial Order

Distribution

introduces Partial Failure

Distributed Async Await

specifies how to implement

Coordination

to combat Partial Order

Recovery

to combat Partial Failure

Sequential Programming Model

for a delightful developer experience

It is common to manage the complexity that Concurrency and Distribution introduce at the application level, resulting in an awful developer experience. Distributed Async Await pushes that complexity to the platform level, offering a delightful developer experience.

Distributed

Async Await

extends the Async Await programming model...

...so Concurrency,

and Distribution,

become first class citizens

Distributed Async Await

asks developers to use just

Promises and Functions

enabling...

Durable Execution

without any proprietary primitives

Async Await pushes Concurrency to the platform level, but does nothing to address Distribution. Unlike Async Await, Distributed Async Await addresses both Concurrency and Distribution at the platform level. Where many Durable Execution solutions force developers to work with proprietary primitives like workflows and activities, Distributed Async Await, like Async Await, uses just promises and functions.

resonatehq.io also proudly presents:

Resonate

— an implementation

of the Distributed Async Await specification

Bringing

reliability and scalability

to the language you love

Currently available in

Python

Run bar() here

@resonate.register
def foo(ctx):
    promise = yield ctx.lfi(bar)
    result = yield promise
    return result

Run bar() over there

@resonate.register
def foo(ctx):
    promise = yield ctx.rfi("bar").options(
        send_to=poll("service-bar")
    )
    result = yield promise
    return result

Run here

Run over there

Sequential code

Concurrent, distributed, and durable executions

Resonate is dead simple, formally verified, and deterministically tested — the way all software should be.