Prashant Singh

threads & ends

[Prashant Singh @TranshapHigsn]

Must read.

[Hacker News Bot @newsycombinator]

Don't End the Week with Nothing https://t.co/rPcdQ9QAMU

[Prashant Singh @TranshapHigsn]

@Paytmcare Shared details on DM.

[Prashant Singh @TranshapHigsn]

@Paytmcare I have been blocked from accessing my paytm account, can you help me with it?

[Brian Armstrong @brian_armstrong]

One of my favorite lessons I’ve learnt from working with smart people:

Action produces information. If you’re unsure of what to do, just do anything, even if it’s the wrong thing. This will give you information about what you should actually be doing.

Sounds simple on the surface - the hard part is making it part of your every day working process.

[Andrej Karpathy @karpathy]

Good post from @balajis on the "verification gap".

You could see it as there being two modes in creation. Borrowing GAN terminology:
1) generation and
2) discrimination.
e.g. painting - you make a brush stroke (1) and then you look for a while to see if you improved the painting (2). these two stages are interspersed in pretty much all creative work.

Second point. Discrimination can be computationally very hard.
- images are by far the easiest. e.g. image generator teams can create giant grids of results to decide if one image is better than the other. thank you to the giant GPU in your brain built for processing images very fast.
- text is much harder. it is skimmable, but you have to read, it is semantic, discrete and precise so you also have to reason (esp in e.g. code).
- audio is maybe even harder still imo, because it force a time axis so it's not even skimmable. you're forced to spend serial compute and can't parallelize it at all.

You could say that in coding LLMs have collapsed (1) to ~instant, but have done very little to address (2). A person still has to stare at the results and discriminate if they are good. This is my major criticism of LLM coding in that they casually spit out *way* too much code per query at arbitrary complexity, pretending there is no stage 2. Getting that much code is bad and scary. Instead, the LLM has to actively work with you to break down problems into little incremental steps, each more easily verifiable. It has to anticipate the computational work of (2) and reduce it as much as possible. It has to really care.

This leads me to probably the biggest misunderstanding non-coders have about coding. They think that coding is about writing the code (1). It's not. It's about staring at the code (2). Loading it all into your working memory. Pacing back and forth. Thinking through all the edge cases. If you catch me at a random point while I'm "programming", I'm probably just staring at the screen and, if interrupted, really mad because it is so computationally strenuous. If we only get much faster 1, but we don't also reduce 2 (which is most of the time!), then clearly the overall speed of coding won't improve (see Amdahl's law).

[Gwen (Chen) Shapira @gwenshap]

❓Why is Postgres still wrong about row counts even after ANALYZE?

❗️One possible issue can be "dependent columns".

Per-column stats assume independence. If columns are related, the planner will over/under estimate and may choose a bad plan.

For example:
– Predicate: departure_airport = 'JFK' AND departure_city = 'NYC'
– Reality: JFK airport is always in NYC
– Planner’s belief: Two separate filters → tiny intersection → very low cardinality

The solution is to teach Postgres about the dependency by creating your own multi-column statistics (MCV):

1️⃣ CREATE STATISTICS bookings_dep (DEPENDENCIES) ON departure_airport, departure_city FROM bookings;
2️⃣ ANALYZE bookings;
That captures the conditional probability matrix—row estimate collapses, index scan chosen.

The screenshot shows how the original row count estimate is 10% of the real row count, and how the custom statistics fix the issue.

[Werner Vogels @Werner]

In a new guest post from #AWS Sr. Principal Engineers Niko Matsakis and @marcbowes take us inside Aurora DSQL's development from scaling write operations without two-phase commit, to overcoming garbage collection hurdles, and embracing Rust. https://t.co/0It6v3v74R

[Brandur @brandur]

Ran into a nice surprise while looking at Postgres' UUIDv7 patch, which is that it guarantees monotonic incrementation on a per-backend basis.

Last writing of 2024: UUIDv7 monotonicity, how it works, and why it's great for writing tests. Happy NY!

https://t.co/NIdrYK5Nhg

[Dmitrii Kovanikov @ChShersh]

At work, I just write raw SQL queries as strings and run them via a thin wrapper from a functional language.

I’ve been doing this for 6 years, and I never regretted.

I also saved a ton of time learning a dozen of ORMs that bring more problems than they solve.

[Murat Demirbas (Distributolog) @muratdemirbas]

[ new blog post ]

Use of Time in Distributed Databases (part 1)

https://t.co/xhBj5At2yt

[Marco Slot @marcoslot]

My favorite thing about pg_parquet is that you can build sophisticated data pipelines directly from PostgreSQL, because it connects PostgreSQL to a universal data storage and exchange platform: S3.

For instance, you can periodically (with pg_cron) copy your Postgres time partitions into compressed Parquet files in S3, and run fast analytical queries using DuckDB, Athena, or Crunchy Data Warehouse without additional load on your operational database.

COPY (select * from events where event_time >= '2024-12-15' and event_time < '2024-12-16') TO 's3://my-events-archive/2024-12-15.parquet';

At the same time, other applications can write Parquet into S3 and pg_parquet can load it directly.

Putting the two together, you can even use pg_parquet to efficiently and reliably exchange data between PostgreSQL servers that cannot directly connect to each other.

[Nik Samokhvalov @samokhvalov]

UUIDv7 is finally committed to Postgres — after approval of corresponding RFC.

This was coded by @x4mmmmmm during our online hacking sessions https://t.co/QrIZwndLX0

As a reminder, you can start using UUIDv7 and benefit (performance-wise) from it right now, there is no need to wait until PG18: migration from UUIDv4 to UUIDv7 is among popular topics the https://t.co/6bi70c5jiP team often discusses with consulting customers:

https://t.co/FMGLqe8Bfv

https://t.co/d8wJqGwOcO

[Yurii Rashkovskii @yrashk]

Did you know you can go DRY in Postgres table definitions – that is, define commonalities in one place and use them in different table definitions?

It's like mixins, allowing you to focus more on the concepts you're introducing —the perfect example of Don't Repeat Yourself.

[Prashant Singh @TranshapHigsn]

@sandeepssrin Congratulations 🥳

[Vlad Mihalcea @vlad_mihalcea]

Just because you are a back-end developer, it doesn't mean you cannot come up with a beautiful UI design.

[Prashant Singh @TranshapHigsn]

@timClicks 🤯

[Tim McNamara @timClicks]

This is going to rock https://t.co/1wxsQroB1q

[Prashant Singh @TranshapHigsn]

@ThePrimeagen @TonyBenoy

[Prashant Singh @TranshapHigsn]

@esotericmeans Azure function logs (“app insights”) is worse.

[Prashant Singh @TranshapHigsn]

@TonyBenoy Does your company even love you?

[Prashant Singh @TranshapHigsn]

@southpolesteve