Yeah, we use yjs and a fork of y-sweet [0]. We have a custom-built control plane that allows us to support many different types of relay server configurations (including self hosting, multi-tenant, per-relay, per-document) and optimize for cost.
Your project looks cool -- especially sub-document support -- thanks for sharing
This looks amazing, but I can't log in, I have a custom domain attached to a custom PDS and because my domain isn't my PDS, I can't log in. Could you please add support for specifying the "Hosting provider"?
They are using Tiptap for their input and just a couple of days ago we called them out on some perf improvements that could be had in their editor: https://news.ycombinator.com/item?id=41036078
I am curious what you mean by the formatting is lost though?
Odd, multiline backtick code works very good, I don't know why I thought that it was also broken.
When you type "test `foo` done" in the editor, it immediately changes `foo` into a wrapped element. When you then copy the text without submitting it, then the backticks are lost, losing the inline-code formatting. I thought that this could also happen to multiline code. Somehow it does.
Type the following:
Test: ```
def foo():
return bar
```
Delete that and type
Test:
```
def foo():
return bar
```
done
In the first case, the ``` in the line "Test: ```" does not open the code block, this happens with the second backtics. Maybe that's the way markdown works.
In the second case, all behaves normally, until you try to copy what you just wrote into the clipboard. Then you end up with
Test:
def foo():
return bar
done
Ok, only the backticks are lost but the formatting is preserved.
I think I have been trained by OpenAI to always copy what I submit before submitting, because it sometimes loses the submitted content, forcing me to re-submit.
ut is a little bit smarter than f0. they provide ui components and server-framework bindings for file uploads.
I feel like f0 is a more minimalistic take on file management. More comparable to Vercel blobs than ut. I don't feel these two are comparable though. ut is a nice product if you are looking for those functionalities though.
I hope this is satire, DRY is more about extraction of shared function not about individual expressions. You write code once, no need to save yourself typing time at the expense of you and other peoples ability to read and understand the code afterward.
> DRY is more about extraction of shared function not about individual expressions
I'm not sure where you get that idea. Repetition anywhere is usually a code smell.
> You write code once
And then you update it when you add new features or the requirements change or you fix bugs, etc. Having to change two symbols is more error prone than changing one. And having to parse more code is harder than parsing less code.
The assign-and-test pattern is common in several languages (e.g. C), and adding a comment that explains the logic should remove all doubt as to what is happening and why, so I see it as a win/win.
In any case, there is a trade-off between terseness and legibility, and while I usually favor more verbose code, I tend to draw the line at needless repetition. But that's my personal preference, and everybody draws that line in different places.
> And having to parse more code is harder than parsing less code.
I'd rather parse three straightforward copies with minor differences than one chunk of dry spaghetti. And in assign & test case, splitting them makes debugging much easier.
This looks really interesting, I wonder if we can get to the point of having this all be local to your machine. The idea to use embeddings to search for relevant code snippets is maybe obvious to some, but just now getting into this stuff, just blew my mind!
I find that the hardest problems to find are interfaces between projects like a bad frontend call into a backend or backend to backend. I wonder if this could index separate projects & draw links between them
Semantic relationships between backend/frontend or microservices are super interesting.
We’re not far off, for example you if you index bloop itself with bloop and ask “What message does the backend send to indicate the frontend should close the eventsource?” bloop will return a decent answer which takes into account the relevant frontend and backend code.
They're having so many outages that they've moved from making statements after each event to aggregating them all and write about all of them on a month-by-month basis.
I don't remember when it started getting worse, but if I do a guess, I'd say around 2018 sometime, which I'd also guess is when they started pushing more changes too.
I would love to be able to add a recommendation system based on this.