akane

Check out pgvector: https://github.com/ankane/pgvector (disclosure: am author)

It uses IVFFlat indexing, but could be extended to support product quantization / ScaNN.

Homomorphic encryption reveals less information to the server about the query than if you were to encrypt keys (with deterministic encryption) and values. It hides the fact that the same query was run multiple times and which key (if any) was matched.

I mainly thought it was neat there's a way to do matching on encrypted data without deterministic encryption. It's based on this example - https://github.com/homenc/HElib/tree/master/examples/BGV_cou... - which explains more about how it works and why it's O(N).

The post doesn't say you should give out your login. It says you should encrypt your access tokens and explains some security implications of current implementations that use them, like how they often give too broad permissions. When you change your password, you often need to reauth all of your devices, but you don't need to reauth your access tokens.

On a related note, arrival time predictions can be biased early to prevent people from missing buses, which also increases the perception of lateness.

https://nextbus.cubic.com/FAQs

On a related note, here's an open-source project I created that you can use to check your own S3 buckets: https://github.com/ankane/s3tk

Thanks for the feedback. I created a better landing page here: https://www.chartkick.com/react

Thanks nk1tz. Done!

Thanks for the feedback!

Update: Hey ak4g, the latest version of pgslice uses this approach. We're seeing roughly 20% less load on inserts with it (in the short time it's been in production). Thanks for the suggestion!

That's correct. It allows us to manage the database size over time for tables where we can archive data after a specific period.

Is this the latest work? https://www.postgresql.org/message-id/ad16e2f5-fc7c-cc2d-333...

We didn't really find anything that fit our needs. We wanted a tool that was simple to use with the ability to do time-based partitioning of existing production tables without downtime.

We currently use Amazon RDS, which doesn't support custom extensions, so pg_partman wasn’t an option for us. I haven't used pg_partman myself, but it looks to have different features.

I think an external tool is a bit friendlier for people who aren't super comfortable with installing Postgres extensions. Also, it doesn't require a restart.

I'm optimistic that Postgres will make all of this trivial at some point.

Edit: changed "more features" to "different features". One of the main goals is the ability to partition existing production tables without downtime, which seems different than pg_partman.

We've been using the tool for around 5 months, but the same approach/triggers for over a year. I wasn't aware the IF/ELSIF trigger approach had potential advantages over EXECUTE, but will definitely look into it.

Yes, we do at Instacart.

Assuming the Julia implementation is correct, you could write tests based on output from that.

Currently, a visit record is created as soon as a user lands on a page with the Javascript, but I'm curious to see other ways people want to it.

Unless you have hundreds of unique visitors per second, this shouldn't be a problem.

It's been on Github for a bit, but this is the first big release.

Training searches from conversions (self-improving searches) is kinda interesting. Elasticsearch is an amazing product but it can be hard to configure, especially for beginners.

Edit: spelling

We looked into PostgreSQL search for a bit, but didn't see a way to train search results from past conversions. Does anyone know if this is possible?

That's exactly why we open-sourced Searchkick :)

We're indexing around 100k documents. What line are you referring to, and what's bad about it?

Awesome, added this to the todo list.

I would suggest denormalizing only after you find a performance bottleneck. As they say, "premature optimization is the root of all evil".

Good suggestion!

Just a pull request away :)

You can always `curl`, then `cat | sh` if you don't trust me :)

For those concerned about a SQL dependency, it might be useful to create projects in different languages that package these functions. These methods were extracted from https://github.com/ankane/groupdate, which you can use for Ruby + ActiveRecord

(edit: spelling)