Fauna Blog

> services such as https://restdb.io/ or https://fauna.com/ These are a no-go. Why should I use a proprietary solution when there are superior free open source offerings? Sure it's more effort to spin up an aws ec2 instance but that's very well worth it. I then have full control over my database and I don't have to deal with proprietary sh*t. > RPC-named express routes is more than sufficient Yes RPC is exactly what I was looking for. It's super simple. I don't need all that REST and GraphQL stuff. > REST solves Honestly, I don't understand what REST solves. > over-engineering a simple app can lead to greater confusion. Yes simplicity is key. > RPC-named express routes is more than sufficient Actually for Node.js there is Wildcard API[1] which I discovered yesterday. It's even simpler than express routes. [1]: https://github.com/reframejs/wildcard-api

Sr. NodeJS/Front End Developer AND Sr. Developer Advocate Fauna is building the first modern operational data platform without compromises or limits. FaunaDB is a serverless database that offers low-latency, global access to both relational and document data, without sacrificing strong data consistency. Scalable, secure, and developer-friendly, FaunaDB is designed to support modern application development in the Cloud. Developers looking to build rich applications look to FaunaDB as the de facto data platform for speed and ease. To build a great company requires exceptionally talented, passionate, and committed team members. Every day we are relentless in our mission to innovate, exceed customer expectations and continually make it easier for developers to build applications using FaunaDB. Join us on this mission. https://fauna.com/

Great question! With Seafowl, the idea is different from what the modern data stack addresses. It's trying to simplify public-facing Web-based visualizations: apps that need to run analytical queries on large datasets and can be accessed by users all around the world. This is why we made the query API easily cacheable by CDNs and Seafowl itself easy to deploy at the edge, e.g. with Fly.io. It's a fairly different use case from DuckDB (query execution for Web applications vs fast embedded analytical database for notebooks) and the rest of the modern data stack (which mostly is about analytics internal to a company). Just to clarify, we're not related to IOx directly (only via us both using Apache DataFusion). If we had to place Seafowl _inside_ of the modern data stack, it'd be mostly a warehouse, but one that is optimized for being queried from the Internet, rather than by a limited set of internal users. Or, a potential use case could be extracting internal data from your warehouse to Seafowl in order to build public applications that use it. We don't currently ship a Web front-end and so can't serve as a replacement to Superset: it's exposed to the developer as an HTTP API that can be queried directly from the end user's Web browser. But we have some ideas around a frontend component: some kind of a middleware, where the Web app can pre-declare the queries it will need to run at build time and we can compute some pre-aggregations to speed those up at runtime. Currently…

Usrbinbash makes a good point regarding the meaning of “relational”. Many people have come to think that “relational” refers to the relationships between entities in the database, when it really means that the database manages data in tabular form. I think this misunderstanding has become more ingrained because people typically normalize their data in RDBMSs, which necessitates greater use of joins. So, when folks talk about a “relational” workload, they often mean executing ACID-compliant joins over a normalized dataset. Because early NoSQL databases had traded transactional consistency for performance and scalability, there’s been an expectation that NoSQL databases can’t support what some think of as a relational workload. To be fair, in the early days of NoSQL, it was necessary to use denormalization in one’s schema to achieve transactional integrity in the absence of joins. However, distributed databases have since overcome the major challenges of achieving consistency at scale. For example, http://Fauna.com is a serverless, document database which supports ACID transactions via the Calvin protocol. This means that you can execute transactionally consistent joins across collections (“tables”), and either normalize or denormalize your data model for all the same design reasons you might in a traditional RDBMS. The principle difference is that records in Fauna are JSON documents rather than rows in a table. This is not to say that denormalization in modern schema design…

Social media are typically quite heavy on tree traversals. That kind of pattern is very similar to trying to resolve a deep ORM query or a deep GraphQL query which also doesn't map very well on 'traditional' relational databases https://en.wikipedia.org/wiki/Object%E2%80%93relational_impedance_mism… I believe this 'issue' depends on: A) the type of join B) whether your relational databases flattens between consecutive joins. C) is there easy/efficient pagination on multiple levels The type of join shouldn't be a problem, SQL engines should in most cases be able to determine the best join. In the cases it can't you can go start tweaking (although tricky to get right, especially if your data evolves, it's possible, you probably want to fix your query plan). B is however tricky and a performance loss since it's really a bit silly that data is flattened into a set each time to be then (probably) put into a nested (Object-Oriented or JSON) format to provide the data to the client. This is closely related to C, in a social graph you might have nodes (popular people or tweets) who have a much higher amount of links than others. That means if you do a regular join on tweets and comments and sort it, on the tweet you might not get beyond the first person. Instead, you probably only want the first x comments. That query might result in an amount of nested groups. So it might look more like the following SQL (wrote it by heart, probably not correct): SELECT tweet.*, …

