ComputerGuru

In practice you’ll never notice the difference between joining on a bigint vs uuid for most OLTP purposes and you’ll be able to generate the uuids in your backend instead of in the db which a) can be very helpful if you’re pre-generating linked records and inserting them pipelined rather than sequentially, saving a lot of round trip traffic, b) reduces concurrency bottlenecks on the db server.

More usefully, a uuidv7 can take the place of both the id and the created_at field (if precision is sufficient), and can (depending on your security comfort) also take the place of the uuidv4 public id field.

With uuidv7 the data is naturally sorted so you don’t run into the issues with btree worst case scenarios that you would with a uuidv4 id, and you can even take it a step further and use BRIN instead of btree indexes for a massive boost (also applicable to serial ids, though).

The seqscan option being a binary on/off is a bit of a misnomer; what it actually does is set the cost associated with a seqscan to be astronomically high so that other options will be preferred over it. An index on age when you're looking up by name won't be used whether or not seqscan is enabled.

Some comments and corrections:

* Use uuidv7 not uuid in general (typically v4)

* in addition to minimizing locked records, make sure your locks are ordered deterministically across all queries (eg by id asc, always) or you’ll deadlock (but postgres has a really good deadlock detector so you’ll more likely just error out if you’re lucky)

* always use explain (generic_plan) to be able to a) copy-and-paste your queries with placeholders for parameters as-is, b) see how your query will actually be optimized when Postgres doesn’t have visibility into the specific parameter values

* use set seqscan = off when testing your query plans esp when tables are empty or nearly so so you can see if indexes will be used when seq scans become less cheap

* everyone defaults to btree indexes which are heavy and increase index bloat. Consider using a hash index instead if you just need to look up by column/id but not sort or get values greater/lesser than a param. You can’t create unique hash indexes but you can create exclude using hash constraints for the same effect (except no multicolumn unique index support)

* learn about GIN (and GIST) indexes. They can speed up common queries without needing new syntax, something people coming from MySQL might not expect to be possible; i.e. you can use them to speed up Plain Jane like ‘%foo%’ queries without switching to FTS.

There’s no need to get all complicated and fancy or introduce more dependencies. For most people, a cron job calling pg_dump_all piped to zstd and copying the output to s3/ftp/whatever is plenty good enough.

Obviously past a certain point carting around full backups becomes time/dollar prohibitive, but this can take you very far.

It runs easily on a vps at your scale, even the same vps serving your app. That used to mean having a modicum of sysadmin knowhow but it’s straightforward these days, especially if you just use a premade docker file.

So 3.6 Flash is a somewhat of an admission that Google miscalculated by charging 3-5x for 3.5 Flash what it did for 3.0 Flash (3x input and output costs plus large token inefficiency changes) despite only modest improvements?

3.5 Flash Lite is only a hair cheaper than 3.0 Flash, but I think 3.0 Flash is a massively more capable model?

If you mean the new windows 11 emoji, they are some of the ugliest design with I’ve ever seen, and I say this as someone that appreciated the previous windows 10 style despite the hate it got.

It’s insane because it literally breaks everything published with the old emoji to date.

Why did the cat get an evil smirk? It seems like adding rain to the umbrella potentially breaks the existing meaning? What’s the emoji that went from three colored circles on a stick to three completely ambiguous widgets?

Emoji with the darkest skin tones can be difficult to see in dark mode — a problem for anyone who sends or receives them. That’s why we built an AI-powered contrast tool that analyzes each emoji at the pixel level, flags when the contrast ratio is too low and suggests high-contrast solutions that are implemented by designers

What part of this is AI? What part of that couldn’t have been done without it? Do they just mean they vibecoded it?

Apple can make them smaller and put them on the device

Someone can, but Apple has essentially admitted defeat and handed the reigns over to Google.

Author also discussing it on their Twitter [0]. I’m reserving judgement for now, but this has lots of potential usecases even apart from replacing postgres.

[0] https://x.com/glcst/status/2077759127682486561?s=46

This is great

Absolutely spectacular, indeed…

and long overdue for outdated devices!

I would pause here and reflect. There is zero chance this performs better (speed, latency, memory, battery life, etc) than Safari on iPhones since the latter has been heavily optimized over the decades for this exact use case. Older devices not even getting iOS updates are likely the devices that will work worst with this software in its current form.

Of course if Apple had allowed third party browser engines from the start, it would likely be a much more even playing field!

