Correction: the readme claims it will work without requiring root, but it does need to manage network namespaces, which afaik may only be available to root users depending on system configuration.
> To run httptap you do not need to be the root user. ... It makes use of linux-specific system calls -- in particular network namespaces ...
We tried to use it alongside pouchdb to provide offline first experience. We ran into a lot of issues, mainly with pouchdb bugs. Then after reading this list [1] of issues in the couchdb architecture we decided to ditch it and stop trying to make pouchdb work.
I can think of two complex pieces of software which intentionally shunned databases thinking they can just do its thing in "flat files" - git and DokuWiki.
What ended happening is that both developed their own custom shi*ty database engines because it turns out that things like indexes are just generally pretty useful, but doing them right is pretty damn difficult. I'm pretty sure that if Linus/git chose e.g. SQLite instead of "flat files", we'd have way fewer data corruption problems, and a more capable/extensible git.
I don’t know if Git’s storage is deserving of this level of scorn—I can’t lay claim to any in-depth knowledge, but if it were indeed a big problem I’d expect it to come up frequently in comparisons with Fossil, which stores things using SQLite. (As a counterpoint, I use git-annex quite a bit, and it almost certainly couldn’t integrate as neatly into Fossil’s storage approach as it does into Git’s.) So I’d appreciate any details here.
All that is beside the point, though: the article above is not about using or not using flat files as a storage primitive, it’s about using files of whatever nature as a replication and version reconciliation mechanism, in view of the fact that concurrent editing is inevitably application-specific, so we might as well lean into it instead of leaving it to a database. In that sentence, “a database” is not just any database, it’s one of a very short list of multimaster databases with relatively loose schemas, which includes CouchDB and—among legitimately FOSS projects—I’d struggle to name more.
This is not a decision about data storage at all, in other words. It is a decision about protocols. Experience shows that the alternative does not end up being an off-the-shelf database (even CouchDB, which does seem like a major road not taken looking back at Canonical’s efforts a decade ago), the alternative is usually a central synchronization server speaking a custom protocol. (CalDAV, CardDAV, Bitwarden, etc.)
And if you want to do your CRDT or OT or whatnot over per-client SQLite databases instead of per-client text files, all the more power to you.
Finally, I tried to phrase my comment above in a way that makes it clear that it’s a suggestion of a direction to have fun in, not of a principle to architect your production app around. So the sneering in your comment is... honestly disheartening to read. Like, do people even hack anymore? I know they do, but every time I read something like this I become a little bit less sure of it.
I am (very) biased but Couchbase has a pretty solid Mobile offering for native apps. I have worked on the Sync Gateway component responsible for replication for the last six years.
Sync Gateway still maintains a CouchDB-compatible REST API, and PouchDB _mostly_ works thanks to that, but there are some corner cases and features that PouchDB does not support so YMMV with it. Our native app libraries have used a more performant websocket-based replication protocol for many, many years now, and I'd really love to have the time investigating a PouchDB adapter using this WS protocol instead.
I'm biased since I work on it, but https://ditto.live/ provides an SDK that allows P2P and cloud sync. You interact with it like a database: write your queries against your data, and it will move between devices automatically
I build an internal project using CouchDB2 as a backend in 2017 and it's still used today. CouchDB definitely surpassed my expectations in what has been possible to do with it. Its biggest advantages are that data sync is effortless and that it uses HTTP as a protocol, so you can communicate directly with it from a web application.
Used it this school year for a research project that needs solid replication of content and a firehose of updates. There are dozens of such projects but nothing beats the simplicity and versatility of basic HTTP calls with JSON documents and the robustness of a 15-years old project that Just Works.
Was some time ago (2016), but we built and released Typeform LITE (form creator via text-entry-like interface for smartphones) with CouchDB + PouchDB which was a pleasure as far as I can remember. Was really neat to get local-first functionality almost out of the box with web tech on smartphones.
We are using it internally as just a document store (with some erlang views but that is it). It scales very nicely, but for smaller documents postgres does the job for us so we are (slowly) moving away to simplify the tech stack.
I tried to build some hobby stuff with it (mostly worked), planning to use it instead of mongodb @work but I got hit by the limitations of the JS engine version used at the time and it got frustrating too fast for a small hobbyist project. The mongodb/couchdb thing at work was cancelled so I didn't spend more time with it.
People behind it are really, really nice though.
One of the top (the top I think ?) obsidian sync plugin uses it.
I was naive when I chose it (I was just starting to program then), but it has served me well. It's replication feature is simple to setup and is robust. It uses a REST API for any calls to the database, and it is a well designed API. I don't use all its features, but I really like it for the ones I use.
I have built advertisement bidders and ad servers. I avoid querying the database on every request (and caches) by creating app in-memory materialized views of the database.
See https://www.confluent.io/blog/leveraging-power-database-unbu... for more about this.
Another cool feature of the replication protocol is that I can tell if all app servers are on the same version of the data.
We are still using couchdb for user profile synchronisations. Basically user details and data from mobile synched to the cloud. In our application users do not interact between one another. So basically we use db per user model. This gives us synchronisation between mobile/web clients. Pity that there is no up to date mobile library for couchDB and we depend on an old one.
We used 1.6 for a large project in 2014 or so, the 2.x release removed key features for us and we were never able to upgrade. The direction they went after that just never really worked for us so we only have that legacy project still running.
CouchDB dev here. 2.x only added new features, not sure what you’re referring to that was removed. The only on incompatibility was the changes feed ids moving from numbers to strings, which is hardly a huge migration :)
Mesos was a derivative idea from some sporadic idea from 2 level scheduling from inside Google based on mapreduce
Mesos was wrong from day one, they thought they have the right idea, but was really caught up by a Small group of Google engineers who happened to be from academia. These engineers were very good at having theoretically nice idea
In the time mesos was invented, Google had its own mesos, which is a similar project by learning wrong lesson from Borg. That thing is Omega.
Eventually everyone decided that Borg was right all along, thus the kubernetes
I have no idea what any of the google tech has to do with anything here.
Quoting from the original spark paper:
> Spark is built on top of Mesos [16, 15], a “cluster operat-
> ing system” that lets multiple parallel applications share
> a cluster in a fine-grained manner and provides an API
> for applications to launch tasks on a cluster
The RAD lab folks who built Mesos were aware of Borg and how it approached the problem of schedling a bunch of different jobs on a collection of disparate hardware. Prior to borg, most large-scale clusters were managed with batch queue software, while borg and mesos are more from the "service management"- a collection of jobs that run concurrently, with priority levels used to preempt lower-priority jobs to allow higher-priority jobs to schedule and run "immediately".
The need for this pops up for nearly every large scale data processing enterprise- with k8s replacing mesos, yarn, and other systems as the cluster scheduler du-jour.
One of the big advantages of a service scheduler versus a batch queue is that you can implement a batch queue on top of a service scheduler much more easily than you can implement a service scheduler on top of a batch queue.
When I started working at TeleAtlas Germany (former Robert Bosch Data; forever a part of TomTom now) in 2005 we still had production processes on the MapEngine technology coming from Etak. We had in-house python bindings that allowed for very productive development. It is fun to see this mentioned here today.
you have to love that the GP says "browsers like Chrome don't allow" and the two responses under it are "Safari does" and "mobile Firefox does" -- literally the only other browsers in the mobile ecosystem
maybe this limitation isn't "browsers like Chrome". Maybe it's JUST CHROME with the limitation, because Chrome sucks, and has for awhile now.
It's almost like the developer of Chrome doesn't want you to use a different search engine. Funny, that
reply