If you all need to do is basic persistence and don't want to bother with setting up your own backend, look into services such as https://restdb.io/ or https://fauna.com/ - be careful about security if you are embedding this in your front-end app. Otherwise, writing your own backend using RPC-named express routes is more than sufficient. The reason why REST became common is that RPC routes can become messy. Another poster gave the example of "SaveWidget" as an RPC endpoint. This can cause problems for some teams that have no conventions and they end up with "SaveFoo" and "BarSave" endpoints. REST solves this somewhat by relying on HTTP verbs so both endpoints are normalised to "POST /foo" and "POST /bar". Finally, if your web app is truely simple with only a couple of backend endpoints needed, then whatever you choose is generally fine. Structural and architectural patterns exist to provide a framework around managing complexity. If your app is not complex, most people - and it's important to consider this includes your future self that has forgotten your implementation details - can grok the codebase without too much trouble. If anything, as your question suggest, over-engineering a simple app can lead to greater confusion.

Fauna | Senior Distributed Systems Engineer | San Francisco | Full time | https://fauna.com Come join the Core team at Fauna, where you’ll be working directly on our strongly consistent, distributed database. This means writing Scala code, every day, and working with other engineers to expand Fauna’s feature set while keeping its promise of ACID-compliance, fault tolerance, and strong consistency. The creation of a distributed database that is strongly consistent requires incredibly disciplined engineering. Our software has been four years in the making, and we’ve taken the time to build things right. You’ll be working with engineers who have been tech leads for JVM teams and for storage backends, and helped architect Twitter’s data infrastructure. Everyone here is a grown up. We for reals follow best practices. We also have lives outside of work, and go home for dinner. Family friendly, remote friendly. Supportive coworkers. Small company with plenty of room for growth, both in technical skills and in your career. You’ll be well-versed in one or more of the following: - Scala or another functional programming language * JVM experience is a plus - Asynchronous programming - Fault-tolerant network services - Performance analysis - Familiarity with some of the following is a bonus: * Storage Engines (LSM Trees, B-Trees, etc) * Consensus Protocols (RAFT, Paxos, ZooKeeper, etc) Most of the team is in San Francisco, CA, but we're open to remote work for…

Fauna[0] which if I recall correctly, also upends Cap Theorum. They implemented Calvin[1] which differs from Spanner [0]: https://fauna.com/ [1]: https://fauna.com/blog/distributed-consistency-at-scale-spanner-vs-cal…

I can attest to that statement: comparing Spanner and CockroachDB is difficult. Spanner and Fauna (where I work) are more comparable (Fauna is based on Calvin, see [0]) since they both support strict serializability (in different ways). The article referenced here is excellent, and it highlights what we've seen from some customers: CockroachDB is (to say the least) a challenge to learn and adequately deploy, I've seen a few others that have a similar lessons-learned result. I'm glad, however, that highly consistent distributed databases provide value in these implementations. Although not OSS, Fauna is comparable and more turnkey (read: much less ops) than these options. [0]: https://fauna.com/blog/distributed-consistency-at-scale-spanner-vs-cal…

