Join the discussion

Write your take first — we'll ask for email only when you're ready to publish.

  • Hacker News
  • There is a simple version of this idea that really resonates with me.

    For about a decade, I've been using flat files on disk or object storage for most of my side projects. There's even a python library that handles some of the plumbing for you [1].

    If you don't have strong record-level concurrency needs then it's a lot nicer, easier, cheaper than a relational or document database. And if you do need that, you can design your data model around what defines a record.

    [1] https://tinydb.readthedocs.io/en/latest/

  • "The main downside of this is the fact that object storage doesn't have transactions, so you can't make sure that both appending the event and updating the state of the world happen in one atomic unit. We write the state first and the event second, so a process dying in between leaves the state correct and the history missing an entry. Nothing detects that, because detecting it would mean something reads the log and compares it to state, and the entire point is that nothing does. So every entry in the log really happened. What you don't get is a guarantee that everything that happened is in it."

    So, they built a thing that pretends to, but does not actually properly handle transactions?

    I guess I should be glad they are not a fintech startup...

  • > Protobuf field names are forever

    If you only have binary encoded protos to worry about (which is typical) then you can rename fields.

  • Along with putting estimated reading times (21 minutes in this case) can authors please start putting estimated writing times?

    Did it take 10 seconds of prompting? Or hours of thought, trial error and revision? Especially when asking people to read for 20+ minutes...

    by i2km
  • > In practice, when you reach for a database engine you're actually reaching for four basic features: unique constraints, transactions, indices, and history tables.

    That might be a very specific assumption. What about serializability? Replication? Materialized views? Procedures? Locking? Access control?

    It’s cool to experiment and try new approaches. Neat one here.

    Could still end up moving to Postgres.

  • This is frustrating to read. Tigres is built on FoundationDB, but doesn't expose all FoundationDB operations like transactions, range reads, and get mapped range. They go through all sorts of complications to handle these issues, including a database for caching (and they don't consider thundering herd problems).

    What if you just ran FoundationDB instead?

  • Articles like this remind me of that Innovation Tokens article.

    Your time and attention is precious as a developer. I'm absolutely sure it's possible to implement uniqueness constraints, transactions, indices, and history yourself, but is that really the most valuable use of your time? There's probably not a need for you to have a unique solution, so you're quite literally just re-inventing something someone already had for not a lot of benefit.

    Wouldn't your time be better spent actually solving the problems that whatever you're building is supposed to solve?

  • This article doesn’t present much motivation for why you would do this.

    To me it reads a bit like, how we built our office without desks: it turns out if you stack two chairs on top of each other, you can balance your laptop on the top and you’ll also have a shelf on the bottom for your things.

Explore Birbla archives