14 ms·

Do you even need a database?

• fifilura 6mo ago
  Isn't this the same case the NoSQL movement made.
  • deleted 6mo ago
    [deleted]
  • dilberx 6mo ago
    [dead]
• the_inspector 6mo ago
  In many cases not. E.g. for caching with python, diskcache is a good choice. For small amounts of data, a JSON file does the job (you pointed to JSONL as an option). But for larger collections, that should be searchable/processable, postgres is a good choice. Memory of course, as you wrote, also seems reasonable in many cases.
  • upmostly 6mo ago
    [dead]
• vovanidze 6mo ago
  people wildly underestimate the os page cache and modern nvme drives tbh. disk io today is basically ram speeds from 10 years ago. seeing startups spin up managed postgres + redis clusters + prisma on day 1 just to collect waitlist emails is peak feature vomit. a jsonl file and a single go binary will literally outlive most startup runways. also, the irony of a database gui company writing a post about how you dont actually need a database is pretty based.
  • upmostly 6mo ago
    The irony isn’t lost on us, trust me. We spent a while debating whether to even publish this one. But yeah, the page cache point is real and massively underappreciated. Modern infrastructure discourse skips past it almost entirely. A warm NVMe-backed file with the OS doing the caching is genuinely fast enough for most early-stage products.
    • vovanidze 6mo ago
      props for actually publishing it tbh. transparent engineering takes are so rare now, usually its just seo fluff. weve basically been brainwashed to think we need kubernetes and 3 different databases just to serve a few thousand users. gotta burn those startup cloud credits somehow i guess. mad respect for the honesty though, actually makes me want to check out db pro when i finally outgrow my flat files.
      • upmostly 6mo ago
        I'm feel like I could write another post: Do you even need serverless/Cloud because we've also been brainwashed into thinking we need to spend hundreds/thousands a month on AWS when a tiny VPS will do. Similar sentiment.
        • hilariously 6mo ago
          You are both right, with the exception that it requires knowledge and taste to accomplish, both of which are in short supply in the industry. Why setup a go binary and a json file? Just use google forms and move on, or pay someone for a dead simple form system so you can capture and commmunicate with customers. People want to do the things that make them feel good - writing code to fit in just the right size, spending money to make themselves look cool, getting "the right setup for the future so we can scale to all the users in the world!" - most people don't consider the business case. What they "need" is an interesting one because it requires a forecast of what the actual work to be done in the future is, and usually the head of any department pretends they do that when in reality they mostly manage a shared delusion about how great everything is going to go until reality hits. I have worked for companies getting billions of hits a month and ones that I had to get the founder to admit there's maybe 10k users on earth for the product, and neither of them was good at planning based on "what they need".
  • phillipcarter 6mo ago
    > seeing startups spin up managed postgres + redis clusters + prisma on day 1 just to collect waitlist emails is peak feature vomit. I'm pretty sure most startups just use a quick and easy CRM that makes this process easy, and that tool will certainly use a database.
  • mamcx 6mo ago
    > people wildly underestimate the os page cache and modern nvme drives And worse, overestimate how safe is their data! All this fancy thing about not using a RDBMS could had been true only if the APIs and actual implementation across ALL the IO path were robust and RELIABLE. But is not! EVERY LAYER LIES ALL of them ALL OF TIME That is why the biggest reason building a real database (whatever the flavor) is that there is no way to avoid pay performance taxes all over the place because you can't believe the IO and having a (single | some files) getting hammered over and over make this painfully obvious. One of the most sobering experiences is that you write your IO with all the care in the world, let the (your brand new) DB run for hours, on good, great, hardware, and in less than a week you will find that that breaks in funny ways. P.D: Was part of a team doing a db
• ghc 6mo ago
  I'm so old I remember working on databases that were designed to use RAW, not files. I'm betting some databases still do, but probably only for mainframe systems nowadays.
  • bob1029 6mo ago
    https://docs.oracle.com/cd/B16276_01/doc/win.102/b14305/architec.htm#i1005793 https://docs.oracle.com/cd/B16276_01/doc/win.102/b14305/arch...
    • ghc 6mo ago
      > Oracle® Database Platform Guide 10g Release 2 (10.2) for Microsoft Windows Itanium (64-Bit) Well, I guess that at least confirms Oracle on Itanium (!?) still supported RAW 5 years ago. I'm guessing everyone's on ASM by now though, if they're still upgrading. I ran into a company not long ago with a huge oracle cluster that still employed physical database admins and logical database admins as separate roles...I would bet they're still paying millions for an out of date version of Oracle and using RAW.
      • evanelias 6mo ago
        > still supported RAW 5 years ago I seem to remember Oracle 10g was first released over 20 years ago? It has been EOL for much longer than 5 years...
        • ghc 6mo ago
          Oh you're right! I was looking at the last documentation update timestamp, but the original release was 2006. That makes a lot more sense than Itanium support in 2021.
• chuckadams 6mo ago
  I need a filesystem that does some database things. We got teased with that with WinFS and Beos's BFS, but it seems the football always gets yanked away, and the mainstream of filesystems always reverts back to the APIs established in the 1980s.
  • tracker1 6mo ago
    FWIW, you can do some things like this on top of S3 Metadata.
    • chuckadams 6mo ago
      Transactions are one thing I want the most, and that's not going to happen on S3. Sure, I can reinvent them by hand, but the point is I want that baked in.
      • tracker1 6mo ago
        Yeah, closest thing there is MS-SQL FILESTREAM, but even that has flaws and severe limitations... you can do similar transaction implemenations for binary data storage in any given RDBMS, or do similarly via behavior to read/write to filestream along with a transactional row lock that corresponds to the underlying data. But that gets its' own complexities.
• z3ugma 6mo ago
  At some point, don't you just end up making a low-quality, poorly-tested reinvention of SQLite by doing this and adding features?
  • gorjusborg 6mo ago
    Only if you get there and need it.
    • upmostly 6mo ago
      Exactly. And most apps don't get there and therefore don't need it.
      • evanelias 6mo ago
        Your article completely ignores operational considerations: backups, schema changes, replication/HA. As well as security, i.e. your application has full permissions to completely destroy your data file. Regardless of whether most apps have enough requests per second to "need" a database for performance reasons, these are extremely important topics for any app used by a real business.
    • z3ugma 6mo ago
      but it's so trivial to implement SQLite, in almost any app or language...there are sufficient ORMs to do the joins if you don't like working with SQL directly...the B-trees are built in and you don't need to reason about binary search, and your app doesn't have 300% test coverage with fuzzing like SQLite does you should be squashing bugs related to your business logic, not core data storage. Local data storage on your one horizontally-scaling box is a solved problem using SQLite. Not to mention atomic backups?
      • 9rx 6mo ago
        > and your app doesn't have 300% test coverage with fuzzing like SQLite does Surely it does? Otherwise you cannot trust the interface point with SQLite and you're no further ahead. SQLite being flawless doesn't mean much if you screw things up before getting to it.