did you look into fauandb (https://fauna.com/) ? if so and you used it, what was you experience running fauna in CF workers?

For this sort of thing I really like fauna (https://fauna.com/). I don't think you really "need" a "backend backend" anymore, and small dev teams are probably better off without them.

Most of the modern frontend hosting services also push for a backend as a service. Whether it be a DBaaS, like Fauna https://www.fauna.com, or Headless CMS, like Cosmic https://www.cosmicjs.com as it gives you the auto-scaling capabilities without the infrastructure time and headache (Disclaimer: I'm CEO at Cosmic)

I had a similar experience. I tried installing some of their CLI tools and was met with some undocumented errors I didn't want to bother digging through code to figure out. > But there is definitely potential. I agree! It's something I'm watching with eager eyes, but don't feel like is the first option I'd turn to when making a technology choice. Another technology that gives me this feeling is FaunaDB [0]. [0]: https://fauna.com/

If you like GraphQL and don't mind managed services: - Fauna (http://fauna.com) or Hasura (https://hasura.io) for the backend - Vercel (http://vercel.com) or Netlify (https://www.netlify.com) for the frontend and functions

https://fauna.com/ is a new database that makes it relatively quicker to build things like commenting systems. I consider something like Disqus plug-and-play. But I think that I would really want is something built in Node that I can import, add configs, and hook into my front-end. FaunaDB comes close, but I would still need to build the comments and moderation UI etc. It would be nice if someone fleshed out a more full commenting example on top of Fauna, but I haven't come across that yet, so I guess I'll eventually need to do that. My site is just a super simple site that runs on top of Vercel w/ Svelte/Sapper

> We don't store any vulnerable data - your passwords neither land on localStorage, sessionStorage, IndexedDB nor any server. > In your database (https://fauna.com/) passwords are stored in encrypted version so nobody can steal them from there. So fauna is not a server and not something running local in the browser from my reading of the above. Looking at fauna.com it seems like it absolutely runs on servers, just as a SaaS. What am I missing here? Or do you just mean that the passwords are not stored on your servers?

> In your database (https://fauna.com/) Unless this is a product marketed exclusively at Evan Weaver, CEO of fauna.com, then this is not "my database".

Netlify Dev also includes support for accessing FaunaDB GraphQL Cloud, launched in beta today (https://fauna.com/blog/getting-started-with-graphql-part-1-importing-a… We are working on adding support for a 100% local development workflow in Netlify Dev. It would be lovely to know what you think is missing from stateful local workflows in both Zeit and Netlify.

FaunaDB already does this. It provides distributed transactions based on Calvin, which does not rely on classic 2PC. See https://fauna.com/blog/acid-transactions-in-a-globally-distributed-dat… and http://cs.yale.edu/homes/thomson/publications/calvin-sigmod12.pdf

Fauna | Scala Engineers, Tech Writers, Solutions Architects | Distributed / Remote https://fauna.com We are hiring aggressively at FaunaDB for Scala and JVM distributed systems roles, as well as field engineering/solution architect roles. We are solving the hardest problem in applied computer science with our global transactional database. https://boards.greenhouse.io/faunadb

This looks like a reasonably complete survey. However, one important topic is missing. That is the strong consistency algorithms used by databases like Spanner and FaunaDB. Those two globally consistent databases use different families of algorithms, so it’s probably worth including both. Here is a comparison between them: https://fauna.com/blog/distributed-consistency-at-scale-spanner-vs-cal…

https://fauna.com/ - FaunaDB: Evan Weaver and Chris Anderson were involved in created a distributed relational datastore. You can use it as an API and never have to think about provisioning or managing a server. It's proprietary, but the prices are insanely low for all the features and convenience you're getting. Zinc Gluconate 15mg + Selenium + Quercetin 200mg (zinc ionosphere): For years I ignored the advice of knowledgeofhealth.com when it came to zinc and quercetin. I finally used it this year and it got rid of my cold in less than 48 hours with no side-effects. This has never happened to me before. Zinc-based supplements get rave reviews on Amazon and they seem legit. Google: selenium virus mutations. (I also took a new Vitamin C formula, Formula 216). https://aureon.ca/ - Safire Project. Some claim it's a fraud, but I'm hoping something good will come out of it. They are using a different model of stars/suns to generate energy and other benefits. There's always molten salt reactors in case this one doesn't pan out.

https://fauna.com/ core functions are based out this paper

Check FaunaDB https://fauna.com/

Distributed ACID transactions across multiple DBs or clusters has been possible for a while if you have been willing to pay the latency penalty for the transaction to complete, hasn't it? As far as I know, Google systems have to pay this latency cost too. From an analysis of Spanner and Calvin [1]: > The cost of two-phase commit is particularly high in Spanner because the protocol involves three forced writes to a log that cannot be overlapped with each other. In Spanner, every write to a log involves a cross-region Paxos agreement, so the latency of two-phase commit in Spanner is at least equal to three times the latency of cross-region Paxos. I suspect that Google's innovation in making these cross-region or cross-cluster transactions viable is partly in their network: having an extremely reliable network with consistent low latency, a lot of which allegedly uses first-party network fiber between disparate locations. This is touched on in a paper that Google published [4]: > Many assume that Spanner somehow gets around CAP via its use of TrueTime, which is a service that enables the use of globally synchronized clocks. Although remarkable, TrueTime does not significantly help achieve CA; its actual value is covered below. To the extent there is anything special, it is really Google’s wide-area network, plus many years of operational improvements, that greatly limit partitions in practice, and thus enable high availability. I'm also not sure that technologies like…

There is also Fauna Query Language. I gave up on choosing a unique name. https://fauna.com/product/fql

So far, my personal projects haven't used a database. If I need a DB (service), these would be my top candidates: - https://supabase.com - https://pockethost.io - https://fauna.com - https://www.edgedb.com They all support serverless and also provide auth (to avoid the user storage/query problem[1]) While SvelteKit does include backend functionality, unfortunately it doesn't have any special DX for databases. I think there are other starter templates built on top of Kit for that... [1]: https://threadreaderapp.com/thread/1651434348174778370.html

Yup, it's not the most sophisticated of cost calculator, obviously there's a wide variation in cost savings from reducing query and compute load and the reduction is app specific. edit: we based some of the calculator variables on https://fauna.com/blog/compare-aws-aurora-serverless-v2-architecture-f…

Funny enough, this actually cuts to the core of why strict serializability is so important. “Technically speaking, every read-only transaction could return the empty-set (which was the initial state of the database) and not be in violation of the serializability guarantee --- this is legal since the system can bring read-only transactions “back in time” and get a slot in the serial order before any transactions that write to the database.” https://fauna.com/blog/serializability-vs-strict-serializability-the-d…