Hacker News Reader

Comment by brigandish | Hacker News Reader

It's a terrible API anyway and if it died I wouldn't shed a tear. If you need a good laugh (or more likely, a heart attack from the blood pressure rise it will induce) have a look at this blog post[1] by Mozilla justifying not using SQLite and choosing to implement the much more "elegant" IndexedDB. That post has too many examples of hubris and delusion for me to bother quoting it here, I'd just be reproducing most of it.

Then you can go to their code comparison page[2] and wonder what the hell they were on about.

> IndexedDB generally simplifies the programming model for interacting with databases, and allows for a wide number of use cases.

They can't be looking at the same code - what have they improved other than to use more Javascript?

The sooner it dies the sooner an alternative can appear… SQLite3, anyone?

[1] https://hacks.mozilla.org/2010/06/beyond-html5-database-apis...

[2] https://hacks.mozilla.org/2010/06/comparing-indexeddb-and-we...

View on HN

I mean I can understand why they dropped websql, as great a project as SQLite is, mandating that browsers expose SQLite is not a spec, and expecting a complete reimplementation of sql by browser developers would be foolish.

But yeah the assertion that indexeddb is any good is hardly convincing.

Nowadays you can use sqlite3 through wasm if you want, though I don’t know how you’d handle the persistence layer.

> Nowadays you can use sqlite3 through wasm if you want, though I don’t know how you’d handle the persistence layer.

There was a post on here in the last month or 2, atleast for reading, that used http range headers for reading the db pages.

as for writing, you're gonna hate this, but a vfs impl. for SQLite using indexedDB as the backing store is your best option (Safari stupidity not withstanding)

> There was a post on here in the last month or 2, atleast for reading, that used http range headers for reading the db pages.

That was for a local SQLite doing remote loads/stores, I was thinking more local loads/stores, what websql would have provided.

> as for writing, you're gonna hate this, but a vfs impl. for SQLite using indexedDB as the backing store is your best option (Safari stupidity not withstanding)

Yeah that’s what I was figuring out but then it feels like the SQLite bits are significantly less useful, and I’m not sure how good indexeddb is at being a block device.

You can still mandate a spec, and if everybody ends up picking SQLite to implement it, so what?

If you write the spec to be compatible with SQLite and everyone picks that, then you have in essence mandated SQLite and your spec is at the mercy of the project’s decisions.

If you write the spec to not be compatible with SQLite then every browser has to implement its own SQL layer which is a huge effort and frankly a waste because SQL is kinda shit.

SQLite is open source. If it goes away from the direction you want, then fork it. That's still way less effort than implementing a bunch of different IndexedDB variants.

"Just use SQLite, lol" is not a spec.

P.S. SQLite doesn't have a spec. Once you start really using it and bumping into version differences, extensions, etc., you'll really feel the pain caused by this.

I didn't say that it is. But you could make a spec that is implementable using SQLite.

And no, it's not the same as mandating SQLite.

> But you could make a spec that is implementable using SQLite.

Yes, that would be the smart choice. But alas.

Why do you care more about this mythical spec - which clearly is s load of rubbish if IndexedDB is anything to go by - versus a working, powerful technology that is as close to being able to be dropped in quickly as one could hope for?

> working

Not after Google and Apple get their hands on it.

You can try to language-lawyer this as much as you want, but it doesn't matter; Browser developers clearly do not want to just adopt SQL into the browser layer without there being multiple independent implementations, and scoping the problem so that you can act all "whoops, wow, what did I trip over right here? so convenient!" to use SQLite and be done with it, is a tactic they almost certainly can predict and see as a bad one, nearly equivalent to just mandating it in the first place.

Like, does anybody here really think their actual complaints are about some minutae about wording in a spec about "mandates" or whatever? Their rejection is quite clearly against the spirit of the design, and again because because they don't think multiple browsers each independently reproducing a whole SQL stack with equivalent semantics is viable. It's not about technical nits or wordsmithing, little coder-logic-tricks aren't going to work.

