tirumaraiselvan

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.

The goal was also probably (re)branding.

OP here. My original submitted title was: It never makes sense to use foldl on lists (in Haskell); first line of the linked content. But someone dropped the bracketed content.

One new alternative is GraphQL which is a query language and server that is able to combine REST endpoints into a single result - making the query a first class object.

I think it would be more correct to just say that GraphQL encourages queries as first class object as it exposes the entire schema and allows for granular querying.

Implementing it by composing REST APIs is, well, an implementation detail. There are other ways to do it too.

You might like our upcoming Scheduled Triggers feature which lets you invoke webhooks according to cron or adhoc timers: https://github.com/hasura/graphql-engine/pull/3553

We experienced a similar orders of magnitude of performance at Hasura by using graphql plan caching and also postgres prepared statements at the same time.

This thread is quite timely as we recently published a post about this here: https://hasura.io/blog/fast-graphql-execution-with-query-cac...

I think it might just be an algorithmic thing. He has one of the top karmas in HN.

This is one of the game-changer use-cases of wasm. Not sure how such a product would work without that technology.

Sorry, it is actually in preview and not officially released yet. You can get the preview image, docs, etc in the PR: https://github.com/hasura/graphql-engine/pull/3042