HN user
http://github.com/tantaman
the observation goes beyond garbage in garbage out. Mainly that we're always operating from some prior and limited understanding. That what may look like a hallucination could be closer to the truth than our current frameworks of understanding allow us to admit. The hermeneutic circle.
Increased taxation would be defensible if it was paired with spending reform. Increasing the tax to just inflate a bureaucracy helps nobody. Increasing the tax and then directly paying people, with no PMC in the middle, seems win-win-win.
How are people handling this... mentally? and preparedness wise? I can't imagine what the next generation may have to live through.
This has been proven out again and again in my experience. Going as far back as being a student advisor in college. Any time I would run into someone using these words (in advising sessions, interviews, casual conversation), the speaker had no further depth when pressed on the topic they were trying to wave at.
There's a time and a place for all of these things. Like everything in life, many people pick the wrong time and wrong place.
Attention to every detail, even the awkward nerd high-five.
us ai?
It's been around 2000 years with many divisions and sects so I don't think you can give a single definition. Early Christians didn't agree on the divinity of Jesus. Hell wasn't christian doctrine until 400CE. Some Christians believe heaven is on earth itself and you'll be resurrected on earth, in your original body, when that times comes.
The person that thinks they're above propaganda is the one most swayed by it.
Queries span frontend and backend. If a query cannot be resolved entirely on the frontend (due to missing data) it falls back to the backend to get the rest of the results.
The DB is smart enough to understand if a query can be fully or partially resolved client side based on what other queries have already been synced.
That video though...
Meta compensates 10x types very well. 3x bonus multipliers, additional equity that can range from 100k-1m+, and level increases are a huge bump to comp (https://www.levels.fyi/)
SQLite had 2 bugs[1] where batch atomic writes would corrupt your DB if you used IndexedDB to back your VFS. It has been patched in SQLite so rolling a new electric release that pulls in the latest SQLite build should fix that.
[1] https://github.com/vlcn-io/js/issues/31#issuecomment-1785296...
LLMs on consumer grade hardware are a thing and will become more so. Something that only needs to understand the space of the application is certainly attainable.
What about an integrated LLM assistant for GIMP? Seems like that's the future for any professional application (e.g., PhotoShop, CAD, Reason)
You think this is a joke but Meta/Facebook has something similar for interop between XHP (https://github.com/hhvm/xhp-lib) and React.
order by aggregates. I can finally resume work on TreeSQL -- https://github.com/tantaman/TreeSQL :)
Really doesn't make sense to me that people jump to microservices rather than creating module boundaries in their monolith.
I came to the same conclusions with my next round of projects and have sadly been keeping them closed :(
Yeah, 1mb of WASM != 1mb of JS.
WASM is much faster to start up since you don't have all the parsing and compiling overhead.
You can get that size down to 600KB using brotli compression fwiw. Maybe even a bit smaller using Roy's latest tricks that no longer require asyncify'd builds of SQLite.
Awesome.
I've made quite a bit of progress on incremental view maintenance for SQLite which I'd like to share in the near future if that's a problem you're also dealing with.
Congrats on the launch!
Looking forward to seeing more people trying out this architecture.
Still hoping we can find some time to collaborate on reactivity, tree-sql, typed-sql or some such other effort in the near future.
The reasons why everything left an "internetless model" seem to be getting lost to time but I explained some reasoning here in this comment: https://news.ycombinator.com/item?id=37500449
The world is a bit different this time around.
Local-first / desktop apps were really easy back in early 2000's and before since users pretty much only had a single device.
Today, users have many devices with many different storage and compute constraints. They also expect their data to be available on all devices and, to top it off, be able to invite outside collaborators.
Handling this heterogenous landscape of devices and collaboration is much simpler in a cloud model. Trying to put more data and compute locally suddenly means worrying about a multitude of device profiles and multi-way sync.
I'd say you're spot on except for point (3). There's a number of crdt and event log approaches that, when combined properly in order to preserve user intent, can solve almost all merge issues of applications that do not require strong consistency.
4. What happens when the user has millions of items?
Partial replication is a problem I haven't seen many people solving but it is definitely the next frontier in this space.
Recently put a video overview together of cr-sqlite and supporting libraries: https://youtu.be/T1ES9x8DKR4?si=Fo_4LIsKljm7Opal
I was never more productive than when using Access (and dBase II before that).
I've never used access and have 0 familiarity with it. Are there any examples I could look at?
I was sad to find that the author proclaimed "just write SQL" then fell into the trap of modeling his data as objects.
If you're going to model your data this way... you might as well use an ORM.
A better way is to just just write SQL (or datalog) and model our data, from DB all the way up to the application, as relations rather than objects.
Rather than re-hash, this idea has previously been discussed on HN here: https://news.ycombinator.com/item?id=34948816
I'm in a 4th camp: we should be writing our applications against a relational data model and _not_ marshaling query results into and out of Objects at all.
Elaborations on this approach:
- https://news.ycombinator.com/item?id=34948816
- https://github.com/papers-we-love/papers-we-love/blob/main/d...