> Browser developers clearly do not want to just adopt SQL into the browser layer

Why would they think it’s more viable as a JavaScript spec than a SQL one? It seems to me it’s about retaining control and about giving what some web devs want - JavaScript everywhere.

Granted that the DOM event API feels clunky, but I actually think they got things mostly right: - low-level storage primitive with support for indices, "you pay only for what you use". - very fast if used in the right way - very large sizes supported - built-in version support, making it easy to do schema and data migrations. - basic query api that again gives you a lot of flexibility and control over performance - can be abstracted away by higher level libraries like Dexie

I've built a web-app heavily relying on IDB, and storage operations are generally much faster than the native app on Android using Realm DB. IDB is backed by leveldb on Chrome, which in benchmarks is consistently faster than sqlite. I'm happy we didn't end up with websql for one.

My biggest gripes are: - The incompatibility with ES6 promises early on (but IE11 still suffers from) was unfortunate. - The auto-commit behaviour of transactions is somewhat annoying and usually has an impact on your architecture if you want to write multiple things in one transaction, but it would have been easy to have memory leaks and deadlocks without this. - Quota management and eviction is wildly inconsistent between browsers, even on Chrome you get evicted when storage gets critically low. - Safari has a history of pretty bad IDB bugs.

SQLite is amazing. But after having worked with it for many years now, I believe it should never be a platform-level API, and not standardizing it for browsers was the right choice.

SQLite has a _lot_ of great features. Many of them only introduced in recent versions, and many of them are optional extensions enabled at compile-time. There is no feasible way to standardize this to get the same functionality across all browsers.

IndexedDB may not be great to work with (at least not without helper libraries), but at least the API surface is small, and much easier to ensure you get the same behaviour in all browsers.

I'd rather advocate for a proper block-level filesystem API that could be used as backing storage for a WASM SQLite library.

> SQLite is amazing. But after having worked with it for many years now, I believe it should never be a platform-level API, and not standardizing it for browsers was the right choice.

No it was never the right choice and it didn't need to become standardized at first place. Writing a query builder is an easy task, implementing a RDBMS on top of indexedDB, ironically implemented on top of SQlite in Firefoxis a much harder tasks.

IndexedDB is absolutely atrocious API wise, and largely useless to query structured data.

> I'd rather advocate for a proper block-level filesystem API that could be used as backing storage for a WASM SQLite library.

This is happening at https://web.dev/storage-foundation/ fwiw

IndexedDB's ugliness is due to being from a time before ES6+ really kicked into gear and we still had the old crud of weird callback stacks (See FileReader for another example).

As for SQLite, as lovely as that'd be, NOONE wanted to spend R&D on building a "SQLite clone" for the web SQL spec, and I can't blame them, how the hell can you justify that effort when SQLite exists and is crazy well tested and proven?

Have you ever tried to use it on a project? It's been a while for me as I moved to PouchDB or SQLite in WASM and never looked back.

Let's say you need to search for age > 19 and less than 30 for a person with the name of Jane or John.

That's nothing complicated, but indexedDB CANNOT DO THIS. I suppose you could do it by iterating every single data entry, but that's a performance no-go for even relatively trivial databases.

Likewise, joins on different stores simply don't exist. Iterating every entry in this case is O(N^2).

Might as well just store a giant JSON blob instead.

Quite literally, my only use of indexedDB these days is storing a SQLite file and whatever interactions PouchDB has (I think they are mostly limited to linking an ID with a JSON blob). Adding insult to injury, despite being a simple key/val store, it's SLOWER than SQLite too.

> Let's say you need to search for age > 19 and less than 30 for a person with the name of Jane or John.

I’m pretty sure you can do that. You can create an IDBIndex that covers multiple fields, then narrow down the search using key ranges. Though, even with key ranges, narrowing down results based on multiple independent ranges requires some manual work:

https://gist.github.com/inexorabletash/704e9688f99ac12dd336

