tirumaraiselvan

> Tier 3 incidents: Novel, complex, cascading failures stay human-led, with AI providing supporting context.

> But here’s the catch.

> If human SREs (okay, now we have to use adjectives like human ) only engage with Tier 3 incidents, i.e. the novel, never-before-seen outages, where do they build the intuition to handle them?

How did they do this before AI? I have done a bunch of complex production level debugging and these Tier 3 incidents are always "starting from scratch" never seen before issues. The main "intuition" I built is persistence and verifying/refuting random hypothesis. In other words, I think we can build an intuition for Tier 3 issues only by engaging with Tier 3 issues.

Although, psychologically, some success in T1 and T2 issues is what gives us the confidence to even approach the T3 issues.

The fact that this question is getting a due regard now, then before AI, shows that all we care about from education is getting a job that pays. And we are worried that jobs are being taken away by AI.

Otherwise this question should bother a parent in every generation.

It also leaves the part of reviewing the code (which I have realised is really quite different skillset from writing code - it needs a sense of something is fishy here or why is this even here or can't this look better).

It may be obvious to conclude that good programmers are good reviewers but I think all variations exist. I wonder how many people don't like their jobs anymore because they don't like reviewing code written by AI.

I think summary is:

1. Paper has not been replaced by any tech because its form still has unique use-cases

2. AI is stuck in "chat" form and not all use-cases can be solved with chat.

Hence "AI will never replace paper" ..... well anything can happen really isn't it? 1 and 2 are quite independent statements.

Out of curiosity, which tool do you recommend?

I am the OP. I added some text while submitting so people know who the author is. Not AI generated.

But the real irony is that even the author points that their authentic work is under constant suspicion because "what if this is AI" has prevaded everyone's consciousness.

Brilliant piece by Booker Prize winning author, Arundhati Roy. She manages to lay bare the entire global politics of AI, starting with the seemingly inconsequentual em-dash.

Response from the organizers: https://proofsandprompts.com/2026/09/10/a-response-from-math...

Now we know why OpenAI told its investors to avoid Glean[1]

[1]: https://www.reuters.com/technology/openai-tells-investor-not...

This article is getting a lot of hate but honestly it does have good amount of useful content learned through practical experience, although at an abstract level. For example, this section:

``` The teams that succeed don’t just throw SQL schemas at the model. They build:

Business glossaries and term mappings

Query templates with constraints

Validation layers that catch semantic errors before execution ```

Unfortunately, the mixing of fluffy tone and high level ideas is bound to be detested by hands on practitioners.

A simple way is perhaps implement a text-to-metrics system where metrics could be defined as SQL functions.

Exactly! Midnights Children and Moors Last Sigh are so non-linear that one cannot expect to get the hang of it till they are atleast 50 pages through. It's usually on the second reading that the amazingness of those initial pages is felt.

Big Rushdie fan here. I used to think it could be because of a lack of cultural context especially for books like Midnights Children and Moors Last Sigh but now I also think that it could also be a matter of taste. Rushdie himself quotes Milan Kundera who said: "...that the novel descended from two parents, Samuel Richardson’s Clarissa and Laurence Sterne’s Tristram Shandy". The latter is a style of writing where all conventional rules of literature are broken, it's just wildly creative so to speak. Rushdie's Midnights Children and James Joyce's Ulysses fall into this category.

If you want to see the other style of writing in Rushdie, I can suggest Shalimar The Clown or The Ground Beneath Her Feet. But these are nowhere near as grand as Midnights Children.

In either category, a fair amount of interest in history helps to enjoy his books.

Hi HN

PromptQL is a programmatic approach to LLM tool composition which has shown remarkable improvement in accuracy (~2x) and repeatability (~4x) when compared to traditional tool calling and chaining approaches.

Fundamentally, PromptQL separates the creation of a query plan from the execution of the query plan. PromptQL uses the LLM to first create a program to compose the different tool calls hence avoiding the challenges with in-context tool chaining like accuracy, repeatability and context limits.

It was published in New Yorker https://www.newyorker.com/magazine/1946/08/31/hiroshima

Fun fact the cover image if this edition was kind of a decoy (perhaps to accentuate the shock): https://www.newyorker.com/magazine/1946/08/31

> RAG doesn't have to involve vector search.

This. Not sure why RAG triggers vector search for everyone. Retrieval Augmented Generation is as generic as it can get.

Why do you think that's more reasonable :)

To me it seems a more risky use-case since you don't have control/observability over what an untrusted user is asking for?

Hasura | Onsite, Remote Hybrid | India (Bengaluru) | Full-time | Software Engineer

Hasura is a venture-backed open-source and Cloud technology company that makes your data instantly accessible over a real-time GraphQL and other API technologies. Hasura connects to your databases, REST servers, GraphQL servers and third party APIs (eg: Stripe, Salesforce) and provides a unified API across all your data sources.

Hasura is looking for a Senior/Staff Software Engineer with proficiency in Rust to become part of the core engineering team. In this position, you will work on developing innovative features on the core product. We are writing the core components of the product in Rust to accelerate feature velocity hence Rust expertise is required. This is an exciting time to join this effort in the early stages.

If you are interested, please apply at: https://hasura.io/careers/?jobId=FjqRMQHVXKnW

It is given here: https://github.com/hasura/graphql-engine/blob/master/archite...

I work at Hasura. You don't need an append-only table always. You may have to add a monotonic ID to your table which increments on DMLs (and use it as the cursor for streaming) and this can be done using a post-DML trigger in Postgres. Also, streaming works over tables with relationships as well so you can get related data in the same stream as well.

Also, there is another interface for real-time subscriptions called live queries which might be more appropriate depending on the use-case: https://hasura.io/docs/latest/subscriptions/postgres/index/#... .

I work at Hasura.

We have 2 interfaces for real-time subscriptions: live queries and streaming. The former has been around for few years now. You can read more here: https://hasura.io/docs/latest/subscriptions/postgres/index/#...

I work at Hasura.

Hasura uses a novel way of batching similar parameterized subscriptions together and then polls under the hood. This means that if there are 1000 subscribers of similar type of query, then underneath Hasura will only make a single query to Postgres (or few queries depending on the batch size). This approach, which we call "multiplexing" in short, scales really really well. And is also the simplest way to get live updates for _any_ query, no matter how many joins, etc.

We talk more about this approach (and comparisons with other approaches), and benchmarks in this post: https://hasura.io/blog/1-million-active-graphql-subscription...

> Any reason you couldn't replace "Postgres" with "a database"

You could! But you would need ideal concurrency semantics.

> I didn't find anything Postgres specific other than maybe "SELECT FOR UPDATE SKIP LOCKED" which you can do without

You mean using some equivalent way to achieve "SELECT FOR UPDATE SKIP LOCKED" ?

For those interested in similar chart but for linux processes: http://www.brendangregg.com/linuxperf.html

Amazing stuff.

My feature request came true :D https://news.ycombinator.com/item?id=18587562

More discussion here: https://www.reddit.com/r/haskell/comments/id8m9w/welltyped_u...

> postgres' query planner isn't clause-order invariant. i.e. a AND b won't necessarily give you the same query plan as b AND a.

Do you have any references which shows this behaviour? Or a way to reproduce it?

> That setup can be great when your application doesn’t require a lot of business logic and the CRUD capabilities that are exposed in the GraphQL API fit your needs (though I believe you can add business logic in Hasura by integrating serverless functions).

(I’m from Hasura)

You can extend business logic in Hasura in a number of ways, including (but not exclusively) ones that work well with serverless and async architectures. Other examples follow:

1. You can extend it by adding business logic in the database via user-defined functions. Eg: You want a fulltext search or a PostGIS function that is better off in the DB anyway.

2. You can bring your own GraphQL server with custom resolvers and Hasura will merge them into its own API and let you “join” across them as well.

3. You can bring REST APIs and add graphql types for them in Hasura and use it as custom resolvers that extend the schema as well.

Hasura’s key value add is an instant GraphQL API backed by your own data-sources (database, GraphQL, REST) and then a fine-grained authorization system on it.

Like Nikolas said, very different from Prisma. Hasura aims to add value as “infrastructure” by guaranteeing performance and security where as Prisma is like an ORM/database toolkit.

We have this feature high up in our priority: https://github.com/hasura/graphql-engine/issues/1514

We already support user defined PG functions to be exposed as graphql queries so this is a natural extension.

TLDR: Read hard books and keep increasing the level.

I agree 100%. The hardest general books are probably in the area of philosophy. My recent fav: The Logic of Scientific Discovery by Karl Popper.