Avatar
Cody
8125b911ed0e94dbe3008a0be48cfe5cd0c0b05923cfff917ae7e87da8400883
Building 👨‍💻 https://jumble.social/ & nostr-relay-tray

You don’t really need to understand the details, just know that it helps filter out spam. If you’re still seeing spam, you can raise the threshold a bit.

It’s a good idea, but it wouldn’t help with the initial reputation issue. A new user would still need the inviter to follow them in order to gain any reputation.

Exactly. If a newcomer starts completely disconnected from everyone in the network, it’s indeed hard to enter the trust graph. But if they come to Nostr through someone they know, they can gain some initial reputation from that recommender, enough to help them stand out from the spam accounts.

A new user only needs to be followed by a regular account to boost their reputation into the top 60%, since spam accounts rarely get any followers, following them would expose the spam account owner.

It’s basically a simple combination of the PageRank and TrustRank algorithms, both of which have plenty of resources online.

In short, if you’re followed by high-reputation users, your reputation goes up too. The more trusted users vouch for you, the more trustworthy you become.

You don’t need to do any configuration. You might want to double-check that your code is up to date, and try refreshing the page a few times since it could be cached.

Replying to Avatar Vitor Pamplona

Fill the form to get the invites to the call: https://formstr.app/i/wotathonsignup

We usually meet every Thursday but this week is on Friday, the 2nd.

I would love to get you presenting a bit of this approach, focusing on what you need as a client and probably how simple solutions can work. The group is mostly service providers that have a hard time figuring out what clients need (especially which formats are better/easier)

I’m not really into meetings, mostly because my English isn’t great haha. But if your protocol is out on GitHub or somewhere, I’d be happy to check it out and throw in a few suggestions.

I initially thought about the new user issue as well. But I realized that new users are usually brought in by an existing user, once that user follows them, their reputation is higher than that of spam accounts.

It doesn’t seem that important, but yes, most of the code was generated by AI. I just handled the review, fixed AI’s mistakes, and made some small optimizations.

The main purpose of this filter is to weed out spam accounts. Since there are a lot of spam users on the Nostr network, normal users usually end up in the top 10%. But this isn’t fixed, so the choice is left to the user. To avoid filtering out too many legitimate users, I’ve set the default threshold at 40%.

The scores are currently based on the network of relationships, your reputation increases when followed by high-reputation users. Since there are a lot of spam accounts in our network, most normal users end up in the top 10%.

I think this is quite different from a social credit system.

I just built a simple pagerank service using AI

The last feature of https://jumble.social/ in 2025:

A reputation filter that hides notes from the bottom X% of users by reputation.

It works across feeds, notifications, and replies, and is especially effective at reducing spam when browsing large public relays. #devstr

一种p2p分布式文件系统吧,我也不是特别了解

https://git.mleku.dev/mleku/smesh/src/branch/master/DDD_ANALYSIS.md

nostr:npub1syjmjy0dp62dhccq3g97fr87tngvpvzey08llyt6ul58m2zqpzps9wf6wl i am forking jumble because i have lots of time at the moment and first thing i wanted to do before changing anything, was get a domain driven design analysis done. i will leave this in the repo where you see it now, you might be interested to read it or at least skim it.

nostr:npub1m4ny6hjqzepn4rxknuq94c2gpqzr29ufkkw7ttcxyak7v43n6vvsajc2jl also, i know you know some stuff about various dev/design/architecture modalities, this is how things are done with DDD

just from first few screenfuls i can see a lot of things that i've noticed with other front end projects, especially the anemic domain model. in my own code i have for quite some years tended towards making a mess at first, and then after i find myself with several 400+ line functions, i go hard on refactoring, moving types that seem to live together into their own packages, and so on, and for which reason you can see here:

https://git.mleku.dev/mleku/next.orly.dev/src/branch/main/DDD_ANALYSIS.md

which was the state of orly until a few days ago (shortly after that was committed) that it evaluated my work pretty good, first it was 7, then after cleaning up the complexity of the 600+ line event handling code, i got upgraded to 7.5, still lots more to do.

i also applied it to the plebian-signer (forked from nostr:npub1qdjn8j4gwgmkj3k5un775nq6q3q7mguv5tvajstmkdsqdja2havq03fqm7 's gooti - i think he wrote that?) and here is the analysis of the codebase, after i added a ton of features, i wanted to get it cleaned up:

https://git.mleku.dev/mleku/plebeian-signer/src/branch/main/DDD_ANALYSIS.md

the signer, in particular, became noticably more performant after applying all of the recommendations in that document, and when i fully complete orly, i think it will also improve, though i have also added a new skill to https://next.orly.dev which is about go memory management and scheduling (just look in the .claude/skills directory). for go, there is some specific architecture to memory management, and what types go on the stack, what goes on the heap, and how to reduce allocations on the heap, and move stuff, especially stuff that the DDD analysis should be immutable, onto the stack, where it is very cheap pass by value (ie, copy) and thus enforce effective mutability with minimal cost.

Sure, I’ll find some time to go through it properly.

No, you’re totally right, it was a bug and it’s fixed now 🫡

Because there’s a space in the emoji shortcode, Jumble didn’t recognize it as an emoji.

Appreciate it, but save the big zap for someone who needs it more than me

Yes, but it’s already the blossom server that Jumble recommends. I’d like to add another one to the list.

That's exactly what I've been focusing on for the past half year. That’s also why I’ve been putting off some new features.

We can know whether an event was delivered, but doing so would make the publishing process feel very slow.

I don’t think it’s worth sacrificing the experience for these rare cases. In most cases, sending succeeds, and if it fails, retrying will likely fail too—it could be a network issue or the relay simply refusing your event.

Usually a reply gets sent to around ten or more relays. To achieve what you’re imagining, you’d have to wait for all of them to respond or time out, which would make the user experience really poor.

That said, it’s true that Jumble marking a post as successful after just one relay accepts it isn’t ideal. I’ll adjust it so it only shows success once maybe a third or half of the relays have confirmed.

Maybe it’s just that the other person set unsuitable relays, or maybe only one or two relays failed — should the user really have to see error messages all the time for that? In most cases, a few relay failures aren’t a big deal. If you need absolute reliability, that’s what centralized platforms are for.

I get your point, but the solution isn’t to fork Jumble. What we really need is a better nostr development kit.

A lot of clients are built on top of NDK, but the problem is that NDK itself has issues and isn’t very actively maintained. That’s actually why I decided not to use NDK in the first place.