Why do I have a sneaky feeling Safari for iOS isn’t fully written in a fully memory safe language?

Lol, this post is number one on the leaderboard on the “filtered” list list. Trusting ai slop to filter out ai is as ironic as it gets.

Note that this breaks a lot of core functionality unless you CAST(s as TEXT) before you use it, eg iirc LIKE won’t work. Then you’re back to the same problem.

Whisper v3 is still the best (by far) when it comes to poor quality input (say background audio from a security camera), though remains more susceptible to hallucination so it's a bit of a tradeoff.

If op is here: you can dramatically improve the robustness and soundness of your benchmark with one simple trick: you can run old versions of ASP.NET (Core) frameworks on newer .NET runtimes with no other changes; i.e. instead of benchmarking ASP.NET 10 + EF 10 on .NET 10 vs ASP.NET 11 + EF 11 on .NET 11, you can bench ASP.NET 10 + EF 10 on .NET 11 vs ASP.NET 11 + EF 11 on .NET 11

(I always upgrade projects by first upgrading the runtime and checking everything then separately (and maybe much later!) upgrading the framework.)

Seems the entire repo and documentation is all ai-generated?

wildly excessive amounts of prose

Not just prose. I think this is part of the reason why you see ridiculous code with insane error handling and type checking even for impossible cases.

This announcement is very much a nothing burger; it’s already been more or less decided that adding leap seconds just isn’t going to be a thing anymore (in our lifetime). Here’s on article from 2022: https://www.timeanddate.com/news/astronomy/end-of-leap-secon...

Bing is the easiest to buy programmatic access to.

But I think they don’t tell you because they sometimes use residential proxies to scrape search results the same way they used residential proxies to scrape the web.

I am very much in camp “minimize your dependencies and take the utmost advantage of what you already have” but I also am in camp “your database is the most important bottleneck component.”

This has two implications:

1) make sure if you use Postgres for anything beyond core rdbms functionality that there is no dependency between the two, so you can rip out the additional functionality and move to a different platform when you end up needing to reduce the load on your db server

2) if using Postgres for non-essentials complicates your db backup workflow, risks the data integrity, makes it difficult to maintain or upgrade your Postgres instance (eg you have to wait months or years for compatibility with newer Postgres versions), or loads relatively shoddy or unstable code into the beating heart of your application, then you should either use a different Postgres server/install/container for these ancillary services or bite the bullet and introduce an alternative dependency, depending on which makes more sense.

Already reported (not as thoroughly but still quite detailed) two weeks ago and silently “closed as not planned” (keep in mind that the specific reason might be an artifact of GitHub workflow/UX and not actually the intended reason) without a acknowledgement or a response.

https://github.com/openai/codex/issues/29353

What even is the point of a public-facing bug tracker “for devs, by devs” when this is how reports get treated? Might as well use Apple’s Feedback Reporter that routes to /dev/null instead.

Anyway, I find it near impossible to see how this wasn’t already caught and flagged internally – it’s not a subtle pattern. Certainly they are at the very least collecting and graphing reasoning tokens vs model vs effort” and such an obvious spike at (multiple) single stops (not even distributed over a narrow range) should have been an immediate statistical red flag… which leads me to believe (combined with the fact the previously reported issue was closed without comment) that they’re at least internally aware of this behavior even if it’s not necessarily an intentional side effect of some internal forcing metric.

Am I the only one that feels three/four years is a mighty ambitious timeline for the upgrade? It seems to be a very significant undertaking…

Yup. This works until it doesn’t (fairly soon thereafter), both from experimentation and understanding of theory. Here’s an illustrative example: https://old.reddit.com/r/Bard/comments/1l1qxk9/why_does_gemi...

Image as in “filesystem snapshot” not as in “media file”.

The best model is 5.6-sol; they are comparing to 5.5 here.

“ Terra has competitive performance to GPT‑5.5 [while being 2x cheaper]…”

To me that means “it’s an inferior product but marketing dictates we try and hide that.”

And “our most robust safety stack to date. We strengthened protections for higher-risk activity, sensitive cyber requests, and repeated misuse, and spent multiple weeks finding weaknesses, pressure-testing our system, and hardening it against real-world attacks” is of zero value to me at best, and most likely to my detriment (increasing refusals or nerfing utility). Why do providers keep leading with that? Are there customers (besides support ChatGPT chatbot users, maybe??) that ask for this?

Codex Spark models already run on Cerebras