hantusk

Check out https://hub.steampipe.io/, available as sqlite/postgtesql extensions

It is implemented here as DuckDB extension: https://github.com/ila/openivm/

Check out mosaic from uwdata which works on top of Observable plot

Or plotly-resampler which works on top of plotly and uses the rust package tsdownsample to aggregate on the 4pixels per pixel shown level (to make antialias work)

the grammar of graphics approach really is a great abstraction, and I'd love to see xy work in that direction

Check out https://github.com/ila/openivm which implements a very large scope of aggregations as incremental operations in an SQL-to-SQL compiler, and extension for duckdb that automatically maintains a materialized view

yeah, also reminded me of wifi sd-cards: https://hackaday.com/2016/06/30/transcend-wifi-sd-card-is-a-...

I can recommend Pixi for this. https://pixi.prefix.dev/latest/

pixi init && pixi add wget

And youre ready to go, everything confined to the venv within the directory

Good opportunities arise for those who stick their neck out. Here's some inspiration for what to blog about: https://simonwillison.net/2022/Nov/6/what-to-blog-about/

It seems he started his blog in 2003: https://simonwillison.net/2003/Jun/12/oneYearOfBlogging/

you're joking because of the other frontpage story with Gemini 3 hallucinating hacker news 10 years in the future, but still lets keep the hallucinations to that page.

Lego brick in build123d: https://build123d.readthedocs.io/en/latest/tutorial_lego.htm...

Gear in build123d: https://github.com/GarryBGoode/gggears

CTEs go a long way towards left to right readability while keeping everything standard SQL.

Reading CSV into a duckdb table will give you that, along with a table for the errors and reason for error: https://duckdb.org/docs/stable/data/csv/reading_faulty_csv_f...

Could definitely be done as a small little bash script

cumin and persian cumin (caraway) is one such example

I agree. So many disparate solutions. The streaming sql primitives are by themselves good enough (e.g. `tumble`, `hop` or `session` windows), but the infrastructural components are always rough in real life use cases.

crossing fingers for solutions like `https://github.com/feldera/feldera` to be wrapped in a nice database, `https://materialize.com/` to solve their memory issues, or `https://clickhouse.com/docs/en/materialized-view` to solve reliable streaming consumption.

Various streaming processing frameworks often have domain specific languages with a lot of limitations of how to express aggregations and transformations.

Since writes to object storage are going to be slow anyway, why not double down on read optimized B-trees rather than write optimized LSM's?

I think https://github.com/uwdata/mosaic is really promising here. See the example https://idl.uw.edu/mosaic/examples/linear-regression.html where the user can recalculate a linear regression based on their selection.

You'd still need to implement any custom selection widgets, data transformations (like other statistical tests) etc. still missing, but i like the technical design to build on top off. It uses https://github.com/observablehq/plot under the hood, which aims to have just as flexible a grammar as ggplot (already quite capable) but with interactive features (built by the creator of d3 and uses it under its hood).

Check out build123d, which has a nicer api for cadquery. I draw sketches in svg if the sketch shapes become too unmanagable to express in code

https://rclone.org/ works great

I don't think it was for the technical fit or performance reasons, but more a philosophy about everything starts with data, and graphics are just visualizations anchored to the data points (or a functionally derived property of the data points).

That also means the d3-* libraries compose really well, since the data is the common binding, and not some conceptual class or custom element.

I also have written a lot d3, between versions 2 and 7, and the refactoring that has happened meant a lot of examples online that were hard to comprehend were even harder to update.

I feel like its more stable now though. Something clicks for me since ive started writing it in more imperative style with svelte+d3 rather than d3 alone. The generated elements are easier for me to reason about, rather than otherwise relying on inspecting the generated elements with dev-tools after the generation.

This site was helpful to me, to combine d3 and svelte: https://svelte.recipes/

For a shortcut, Musescore has a plugin called colornotes that does this, installable from the GUI. You can alter the color scheme by editing the .js plugin code: https://github.com/musescore/MuseScore/blob/master/share/ext...

It can also print note names inside of each head.

more specifically it's using the svelte wrapper of three.js called Threlte: https://threlte.xyz/

Check out Descript. It's been awesome when I used it in the past

I liked SQL workbench (https://news.ycombinator.com/item?id=39537794) which has the same core ideas but more usable features at this point (query history, parquet support and charts) - if you hadn't seen it maybe some of its features will inspire you.

you could consider hosting an empty postgresql database, compile your code as a postgresql foreign data wrapper and expose it as a view. Nothing is more compatible with the postgres wire protocol than postgresql itself ;)

turbot compiles their steampipe plugins in this way. Example: https://github.com/turbot/steampipe-plugin-net

SQLGlot brands itself as an sql optimizer also: https://github.com/tobymao/sqlglot?tab=readme-ov-file#sql-op... but I haven't tried that aspect of it personally

Simo linked some older papers with this same idea: https://twitter.com/cloneofsimo/status/1765796493955674286

Digging into the low rank structure of the gradients, instead of the weights seems like a promising direction for training from scratch with less memory requirements: https://twitter.com/AnimaAnandkumar/status/17656138151468933...

Not affiliated, but happy modal.com user, which has very fast cold starts for the few demos i run with them.

That's not true for postgres scanning: https://duckdb.org/2022/09/30/postgres-scanner.html

So i would think we'd see similar speedups for sqlite even without copying any data

I thought the API here was quite neat. It's fairly simple to implement a lancedb backend for it instead of sklearn/faiss/mrpt as the source code is really simple.

This repo is basically just a nice api and the needed chunking and batching logic. Using lancedb, you'd still have to write that, as exemplified here: https://github.com/prrao87/lancedb-study/blob/main/lancedb/i...