Perhaps the most developed demonstration is at https://thoughtliner.com/thought/11 (click on the button to show responses to see more).
The site is maybe 50% of what I would consider MVP, but work on it has been mostly dormant for the last several months. A more serious effort might resume in 2022.
I started working on it because I thought it could help me organize my own thoughts. It could be a useful resource for people, but I also think the interested audience would be fairly niche. As you dig into various arguments, the topics can easily become fairly esoteric or technical.
If you have interest in it (e.g. you have ideas to contribute or just want to be informed of a "launch"), you should be able to reach me at support@ the domain.
What if there were a “structured arguments” wiki
Each topic could have some tree structure, like side A has a list of points, click each point to see side B’s reply
Reducing debates down to their atomic points without all the fluff of reading a flame war thread
Everything must be written with the clarity and succinctness of Wikipedia including sources
If you're interested, please get in touch.
- what exactly is the use case?
- why isn't e.g. SharePoint or Dropbox version history sufficient?
One should not need PostgreSQL for small problems.
I use SQLite quite a bit and I've never found it to be unsafe or insecure.
I got it working in 32 bit Linux, but have no clue about how to convert it to something modern.
Kind of like a combination of Spotify and good old iTunes.
I’m familiar with RxJS and have always thought it would be nice to have some syntax sugar for common operations. But I’m not sure how the concept would apply to monads in general.
async { const a = await getA(); const b = await getB(a); return await getC(b); }
Is the same as:
getA().then((a) => getB(a)).then((b) => getC(b));
Observable is interesting, because it has multiple flatMap variations, like concatMap, switchMap etc.
There could be different await keywords that represent these operators. Example:
asyncObservable { const request = await myRequestStream(); const response = switchMap sendRequest(request); return response; }
This should be equivalent to:
myRequestStream().switchMap((request) => sendRequest(request))
In general, the advantage of this syntax is, that you can work on die values directly, instead of needing to work with the Observable.
my particular use case is trying to load balance git ssh
It might be nice to be able to do layer 7 partitioning of load, but that doesn't seem essential.