• freedomben 6mo ago
  I avoided DBs like the plague early in my career, in favor of serialized formats on disk. I still think there's a lot of merit to that, but at this point in my career I see a lot more use case for sqlite and the relational features it comes with. At the least, I've spent a lot less time chasing down data corruption bugs since changing philosophy. Now that said, if there's value to the "database" being human readable/editable, json is still well worth a consideration. Dealing with even sqlite is a pain in the ass when you just need to tweak or read something, especially if you're not the dev.
  • giva 6mo ago
    > Dealing with even sqlite is a pain in the ass when you just need to tweak or read something, especially if you're not the dev. How? With SQL is super easy to search, compare, and update data. That's what it’s built for.
    • freedomben 6mo ago
      Pain in the ass was way too strong, I retract that. Mainly I meant relative. For example `nvim <filename>.json` and then /search for what I want, versus tracking down the sqlite file, opening, examining the schema, figuring out where the most likely place is that I care about, writing a SQL statement to query, etc.
      • giva 6mo ago
        Well, you still need to track down the <filename> part and knowing what you want to search, so you need to examine the schema anyway. However, if your all application state can be represented in a single json file of less than a dozen MB, yes, a database can be overkill.
        • freedomben 6mo ago
          > Well, you still need to track down the <filename> part and knowing what you want to search, so you need to examine the schema anyway. Yes agreed, but it's usually a lot easier to find the filename part, especially if the application follows XDG. Sqlite databases are usually buried somewhere because they aren't expected to be looked at.
• fatih-erikli-cg 6mo ago
  I agree. Databases are useless. You don't even need to load it into the memory. Reading it from the disk when there is a need to read something must be ok. I don't believe the case that there are billions of records so the database must be something optimized for handling it. That amount of records most likely is something like access logs etc, I think they should not be stored at all, for such case. Even it's postgres, it is still a file on disk. If there is need something like like partitioning the data, it is much more easier to write the code that partitions the data. If there is a need to adding something with textinputs, checkboxes etc, database with their admin tools may be a good thing. If the data is something that imported exported etc, database may be a good thing too. But still I don't believe such cases, in my ten something years of software development career, something like that never happened.
  • Sharlin 6mo ago
    Not sure if sarcastic…
    • fatih-erikli-cg 6mo ago
      It isnt sarcasm. I don't really find a case that a database that has it's own query language like SQL is needed. It won't be different than storing a JSON file and filter the content with a for loop, the dev (e.g. me) will be returning a JSON on REST API at the end. A query language may be a good thing if you are working in a team, thats it. SQL is indeed isnt a good thing.
      • Sharlin 6mo ago
        Um, so your use cases are extremely narrow and limited. That's an astonising failure of imagination and a lack of understanding of real-world computer systems if you cannot understand why people have a real need of both the power of SQL and the performance of RDBMSs.
        • fatih-erikli-cg 6mo ago
          PostGIS is an extension of PostgreSQL. It claims that it has some geography features. I think it is not really related with a database. It brings only a function (HAVERSINE) that gets distance of two points on earth. It is couple of lines of code. It is not really a software project, but a detail about how the earth coordinates are calculated, and I think it is a total made up story. The real computed thing works like math.sqrt function.
• gavinray 6mo ago
  Not to nitpick, but it would be interesting to see profiling info of the benchmarks Different languages and stdlib methods can often spend time doing unexpected things that makes what looks like apples-to-apples comparisons not quite equivalent
• srslyTrying2hlp 6mo ago
  I tried doing this with csv files (and for an online solution, Google Sheets) I ended up just buying a VPS, putting openclaw on it, and letting it Postgres my app. I feel like this article is outdated since the invention of OpenClaw/Claude Opus level AI Agents. The difficulty is no longer programming.
• jbiason 6mo ago
  Honestly, I have been thinking about the same topic for some time, and I do realize that direct files could be faster. In my (hypothetical, 'cause I never actually sat down and wrote that) case, I wanted the personal transactions in a month, and I realized I could just keep one single file per month, and read the whole thing at once (also 'cause the application would display the whole month at once). Filesystems can be considered a key-value (or key-document) database. The funny thing about the example used in the link is that one could simply create a structure like `user/[id]/info.json` and directly access the user ID instead of running some file to find them -- again, just 'cause the examples used, search by name would be a pain, and one point where databases would handle things better.
  • m6z 6mo ago
    I have found that SQLite can be faster than using text or binary files, confirming their claims here: https://sqlite.org/fasterthanfs.html https://sqlite.org/fasterthanfs.html
• forinti 6mo ago
  Many eons ago I wrote a small sales web application in Perl. I couldn't install anything on the ISP's machine, so I used file-backed hashes: one for users, one for orders, another for something else. As the years went by, I expected the client to move to something better, but he just stuck with it until he died after about 20 years, the family took over and had everything redone (it now runs Wordpress). The last time I checked, it had hundreds of thousands of orders and still had good performance. The evolution of hardware made this hack keep its performance well past what I had expected it to endure. I'm pretty sure SQLite would be just fine nowadays.
  • da02 6mo ago
    What type of product or service were they selling?
    • forinti 6mo ago
      A calendar for cutting your hair according to the phases of the moon.
      • da02 6mo ago
        Sounds like a tough business. The profit margins must have been razor thin.
        • forinti 6mo ago
          Jokes aside, the guy made an impressive amount of money with this. I should have charged him a percentage. Even if I had charged 0.5%, I would have made more money.
          • da02 6mo ago
            Retail customers or B2B? What was stopping you from starting a similar business, but different product category?
• jwitchel 6mo ago
  This is a great incredibly well written piece. Nice work showing under the hood build up of how a db works. It makes you think.
  • goerch 6mo ago
    About what?
  • hunterpayne 6mo ago
    Sorry to break it to you, but the article doesn't describe that at all. In fact, the reason why a DB has such great performance isn't mentioned at all. Learn what a datapath architecture is and how a DB kernel works if you are interested in that topic. And then there is how an optimizer works, how the prepare time works, how metadata is handled, etc...
• randusername 6mo ago
  Separate from performance, I feel like databases are a sub-specialty that has its own cognitive load. I can use databases just fine, but will never be able to make wise decisions about table layouts, ORMs, migrations, backups, scaling. I don't understand the culture of "oh we need to use this tool because that's what professionals use" when the team doesn't have the knowledge or discipline to do it right and the scale doesn't justify the complexity.
  • goerch 6mo ago
    Hm, I somewhat understand your point of `making wise decisions`. But doesn't that concern all kinds of software development? For me, it does.
