pjot

I don’t think it’s necessarily the use case changed but maybe the constraints. Streaming directly to Clickhouse is a great solution. Recent approaches I’ve seen though buffer data as parquet in object storage first, and read data from there. Im not sure if CH would be the preference

Thought this was the ascii Star Wars in your terminal à la

  telnet towel.blinkenlights.nl

1008 pages, wow!

It also made a really satisfying “boyoyoyinnng” sound

Will need to degauss after this

Where do you get this free beer?

I used to love watching the “unlimited” storage counter increase as each second went by

I wonder how this would work in trying to parallelize the worker threads (multiple duckdb instances) coordinating them via Quack.

Ducks all the way down!

One step further are those who want to point an llm directly at the data warehouse to get the data needed to run predictions

See also the bullwhip effect

https://en.wikipedia.org/wiki/Bullwhip_effect

Here’s a different kind of binary clock https://www.hey.earth/posts/binary-clock

The actual post from Anthropic: https://www.anthropic.com/institute/recursive-self-improveme...

  > created bunch of fake spam pages and trying to mine crypto

Pages like GitHub pages? We’re repos being created in your account? Curious how you discovered that your tokens were pwned

After years of using orchestration tools like airflow and dagster so many lightbulbs have just lit up in my head.

I wish documentation for tools would explain their abstractions concepts in terms of its primitives.

Great post, thanks!

  > The Chinese are a decade ahead of the west when it comes to building cars.

Is this true? From years of watching Top Gear any Chinese car that was tested was laughably bad.

DuckDB has indexes. One specifically for highly selective point lookups. The structure is called an adaptive radix tree. The workloads you’re describing are sort of duckdb’s bread and butter (even the parquet stuff it’ll handle out of the box)

https://duckdb.org/2022/07/27/art-storage

To be fair, pie charts are horrible in general.

Re-reading your comment :) Yes, my demo has just a simple loop when loading the embeddings.

I was replying more towards the latency you mentioned. Because duckdb runs on device, you save yourself the additional round trip network time when comparing similarities.

I did this but used duckdb as the vector store. Works really well, quite fast too.

https://github.com/patricktrainer/duckdb-embedding-search

For me, it helps to slow down my thoughts and aides deep work. I draw diagrams, connect blurbs with arrows, and “link” to other page numbers.

Claude Code release notes:

  > Version 2.1.32:
     • Claude Opus 4.6 is now available!
     • Added research preview agent teams feature for multi-agent collaboration (token-intensive feature, requires setting
     CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1)
     • Claude now automatically records and recalls memories as it works
     • Added "Summarize from here" to the message selector, allowing partial conversation summarization.
     • Skills defined in .claude/skills/ within additional directories (--add-dir) are now loaded automatically.
     • Fixed @ file completion showing incorrect relative paths when running from a subdirectory
     • Updated --resume to re-use --agent value specified in previous conversation by default.
     • Fixed: Bash tool no longer throws "Bad substitution" errors when heredocs contain JavaScript template literals like ${index + 1}, which
     previously interrupted tool execution
     • Skill character budget now scales with context window (2% of context), so users with larger context windows can see more skill descriptions
     without truncation
     • Fixed Thai/Lao spacing vowels (สระ า, ำ) not rendering correctly in the input field
     • VSCode: Fixed slash commands incorrectly being executed when pressing Enter with preceding text in the input field
     • VSCode: Added spinner when loading past conversations list

Not sure how you missed it, it’s here: https://fs.blog/about/

“Hover” seems to be causing some confusion. It’s more of a “shallow” press. Like the opposite of “pressing into” when 3D Touch was a thing

Similar is the save icon, though for a different reason. It conveys its function well, but one first needs to know what a floppy disk even is!

I’ve found myself writing code intending to write prompts for writing better code.

Soon enough Im sure we’ll start to see programming languages that are geared towards interacting with llms

Author of the mentioned DuckDB-DOOM here!

This is awesome - multiplayer is a great addition. Really like the cone in the mini-map too

A “fully dressed” poboy in New Orleans is one with all the fixing’s

Ha! I made this. I’m not a robot either :)

Author here, wild to see this at the top of HN!

You can play it here: https://patricktrainer.github.io/duckdb-doom/

Pressing “L” enables (very) verbose logging in the dev console and prints much of the sql being executed.

Rather than juggling your parent’s __init__ on another thread, it’s usually clearer to:

1. Keep all of your object–initialization in the main thread (i.e. call super().__init__() synchronously).

2. Defer any ZMQ socket creation that you actually use in the background thread into the thread itself.