vsroy

The tele-op stuff is very interesting. Are there off the shelf SDKs for this type of thing or do you need to build it yourself?

o1-pro understands JS proxies better than me tbh, so probably a positive acknowledgment.

The API is basically the prompt LOL. I chucked in the API, and had o1-pro write tests + fix bugs until it worked.

Yes that is exactly what it is! It's basically a very small upgrade over my favorite database: A JSON-file :)

dang -- why was this flagged? Seems like a perfectly reasonable post.

The implementation is very clearly included, if you... scrolled down.

And the point is, you could easy do `const db = new Database("./database.sqlite")` instead.

The wrapper makes it so manipulating your database is just like manipulating a plain Javascript object.

100% ;)

Follow-up question is: Isn't it extremely unlikely to output 0?

Is the thing that's going on here that softmax can't push a value to 0, but by subtracting 2 softmax maps we can output 0s?

Thanks for the help. After upgrading my instance, all the query times dropped dramatically. The thing is, I did not even upgrade the instance that much (micro -> medium).

I'm guessing some important bottleneck was being hit, but I have no idea what it was (maybe 1GB RAM was causing spillover to disk in a query or something? like that?).

It seems important to understand what bottleneck I hit -- but frankly, I have no idea.

It seems like the modern solution is to use something like temporal.io -- (related to windmill). Alas, surely people have been solving this problem for ages now without temporal.io

This has a context window of 65K for the storywriter version.

Server actions is amazing. I finally will never need to write a single POST/GET request, it's the perfect RPC.

Thanks for the response.

One thing to clarify: It's a 300K x 300K similarity matrix, which means I have 300K embeddings. Each embedding itself only has dimension 512.

In other words, the similarity matrix is the similarity between each embedding & every other embedding in the 300K set of embeddings.

Regardless, I think Dask will be useful here.

I imagine with these types of things the vast majority of the work is writing integrations. Could you explain how this makes writing integrations easier?

I'm hosting an open-source S3 (SeaweedFS) on hetzner, and I'm doing a direct download from hetzner => the other cloud provider.

I'm not aware of speed test sites that allow you to select the location (i.e doing a speed test from cloud provider A to Hetzner).

I'll look into what's going on by running some CLI speed tests on hetzner.

Since no one seems to be commenting; this is very cool. Can you explain what you mean by TS-to-bytecode? Presumably; you're not interpreting JS. So, what are you interpreting; the types themselves? I guess this actually makes a lot of sense, since Typescript's type system is its own programming language.

This is super nice! I tried to build something similar (PDF reader x Stack Overflow; as you read you can see highlights that link to Stack Overflow style posts): https://chimu.sh (site is broken right now), but it didn't work out.

The thesis was to make annotated textbooks, so if 100 people read a book then the 101th person could benefit from the knowledge of the previous 100 people.

I hope you guys consider the multiplayer aspect of note-taking!

How does Readbean beat Nginx? My assumption was that forking is very slow.

Does Remix also not only ship JS for the interactive bits? I.e, you send over some HTML & then hydrate it with Javascript, right?

You can get pretty far using LMDB, specifically, its compound-key feature is quite good, and gets you a decent chunk of the relational model. Combined with Message Pack encoding, you can get an extremely concise data layer.

https://github.com/kriszyp/lmdb-js/discussions/170

I think there's a reason Tail Scale used a literal JSON file for up till 150 MB. of data: https://tailscale.com/blog/an-unlikely-database-migration/

So, I think the unconventional wisdom is correct.

Context: I see a bunch of people here recommending SQLite. I have a suggestion, try out LMDB. It's kind of like noSQL SQLite. It's a simple in-process K/V store with a few features like compound keys that allow you to model relational data well enough.

I recently used lmdb for webhighlighter.com (specifically the wrapper: https://www.npmjs.com/package/node-lmdb), and it was a fantastic decision.

A lot of people here say "use SQLite for small projects". But even using SQLite can be significant over-engineering. Running migrations? Writing SQL? That's too much effort for me.

For example: In my application, people can leave comments on a (what is effectively) a post. A SQL-native solution might have a table for comments, with foreign keys to post IDs. That's 10x more engineering then I want to do for an MVP. I just store all the comments as an array on a post. This means reads read all the comments and writes require reading all the comments, appending, and then re-writing. That's totally fine, and will probably scale me to 100x my current traffic.

LMDB-JS is great. It allows you to serialize arbitrary JS objects to LMDB using the message pack encoding system. This makes for some super concise code.

Here's my entire data layer: - Interface: https://github.com/vedantroy/grape-juice/blob/main/site/app/... - Implementation: https://github.com/vedantroy/grape-juice/blob/main/site/app/...

TL;DR -- I won't use SQLite, for, I don't know, my first 10K users?

People here are complaining about how Tailwind is annoying because the className strings are too long. The correct solution is to write a quick 1-file helper.

See: https://gist.github.com/vedantroy/80fb2feb21b07b6f53032b8725...

I wrote that. It allows me to do stuff like:

    const Button = tw.div(`
        bg-blue-500
        rounded
    `)

Update: I've noticed that a bunch of people have created posts, but no one has highlighted anything. Is the site hard to use / is it confusing how to create highlights?

Quick note on usage:

Highlight text on the page and then a button will pop-up, allowing you to create a comment.

Hey HN!

Web browsing is currently a solitary activity. You may discover a cool blog, but, unlike a Google Doc, you can't leave a comment on it for everyone to see.

Web Highlighter fixes this. Go to webhighlighter.com/upload and and paste in (almost) any URL to get a real time, collaborative version of the web-page. Share it with people and let them comment away.

Features:

- View other people's comments & reply to them

- Write your own comments by highlighting text on the page and hitting the comment button

- See other people's mouse cursors and what text they've currently selected on the web-page

- Chat with people by pressing the "/" key

- Everything is real time. Comments, mouse cursors, replies all update instantly.

Google Drive doesn't seem to have this issue. E.g, you can upload a pirated file to Google Drive and Drive won't take it down. People can upload their own content to Chimu and I won't/can't be aware of its license (unless someone notified me).

Besides that, there's also a ton of publicly available textbooks online. Example: http://neuralnetworksanddeeplearning.com/

Could you explain to me the benefit this tool offers over something like Playwright + docker-compose (which I think also does stuff like this)?

With styled components my react might look like this:

``` <Question> {...} <Footer> < button> { ... } </button> <QuestionBadge> </QuestionBadge> </Footer> </Question> ```

That's easier than

``` <div className = " ... "> { ...} <div> <div> </div> ```

I have been using tailwind. One thing I've noticed is that it can become unmaintainable compared to styled-components since you just have divs with classes (and it's hard to read 50 nested divs).

Has anyone used something like Tailwind-Styled-Component [1] and found it worthwhile?

https://www.npmjs.com/package/tailwind-styled-components