• ForHackernews 6mo ago
  Surprised to see this beating SQLite after previously reading https://sqlite.org/fasterthanfs.html https://sqlite.org/fasterthanfs.html
  • ethan_smith 6mo ago
    The SQLite "faster than filesystem" page is specifically about reading small blobs where the overhead of individual filesystem calls (open/read/close per blob) exceeds SQLite reading from a single already-open file. Once you're talking about reading one big JSON file sequentially, that overhead disappears and you're just doing a single read - which is basically the best case for the filesystem and the worst case for SQLite (which still has to parse its B-tree, check schemas, etc).
• XorNot 6mo ago
  I've just built myself a useful tool which now really would benefit from a database and I'm deeply regretting not doing that from the get-go. So my opinion has thoroughly shifted to "start with a database, and if you _really_ don't need one it'll be obvious. But you probably do.
• kabir_daki 6mo ago
  [dead]
  • bevr1337 6mo ago
    > The real question isn't "do you need a database" but "do you need state" — and often the answer is no. This is a solid takeaway and applies to a lot of domains. Great observation
    • datadrivenangel 6mo ago
      But if you have state, and that state needs to persist between program executions, then for the love of resiliency and all that is robust, consider using a SQL database!
  • tetha 6mo ago
    > The real question isn't "do you need a database" but "do you need state" — and often the answer is no. We have a bunch of these applications and they are a joy to work with. Funny enough, even if you have a database, if you wonder if you need caches to hold state in your application server, the answer is, kindly, fuck no. Really, really horrible scaling problems and bugs are down that path. There are use cases to store expensive to compute state in varnish (HTTP caching), memcache/redis (expensive, complex datastructures like a friendship graph), elasticsearch/opensearch (aggregated, expensive full-text search), but caching SQL results in an application server because the database is "slow" beyond a single transaction brings nothing but pain in the future. I've spent so much energy working around decisions born out of simple bad schema design decisions and tuning...
• JohnMakin 6mo ago
  everyone thinks this is a great idea until they learn about file descriptor limits the hard way
• Joeboy 6mo ago
  Don't know if it counts, but my London cinema listings website just uses static json files that I upload every weekend. All of the searching and stuff is done client side. Although I do use sqlite to create the files locally. Total hosting costs are £0 ($0) other than the domain name.
• shafoshaf 6mo ago
  Relational Databases Aren’t Dinosaurs, They’re Sharks. https://www.simplethread.com/relational-databases-arent-dinosaurs-theyre-sharks/ https://www.simplethread.com/relational-databases-arent-dino... The very small bonus you get on small apps is hardly worth the time you spend redeveloping the wheel.
  • adrian_b 6mo ago
    Sharks vs. dinosaurs seems indeed an appropriate metaphor. During Cretaceous, when dinosaurs were at their peak, sharks had already become very similar to the sharks of today, e.g. there were big sharks that differed very little from the white sharks and tiger sharks of today. Then the dinosaurs have disappeared, together with the pterosaurs and the mosasaurs, and they have been replaced by other animals, but the sharks have continued to live until today with little changes, because they had already reached an optimized design that was hard to improve. Besides the sharks, during Cretaceous there already existed along the dinosaurs other 2 groups of big predators that have changed little since then, crocodiles and big constrictor snakes similar to the pythons of today. Therefore all 3 (sharks, crocodiles and big constrictor snakes) are examples of locally optimum designs that have been reached more than 70 million years ago, without needing after that any major upgrades.
