reltuk

Similar arguments are also seen in https://graphitemaster.github.io/aau/.

When using unsigned ints for backward iteration, I'm partial to looping as:

  for (i = size - 1; i < size; i--) {
    ...
  }

since it has so much symmetry with forward iteration.

To quickly answer these...

- it's content addresses / merkle DAG all the way down. The commit's hash is something like meta (author, description, timestamp) + parents hash + root value hash. The root value is composed of the schema, and pointers to table and index maps. Tables and indexes are merkle DAGs of the table data organized in a structure a bit like a B-tree, but with cut points chosen by a rolling value hash in order to probabilistically re-synchronize on incremental changes. Some details: https://www.dolthub.com/blog/2020-04-01-how-dolt-stores-tabl... , https://www.dolthub.com/blog/2020-05-13-dolt-commit-graph-an...

- currently table data is stored row major for full rows of the table and so diffing cannot efficiently ignore individual columns.

- direct conflicts are computed on a row-by-row basis, using the primary key of the row. And then constraints and foreign key references are maintained and validated across merges and edits.

HTH, happy to answer any further questions :).

It's a play on git, which is itself regional slang.

Yeah, pgx is quite impressive and is a great set of bindings with very accessible examples, etc. Definitely something to be aware of for people that prefer building things in Rust. Thanks for pointing it out here.

I think the contract in the context package is that WithCancel may leak resources if cancel is not called and the parent context is cancelable but never canceled. At least, that seems to be the behavior I see in the implementation here:

https://github.com/golang/go/blob/master/src/context/context...

So in this case, errgroup probably doesn't have a choice and needs to call cancel() at some point.

We blogged about using S3 and gRPC's `longrunning.Operation` pattern to move work out of a synchronous RPC in order to support much larger payloads.

Hi Hacker News! We wrote a short blog post showing how forks and pull requests in DoltHub work in a data collaboration context. It's really neat being able to open a pull request against a SQL database.

We blogged about how Dolt implements `dolt merge`. Merges of divergent histories in databases is a super interesting problem in general. Dolt takes a simple approach that works pretty well for the dictionary style databases we're currently targeting as a use case, but we would love to hear feedback on our approach and communication in this space in general.

We blogged about how Dolt shares storage across versions of the database as it changes across commits.

कर्मण्येवाधिकारस्ते मा फलेषु कदाचन

Transliteration:

karmaṇy-evādhikāras te mā phaleṣhu kadāchana

You can read more here: https://www.holy-bhagavad-gita.org/chapter/2/verse/47

Yes exactly. Sorry for failing to include the link in my earlier comment.

When I saw this question, I went to find a link so that I could recommend Patrick Healy's reading. I was pleasantly surprised to see that it now available for free on the internet.

It's quite rushed and somewhat flat at parts. Some of the abridged recordings I've listened to do more justice to the excerpts they've chosen. But it's a heroic effort none the less. For me, it made the full Wake accessible and alive in a way that made me really enjoy spending time with it.

Good news for you, if you're willing to spring for it: http://www.foliosociety.com/book/SAE/sound-fury-william-faul...