Anton Zhiyanov

Here are my favorites: - Jacob Kaplan-Moss (https://jacobian.org/) [Engineering leadership, OSS] - Anton Zhiyanov (https://antonz.org/) [SQL, Go, Python] - Julia Evans (https://jvns.ca/) [SQL, Linux, Python, Go, Web] - Brandur Leach (https://brandur.org/) [Postgres, Go, Ruby, Web] - Brandon Rhodes (https://rhodesmill.org/brandon/) [Python, Astronomy, Linux] - Nathanial J Smith (https://vorpus.org/blog/) [Python, Async, Linguistics] I also write occasionally at https://rednafi.com.

This is a great idea! On a related note, I love how nalgeon [0] has interactive blog posts [1] on SQLite release notes using WASM magic [0] - https://news.ycombinator.com/user?id=nalgeon [1] - https://antonz.org/sqlite-3-45/

I love these kinds of interactive code/sandbox projects! The author's example page [1] gives some more background on the design of Codapi as well [2]. Excited to try this out! Another similar project is Runno which runs client-side in the browser [3]. [1] https://antonz.org/code-examples/ [2] https://codapi.org/ [3] https://runno.dev/

See also these unofficial interactive release notes: https://antonz.org/sqlite-3-44/ - discussed here: https://news.ycombinator.com/item?id=38095239 My favourite new feature is order by in aggregates, e.g. select group_concat(name order by name desc)

This book looks amazing! Well done! I clicked around on your blog and found this page: https://antonz.org/sql-window-functions-ranking/ If the book is written like this, showing these sort of examples, then I am in!

Great explanation, I highly recommend the author’s book https://antonz.org/sql-window-functions-book/

I am amused by the number written by Dr. Hipp. I appreciate his desire to keep core small and stable, but some of these would be great to get promoted into the base package. News to me, there is a Python package[0], sqlean-py, which makes it trivial to bring in these extensions. [0] https://antonz.org/sqlean-py/

Another way to store booleans that can be worth mentioning is to add (or not) a parameter in the url without a value. To reuse the example from https://antonz.org/storing-state/#boolean-value {"search": "potatoes", "popular": true} can be serialized as ?search=potatoes&popular

I implemented this in pure Python a few days ago in case anyone finds it helpful, here it is: https://gist.github.com/pirate/7e44387c12f434a77072d50c52a3d18e My implementation supports graceful degradation between nanosecond scale resolution, microsecond, and millisecond, by using 12 bits for each and filling up the leftmost bits of rand_a and rand_b. Not all environments provide high resolution system clocks with no drift, so it's is important to maintain monotonicity when generating IDs with a low-res timestamp as input. You still want the bits that would've held the nanosecond value to be monotonic. Neither of the existing uuid_utils and uuid7 python libs that can generate UUID7s support this monotonicity property. Am planning on using this for ArchiveBox append-only "snapshot" records, which are intrinsically linked to time, so it's a good use-case imo. There's another great resource here that I think is one of the best explainers of UUIDv7: https://antonz.org/uuidv7/ Whatever you do, don't implement the cursed 36-bit whole-second based time UUIDv7 variant that you occasionally see on StackOverflow / blog posts, stick to 48!

The author's original blog post, which goes into some more detail: https://antonz.org/solod

https://antonz.org/sqlite-is-not-a-toy-database/ — 240K inserts per second on a single machine in 2021. The problem you describe is real, but the TPS ceiling is wrong by three orders of magnitude on modern hardware.

Came here to post this. I’m wondering how Redka will compare with Postgres (and Redis) in terms of performance though. Edit: https://antonz.org/redka/#performance

I like the "does the problem justify the solution's complexity" question. The deserialization performance improvement seems like an actually important benefit though. Also https://antonz.org/go-json-v2/#marshalwrite-and-unmarshalread not completely sure but maybe combining dec := json.NewDecoder(in) dec.Decode(&bob) to just json.UnmarshalRead(in, &bob) is nicer...mostly the performance benefit though

Interactive tour of new features: https://antonz.org/go-1-25/

If you find the official release notes a bit dry (they really are), I've prepared an interactive version with lots of examples: - Iterators (range / types / pull / slices / maps). - Timer changes (garbage collection and reset/stop behavior). - Canonical values with the `unique` package. - HTTP cookie handling. - Copying directories. - Slices and atomics changes. https://antonz.org/go-1-23

Fair enough if it’s not your tool of choice, but I think you may have missed a lot of what SQLite can do these days. https://antonz.org/sqlite-is-not-a-toy-database/

I think you are thinking "hashmaps", not nosql. There are some ways of persisting hash maps to disk [1], but the workhorse of most ACID DBs (including popular nosql DBs like mongo) are B-Trees, which have O(log n) complexity for all operations. In any case when working with JSON columns in SQL it is useful to index the documents internal fields, which the OP doesn't talk about. Found a nice example in this blog post [2]. -- 1: https://en.wikipedia.org/wiki/Linear_hashing 2: https://antonz.org/json-virtual-columns/

Clickable: [1]: https://www.sqlite.org/expridx.html [2]: https://www.sqlite.org/gencol.html [3]: https://antonz.org/json-virtual-columns/ See also: https://www.sqlite.org/json1.html When you format links as code, they don't become links.

I wish sqlite was performance focused. Perf is pretty much always worse than a db server, even after tuning the pragmas (the way it locks tends to limit single threaded perf and concurrency). Main benefit of sqlite is just its portability since you can easily embed it. It's nice for slapping a db backend on a client installed app, where trying to spin up a db server would be problematic. There's probably an extension for permissions in sqlite but out of the box the db files are plaintext (you need an extension for that). Good starting point for extensions: https://antonz.org/sqlean/

See also: "Automate your Python project with Makefile" https://antonz.org/makefile-automation/

If you're going to use SQLite as an application file format, you should: 1. Enable the secure_delete pragma <https://antonz.org/sqlite-secure-delete/> so that when your user deletes something, the data is actually erased. Otherwise, when a user shares one of your application's files with someone else, the recipient could recover information that the sender thought they had deleted. 2. Enable the options described at <https://www.sqlite.org/security.html#untrusted_sqlite_database_files&g… under "Untrusted SQLite Database Files" to make it safer to open files from untrusted sources. No one wants to get pwned when they open an email attachment. 3. Be aware that when it comes to handling security vulnerabilities, the SQLite developers consider this use case to be niche ("few real-world applications" open SQLite database files from untrusted sources, they say) and they seem to get annoyed that people run fuzzers against SQLite, even though application file formats should definitely be fuzzed. https://www.sqlite.org/cves.html They fail to mention any of this on their marketing pages about how you should use SQLite as an application file format.

Integrating live code editors within docs and tutorials is great. Another example of this I saw recently using SQLite (compiled to Wasm) in the browser: https://docs.sqlitecloud.io/docs/sqlite And if you ever want something similar for more general backend APIs (without relying on Wasm or the browser to run the software), https://codapi.org/ looks very slick e.g. as demonstrated in https://antonz.org/sql-upsert/ - discussed on HN previously [0] Inspired by https://www.db-fiddle.com/ my colleagues ended up building a fairly bespoke setup for XTDB's docs (XTDB doesn't yet compile to Wasm) shortly before I came across Codapi, although our requirements were even more particular, e.g. see https://docs.xtdb.com/tutorials/financial-usecase/time-in-finance.html - the backend here is https://github.com/xtdb/xt-fiddle which runs purely on top of Lambda Snapstart, and embedded within docs based on Astro's Starlight [1] and Web Components [0] https://news.ycombinator.com/item?id=38663717 [1] https://starlight.astro.build/