• MattRogish 6mo ago
  "Do not cite the deep magic to me witch, I was there when it was written" If you want to do this for fun or for learning? Absolutely! I did my CS Masters thesis on SQL JOINS and tried building my own new JOIN indexing system (tl;dr: mine wasn't better). Learning is fun! Just don't recommend people build production systems like this. Is this article trolling? It feels like trolling. I struggle to take an article seriously that conflates databases with database management systems. A JSON file is a database. A CSV is a database. XML (shudder) is a database. PostgreSQL data files, I guess, are a database (and indexes and transaction logs). They never actually posit a scenario in which rolling your own DBMS makes sense (the only pro is "hand rolled binary search is faster than SQLite"), and their "When you might need" a DBMS misses all the scenarios, the addition of which would cause the conclusion to round to "just start with SQLite". It should basically be "if you have an entirely read-only system on a single server/container/whatever" then use JSON files. I won't even argue with that. Nobody - and I mean nobody - is running a production system processing hundreds of thousands of requests per second off of a single JSON file. I mean, if req/sec is the only consideration, at that point just cache everything to flat HTML files! Node and Typescript and code at all is unnecessary complexity. PostgreSQL (MySQL, et al) is a DBMS (DataBase Management System). It might sound pedantic but the "MS" part is the thing you're building in code: concurrency, access controls, backups, transactions: recovery, rollback, committing, etc., ability to do aggregations, joins, indexing, arbitrary queries, etc. etc. These are not just "nice to have" in the vast, vast majority of projects. "The cases where you'll outgrow flat files:" Please add "you just want to get shit done and never have to build your own database management system". Which should be just about everybody. If your app is meaningfully successful - and I mean more than just like a vibe-coded prototype - it will break. It will break in both spectacular ways that wake you up at 2AM and it will break in subtle ways that you won't know about until you realize something terrible has happened and you lost your data. Didn't we just have this discussion like yesterday (https://ultrathink.art/blog/sqlite-in-production-lessons https://ultrathink.art/blog/sqlite-in-production-lessons)? It feels like we're throwing away 50 years of collective knowledge, skills, and experience because it "is faster" (and in the same breath note that nobody is gonna hit these req/sec.) I know, it's really, really hard to type `yarn add sqlite3` and then `SELECT * FROM foo WHERE bar='baz'`. You're right, it's so much easier writing your own binary search and indexing logic and reordering files and query language. Not to mention now you need a AGENTS.md that says "We use our own home-grown database nonsense if you want to query the JSON file in a different way just generate more code." - NOT using standard components that LLMs know backwards-and-forwards? Gonna have a bad time. Enjoy burning your token budget on useless, counter-productive code. This is madness.
• matja 6mo ago
  If you think files are easier than a database, check out https://danluu.com/file-consistency/ https://danluu.com/file-consistency/
• stackskipton 6mo ago
  SRE here. My "Huh, neat" side of my brain is very interested. The SRE side of my brain is screaming "GOD NO, PLEASE NO" Overhead in any project is understanding it and onboarding new people to it. Keeping on "mainline" path is key to lower friction here. All 3 languages have well supported ORM that supports SQLite.
  • tracker1 6mo ago
    I'm mostly with you here... it's amazing how many devs don't have a certain amount of baseline knowledge to understand file-io, let alone thin abstractions for custom data and indexing like tfa. Then again, most devs also don't understand the impacts of database normalization under load either.
  • goerch 6mo ago
    Sorry, this I think is a dangerous attitude: for me it is not about onboarding. Every newcomer reading `Huh, neat` is poised to repeat the mistakes of us and our ancestors.
• ktzar 6mo ago
  Writing your own storage is a great way to understand how databases work (if you do it efficiently, keeping indexes, correct data structures, etc.) and to come to the conclusion that if your intention wasn't just tinkering, you should've used a database from day 1.
• koliber 6mo ago
  I love this article as it shows how fast computers really are. There is one conclusion that I do not agree with. Near the end, the author lists cases where you will outgrow flat files. He then says that "None of these constraints apply to a lot of applications." One of the constraints is "Multiple processes need to write at the same time." It turns out many early stage products need crons and message queues that execute on a separate worker. These multiple processes often need to write at the same time. You could finagle it so that the main server is the only one writing, but you'd introduce architectural complexity. So while from the pure scale perspective I agree with the author, if you take a wider perspective, it's best to go with a database. And sqlite is a very sane choice. If you need scale, cache the most often accessed data in memory and you have the best of both worlds. My winning combo is sqlite + in-memory cache.
  • upmostly 6mo ago
    Seeing the Rust 1M benches were an amazing reminder as to how fast stuff really is.
    • koliber 6mo ago
      The reality is that things will be blazing fast in any language if you save things by PK in HashMaps.
      • tstenner 6mo ago
        In the benchmark Rust is more than 50% faster than the runner up
        • koliber 6mo ago
          Correct. Order-of-magnitude-wise, it's roughly the same as the alternatives. In the context of writing a new service for a new company, you should not spend one second thinking about whether your technical choices will allow you to serve 100,000 requests per second, or 150,000 requests per second. If you are, you are focusing on the wrong thing. If you get to 1,000 requests per second with a real paying client base you already achieved more than most dream of. On the other hand, if you are optimizing a mature distributed low-latency equity trading system that is consuming ten's of thousands of market data ticks per second, a 50% improvement in performance on a 20 machine cluster might turn into some real $$$ savings. But that's not what this article is about.
• rglover 6mo ago
  A few months back I decided to write an embedded db for my firm's internal JS framework. Learned a lot about how/why databases work the way they do. I use stuff like reading memory cached markdown files for static sites, but there are certain things that a database gives you (chief of which for me was query ergonomics—I loved MongoDB's query language but grew too frustrated with the actual runtime) that you'll miss once you move past a trivial data set. I think a better way to ask this question is "does this application and its constraints necessitate a database? And if so, which database is the correct tool for this context?"
  • tracker1 6mo ago
    For me, I just wish MongoDB had scaling options closer to how Elatic/Cassandra and other horizontally scalable databases work, in that the data is sharded in a circle with redundancy metrics... as opposed to Mongo, which afaik is still limited to either sharding or replication (or layers of them). FWIW, I wish that RethinkDB had seen more attention and success and for that matter might be more included to use CockroachDB over Mongo, where I can get some of the scaling features while still being able to have some level of structured data.
• nishagr 6mo ago
  The real question - do you really need to hack around with in-memory maps and files when you could just use a database?
• swiftcoder 6mo ago
  I feel like someone who works for a DB company ought to mention at least some of the pitfalls in file-based backing stores (data loss due to crashes, file truncation, fsync weirdness, etc)
• ozgrakkurt 6mo ago
  You need databases if you need any kind of atomicity. Doing atomic writes is extremely fragile if you are just on top of the filesystem. This is also why many databases have persistence issues and can easily corrupt on-disk data on crash. Rocksdb on windows is a very simple example a couple years back. It was regularly having corruption issues when doing development with it.
  • dkarl 6mo ago
    Honestly, at this point, if I had a design that required making atomic changes to files, I'd redo the design to use SQLite. The other way around sounds crazy to me. "Why use spray paint when you can achieve the same effect by ejecting paint from your mouth in a uniform high-velocity mist?" If you happen to have developed that particular weird skill, by all means use it, but if you haven't, don't start now. That probably sounds soft and lazy. I should learn to use my operating system's filesystem APIs safely. It would make me a better person. But honestly, I think that's a very niche skill these days, and you should consider if you really need it now and if you'll ever benefit from it in the future. Also, even if you do it right, the people who inherit your code probably won't develop the same skills. They'll tell their boss it's impossibly dangerous to make any changes, and they'll replace it with a database.
    • duped 6mo ago
      The problem is that most of the time when you want "atomic changes to files" the only safe API is copy the file, mutate it, then rename. That doesn't factor in concurrent writers or advisory locks. If that kind of filesystem traffic is unsuitable for your application then you will reinvent journaling or write-ahead logging. And if you want those to be fast you'll implement checkpointing and indexes.
    • ricardobeat 6mo ago
      > They'll tell their boss it's impossibly dangerous to make any changes, and they'll replace it with a database. This, 100%. Development today is driven by appearances though, you can take advantage of that. Give it a cute name, make sure you have AI generate an emoji-rich README for it, publish it as an open source npm package, then trigger CI a few thousand times to get a pretty download count. They will happily continue using it without fear!
• 827a 6mo ago
  I'm a big fan of using S3 as a database. A lot of apps can get a lot of mileage just doing that for a good chunk of their data; that which just needs lookup by a single field (usually ID, but doesn't have to be).
  • tracker1 6mo ago
    I worked in an org where a lot of records were denormalized to be used in a search database... since I went through that level of work anyway, I also fed the exports into S3 records for a "just in case" backup. That backup path became really useful in practice, since there was a need for eventually a "pending" version of records, separate from the "published" version. In practice, the records themselves took no less than 30 joins for a flat view of the record data that was needed for a single view of what could/should have been one somewhat denormalied record in practice. In the early 2010's that meant the main database was often kicked over under load, and it took a lot of effort to add in appropriate caching and the search db, that wound up handling most of the load on a smaller server.
• winrid 6mo ago
  My recent project - a replacement for CodeMaster's RaceNet, runs on flat files! https://dirtforever.net/ https://dirtforever.net/ Just have to use locks to be careful with writes. I figured I'd migrate it to a database after maybe 10k users or so.
  • mfro 6mo ago
    Neat, what happened to the original system? Last I checked multiplayer was working in DR2.
    • winrid 6mo ago
      EA is shutting down Clubs. That is the primary motivation here. Sadly no solution for non-rooted consoles.
  • goerch 6mo ago
    And crashes you can exclude? Good luck!
    • winrid 6mo ago
      The security level is the same actually as the codemasters servers.
• SyndicateLinks 6mo ago
  [dead]
