What most don't realize about Paul and many of this generation are two things.
1. The amp is cleaner than it sounds.
2. Standard Tuning.
Proving... You don't need maximum gain and a down tuned baritone to sound heavy in Rock. The riff is the star. 😎👍
If you know the story of the rock band Rush and have seen the YouTube videos from the tour this week, they will bring a tear to your eye. Anika Nilles is a hero.
@burkeholland@BrigitMurtaugh Did something change with the availability of Opus 4.6 in Copilot? It started asking me to upgrade today, I’m on Copilot Pro+ and have plenty of usage-based billing. Thanks.
Very true.
Databases do a lot caching (from disk mostly) and keep it consistent, even when we aren’t paying attention. If at all possible, just use the database. Optimize the queries.
Databases have also figured out the hard parts of replication: transactions and ordering. Hit a database secondary if you don’t wanna hit the primary. There is exactly one dimension of inconsistency, which is time.
Third, use an analytics database if you want aggregation. Accept the time delay and design for it.
Almost never, in my opinion, is “database data in Redis/memory” the right answer, unless you are very tolerant of inconsistency.
Cache invalidation is hard because the moment you copy data to make a system faster, you create two truths that can drift apart:
- One is the real data,
- one is the saved fast version.
"Just update the cache when data changes" is practically useless advice.
That only sounds clean if you ignore delays, failures, race conditions, multiple services, retries, out-of-order events, and users reading data while writes are still moving through the system.
In general, you need rules for
- when the fast version is still safe,
- when it must be replaced,
- who decides that,
- what happens when that decision is late, lost, or wrong.
Cache invalidation is a constant trade between speed and correctness, and people often pretend they can fully have both.
My Unicode libraries were the fastest in town for years, but it looks like @aymanbagabas@charmcli has a new faster one. Had to happen eventually.
https://t.co/1uTi9HH5xL
My recommendation rn is that you have AI review its own code at least 3 times before a human review.
Once at the end of the current turn.
Once before you submit the PR.
Once after PR submission.
If you do that much you will weed out a lot of dumb mistakes from the agent.
Intuitively, yes, but it might be like the human programmer experience with strong types/compilers.
On the one hand, LLMs are not very deterministic. So if we see strong types as adding back that determinism, this is compelling.
Furthermore, strongly typed languages can exhaust humans, who are just trying to get something done. The LLM won’t get tired, and will give us a stronger, correcter program than we would otherwise have gotten.
OTOH! Type enthusiasts (I am one) have begrudgingly learned that dynamic languages can be every bit as correct as static languages. On that same other hand, high-level languages look like English, on which the LLMs were trained. Perhaps some transfer learning happens.
Overall, I’m on the side of Greg’s hypothesis, but I also know it might not actually net out to be true.