flow VS noria

We use a macaddr8 that embeds a wall-clock timestamp (so they're ascending order, achieving data locality) with some additional randomness. It's worked really well for us:

https://github.com/estuary/flow/blob/master/supabase/migrati...

we use macaddr8 instead of bigint, because it has a postgres serialization / JSON encoding which lossless-ly round-trips with browsers and it works well with PostgREST. The same CANNOT be said for bigint, which is a huge footgun.

I can't claim to know much about CloudQuery, but we are an open-source platform with CDC connectors from PostgreSQL and materializations to BQ and elsewhere. We also have fully-managed connectors if you don't want to deal with hosting.

This is essentially how we model things in Flow (disclosure: I work there). We call them Derivations, which are data products that are built (derived) from other data products. Each data product (we call them Collections) is backed by a set of append-only logs, so they can be read by many different consumers at different times. IDK if our product can work for you since we don't (yet) support stuff like MQTT, but there's a pretty generous free tier if you'd be able to push the data over HTTP. Either way, I just think it's cool that others have independently arrived at similar ideas about how to model streaming tasks!

We Estuary Git Docs have an open-source connector for Kafka -> Snowflake that could perform the tasks of a) flattening the data and b) removing duplicates via exactly once end to end delivery

Estuary Technology | Backend Engineer | Developer Evangelist | Rust, Go | REMOTE OR HYBRID | UTC-7 to UTC+2

Regional offices in NYC & Columbus, OH

Estuary (https://www.estuary.dev/) is the first real-time Data Operations platform for future-proof pipelines, including both historical and real-time data set up in minutes.

Our team is rapidly growing, VC funded and led by two successful, repeat founders.

We primarily develop in Rust and Go and are heavily built on top of gazette which is an internally developed streaming engine.

Flow: https://github.com/estuary/flow

Gazette: https://gazette.readthedocs.io/en/latest/

Backend Engineer: https://www.estuary.dev/about/#backend

Developer Evangelist: https://www.estuary.dev/about/#developerevangelist

^This is an exciting opportunity to make direct impact and shape user perception of a new product that brings a fresh experience to working with real-time data.

As this is a unique role, we are open to a variety of personas (data engineers, backend developers, Solutions Engineers and of course DevRel professionals).

Estuary offers full health benefits, competitive salary, unlimited PTO, 401K, equity, and a culture that values trust, transparency, and a flexible work environment to optimize your work/life balance.

To apply, send your resume and any questions to [email protected]

Flow Gazette We are looking for a backend engineer who is early in their career (around 1-3 years of industry experience) to join our team.

Estuary Technology | Junior Backend Engineer | Rust, Go | REMOTE OR HYBRID | Regional offices in NYC & Columbus, OH

Estuary (https://www.estuary.dev/) is the first real-time Data Operations platform for future-poof pipelines, including both historical and real-time data set up in minutes.

Our team is rapidly growing, VC funded and led by two successful, repeat founders.

We primarily develop in rust and go and are heavily built on top of gazette which is an internally developed streaming engine.

Flow: https://github.com/estuary/flow

Gazette: https://gazette.readthedocs.io/en/latest/

We are looking for a junior backend engineer with 2-3 years of industry experience.

For engineers who have an unquenched curiosity and drive to solve complex distributed systems problems, this is an opportunity to advance your career alongside a team of subject matter experts.

We are focused on expanding our catalog of open-source data connectors and building out our managed service platform.

ESTIMATED COMPENSATION: $110,000 - $150,000.

Estuary offers full health benefits, competitive salary, unlimited PTO, 401K, equity, and a culture that values trust, transparency, and a flexible work environment to optimize your work/life balance.

Email your resume to [email protected] to apply!

It does seem like a weird bug that this would cause errors https://github.com/estuary/flow/runs/5642694619?check_suite_... seems like it should be some kind of warning instead of an error?

where you'd subscribe for live updates.

[1]: https://github.com/estuary/flow

> Automatically managed, application-transparent, physical denormalisation entirely managed by the database is something I am very, very interested in.

Sounds a bit like Noria: https://github.com/mit-pdos/noria

It feels more than a little bit coincidental to call it Noria when https://github.com/mit-pdos/noria exists (and has been posted about here on HN)... especially with the whole bit about incrementally computing changes.

Is this similar in spirit to Noria?

https://github.com/mit-pdos/noria

I assume you have studied Noria? https://github.com/mit-pdos/noria

If you want to look how databases are implemented in rust try https://github.com/mit-pdos/noria

Only tangentially related, but I wondered what were the difference between ReadySet and Noria, and they address this exact question in their repository I'm really glad to know that the ideas behind Noria didn't die when Noria was abandoned after /u/jonhoo graduated.

:wave: Author of the paper this work is based on here.

I'm so excited to see dynamic, partially-stateful data-flow for incremental materialized view maintenance becoming more wide-spread! I continue to think it's a _great_ idea, and the speed-ups (and complexity reduction) it can yield are pretty immense, so seeing more folks building on the idea makes me very happy.

The PlanetScale blog post references my original "Noria" OSDI paper (https://pdos.csail.mit.edu/papers/noria:osdi18.pdf), but I'd actually recommend my PhD thesis instead (https://jon.thesquareplanet.com/papers/phd-thesis.pdf), as it goes much deeper about some of the technical challenges and solutions involved. It also has a chapter (Appendix A) that covers how it all works by analogy, which the less-technical among the audience may appreciate :) A recording of my thesis defense on this, which may be more digestible than the thesis itself, is also online at https://www.youtube.com/watch?v=GctxvSPIfr8, as well as a shorter talk from a few years earlier at https://www.youtube.com/watch?v=s19G6n0UjsM. And the Noria research prototype (written in Rust) is on GitHub: https://github.com/mit-pdos/noria.

As others have already mentioned in the comments, I co-founded ReadySet (https://readyset.io/) shortly after graduating specifically to build off of Noria, and they're doing amazing work to provide these kinds of speed-ups for general-purpose relational databases. If you're using one of those, it's worth giving ReadySet a look to get these kinds of speedups there! It's also source-available @ https://github.com/readysettech/readyset if you're curious.

It seems similar to MIT's Noria [1]

> Noria is a new streaming data-flow system designed to act as a fast storage backend for read-heavy web applications based on Jon Gjengset's Phd Thesis, as well as this paper from OSDI'18. It acts like a database, but precomputes and caches relational query results so that reads are blazingly fast. Noria automatically keeps cached results up-to-date as the underlying data, stored in persistent base tables, change. Noria uses partially-stateful data-flow to reduce memory overhead, and supports dynamic, runtime data-flow and query change.

[1] https://github.com/mit-pdos/noria

Materialize is really neat, also checkout https://github.com/mit-pdos/noria. It inverts the query problem and processes the data on insert. Exactly like what most applications end up doing using a no-sql solution.