sporadic alternatives and similar libraries

Based on the "Control Flow" category.
Alternatively, view sporadic alternatives based on common mentions on social networks and blogs.

async

9.4 4.8 L4 sporadic VS async

Async utilities for node and the browser
Bluebird

9.0 3.6 L2 sporadic VS Bluebird

:bird: :zap: Bluebird is a full featured promise library with unmatched performance.

Amplication: open-source Node.js backend code generator

An open-source platform that helps developers build backends without spending time on boilerplate & repetitive coding. Including production-ready GraphQL & REST APIs, DB schema, DTOs, filtering, pagination, RBAC, & more.

Promo amplication.com

q

8.6 0.0 L3 sporadic VS q

A promise library for JavaScript
Javascript State Machine

7.6 0.0 sporadic VS Javascript State Machine

A javascript finite state machine library
when

5.6 1.6 L5 sporadic VS when

A solid, fast Promises/A+ and when() implementation, plus other async goodies.
step

4.6 0.0 L5 sporadic VS step

An async control-flow library that makes stepping through logic easy.
contra

2.9 0.0 L4 sporadic VS contra

:surfer: Asynchronous flow control with a functional taste to it
angular-async-loader

1.8 0.0 sporadic VS angular-async-loader

Load modules and components asynchronously for angular 1.x application.
modern-async

1.7 0.0 sporadic VS modern-async

A modern JavaScript tooling library for asynchronous operations using async/await, promises and async generators
ObjectEventTarget

0.7 0.0 L4 sporadic VS ObjectEventTarget

A same behaviour EventTarget prototype, that can work with any object from JavaScript
OF

0.5 0.0 sporadic VS OF

🍬 Promise wrapper with sugar 🍬

* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.

Do you think we are missing an alternative of sporadic or a related project?

Add another 'Control Flow' Library

Popular Comparisons

README

sporadic

Composable Concurrency Abstractions for JavaScript.

Example

#!/usr/bin/env node

(async () => {
  const sporadic = require('sporadic')
  const channel = await sporadic.channels.open()

  const wasReceivedPromise = sporadic.channels.send(channel, "Hello, World!")
  const messagePromise = sporadic.channels.receive(channel)
  const promises = [ wasReceivedPromise, messagePromise ]

  const [ wasReceived, message ] = await Promise.all(promises)
  console.log(wasReceived) // ==> true
  console.log(message) // ==> Hello, World!
})()

Installation

Through UNPKG (for browsers):

<script src="https://unpkg.com/sporadic/dist/index.js"></script>

Through NPM:

$ npm install sporadic

To install the development snapshot, use npm link. For example, on this cloned repository:

$ npm link .

And then, on your project:

$ npm link sporadic

Stable releases are tags in the branch release. The master branch here is only to track the next releases, please don't rely too much on that branch. All the hard work is made on the development branch.

Documentation

For every submodule within this sporadic library, there's an API documentation available at the directory docs/ under the filename SUBMODULE.md, where SUBMODULE stands for the submodule provided with this library (yes, I know the redundancy :joy:). Each submodule corresponds to a concurrency abstraction. Currently, the following abstractions are implemented:

sporadic.streams, an abstraction for reactive streams made of multiple publishers and multiple subscribers. The subscription process is implicit, the reference for the stream object is all that is needed.
sporadic.channels, an abstraction for synchronous queues made of many producers and consumers. This concurrent data type is a bare minimal tool for pipelines of chained producers and consumers.
sporadic.coroutines, an abstraction for suspendable subroutines. Such abstraction also behaves as a task/promise whenever we wait for the final coroutine result (but keep in mind that coroutines can "loop" forever). It's kinda like the JavaScript generators, with the sole difference of being asynchronous instead synchronous calls (and thus, allowing us to mix asynchronous I/O with that).