But at least algorithmically speaking, that’s roughly the same thing that a database natively supporting such queries would be doing, so the big-O performance should be the same. Though I wouldn’t be surprised at all if it’s slower in practice.

WebSQL was what we all wanted. But if I remember right, it couldn't be standardised because the W3C requirement insists that there should be atleast 2 different implementations of it in the clients - however all the browsers that supported it only built it using SQLite (which is a very obvious choice). If atleast one of the browser had built an implementation with a different database backend (like perhaps BerkleyDB), it could have become a web standard and a reality today. Instead, we are stuck with crap like IndexedDB.

If a least one browser had used a different backend, the API behavior would have had to actually be defined instead of just saying "behaves like SQLite". And that defined behavior would have to be implementable on top of both SQLite an the other backend.

All doable, but quite a lot of work. Once you start looking at the details, every single database has its own SQL dialect and they're not all that compatible except for the simplest queries.

> Instead, we are stuck with crap like IndexedDB.

Which is implemented on top of Sqlite in many browsers, what a joke.

It's easier to implement IndexedDB on top of a SQL database than the other way around, so people claiming IndexedDB is "lower level" are ignorant.

That's a shame. So we don't have it for bureaucratic reasons? What was the rationale behind that rule?

IndexedDB does indeed suck, but there's really no alternative to it if you want Safari and Firefox support. Fortunately, in Chrome we have the FileSystem Access API which has a feature that lets you write into an "origin private" store, similar to how IndexedDB partitions storage per origin.

There's even recent work to add even higher performance APIs into the Filesystem Access API and the reception from Firefox and Safari has been positive. Really early work is happening here: https://github.com/WICG/storage-foundation-api-explainer and the latest proposal is here: https://docs.google.com/document/d/121OZpRk7bKSF7qU3kQLqAEUV...

> There's even recent work to add even higher performance APIs into the Filesystem Access API and the reception from Firefox and Safari has been positive.

Positive as in: "FileSystem Access is a significant security risk and we're not going to implement this"? https://www.chromestatus.com/feature/6284708426022912

Positive as in "No, we don't want fifteen different file access apis, and we don't think Storage Foundation API is going anywhere"? https://www.chromestatus.com/feature/5670244905385984

And even though this is a draft created and authored exclusively by Googlers, even other Googlers are confused: https://github.com/WICG/storage-foundation-api-explainer/iss...

Storage Foundation is being merged with the Origin Private part of the Filesystem Access API specifically to address feedback from Safari and Firefox teams about too many File APIs on the web, and if they only implement the Origin Private part of the spec there’s no more risk than IndexedDB since it doesn’t interact with the real file system.

> Storage Foundation is being merged with the Origin Private part of the Filesystem Access API specifically to address feedback from Safari and Firefox teams about too many File APIs on the web

Good. Still doesn't mean there's positive feedback.

> if they only implement the Origin Private part of the spec there’s no more risk than IndexedDB since it doesn’t interact with the real file system.

If. Or it may go the HID way: https://news.ycombinator.com/item?id=27512354

I wouldn't hold my breath for "positive feedback" on these APIs.

> FileSystem Access is a significant security risk and we're not going to implement this

Right now the Mozilla position is 'defer', not 'harmful'. See https://mozilla.github.io/standards-positions/#native-file-s....

That means yes, they're not implemented today, but they're open to doing so later on, given further specification development and real-world investigation to confirm that the security implications are minimal.

> No, we don't want fifteen different file access apis

Looks like there is some ongoing work to synchronize these APIs to resolve that concern: https://docs.google.com/document/d/121OZpRk7bKSF7qU3kQLqAEUV...

---

I 100% agree Google is too aggressive at publishing and releasing these features without widespread consensus from other vendors. If they were doing so with just origin trials or behind a flag that would seem reasonable to me, but the widespread release is surely going to cause problems for these specs, when they must be aware that further development and changes is going to be required. I'm not clear how they intend to mature these standards without breaking the early adopters.

