pauldowman
Verified commits: sign your Git commits and avoid impersonation risk
Scaling Yourself: Meeting Hacks
Tips for Remote Pair Programming
The best explanation so far of Prisma, the realtime GraphQL database layer
A plea for moderation and understanding on diversity in tech
How to use GraphQL with Meteor
HashBang Weekly. A weekly newsletter on all things GraphQL, ReactJS, and Meteor
Building a live chat app in 40 minutes with React and Meteor
Matt talked about how Meteor came to be and where it’s going. We talked about the forthcoming Galaxy hosting platform, React, being opinionated, and the Meteor Development Group’s decision making process about which components make up the Meteor stack.
I Interviewed Matt DeBergalis (Meteor Founder) on the Future of Meteor
Why Android doesn’t need a billion dollar success story
The Meteor universe – a list of Meteor JS resources
The future of app development: 4 upcoming trends in 2014
Stress-free production deployment
How to use actual source files for blog code examples
"Even when a backup is incremental, you don't have to worry about restoring the full backup, then each of the incrementals in turn; an incremental backup acts as if it's a full backup, it just takes less disk space"
.... nice!
There's no automatically fixing a conflict so the second transaction fails. Since there's full isolation that's pretty standard optimistic locking: http://en.wikipedia.org/wiki/Optimistic_locking
In most cases the transaction would succeed if it was automatically retried.
I think it's easily fixed with a merge, as I described here: http://news.ycombinator.com/item?id=1929691
My idea was that if there are concurrent transactions, then you just need a merge when the second one commits.
This is "optimistic locking": since they're probably updating different subdirectories it would be a trivial merge. If they update the same attribute of the same entity (i.e. they both change the same line of the same attributes.json file) then there's a conflict and the second commit fails.
This still requires a lock but only a tiny one, just at the moment of actually updating refs/heads/<branchname> (whereas right now it's around the whole transaction which obviously sucks).
Are there any flaws in that?
The reason I haven't done it yet even though it sounds pretty trivial is that with Grit (the Ruby Git library) the merge will need to use the working directory and that's a problem for concurrency (and also because I want the working directory to be useable by a human). I was thinking that with a bit of extra work I could make it happen in memory somehow.
Paul