CathalMullan

There are plans to experiment with language level comptime support too: https://github.com/rust-lang/rust/pull/148820

Pretty clear it's all AI. The @zigbook account only has 1 activity prior to publishing this repo, and that's an issue where they mention "ai has made me too lazy": https://github.com/microsoft/vscode/issues/272725

There's an experimental feature which separates storage and compute.

https://www.orioledb.com/docs/usage/decoupled-storage

There's also 'poop', which is a nice middle-ground between 'hyperfine' and 'perf'. https://github.com/andrewrk/poop

Feels like NewSQL DBs (CockroachDB, YugabyteDB, TiDB, etc.) may hit the sweet spot in regards to ease of deployment, and scalability.

Relatively easy to get started with a 'production-grade' cluster.

And they typically don't require any external load balancers, connection poolers, etc.

I'd like to think once NewSQL DBs mature, we'll see a shift away from using/abusing SQLite for these kinds of use cases.

Related article from the same author: https://kentcdodds.com/blog/i-migrated-from-a-postgres-clust...

A word of warning when it comes to Vultr. While they are listed as a member of the "Bandwidth Alliance", they don't discount egress automatically. You need to request the discount from support.

See: https://www.answeroverflow.com/m/1118148928915918990

> These are expensive servers, crossing into six digits, but not $200k.

https://news.ycombinator.com/item?id=25865967

CAX11 looks like a great deal, especially with IPv4 disabled.

You can avoid creating .DS_Store files on network and USB volumes like so.

  defaults write com.apple.desktopservices DSDontWriteNetworkStores -bool true
  defaults write com.apple.desktopservices DSDontWriteUSBStores -bool true

Lately, I've been investigating 'serverless' databases (PlanetScale, Turso) that charge based on the number of rows read/scanned. As a result, instead of just relying on the perceived performance of a query, I've started monitoring the number of rows scanned, which has emphasized the importance of indexes to me. Granted, the cost per rows read is minuscule (PlanetScale charges $1 per billion!), but it's still something I keep in mind.

Only used for metrics, apparently. [0]

  /**
   * These author ID lists are used purely for metrics collection. We track how often we are
   * serving Tweets from these authors and how often their tweets are being impressed by users.
   * This helps us validate in our A/B experimentation platform that we do not ship changes
   * that negatively impacts one group over others.
   */

[0]: https://github.com/twitter/the-algorithm/blob/7f90d0ca342b92...

The Rust re-write is being worked on in a separate repo: https://github.com/pydantic/pydantic-core

Another tool in this space is Dasel[1], which can handle querying/modifying JSON, YAML, TOML, XML and CSV files.

[1] https://github.com/TomWright/dasel

Since Wing compiles to Terraform, you should be able to manually run Infracost (https://www.infracost.io) to get an idea of costs.

Having that capability baked into the language/compiler would be a great addition.