emschwartz

Don’t love that the built in network layer is tightly integrated with a specific cloud service…

Part 1: https://blog.cloudflare.com/quicksilver-v2-evolution-of-a-gl...

Have you tried it on embedding models that were specifically trained to support binary quantization? For example, Mixedbread and Nomic

This is a great, detailed look at the current set of coding tools. Thanks for writing it up!

(This is one of those posts that made me really happy to have built https://scour.ing because I would have missed it otherwise!)

Fascinating. Love reading about the different model personalities!

Useful tip, thanks!

Sweet! I'm excited to follow along. I'm using SQLite right now and it would be interesting to have an in-process Postgres-compatible DB. Best of luck with it.

Very interesting. Thanks for sharing!

I built https://scour.ing -- a service that scours noisy feeds (like HN Newest) to find content that matches your interests. It's actually how I came across this post when it had only 3 points :)

Have you tried Cloudflare workers?

Ah, that's great! Thanks for sharing that.

I had actually implemented full text search + vector search using RRF but I kept it disabled by default because it wasn't meaningfully improving my results. This seems like a good hypothesis as to why.

Most of the commercial and open source offerings for hybrid search seem to be using BM25 + vector similarity search based on embeddings. The results are combined using Reciprocal Rank Fusion (RRF).

The RRF paper is impressive in how incredibly simple it is (the paper is only 2 pages): https://plg.uwaterloo.ca/~gvcormac/cormacksigir09-rrf.pdf

Yeah, that's exactly right. You take the embedding of your query and then compare it to the embeddings of your documents (or chunks of documents).

You can use vector databases that implement the Approximate Nearest Neighbors (ANN) algorithm, or if you don't have too many documents you can just brute force the similarity comparison.

I'm not sure at what point you _really_ need or want a vector database, but anecdotally, calculating the Hamming distance for a couple thousand vectors seems pretty negligible.

Great list!

Another email option I’d recommend is https://improvmx.com

Sounds interesting! I'm seeing an HTTP error (R_END_OF_FILE_ERROR) when trying to load the site.

(Author here) I'm glad you liked the post/proposal!

That's a good question. I think the tie-in with Tokio mostly relates to a couple of things:

1. calls to `tokio::spawn`

2. async I/O traits like `AsyncRead`/`AsyncWrite`

3. direct usage of Tokio I/O

For 1, it would be great if more libraries switched to using more structured concurrency primitives instead of using spawn. In the cases where it does make sense to have a spawning function, it would be nice if they used crate-exported traits like [hyper::rt::Executor](https://docs.rs/hyper/latest/hyper/rt/trait.Executor.html) so that the functionality could be abstracted over different runtimes.

For 2, hopefully those traits will eventually be standardized in std.

For 3, it would also be nice if the necessary functionality were abstracted into crate-exported traits that were implemented for the Tokio structs.

Buuuut, all of that said. It's thorny and a lot of the ecosystem is indeed wedded to Tokio.

In a similar vein, Andrew Kelly, the creator of Zig, gave a nice talk about how to make use of the different speeds of different CPU operations in designing programs: Practical Data-Oriented Design https://vimeo.com/649009599

I did the course without the book. I haven’t actually looked through the book, but the Coursera class was definitely enough on its own.

I loved this course and would strongly recommend it to anyone who works with computers that hasn't taken low-level CS classes.

This course does an exceptional job of giving you an intuitive understanding of some critical parts of how a computer works that affect higher-level programs and programming languages (for me the biggest aha! was grokking the difference between the stack and the heap). It is also incredibly fun to appreciate how magical it is that these complicated machines we use are just built from these simple circuits that you keep building up and building up through the course. Finally, the teachers did a fantastic job of simplifying what could be multiple semesters worth of material to quickly give you the gist of things like assembly languages, without oversimplifying.

Really can't recommend this enough if you have the time to do it. FWIW, the first part of the course (from NAND gates to building a CPU) is very fun and fairly easy. The second part (going from a computer to a full operating system) is quite a bit more work.

I understood the crux of the argument to be that the holy grail UX is having an always-on AI assistant you can have a spoken conversation with. He says that Google’s combination of hardware, Android, loads of data on the user, and good enough AI chops might be a combination that makes an assistant so helpful that it would get people to switch away from iOS to use it.

My understanding is that Fly.io also started using Nomad but ended up running into big reliability issues at scale across many regions. I'm curious if you all are using it differently or haven't gotten to that scale yet.

:) great reason!

I would very much second the suggestion to do David Tolnay’s Proc Macro Workshop if you want to start understanding how to write them. I’d been writing Rust for years but always kind of avoided proc macros.

When I had a need for them, I went through only the first section of the workshop and everything clicked. You can just do the derive macro section and all the strange and scary-looking macro syntax will make sense. I realized that there is only a bit of extra syntax but it’s used very often so it can seem a little overwhelming when reading macro code.

https://github.com/dtolnay/proc-macro-workshop

I’ve been working on an open source project built on OpenTelemetry and Prometheus client libraries (https://autometrics.dev). The DX of the OTel libraries is pretty painful in all the languages we’ve used. Granted, we’re using them for metrics while traces are more common, but still.

I think the fundamental issue for the DX is that it’s trying to do everything everyone might want out of all of the observability signals. That’s a useful and laudable goal but it means that everything is configurable and it sometimes feels like there are too many knobs that you can and must adjust to get it to do what you want.

Yup, that's my understanding as well

Interesting, thanks!

That's a good data point, thanks!

> <Insert product hunt>

Whoops!

In any case, looks pretty useful!

All of HN works at startups that haven’t found product-market fit yet

I don’t know whether it’s the medium or the current offerings but I was gifted an Oculus, played with it for under a week, and haven’t gone back to it. Maybe VR will be a thing in the future but somehow I’m not seeing it now.

Anyone else in a similar boat? Or have a theory why it’s less compelling than a traditional gaming console?