• tracker1 6mo ago
  I'd argue for using LevelDB or similar if I just wanted to store arbitrary data based on a single indexable value like TFA. That said, I'd probably just default to SQLite myself since the access, backup, restore patterns are relatively well known and that you can port/grow your access via service layers that include Turso or Cloudflare D1, etc.
  • moregrist 6mo ago
    Embedded KV stores like LevelDB are great for what they are, but I’ve often found that I’ll need to add an index to search the data in a different way. And then another index. And at some point you want to ensure uniqueness or some other constraint. And then you’re rewriting a half-complete and buggy SQLite. So I’ve come around to defaulting to SQLite/PostgresQL unless I have a compelling need otherwise. They’re usually the right long-term choice for my needs.
    • tracker1 6mo ago
      Absolutely... I was just bringing it up, as it seems to have in the box support for a lot of what TFA is discussing. I'm generally more inclined to just use SQLite most of the time anyway. That it's now in the box (node:sqlite) for Deno/TS makes it that much more of an easy button option.
• allknowingfrog 6mo ago
  I've used foreign keys and unique indexes to enforce validity on even the smallest, most disposable toy applications I've ever written. These benchmarks are really interesting, but the idea that performance is the only consideration is kind of silly.
• amw-zero 6mo ago
  I think so, yea.
• linuxhansl 6mo ago
  Hmm... Sure, if you do not need a database then do not use a database. Don't use a sports-car to haul furniture or a garbage truck as an ambulance. For the use case and scale mentioned in the article it's obvious not to use a database. Am I missing something? I guess many people are the using the tools they are familiar with and rarely question whether they are really applicable. Is that the message? I think a more interesting question is whether you will need a single source of truth. If you don't you can scale on many small data sets without a database. I will say this before I shut up with my rant: If you start with a design that scales you will have an easier to scale when it is time without re-engineering your stack. Whether you think you will need to scale depends on your projected growth and the nature of your problem (do you need a single source of truth, etc.) Edits: Spelling
• cratermoon 6mo ago
  I worked one place that shoehorned SQL Server into a system to hold a small amount of static data that could easily have been a config file or even (eek) hard-coded.
• jrecursive 6mo ago
  I suggest every developer write a database from scratch at least once, and use it for something real. Or, even better, let somebody else use it for something real. Then you will know "why database".
  • goerch 6mo ago
    Hm, sometimes opening a book could do wonders? But these were the old times...
  • yubblegum 6mo ago
    It's indeed an amazing design and implementation space to explore. If distributed it is nearly comprehensive in scope. (However, did lol @ your "every developer" - that's being super kind and generous or "developer" is doing heavy lifting here.)
  • traderj0e 6mo ago
    My first time was with a Bukkit plugin as a kid. One of my updates broke existing flat json files. Someone asked me if it has MySQL support, I didn't know what that was, then realized oh this is nice. There are also things besides databases that I'll DIY and then still wonder why so many people use a premade tool for it, like log4j
  • subhobroto 6mo ago
    I'll do one better. I suggest every developer learn how to replicate, backup and restore the very database they are excited about, from scratch at least once. I propose this will teach them what takes to build a production ready system and gain some appreciation for other ways of managing state.
    • gf000 6mo ago
      If the app is not running, then `cp sqlite.db sqlite.db.BK`
      • subhobroto 6mo ago
• rasengan 6mo ago
  Sounds like a good way to waste the only scarce resource: time.
• traderj0e 6mo ago
  The "database" in this article is only a read-only KV-store. Mind that the hard part of a KV store is writing. Still the benchmarks are interesting.
• pstuart 6mo ago
  In order to ask this question it's important to understand the lifecycle of the data in question. If it is constantly being updated and requires "liveness" (updates are reflected in queries immediately), the simple answer is: yes, you need a database. But if you have data that is static or effectively static (data that is updated occasionally or batched), then serving via custom file handling can have its place. If the records are fixed width and sorted on the key value, then it becomes trivial to do a binary search on the mmapped file. It's about as lightweight as could be asked for.
  • goerch 6mo ago
    But then you'll get two files to join?
    • pstuart 6mo ago
      I should have been clear with the assumption baked into that statement: the data in question is in a single file, with fixed size fields and sorted by primary keys. That precludes "looser" datasets, but I believe my point stands for the given context.
