Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Scan for outdated or missing drivers - takes under a minute3Repair Windows errors before they cause bigger problemsTo run dependent tasks in order while allowing independent tasks to overlap, use Kahn’s algorithm to maintain a set of ready nodes, then add a separate asynchronous scheduler to dispatch them. The algorithm supplies dependency order; the runtime must also define concurrency, results, errors, and cancellation.
Model the dependency graph
Represent each task as a node and each dependency as a directed edge. Use the convention A -> B to mean that A must finish in the required prerequisite state before B can run. The graph-run project describes the same dependency-before-dependent contract: graph-run documentation.
As an Amazon Associate I earn from qualifying purchases.
Keep a registry of node identifiers, an adjacency list mapping each node to its successors, and a remaining-indegree count for each node. Indegree is the number of prerequisite edges that have not yet been satisfied. Before running anything, decide how the API treats duplicate identifiers, unknown dependencies, repeated edges, and self-edges; these are input-validation choices, not rules imposed by Kahn’s algorithm.
Use Kahn’s algorithm to find ready work
- Initialize the remaining-indegree count for every node.
- Add every zero-indegree node to a ready queue.
- Take a ready node. For a pure sort, emit it immediately; for a runtime, dispatch it and wait for the prerequisite state your API requires.
- Once a node qualifies as processed, decrement the remaining-indegree count of each successor. Add a successor to the ready queue when its count reaches zero.
- Continue until no ready node remains.
Several nodes may be ready at once, so a graph can have more than one valid topological ordering. A FIFO queue is a straightforward policy; use a priority structure if callers need a particular order among equally ready tasks, and document that choice.
#1 Best Overall
Turn the ready queue into an asynchronous scheduler
A topological sort returns an ordering; it does not itself execute tasks in parallel. A scheduler should dispatch ready operations asynchronously, subject to a concurrency limit, and collect their outcomes. The graph-run documentation makes this distinction, describing a runner that awaits asynchronous work while allowing independent operations to run concurrently: graph-run.
Track scheduled and completed tasks separately
Do not release a successor merely because its prerequisite was started. Track work that is ready, running, and completed as separate states. When an operation finishes in the state required by your contract, update its successors’ remaining-indegree counts and enqueue any newly eligible work. A worker limit caps the number of active operations; if no slot is free, ready nodes wait in the queue.
In JavaScript, async/await has the same concurrency semantics as promise chains, as MDN explains: Using promises. Awaiting one operation suspends that async function; it does not make a different task dependent on it unless the scheduler imposes that dependency. This is asynchronous coordination, not parallel CPU execution on the browser’s main thread.
Free tools Windows power users keep installed
One-click scans. No signup required.
Keep CPU-heavy work from monopolizing the browser
Browser JavaScript jobs run to completion. A long synchronous task can therefore delay input handling and other work on the same thread. A DAG scheduler can coordinate asynchronous operations, but it does not make CPU-intensive functions yield automatically. MDN describes the browser’s execution model and run-to-completion behavior here: JavaScript execution model.
Rank #3
Choose and document failure behavior
Failure semantics determine whether downstream nodes are allowed to run. For a strict dependency contract, release a successor only after its prerequisites succeed; if a prerequisite fails, mark the successor blocked and report the failure. An alternative API might treat failure as a completed prerequisite or continue independent branches, but it must state that explicitly. Decide whether the runner stops at the first error, returns branch-level outcomes, or aggregates errors; there is no universal policy established by the cited runtime example.
Whichever policy you choose, distinguish a task’s failure from a cycle. A failed task can block descendants even when the graph is acyclic. A cycle is a structural condition in which no topological ordering can satisfy all edges.
Detect cycles instead of accepting a partial run
For a pure ordering function, compare the number of emitted nodes with the graph’s total node count. If fewer nodes were emitted, the remaining graph contains a cycle or is blocked by one; the output is not a complete valid order. Report the condition rather than treating the partial list as success. In an executor, use the same structural check while accounting separately for nodes intentionally blocked by failed prerequisites. The graph-run documentation discusses cyclic graphs and their dependency-order consequences: graph-run documentation.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchMake cancellation reach the work
A Promise does not provide a universal cancellation protocol. MDN notes that cancellation generally has to reach the underlying asynchronous operation, often through AbortController and AbortSignal: Using promises.
If your runner accepts an AbortSignal, pass it to operations that support it and define what abort means: it can stop future dispatch, signal active operations, or do both. A signal cannot guarantee that an operation which ignores it will stop. The graph-run documentation also describes skipping pending work when its supplied signal fires: graph-run.
Specify the runtime contract
Before exposing the runner, make its behavior predictable for callers. Document these choices:
- Input validation: how duplicate node IDs, unknown dependencies, duplicate edges, and self-edges are handled.
- Ready-node order: whether equally ready nodes use FIFO insertion order or a documented priority rule.
- Concurrency: the limit on active work and whether a caller can configure it.
- Prerequisite success: whether a dependent waits for successful completion, any completion, or another defined state.
- Errors: whether failure is fail-fast, branch-local, or aggregated, and how blocked descendants appear in results.
- Cancellation: whether abort prevents new work, signals running tasks, or both, and what happens to results already collected.
- Cycles: whether diagnostics identify only that a cycle exists or also identify affected nodes.
The Promises/A+ specification describes promise behavior, not a DAG scheduler’s policies: Promises/A+. Treat ordering, dispatch, and failure handling as separate parts of your API contract.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
