Should be added now if you refresh your Profile page. I've added an Account Settings button that lets you reset all your card votes and delete your account and all its data.
75 karma · joined November 20, 2019
The more I read this reply, the more I agree with it, and I think it may actually not be that difficult of a change. Card sets could be integrated into the existing cluster concept and I could just give users the ability to choose which sets (clusters) they swipe on and the weighting that they apply to each. They could also decide which clusters should be factored into their similarity matching. I _think_ this will all work with the existing CUBE concept, which is exciting, because many other proposed solutions by others didn't fit nicely within that mathematical structure.
You've honestly given me a lot to think about and I think I see a better way forward now. Your insight really increased my mood because I think you've discovered something very important that I am likely going to be spending quite a bit of time on in the next coming weeks and months.
Thanks so much!
I actually really like your mock-up and really appreciate that you took the time to make it. Hopefully you don't mind if I take quite a bit of inspiration from it, because I definitely think it looks much better than my current one.
Yeah, I agree that the network effect is one of the biggest problems. Retention seems very tricky with a concept like this because while posting it to reddit or HN can result in many registrations, few people stick around because there isn't much to do on the site because there's so few users at the moment. It honestly does make motivation pretty difficult, but I am indeed going to stick with it regardless.
With regard to your last 4 numbered points, currently 0% == not answered == neutral, and this is mostly due to technical limitations. Your default similarity cube is just (0.0, 0.0, 0.0, 0.0, 0.0, ..., 0.0) (50 zeroes), and voting on cards adjusts this accordingly. Such that if you answer 100% to every card in the first cluster and answer no other cards then your CUBE would look like (1.0, 0.0, 0.0, 0.0, 0.0, ..., 0.0)
I was thinking about a potential way to solve this, but as of right now due to the constraints of CUBE similarity matching, this is the current solution.
Thanks again for such an insightful reply!
So, the problem we'd like to solve is what set of 250 or so cards has the highest predictive value in that similar answers lead to the best interpersonal matches?
The problem with hobbies is that there are so many of them and not many people feel very strongly one way or the other about many of them. You probably wouldn't not give someone a chance just because they prefer ping pong to pool, for example. Rather, I was looking for what might be deal-breakers.
The Interests page and tagging in general is what I am hoping will fill that need of specifying your individual interests and matching based on them. Here is where you can tag yourself with whatever you'd like and then search for users and posts based on these tags. The card swiping's function is mostly just a first-pass elimination filter.
I had the thought of perhaps doing categories instead with regard to cards. For example, sense of humor is often very important in people. Perhaps 50 of the cards should be memes? And then perhaps 50 of the cards be political, 50 of the cards be hobbies, etc.? Or perhaps there could be multiple similarity percentages, each of a different category? It's still very experimental and I'm not sure what the correct path is.
For authenticating with Google and Facebook I used the oauth2 crate.
For logging in in general I used private encrypted cookies as described on this page: https://api.rocket.rs/v0.4/rocket/http/enum.Cookies.html
I used a Request Guard that decrypts this cookie into the corresponding user identifier. Here's a link to that page: https://api.rocket.rs/v0.4/rocket/request/trait.FromRequest....
I've been working on this for a little over a year now, off and on.
Let me know if would like me to expand on any of these points.
I'm using tokio-postgres for my database library and both it and Rocket are async, so they synchronize very well together. I do not believe Diesel is currently async, but in either case I'm using tokio-postgres instead so I haven't had to look into how to integrate Diesel with Rocket.
Other than that, my needs were pretty simple and I used well-supported platforms, so I haven't really run into any major issues yet.
Pros:
1) Allows for instant similarity-searching. I am using the Postgres CUBE data structure to index users' votes and it has a limit of 100 items. So, if I didn't use clusters then there could only be 100 cards maximum, but ideally you would have even less than that because the CUBE can start to slow down when you approach that limit.
2) It's also a bit of a privacy feature as people can only see how you voted along cluster lines, and not how you voted on individual cards. This provides the aforementioned plausible deniability.
Cons:
1) Not all clusters are ideal, as you've seen. I spent a lot of time exploring different clustering algorithms and none of them were perfect. Some cards were naturally a part of multiple clusters and others didn't align to any at all. I'm sure a lot of this comes down to card choice, which I definitely could improve.
2) Can be confusing to users as opposed to just listing theirs and others votes on cards.
---
If you'd like to help and create better clusters, I'd definitely be open to tweaking them. Most of the required data can be found by navigating to the Cards page. For example, if you go there and click "War on Drugs" and then click "View Correlations", you'll find that "War on Terror" correlates the most with "War on Drugs". This data can then be used to try and create your own clusters. I've found it to be a very tricky puzzle satisfying all the constraints.
In the end, for performance reasons, I felt like I had to choose between either having clusters or only 50-75 cards, and I chose clusters. There's probably a better way of doing it, but I was unable to find it at the time.
I spent some time already and plan to spend a lot more on moderation tools to mitigate the effects of your second point. Ideally fake profiles can be both reported and detected, but as of yet I have not invested too much time into these efforts, other than adding basic reporting features and a moderation page for those with sufficient power.
I tried to mitigate your third point by only allowing users to see your total cluster vote as opposed to your individual card votes. As a result, there is a bit of plausible deniability as your vote for each card is somewhat masked by the average. This could be furthered by reducing the cluster count and thereby making each cluster larger and mask more individual card votes.
As for its reason for being, it's mostly because I just think it's a bit of a shame how there could be this awesome person down the street or in my city, and I could live my whole life without finding that out. I was hoping to develop a service that might alleviate that.
For example, if you were into some obscure Steam game, you could specify that as an interest and potentially see that someone else near you also shares that interest as well. You then might message them, play together, and then if you hit it off some time down the line you could eventually meet in real life as well.
Hmm, yeah, the swiping UX seems to be pretty tricky to get right. Initially I didn't have the percentage but some early testers highly recommended I add it for two reasons:
1) They couldn't see well and found the addition of the percentage was helpful in clarifying their swipe value.
2) It made it more obvious that the magnitude of swiping mattered, as opposed to swiping just being a binary yes/no option.
The two concepts idea is interesting. I'll have to think more on that. I think it might be tricky to implement though, because not every topic has a natural converse.
I was looking for a project to learn Rust with and improve my webdev skills, so I came up with the idea of Kardius. After reading The Rust Programming Language I began work on it. I posted it on reddit some months ago and tried to iterate on their feedback, so now hopefully it's ready for the big stage of Hacker News! (still very nervous though)
Basically, I had remembered Paul Graham's advice of "make something that you yourself would want", and I had always wanted a way of finding like-minded people around me. I had the idea for a website / app that let you swipe on concepts instead of people. For example, cards like "Hunting, Vaccines, Cities, Podcasts" would appear, and swiping right on them would mean you liked the idea or identified with the concept, with swiping left indicating the converse.
So, I made just that. It then uses the Manhattan distance formula to compute your similarity to others. You can also view statistics like the average swipe value for a card and how that card correlates with other ones (e.g. Hunting and Guns are highly correlated with each other).
You can then also view clusters of cards on profile pages. These are groups of cards with votes highly correlated with one another (initially found via SciKit's Agglomerative Hierarchical Clustering Function). You can then see how users align to these clusters. Another reason for clusters is because I am using the Postgres CUBE data structure to compute similarity between users, and CUBE caps out at 100 elements (and there's currently 250 cards). So to resolve that votes for cards are clustered into, well, clusters, and then the distance between CUBEs can be calculated, and this can all then be indexed for high performance similarity searching.
There is also the Interests page that lets you enter your individual interests. This is because not every interest can be a card as there can only be so many and the ones that do exist should be well-known and relatively controversial to give better predictive power. So, once the base similarity is established via swiping on popular topics, this page lets you tag yourself with whatever you'd like and then also search users and posts for these tags as well. There's also an interface on the Conversations page to easily keeping track of the latest posts for your interests.
In addition, you can privately message users and publicly create posts and tag them with whatever you'd like (examples: Rust, Hiking, etc.). You can also filter users and posts by date, similarity, age, and distance.
My backend dependencies are currently rand, bcrypt, serde, rusoto (for uploading avatars to s3), oauth2, reqwest, time, rocket, tokio, futures, deadpool (database connection pool), web-push, deunicode, async-stream, and pin-project-lite.
For Rocket I am using the async branch (recently merged to master, hooray!) and thus far it's been great. I'm extremely happy with it, both due to its technical merit but also because of the tremendous help the creators provide in terms of technical support. It was my first Rust project so I had a ton of beginner questions along the way and they were always extremely patient and insightful. The rocket server is currently hosted on a free-tier AWS EC2 instance.
For real-time messaging, I ended up creating a Server Sent Events library. It's basically just a channel that the multi-threaded Rocket server sends commands to (join this user to this room, send this message to this user or room, etc.). The library has a bunch of hash tables that keep track of all the rooms, users, and subscriptions. I also recently added support for an event log so users can temporarily disconnect and then receive all the messages they missed upon their return without having to refresh. If there is any demand for this I'd be happy to polish it up a bit and throw it on GitHub, as I'm sure my implementation is far from ideal.
On the frontend I am using React and... that's it actually. It's probably not the wisest decision (although I am kind of afraid of npm) but I ended up just creating minimal libraries for everything I normally would use a dependency for. My simplistic Markdown parser is around 150 lines, my Axios "clone" is just a small 100 line wrapper for fetch, my routing library is just matching the URL against my small list of path regexes and returning the corresponding component to render, etc.
Returning to the website's features themselves, I tried to make as many available as possible without logging in, as I generally dislike logging into sites, so no pressure to create an account at all! What I'd like more than anything is any suggestions or feedback that you might have, because I'm perpetually full of doubt and indecision on the proper course of action to take. Another thing I'm struggling with is marketing and actually getting it out there, as I know nothing of that world, and I always feel kind of weird about self-promotion. Anyways, thanks so much for reading!