• jmull 6mo ago
  > Binary search beats SQLite... For a pure ID lookup, you're paying for machinery you're not using. You'll likely end up quite a chump if you follow this logic. sqlite has pretty strong durability and consistency mechanism that their toy disk binary search doesn't have. (And it is just a toy. It waves away the maintenance of the index, for god's sake, which is almost the entire issue with indexes!) Typically, people need to change things over time as well, without losing all their data, so backwards compatibility and other aspects of flexibility that sqlite has are likely to matter too. I think once you move beyond a single file read/written atomically, you might as well go straight to sqlite (or other db) rather than write your own really crappy db.
  • WatchDog 6mo ago
    It's also just wrong, their SQLite benchmark is only using a single thread for the SQLite connection. It's much faster with multiple connections.
• goerch 6mo ago
  Pretty sure the origin should be `dbunpro.app`, no? I'd think the consensus should be: do you even need the file system?
• oliviergg 6mo ago
  Please … Every few years the pendulum swings. First it was “relational databases are too rigid, just use NoSQL.” Then “NoSQL is a mess, just go back to Postgres.” Now: “do you even need a database at all, just use flat files.” Each wave is partially right. But… each wave is about to rediscover, the hard way, exactly why the previous generation made the choices they did. SQLite is the answer to every painful lesson learned, every scar from long debug night the last time someone thought “a JSON file is basically a database.”
  • debo_ 6mo ago
    Michael Stonebraker used to write long, scathing critiques of modern data storage/retrieval fads, and how they were forgetting important historical lessons. They were terrific reads; his writing on object-oriented databases was the most fun technical reading I did in grad school. And I even learned a lot!
    • kevstev 6mo ago
      Where was this? I would like to read. I have read his papers and they are great, and usually surprisingly readable.
      • debo_ 6mo ago
        It has been a long time, but I think we were reading out of various editions of the Red Book http://www.redbook.io/ http://www.redbook.io/
  • goerch 6mo ago
    Yes, but you are probably a bit too polite. And I'm not sure how to do justice to SQLite, Postgres and my new favourite toy DuckDB.
    • mdp 6mo ago
      I've been really happy with DuckDB, and I love that fact that it can operate directly on things like JSON an JSONL. It's become my data swiss army knife.
• waldrews 6mo ago
  File systems are nice if you need to do manual or transparent script-based manipulations. Like 'oh hey, I just want to duplicate this entry and hand-modify it, and put these others in an archive.' Or use your OS's access control and network sharing easily with heterogeneous tools accessing the data from multiple machines. Or if you've got a lot of large blobs that aren't going to get modified in place. What the world needs is a hybrid - database ACID/transaction semantics with the ability to cd/mv/cp file-like objects.
• 0x457 6mo ago
  > Do you even need a database? Then proceeds to (poorly) implement database on files. Sure, Hash Map that take ~400mb in memory going to offer you fast lookups. Some workloads will never reach this size can be done as argument, but what are you losing by using SQLite? What happens when services shutdowns mid write? Corruption that later results in (poorly) implemented WAL being added? SQLite also showed something important - it was consistent in all benchmarks regardless of dataset size.
• throwway120385 6mo ago
  I dunno. Even in embedded systems every time I've started without a database I've eventually come to need something like a database, and in every case I've found myself building essentially an ad-hoc poorly managed database into the application including marshalling/unmarshalling, file management, notification, and so on because each new feature over the top of regular files was just that much easier to add versus switching to a database system. However the driving motivation for adding a database is not necessarily managing data, but the fact that the database system creates a nice abstraction layer around storing data of relational or non-relational form in non-volatile memory and controlling access to it while other systems are updating it. And because it's a nice abstraction, there are a lot of existing libraries that can take advantage of it in your language of choice without requiring you to completely invent all of that stuff over the top of the filesystem. That has knock-on effects when you're trying to add new functionality or new interaction patterns to an existing system. And in cases where two or more processes need to communicate using the same data, a database gives you some good abstractions and synchronization primitives that make sense, whereas regular files or IPC require you to invent a lot of that stuff. You could use messaging to communicate updates to data but now you have two copies of everything, and you have to somehow atomize the updates so that either copy is consistent for a point in time. Why not use a database? Knowing what I know today I would start with some kind of database abstraction even if it's not necessarily designed for transactional data, and I would make sure it handled the numerous concerns I have around data sharing, consistency, atomicity, and notification because if I don't have those things I eventually have to invent them to solve the reliability problems I otherwise run in to without them.
• charcircuit 6mo ago
  >So the question is not whether to use files. You're always using files. The question is whether to use a database's files or your own. It's the opposite. A file system is a database. And databases can recursively store their data within another database.
• tonymet 6mo ago
  If the cloud is just someone else’s hard disks (etc) then RDBMS is just someone else’s btree
• hnlmorg 6mo ago
  > Every database you have ever used reads and writes to the filesystem, exactly like your code does when it calls open(). Nope. There are non-persistent in-memory databases too. In fact, a database can be a plethora of things and the stuff they were building is just a subset of a subset (persistent, local relational database)
• jmaw 6mo ago
  Very interesting, I'd never heard of JSONL before: https://jsonlines.org/ https://jsonlines.org/ Also notable mention for JSON5 which supports comments!: https://json5.org/ https://json5.org/
• zkmon 6mo ago
  Sure. Go ahead and use JSONL files and implement every feature of SQL query. Congrats, you just reinvented a database, while trying to prove you don't need database.
• jmaw 6mo ago
  While this is certainly cool to see. And I love seeing how fast webservers can go.. The counter question "Do you even need 25,000 RPS and sub-ms latency?" comes to mind. I don't choose a DB over a flat file for its speed. I choose a DB for the consistent interface and redundancy.
• FpUser 6mo ago
  I think this whole article and post is an attention / points seeking exercise. It is hard to imagine programmer who would not know difference between DBMS and just bunch of files and when to use which
  • mikenikles 6mo ago
    Of course it is :).
• theshrike79 6mo ago
  I have a vague recollection that 4chan (At least at one point) didn't use any kind of backend database, they just rewrote the static pages with new content and that was it. That's why it could handle massive traffic with very little issues.
  • flomo 6mo ago
    I have a vague recollection that HN also doesn't use a database, it serializes the data structures or something.
  • ogurechny 6mo ago
    It is a typical solution from the 90s, first steps of interactivity after hand-written HTML pages served by Apache. POST request is handled by some Perl script that rewrites the HTML page, then redirects to it or directly sends it as a reply. See the most basic frame-based chats (no Javascript, no nothing). It only handles massive traffic if reads of those static pages are frequent, and updates are rare. When thousands of users are posting, you have to either block everyone on each write, or subdivide the required synchronisation between boards. Also, the regenerated pages might be used just a couple of times before the next rewrite happens (or not viewed at all, like far away board pages, but you still have rewrite all involved pages as a batch), and not much caching happens. In addition to that, each short comment causes multiple full long pages to be regenerated, and stored on disk. You basically get a very ineffective database with very ineffective primitives. So usually every image board owner starts with decoupling of message posting and page updates to only regenerate pages once in a while, and process multiple edits at once, then some things stop working, as they assume each state change happens in full in multiple places, then they try to rewrite everything or switch to a real database engine.
• agustechbro 6mo ago
  To not destroy the article author and apreciate his effort to prove something, that might be useful in a extreme case of optimization with a limited ammount of data and NO NEED to update/write the files. Just a read cache only. If you need to ever update a single byte in your data, please USE A PROPER DATABASE, databases does a lot of fancy thing to ensure you are not going to corrupt/broke your data on disk among other safety things.
• cold_tom 6mo ago
  you can get surprisingly far with files, but the moment you care about things like concurrent writes or not losing data on crash, the whole thing changes at that point you're not choosing speed vs simplicity anymore -you're choosing how much risk you're willing to carry
• orthogonal_cube 6mo ago
  SQLite did decently well but I think they should’ve done an additional benchmark with the database loaded completely into memory. Since they’re using Go to accept requests and forwarding them to their SQLite connection, it may have been worthwhile to produce the same interface with Rust to demonstrate whether or not SQLite itself was hitting its performance limit or if Go had some hand in that. Other than that, it’s a good demonstration of how a custom solution for a lightweight task can pay off. Keep it simple but don’t reinvent the wheel if the needs are very general.
• devilsdata 6mo ago
  This is a cool exercise, but I would hesitate to choose files over SQLite or another Dockerised relational database in production. They are overoptimising for the simplest part of writing the application; the beginning. They've half-implemented an actual database, with none of the safety features. There are a lot of potential headaches that this article has avoided talking about; perhaps because they haven't experienced them yet. See: https://danluu.com/file-consistency/ https://danluu.com/file-consistency/ What happens when you need to start expanding the scope of this feature? Joining users on profiles, or users on orgs? Ask yourself: how many shops have seriously written an application backed by files and stuck with it over the long-run? The answer is likely very few. Therefore, this is likely doubling up the work required. There is a reason people reach for a database first. I'd strongly encourage anyone to avoid doing stuff like this.
  • bpavuk 6mo ago
    and then there is a decent amount of software that's mostly "one and done" and has immense performance constraints - games and anything that has to do with real-time. for game engines, a custom data format from the very start makes a lot of sense because your budget is usually less than 17ms and 8 threads on low-end hardware and 8.(3)ms across 16 threads on high-end. there, "smart data structures and dumb code beat dumb data structures and smart algorithms" couldn't be more true. yet, for a generic app or server, just don't fuck your brains and go with SQLite
• allthetime 6mo ago
  Funny, I was just hard at work on my new article “Just use a database”.
