FoundationDB Flow

100%

FoundationDB Flow

✓ Published0🌍 Public

Last edited Feb 3, 2016

Created on Dec 26, 2016

This example compares the performance of Flow, a C++11 actor-based concurrency language, against other programming languages using the ring benchmark. A table lists execution times for Ruby, Java, Erlang, Go, and Flow, showing Flow completing 1,000,000 message sends in 0.075 seconds. The code samples demonstrate Flow’s `ACTOR` and `wait` keywords for asynchronous futures and promises. The benchmark data comes from external sources circa 2010, with Flow’s result derived from its native-code compilation and callback-based actor rewriting.

AI-generated description

Similar vizzes

Loading thumbnail…

Reactor-based framework versus Node.js streaming

The benchmark compares a JVM-based Reactor framework using Java NIO FileChannel.transferTo (sendfile) with a Node.js streaming application using fs.createReadStream and pipe, both serving a 1MB file. Under Apache Bench with 100 concurrent users, the JVM framework shows roughly double the throughput and lower latency, with mean total time of 121ms versus 254ms. A single-user test confirms the JVM framework sustains higher requests per second. The example highlights how the Reactor framework’s multi-threaded event handling outperforms Node.js’s single-threaded streaming for file transfers.

Aackuser

56% match

Loading thumbnail…

Gist 69a9d27f495ef695f39947559d3ead66

This example demonstrates a Kotlin-based reactive flow pipeline that emits a sequence of eight "Hello" messages at 700-millisecond intervals. The visualization pairs two components: an `Activity_Flow.kt` file that subscribes to a lifecycle-scoped `Flow` collector, and a `ViewModel_Flow.kt` file that defines the `triggerFlow()` function using the `flow` builder with `repeat` and `delay` operators. The code highlights the use of Kotlin coroutines and the Flow API for asynchronous, time-based data streaming, though it does not render any graphical output.

HHsuHsiaoHsuan

54% match

Loading thumbnail…

Async/await 6

The example shows an asynchronous JavaScript flow where the program awaits one operation, then runs two independent tasks in parallel via `Promise.all`. The code displays `doA()`, followed by `doB(a)` and `doC(a)` as the two concurrent calls after the first result resolves. It uses native `async`/`await` syntax with `Promise.all()` to coordinate these dependent and independent steps. No rendering library or data source is visible; the visualization focuses purely on the sequence and branching of these promises.

PPanJ

50% match

Loading thumbnail…

AB Benchmark Node.js (via Restify) - 10,000 requests (10 concurrent)

This example displays the results of an ApacheBench load test against a Node.js Restify server, showing 10,000 requests completed with 10 concurrent connections. The visualization plots the percentage of requests served within specific time thresholds, from the 50th percentile at 3 milliseconds up to the longest request at 18 milliseconds. The chart uses D3.js to render the distribution of response times, with data parsed from the ApacheBench text output. The visualization highlights the server’s consistent performance, as most requests complete within 4 milliseconds, and reveals the small variance in request handling times.

HHugoberry

50% match

Loading thumbnail…

Comparing the performances of various DBMS using dplyr for large-ish data

This example compares the execution times of data manipulation operations across different database management systems using the `dplyr` and `dbplyr` R packages. It benchmarks a `group_by` with `summarise` and a `left_join` with `mutate` on a 50-million-row tibble, running the same queries against in-memory data frames, SQLite databases (in-memory and file-based), and PostgreSQL. The code uses `system.time` to measure the elapsed user and system times for each operation, recording results in a benchmark summary table. The visualization highlights performance differences across database backends for typical data wrangling tasks.

RRCura

49% match

Loading thumbnail…

globby - chuhai

This example compares the performance of two glob-matching libraries—the local `globby` fork and the upstream `globby` master—against `glob-stream`, using the `chuhai` and `ava` benchmarking suites. It shows raw operations per second for three pattern scenarios (negative globs and multiple positive globs) across async and sync APIs, with results from 10 runs each. The code directly invokes `globby.sync()`, `globby()`, and `glob-stream`'s `create()` to measure throughput, while the markdown output lists the fastest implementation per test. Data is generated from a temporary directory containing 500 files per subfolder, and the rendering is plain text from benchmark results.

HHypercubed

49% match

Loading thumbnail…

Gist 1f8fbb4e3c5e59a3a46d

This streamgraph visualizes the rise and fall of programming language popularity on GitHub from 2008 to 2009, using a stacked area layout rendered in SVG via D3 v3. Each colored band represents a language’s share of activity per month, with the x-axis showing time and the y-axis the percentage of total activity. The data reveals how languages such as C, JavaScript, and Ruby dominate the early period, while smaller languages like Erlang, Scala, and Haskell appear intermittently, and the overall composition shifts dramatically over time as different languages gain and lose share.

CCaged

49% match

Loading thumbnail…

Gist 7642122

This visualization compares write performance between Apache CouchDB and couchup, a Node.js implementation using levelup and leveldb. It presents benchmark results from three tests—new writes, edits, and optimized edits—as raw text output from the `compare-new-writes.js` script, showing couchup outperforming CouchDB in the final run. The description highlights the optimization strategy of storing only new keys with complex key sequences and using `level-peek` for reads, avoiding overwrites and deletes.

Aalessioalex

49% match