I don't agree they're not desirable features though. Honestly I desperately wish Safari & Firefox would engage more and drive these specs themselves! It would be better to get their voices in the decisions that'll define these specs, rather than letting Google define the future of the web all by themselves.

There's clearly demand for these features (read the comments of https://github.com/mozilla/standards-positions/issues/154 for some examples). It would be better to have privacy and security baked in with input from a broad group of actors (I think we can all agree that Firefox is going to be a more useful voice than Google in that sense). It's not helpful to let Google run off and write every standard themselves, with other browsers watching from the sidelines until it's sufficiently done (and unchangeable) and then having to either adopt the existing standard as-is by necessity or to refuse to support many real world web applications (for as long as that's tenable).

Make no mistake - Chromium has the market share to be a workable target, and these APIs work well for developers and are genuinely useful. They will be used. There will be (in some areas there already is) a whole world of web apps using these APIs which only work in Chromium by necessity, no matter how much they'd like to support other browsers. As those get adopted by users, that's only going to drive the web further towards Chromium, until other browsers have to die or adopt the (entirely Google-written) standards themselves too to support the next generation of webapps.

This is happening on desktop in some areas already. In IDEs, for example - if you buy any IoT based on Espruino, the primary dev tool only works in Chrome due to WebUSB/WebBluetooth (https://www.espruino.com/Web+IDE), while tools like Godot Editor are already talking about Chrome-only save/load support using these filesystem APIs (https://godotengine.org/article/godot-editor-running-web-bro...), and I'd be extremely surprised if GitHub Codespaces and other tools aren't looking at doing the same. These are popular tools - many users want to use them, and they will have to switch to a Chromium-based browser to do so.

Mobile is somewhat protected due to Safari being the only option on iPhone, but I wouldn't be surprised if the ongoing antitrust cases force them to open that up to make PWAs look like a plausible app store competitor, and the exact same thing happens there.

WebExtensions is a case study of the same effect in the past. Chromium has so much weight that once they fully design and adopt an API and build an ecosystem around it, other browsers have to follow or get cut off. If Firefox & Safari had engaged with WebExtensions much earlier, they could have been driving it themselves and building consensus. Instead, they've had to copy every Google API while just tweaking around the edges.

One exception, interestingly: Brave is doing some intriguing work on driving decentralization APIs for the web (native Web3, native IPFS). It's early days, but I'm hopeful that this might have the same effect in the opposite direction for those features!

Firefox and Safari do engage early, and they do participate in discussions. GitHub comments are a very small visible part of it.

However, Chrome simply inundates them with APIs. There are 50 to 100 new APIs that Chrome releases with each new version. And a new version comes out once every two months. So, Firefox and Safari have to be "actively engaged in discussions" on 300 to 600 new APIs a year [1].

This is not sustainable in any way, shape, or form. Hell, Microsoft gave up on developing a browser of their own, and they are definitely not lacking in resources. How is Mozilla expected to cope? Safari has decided to set their own pace, and flat out refuse APIs that breach security and privacy, because by this time Chrome teams should really know better (if only they cared).

So, no, it's not true that Mozilla and Safari are "not engaged at an early stage". They are, to the best of their abilities and resources. But they also have browsers to develop, and in the end there are only so many hours in the day.

[1] https://web-confluence.appspot.com/#!/confluence

I hear you, I'm not saying it's easy! Firefox especially desperately needs more funding here (and Apple more competition, on mobile at least).

That said, that API count is referring to individual methods & fields (see https://web-confluence.appspot.com/#!/catalog) not whole specifications. I'm mainly concerned about them reviewing and making contributions to write these specs, rather the work to fully implement them, so that at least they end up with something they might be happy implementing in future.

Either way, if every few months Chrome can genuinely churn out hundreds of APIs that developers genuinely want and use (a big caveat!) and Firefox/Safari can't keep up, then that's game over. Chromium has the market share, people will start using these APIs, serving a relatively worse and worse version for the slower browsers (if they bother), and eventually the older browsers will either have to implement them to according to these defacto standards, design & implement a sufficiently better alternative somehow, or die (for the average user, at least).

Firefox beat IE last time because it took the 2nd option: it had better alternatives to Microsoft's non-standard web technologies (primarily: consistent APIs backed by clear standards and good tools that solved the same problems) and thereby managed to capture web developers and lead the compatibility game, rather than following. I don't see how they can do the same again if they can't propose workable alternatives to new standards other than 'defer' or 'reject'.

> Either way, if every few months Chrome can genuinely churn out hundreds of APIs that developers genuinely want and use (a big caveat!) and Firefox/Safari can't keep up, then that's game over.

It very much is, and has been for a while: Google completely dominates all of web-related standards bodies. And the specs that are rushed to completion in Chrome are more likely than not to be fully authored by Googlers only (sometimes with egregious disregard for standards work, see WebHID [1]).

[1] Issue https://github.com/mozilla/standards-positions/issues/459#is... and timeline https://news.ycombinator.com/item?id=27512354

Ok, if we take this as given then non-Chromium is dead. Yikes. I'm not convinced it's a lost cause yet, but yes it looks like a very plausible future imo.

Assuming that then, if we want healthy web standards then it sounds like the only option is to shut down Firefox et al ASAP (or make it another chromium wrapper) and spend that engineer time & money instead getting involved in these specs and Chromium development to try and provide non-Google input and ideas, and somehow transform Chromium itself into a community endeavour. If there's an inevitable chromium monopoly then that seems like the only choice. Unless something else blocks the chromium monopoly, e.g. Google antitrust of some sort, but that doesn't seem imminent (for Chrome specifically).

A somewhat bleak future, but if this becomes inevitable then that seems like the best option unfortunately.

I think that this may as well be a pendulum: many browsers, IE6 monopoly, many browsers, Chrome monopoly. We may yet swing back to many browsers at some point in the future :)

> That post has too many examples of hubris and delusion for me to bother quoting it here

Well, I could not help myself.

>> While versions of Safari, Chrome, and Opera support a technology called Web SQL Database, which uses SQL statements as string arguments passed to a JavaScript API, we think developer aesthetics are an important consideration, and that this is a particularly inelegant solution for client-side web applications.

>> We .. also spoke with Microsoft, who agree with us that IndexedDB is a good option for the web

OMG!! MS thought not doing what Apple and Google wanted was a good option. Earth shattering.

As for the code examples, both sets look horrible, but this and "_developer aesthetics_" don't go together. This is how they think their `JOIN` is "better" than SQL `JOIN`.

    candyEaters = [];
    function displayCandyEaters(event) {
      var display = document.getElementById("purchaseList");
      for (var i in candyEaters) {
        display.textContent += ", " + candyEaters[i].name + "bought " +
                               candyEaters[i].count + "pieces";
      }
    };

    var request = window.indexedDB.open("CandyDB",
                                        "My candy store database");
    request.onsuccess = function(event) {
      var db = event.result;
      var transaction = db.transaction(["kids", "candySales"]);
      transaction.oncomplete = displayCandyEaters;

      var kidCursor;
      var saleCursor;
      var salesLoaded = false;
      var count;

      var kidsStore = transaction.objectStore("kids");
      kidsStore.openCursor().onsuccess = function(event) {
        kidCursor = event.result;
        count = 0;
        attemptWalk();
      }
      var salesStore = transaction.objectStore("candySales");
      var kidIndex = salesStore.index("kidId");
      kidIndex.openObjectCursor().onsuccess = function(event) {
        saleCursor = event.result;
        salesLoaded = true;
        attemptWalk();
      }
      function attemptWalk() {
        if (!kidCursor || !salesLoaded)
          return;

        if (saleCursor && kidCursor.value.id == saleCursor.kidId) {
          count++;
          saleCursor.continue();
        }
        else {
          candyEaters.push({ name: kidCursor.value.name, count: count });
          kidCursor.continue();
        }
      }
    }

It's terrible, isn't it? Have these people ever used SQL? Doubtful, it they had then they might know the difference between joins and cursors!

I think indexedDb is just too low level for your use case. Because it’s actually very good! This low level primitive allows to implement various approaches on top of it, such as the excellent Dexie.js. You should have a look at it, it made me like indexedDb

Another vote for Dexie, the Typescript support is alright as well.

> Because it’s actually very good!

It's built on top of Sqlite in Firefox, it isn't "low level". Give me Sqlite directly instead of that horrible stuff.

This is an implementation detail. The fact is that indexedDB API is lower level than SQL.

> This is an implementation detail. The fact is that indexedDB API is lower level than SQL.

Why do you keep on claiming that? No it is not lower level than SQL. It's trivial to implement IndexedDB on top of of a SQL database. Good luck doing the other way around and that's the whole point of things. SQlite does everything IndexedDB does and more.... indexedDB isn't lower level, it's just more basic and limited. I have yet to see a SQL database equivalent to SQlite implemented on top of IndexedDB.

indexedDb is an API. This API is more primitive and limited than SQL. This API is basically a key value store with indices and transactions. This is what many SQL databases are implemented on top of (Postgres for example).

So yes it is absolutely possible to implement a SQL database on top of indexed DB, and that would be the architecturally logical thing to do.

The fact that Firefox goes the other way around is an implementation detail. What they did is called « emulation »: run a low level interface on top of a higher level one. This technique is very common and does not mean that the abstraction levels of API are suddenly magically reversed. It’s just an implementation detail of the architecture.

You can run NES code in an emulator in JavaScript on the web. Does this make NES assembly higher level than JavaScript ? No.

> indexedDb is an API. This API is more primitive and limited than SQL. This API is basically a key value store with indices and transactions. This is what many SQL databases are implemented on top of (Postgres for example).

SQL isn't an API. It's a language. Something to query a SQL database in the browser would constitute the API (thus WebSQL). You are mixing up language and API here. That's your first mistake.

> So yes it is absolutely possible to implement a SQL database on top of indexed DB, and that would be the architecturally logical thing to do.

And it's trivial to implement indexedDB over Sqlite, in fact, that's what Firefox did.

Where is the other way around? Where are RDBMS implemented on top of indexedDB?

> The fact that Firefox goes the other way around is an implementation detail.

No it isn't. It demonstrates my point entirely, that it is trivial to implement indexedDB on top of Sqlite, which makes Mozilla developers a bunch of hypocrites for not letting developers access an Sql layer directly.

Ok, look, I disagree.

I'll let you try to reconcile yourself about why "Mozilla developers are a bunch of hypocrites". I presented to you a very straightforward explanation that does not imply bad intent from an entire group of people.

I am sorry that this explanation does not fit your world view.

To me, what you say is the equivalent of saying « assembly is higher level than JavaScript because someone implemented a virtual machine that runs assembly code, in JavaScript in the browser ».

Just because someone at Mozilla used this technique for some technical reason (it is indeed often easier to emulate low level stuff on top of high level stuff, rather than the opposite) does not change the fact that IndexedDB is an API, is not built on top of SQLite, and is lower level than any API based SQL.

"Lower level" is a basic software engineering shorthand for minimal abstraction.

https://computersciencewiki.org/index.php/Higher_level_and_l...

IndexedDB builds on top of SQLite, so it's considered "higher-level", not lower level.

Indexeddb is not built on top of SQLite. IndexedDb is an API. This API is more primitive and limited than SQL. This API is basically a key value store with indices and transactions. This is what many SQL databases are implemented on top of (Postgres for example).

So yes it is absolutely possible to implement a SQL database on top of indexed DB, and that would be the architecturally logical thing to do.

You can run NES code in an emulator in JavaScript on the web. Does this make NES assembly higher level than JavaScript ? No.

What you say is the equivalent of saying « assembly is higher level than JavaScript because someone implemented a virtual machine that runs assembly code, in JavaScript in the browser ».

Just because someone used this technique for some technical reason does not change the fact that indexedDb is an API, is not built on top of SQLite, and is lower level, because you could build SQL databases on top of it.

I agree with everything you said, and it was the first time I got disappointed by Mozilla. Their excuse was "well we'd have to spec a common SQL and we don't want to do that". No there was no need to spec a common SQL for all browsers, let vendors choose whatever SQL version they want to implement. People have been building query builders for years, it's easy, much easier than re-implementing a RDBMS on top of IndexedDB. Then I learned that Firefox implemented IndexedDB on top of SQlite, what a freaking joke...

It made me really angry at Mozilla. WebSQL was so invaluable to me.

IndexedDB is indeed cancer. Usually it's also unnecessary, as you can store a significant amount of data in localStorage and the API is extremely simple to use.

If you need to store more data, why not do it on the server? What are the use cases for having a full-blown relational db client-side?

> If you need to store more data, why not do it on the server? What are the use cases for having a full-blown relational db client-side?

Easier / cheaper to host only static files.

> IndexedDB is indeed cancer.

So is PHP according the infallible SV pundits.

> it's also unnecessary, as you can store a significant amount of data in localStorage and the API is extremely simple to use.

Either you've never actually tried to store significant amounts of data in localstorage, or you're from the era of "640k is enough".

To say nothing of having no indexing functionality with localstorage, or paying the 33% base64 tax to put anything remotely binary into it.

> If you need to store more data, why not do it on the server?

"Because there is always, ALWAYS a high speed, low latency 100% uptime connection" /s

In answer to your last question, we have developed two PWAs reliant on local databases.

1. Was a product catalogue for use in stores, letting users filter down to select a particular appliance. two key requirements were that not all stores had great wifi coverage, and they wanted to easily update the catalogue (which meant no app recompilation).

So, Dexie atop IndexedDB, with indexes on the various facets for searching, and a simple settings page to run a sync. Dexie stored the product data, and a "immutable" SW cache strategy was used to keep the images available.

2. A detailed report generation app, Key requirement, must work with patchy connectivity as reports need to be taken in the field with unknown signal availability. Reports are locally stored and synced periodically (connection permitting). Again, Dexie atop IndexedDB, this time the images stored in the db as blobs prior to upload.

> So is PHP according the infallible SV pundits

Sarcasm is unnecessary but I'll admit that so is the word "cancer".

Your first example is a great one, although the catalog would have to be really huge to not fit in memory; and since it is static (the users don't update it) it can be upgraded by downloading a json file regularly?

The second example doesn't explain why you would need a relational db.

Anyway my point is not to second guess applications that run well, and even less to argue with people who have already mastered IndexedDB -- good for them!

My point is for people on the fence to take a good, hard look at what's possible with localStorage and make sure that before they embark on the IndexedDB voyage, they are absolutely, positively certain that they have no other choice.

I recently came across an app that stores a couple of user preferences on IndexedDB; the funny part is that the comments complain for paragraphs about its quirks and general unpleasantness. The time spent complaining in the source would have been better spent switching to localStorage.

> So is PHP according the infallible SV pundits.

Irrelevant, nobody is forced to use PHP as a server side technology. On the other hand, browser API are limited with what browser vendors implement, so there is no choice.

It's surprising how confident you are when you know so little. localStorage and indexedDB are very different in how they store data and read data, you also don't know the advantages both have over storing data on a server without using it as a full blown relational db.

Agreed. All my respect for Mozilla went out the window after finding out they were the drivers for getting WebSQL removed as a spec.

I must admit there's a bit of schadenfreude in knowing that Firefox is almost irrelevant now, while SQLite keeps going from strength to strength.

I'm glad people are finally speaking out after all these years. I hated IndexedDB and got lambasted for expressing my views on this very forum. And I also recently just learned that IndexeDB was build on top of Sqlite in Firefox... what a cynical joke...

Reply on news.ycombinator.com