• sgarland 6mo ago
  If you’re going to do something bizarre like this, then why store it as human-readable? If you have fixed-size fields as they do here, make your own serialization format. You’re still doing byte-offset seeks, but it’ll be much faster. At the very least, use a monotonic key, so you can avoid having to periodically sort.
• kvikuz 6mo ago
  [dead]
• tejohnso 6mo ago
  I remember reading a story from Robert C. Martin, if I recall correctly, about writing an application and trying to decide which DB to use. In the end, they put the DB access paths behind an abstraction and decided that they'd just use the file system to start with, and easily switch it out later. In the end, they shipped, and never did need to use a real DB.
• briandw 6mo ago
  The article is fine, but I wanted to call this out. "Every database you have ever used reads and writes to the filesystem, exactly like your code does when it calls open()." Technically not true. Applications like SQLite use mmap to map the file into a locally addressable memory space. This lets you skip the syscalls when reading and writing. The kernel can map that data in dynamically much faster than a userland process can. Later in the article they go over the process of reading in the entire file into memory, again mmap is much better at this. Would have been nice to see that approach used.
  • fg137 6mo ago
    The article definitely oversimplifies the IO happening in a database. That said, depending who you are talking to, they may not agree with you on "mmap is much better than this". Some people will say you should do what you need in the application logic instead of depending on APIs from the OS. (although not necessarily for the specific example here) https://db.cs.cmu.edu/mmap-cidr2022/ https://db.cs.cmu.edu/mmap-cidr2022/
  • akoboldfrying 6mo ago
    The backing store being used by map() is still a file in a filesystem, so I would say their overall claim is technically true. It's the "exactly like your code does when it calls open()" part that oversimplifies a little (though, again, remains technically true -- it's just giving an example of a thing you can do with a file, not exhaustively listing all the things you can do with a file).
  • PaulDavisThe1st 6mo ago
    > The kernel can map that data in dynamically much faster than a userland process can. Not necessarily. The kernel's mmap implementation has quite a strong bias towards certains kinds of access patterns; deviate from them and it can become slower than read(2). We tried using mmap(2) for audio file i/o in Ardour, and it got notably less bandwidth than just using read(2).
    • debatem1 6mo ago
• janalsncm 6mo ago
  I have come at it from another angle, so maybe it’s useful perspective. A lot of data pipeline work can function pretty well with each step producing artifacts that the next can consume. If you need unique items, use uuids. If you want to check whether an item exists, use a hash of something (maybe a url). And each day goes in its own subdirectory. It works. Sometimes, though, you end up reinventing database constructs. Joins, indexing, versioning. A little of that is ok, but it gets gnarly fast. If you mess up, it could mean corrupting your data in a way that’s irreversible. Or, corrupting your data in a way that’s reversible but really hard. So a database has the benefit of enforcing consistency that a glob over json files doesn’t. It doesn’t mean every one-off script needs a blue-green Postgres DB, but there can be an inflection point.
• a34729t 6mo ago
  I sympathize with this so hard. I frequently conduct system design interviews where the problem could easily be handled on a single machine with a flat file, let alone sql lite. Only the rare candidate mentions this; mostly I get a horde of microservices and queues and massive distributed databases that are totally unneccessary.
  • pdimitar 6mo ago
    I mostly agree but I had plenty of cases where the project / team was forced to reinvent a query engine over flat files and/or in-memory caches. From that POV I moved from the extreme of "you don't need a state at all (and hence no database)" to the bit more moderate "you usually don't need a file or a DB but you almost certainly will want to query whatever state you store so just get a DB early". I strongly sympathize with "no microservices" of course. That's an overkill for at least 99% of all projects I've ever seen (was a contractor for a long time). But state + querying is an emergent property as a lot of projects move beyond the prototype phase.
• tnelsond4 6mo ago
  I love SQLite, I love the idea, I love having something mature and lightweight, but like the author I discovered it's overkill or dare I say insufficient for certain use cases. I was building a client side dictionary app with search functionality and thought that using sqlite's wasm port would be the perfect solution. I used SQLite for a couple years and it started to wear on me. The database files were bigger than they should be, they didn't compress super well, the loading time was a bit slow. Linear search wasn't very fast either. Editing SQLite files and doing joins and stuff was slow and frustrating as well. I wanted something simpler. I didn't need atomics, I didn't need writes, so I just handrolled a set of indexes from the source tsv files and compressed those with zstd and decompressed them via wasm on every load. Decompressing and loading was now faster than straight loading via SQLite and since my module was 52kb of wasm instead of 800kb for SQLite I could load as many instances of the module as I wanted with no regrets. I use stringzilla for linear scans and it's ridiculously fast. SQLite is great, but it's not the solution for every problem.
  • jfreds 6mo ago
    The author of stringzilla, Ash Vardanian, has a bunch of really cool talks/lectures/demos. Highly recommend checking him out if you like that kind of thing :)
    • tnelsond4 6mo ago
      Yeah, I probably should since I want to add glob or regex support later. It's a little out of the scope of stringzilla but I should still be able to use it for the heavy lifting
  • Hendrikto 6mo ago
    > The database files […] didn't compress super well That’s a good thing. If they were compressible that would indicate inefficiency in the SQLite format.
    • tnelsond4 6mo ago
      Well, I went and looked at it again and it seems like SQLite databases although larger than my custom format do compress to a 10% smaller size provided there's no indexes. But my custom format uses indexes so it's not really a good comparison. I guess I should see what it's like with indexes. But at the end of the day SQLite just doesn't meet the needs of my project due to it's size and lack of free decompression support. Passing a decompression stage before giving it to SQLite is unwieldy and requires a separate decompression module and incurs a copy operation. I don't know enough about SQLite to attempt to compile and integrate the zstd decompressor into it.
• thutch76 6mo ago
  I love reading posts like these. I will still reach for a database 99% or the time, because I like things like SQL and transactions. However, I've recently been working on a 100% personal project to manage some private data; extracting insights, graphing trends, etc. It's not high volume data, so I decided to use just the file system, with data backed at yaml files, with some simple indexing, and I haven't run into any performance issues yet. I probably never will at my scale and volume. In this particular case having something that was human readable, and more importantly diffable, was more valuable to me than outright performance. Having said that, I will still gladly reach for a database with a query language and all the guarantees that comes with 99% of the time.
• perrygeo 6mo ago
  Let's put it this way. I always end up needing the functionality and ACID guarantees of a database. I always wish I had a database. But some times I'm forced to use the project's legacy data stores (often flat-file data lakes) and watch every wheel get reinvented as we struggle to glue consistency, transactions, a bespoke query language, etc. onto an unwilling pile of unstructured data.
• WatchDog 6mo ago
  The sqlite benchmark is not very optimised. Just adding: db.SetMaxOpenConns(runtime.NumCPU()) db.SetMaxIdleConns(runtime.NumCPU()) Made the performance on my machine go from 27,700.99 r/s to 89,687.36 r/s. I also tried making the get user a prepared statement, and storing the timestamp as an unix timestamp integer, but that didn't make much difference for me.
• chrismorgan 6mo ago
  > The index format is simple: one line per record, exactly 58 bytes: <36-char UUID>:<20-digit byte offset in data file>\n. It would be much better to write all of this as binary data, omitting separators. • Since it’s fixed-width and simple, inspecting the data is still pretty easy—there are tools for working with binary data of declared schema, or you could write a few-liner to convert it yourself. You don’t lose much by departing ASCII. • You might want to complicate it a little by writing a version tag at the start of the file or outside it so you can change the format more easily (e.g. if you ever add a third column). I will admit the explicit separators do make that easier. You can also leave that for later, it probably won’t hurt. • UUID: 36 bytes → 16 bytes. • Offset: 20 bytes (zero-padded base-ten integer) → 8 bytes. • It removes one type of error altogether: now all bit patterns are syntactically valid. • It’ll use less disk space, be cheaper to read, be cheaper to write, and probably take less code. I also want to register alarm at the sample code given for func FindUserBinarySearch. To begin with, despite a return type of (*User, error), it always returns nil error—it swallows all I/O errors and ignores JSON decode errors. Then: entryID := strings.TrimRight(string(buf[:36]), " ") That strings.TrimRight will only do anything if your data is corrupted. cmp := strings.Compare(entryID, id) Not important when you control the writing, but worth noting that UUID string comparison is case-insensitive. offsetStr := strings.TrimLeft(string(buf[37:57]), "0") Superfluous. ParseInt doesn’t mind leading zeroes, and it’ll probably skip them faster than a separate TrimLeft call. dataOffset, _ := strconv.ParseInt(offsetStr, 10, 64) That’s begging to make data corruption difficult to debug. Most corruption will now become dataOffset 0. Congratulations! You are now root.
• deleted 6mo ago
  [deleted]
• keithnz 6mo ago
  so the article benchmarks speed, but I don't really think most people are making the choice based on speed. Robustness is really the driving force (well at least for me). So for CRUD operations I have way more confidence with something like SQLite than using files. Files are workable in many situations, but much easier if you default to things like SQLite and use files only when you think there is a specific advantage.
  • amarant 6mo ago
    It's like the old words of wisdom say, the fastest way to manage your data is to pipe it to /dev/null
• Openpic 6mo ago
  [dead]
• deleted 6mo ago
  [deleted]
• inasio 6mo ago
  There's a whole thing this days about building solvers (e.g. SAT or Ising) out of exotic hardware that does compute in memory. A while back I wondered if one could leverage distributed DB logic to build solvers for massive problems, something like compute in DB.
• thegdsks 6mo ago
  For anything that starts as a side project, SQLite covers it. The moment you need to ask this question the answer is usually "not yet." Ship first, migrate when it actually hurts
  • kantselovich 6mo ago
    If there is no database, where one should persist state? Most software is stateful and needs to persist state across restarts, so I would argue that one needs at least SQLite. On SQLite being safe default: in practice it means supporting multiple databases, say SQLite and Postgres, this is more complicated that supporting just Postgres. As soon as a project leaves localhost and enters cloud development you need talk to a database over network, which warrants MySQL or Postgres. Which is more complicated: supporting a docker container with mysql or Postgres for local development OR supporting multiple databases in the project? Of course, the answer could be “it depends”, I but I would not call SQLite a default choice. It would be if you are writing desktop or mobile app, but for anything like a web app it’s a questionable choice.
• Waterluvian 6mo ago
  My personal toolbox’s section for databases has three items: files (usually JSON), SQLite, Postgres. I haven’t and I doubt I will ever run into a situation where none of those fit. They exist, I’m sure, but I’m too general purpose to ever need anything else.
• afpx 6mo ago
  Not directly related, but this is a good example of why I love dependency injection. In most systems, I typically define the interface, implement something super simple at first, and as I iterate I re-evaluate, and I can easily* swap between implementations. * Not always super easy
• jwilliams 6mo ago
  Is it just me or is this sorely lacking any consideration for inserts? Or durability?
• Mawr 6mo ago
  > Binary search beats SQLite. This was unexpected. Plain sorted files with a hand-rolled index outperform SQLite's B-tree by about 1.7x at every scale. SQLite does more work per lookup than a hand-rolled binary search, even for a simple primary key read. That overhead is worth it when you need the features. For a pure ID lookup, you're paying for machinery you're not using. 1. You're paying very little for 1000x the features. 2. The chances your application will keep doing "pure ID lookups" forever are zero. The moment you need to query the data in any other way or have more than one writer you're going to have to throw all this nonsense code into the trash. 3. Do you need the 1.7x speedup? No, of course you don't. It's just optimizing for the sake of optimizing. I'd have just used sqlite to begin with and not benchmarked anything. No custom code, no need to waste any time, great performance, amazing flexibility — all with minimum effort.
• dxxvi 6mo ago
  Before reading that post, I would use sqlite/duckdb for everything related to data. After reading that post, I will use sqlite/duckdb + Rust for everything related to data :-)
• econ 6mo ago
  Back when Ajax was a hip new thing someone asked me why xml? We later answered that question with JSON of course but his hypothetical solution was much more hilarious. I'm calling it the html database. He made two mockups. One where everything was a richly formatted static html file and one that used a blogging platform. It had things like archives by month each with their own url. A paginated front page with chunk from each posting. It was pretty funny and I couldn't really see something wrong with it. In his demo he pulled in a document with a table in it and inserted the table into a div. One version used the domparser but he also made one with <!-- table start --> and <!-- table end --> and chopped out a substring. In the 80's, because of resource constraints, a standard thing to ask was "why is my data not formatted the way I need it?" IOW when to format it properly? when it is created? When it is consumed? Both? At some other time? If you are going to create it one time and consume it 100 000 times html is a great "DB"
  • AlienRobot 6mo ago
    He invented the RESTful DB.
• Anamon 6mo ago
  DB-less is underrated. You can take it even further. One of my favourite websites ever loads its entire main content index into the client as a JSON file. It's about 5 MBs I think, so maybe 10% of the ad and autoplay video crap most "modern" websites make you download in the first few seconds. Except that this initial download actually gives you an amazing UX in return, because all the searching, filtering, pagination etc. happens entirely client-side without further network requests. I don't know any other website that is as much of a joy to just browse through. You never wait for anything until the point that you found what you want and actually want to open a detail page. Just wonderful.
• Panzerschrek 6mo ago
  I agree that using a database in many cases is overkill. And I don't understand at all who and why uses so-called in-memory databases.
• tomasvojtech29 6mo ago
  [dead]