RonSijm @ RonSijm @programming.dev

Posts

6

Comments

159

Joined

2 yr. ago

well sure, as a user FOSS is ideal, but as a developer it's not ideal you're not getting paid for your software...

Just paying a developer once for software you use seems like a decent compromise

[...] Blazor WASM has a massive initial payload, which makes it slow and heavy.

Blazor WASM doesn't need to have a massive initial payload, that's only if you're making your projects too big, and aren't really structuring them correctly. To be fair, Microsoft hasn't really done anything to make this easier, or address this

(Shameless self promotion) - I however, have fixed that: https://github.com/RonSijm/RonSijm.Blazyload Your "landing page" should basically ideally be pretty much the only thing that's initially loaded, so that the initial load is fast. Once that is done, you can quietly lazy load the rest of the dlls you need

I read someone saying that the lack of contributors was due to the software stack being unconventional and takes people a while to get used

I don't think the software stack does matter that much. I've downloaded the Lemmy source and ran it from source, and my main caveat with it is the structure. I would have liked to see a much more modular design, with an add-on kind of system. Now, when an instance owner wants to add a feature, their only two options are either to: Try to get their specific feature into Lemmy main, or create a specific Lemmy fork with their own feature(s).

The entry level to just create your own Lemmy add-on would be much smaller than to try to get something new into the main repo. Plus it'd give you a sense of ownership when you'd see something like "50 instances have added your add-on" - over "I made a cool feature, it got PRed into main, and pretty much no one knows who build it"

For example, a great system is something like Home Assistant - Where this is a structure of "Addon-Repo" and "Addons" - with a Main Repo and you can add your own custom repo, or just install from .zip if you want that for some reason. Kind of similar as something like Nuget

If people could "contribute" with their own standalone things instead of having to PR stuff into a repo, you'd get much more contributions and user created add-ons

[From the github comment]

The issue I see with the RFC is not wanting to allow users to add tags to ease the burden on moderators. This comes from a lack of users with privileges, so moderators are overworked and need to rely on bots.

If the tags are just kinda "plain old hashtags" - and not something cool like I mentioned in the previous post 😉 -

Possibly you could have a look at how Gazelle handles tags, where it's just a voting system. For example, this is "Kanye West" https://i.imgur.com/adTe4t8.png - then tags are no longer a boolean yes/no system, but a user-voted system. And then it's no longer a moderation concern to have to correct tags, and you don't need "User privileges" to manage the tags either.

It's just a pretty chaotic system though - you might still want moderators to remove bad tags and/or ban users from creating tags if they're always adding nonsense.

Could be some point based system like Stackoverflow - users with n points can vote on existing tags, users with n+ points can add their own new tags

I'm not very familiar with the ActivityPub protocol, but there are easy ways to flatten an hierarchy.

For example, the tag could literally be "NSFW/Porn/Straight" - though I assume then there's no system in place to request tags by their parents.. So posts with that tag would just get 3 tags: "NSFW", "NSFW/Porn" and "NSFW/Porn/Straight" in the API, and would be hidden / breadcrumbed in the UI.

Though it's not ideal to do it like that, as it would make maintaining structure more complicated - though not impossible.

Just curious, how open / extendable is ActivityPub? Just to say "the protocol doesn't have it (yet)" - doesn't mean it can't be implemented, either properly or through some workaround like mentioned above

I like how they've done it, but from an "instance owner" perspective I can kinda see how it could become annoying to support 5 different FE UIs...

I've tested https://phtn.app - and over there it seems when you login it sends the login request straight to https://programming.dev/api/v3/user/login - (which is good)
While mlmym sends the login attempt to it's own backend to proxy it - which is bad, since anyone could alter the code and log the login requests on their server and capture your auth data.

I've been looking into mlmym, but it's programmed in GO, which I'm not familiar with, so that's not great (for me) - though I've seen you can compile GO into WASM - so my idea is to do that so it can be hosted stateless (like in s3 or even just github pages) without any backend. If then the auth can be fixed, it could practically be used from any location and the instances wouldn't have to host their own version of mlmym

I'd like tags, but they'd have to be something different than just communities / categories, since that's already what communities are for.

I've build multiple CMS like systems, and how I've implemented tags before, and liked the most was as a node tree - Since a lot of the comments are focused on NSFW, to illustrate an example:

• SFW
• NSFW
  • NSFW/Porn
    • NSFW/Porn/Straight
    • NSFW/Porn/Gay
  • NSFW/Gore

This allows users to use tags as a sort of searching mechanism with an hierarchy, and fine-tune how specific they want to search for a specific thing. Do you want all NSFW stuff, or something more specific.

The downside is that it could get complicated to maintain a good tag structure, plus you might run into scenarios where 1 subtag might fall under more categories. In that case a "Parent 1-x> Child tree" doesn't work anymore, and you'll end up making an "Parent x-x> Child structure" - which is even more difficult to maintain

The argument against tags, is that posts are already categorized by communities. Though not everything, and not every niche thing needs it's own community in my opinion. Look at !programming@programming.dev for example - a "general purpose community". Just taking the top 2 posts there, you could still create a similar note-tree tag structure there like:

• Programming
  • IDEs
    • VSCode
      • VSCodium
  • Code Style
    • Tabs VS Spaces

These tags could still be "communities", but communities are non-hierarchical, and at what point to we really need an extreme niche "Tabs VS Spaces" community? If there would be a tag system like this, people could select the "Code Style" tag, and see posts under that tag plus all child tags.

This is just an idea for tag structuring, the concepts of ACLs of "who can make these tags" and "who can move around tags" or "who can append new child tags" - and "Introducing new child tags could require reordering the parent content into those tags" is an whole other discussion

I don't know, I've asked in an issue of their repo: https://github.com/rystaf/mlmym/issues/77 - they might clarify why they removed it.

Apparently some of the links in the gist file are mirrors: https://o.opnxng.com/ and https://lemmy.bolha.one

The downside of these local mirrors is probably that the auth credentials are POSTed to those sites - apparently due to limitations or Lemmy. But so it would be better instances hosted their own versions

I don't know if there's a "definitive guide" - it's not that complicated to get a torrent client up and running. What kind of content are you looking for? Movies, Series, Music, Games, Books..?

Best is probably to try to get access to a decent private tracker, and an "easy" one - one with a bonus point system for seeding and uptime - that makes it much easier to keep a good ratio with a NAS, if you're just permanently seeding everything you download, you'll get points and "rise the ranks" of that tracker.

Once you're a high enough rank on that tracker, you'll get access to their "Invite Forums" where other private trackers advertise and give out invites to their trackers

What software/OS are you running on your NAS? If you're running some goofy software on a private tracker your client might not be whitelisted.

Besides that - this NAS is attached to your home network I assume? Is it behind a router? Are the ports you're using for torrenting port-forwarded?

What tracker are you testing this on? A bunch of trackers will have a "Connectivity check" that will tell you whether or not your client is connectable

Suggestions for being able to recreate your own websites:

• Own local backup
• Copy from Wayback - https://web.archive.org/

YIKES... This shows the importance of keeping backups in a different cloud, or on-premise or something - and not trust one provider with your entire company / website

I don't think this will necessarily help solve issues you wouldn't be able to solve without this, though I used similar tools in the past (Ozcode) and it did make debugging easier / faster

preemptively running source as it was written

It's not preemptively running source as it's being written, it's preemptively evaluating methods as you're debugging it

This looks like it's preemptive compiling, which isn't just unwise, it's potentially dangerous.

So I think what you might mean is preemptively evaluating methods at runtime? - which would be unwise / potentially dangerous - since it could cause side effect

For example, evaluating a method that increments something and modifies the state. So if it's preemptively called by the debugger, the state would be modified, and the actual invocation would be different

I installed the Resharper RC, and this is how it looks like in a small project that parses an excel file: https://i.imgur.com/g4s0P3h.png

So, in the example my debugger is still on the allTheFieldsEmpty line and hasn't ran it yet, but resharper already evaluated it to false. Then it also greyed out everything in the if(allTheFieldsEmpty) block, since it knows it wouldn't hit that

The next line you can see there was a warning, "Possible impure evaluation" - which is that I assume you were talking about, and it didn't evaluate that yet. I can click the box and make it evaluation it.

The debugger inspects the method, as the article mentions, it check for the PureAttribute - indicating that it's safe to use

After I marked that GetMappingField method as Pure, it actually did evaluate it without any interaction, and it predicted it would throw an exception https://i.imgur.com/zQ0K3Ge.png - seems pretty useful so far

am unsure just how revolutionary this feature is

It's not. This feature existed for dotnet in bugaid (which then got renamed to Ozcode) (which then got killed by Datadog) for the last 10 years already

I can't even "scrub my post history" anymore... The account is in readonly mode basically - and I can't delete or edit anything from my history

Another thing that surprised me was how much chatGPT bot spam there is

Not really a bad thing. Part of the protest was to devalue the platform...

See what /r/ProgrammerHumor/ is doing - all titles are camelCase, and all the comments started including and returning things. It's not really something anymore that reddit could sell to AI content farms.

If mods are removed for participating in the blackout, the next best thing is probably to let their sub go completely unmoderated and let things turn into a shitshow with unable content by spam bots.

Don't think you can really teach an AI bot something by letting it regurgitate it's own output

Really neat, was hoping someone would build something like this. I'm not the biggest fan of the default Lemmy skin.

But the login is a bit sketchy... I checked the network, and logging in just sends your credentials to their site (POST https://mlmym.org/programming.dev/) with the password in cleartext.

Not saying that the developer has any bad intentions, but if anything is misconfigured, like nginx logging incoming requests or something, it would be a security disaster if someone would somehow be able to access it

I don't know if this is a limitation of Lemmy / ActivityPub but I'd prefer if the auth happened directly to the Lemmy instance.

Personally I don't have any problems with it (if that was directed at me) - I've added 418 as "unhandled exception code" response to a bunch of applications, so I can easily differentiate whether my application is throwing an error, or whether it's some middleware gateway AWS io-thing

I was just curious what OP thought about it, since in the early days it wasn't uncommon to add goofs or easter-eggs into software, but nowadays not done so much... and apparently the "HTTP Working Group" doesn't like it either... So I was curious whether OP though in hindsight whether it should've been added or not

Do you regret adding it, or with the knowledge you have today, would you still add the 418?

Since a bunch of languages have not implemented it, or/and has long discussions about it:

https://github.com/dotnet/runtime/issues/15650
https://github.com/golang/go/issues/21326
https://github.com/nodejs/node/issues/14644
https://github.com/psf/requests/issues/4238
https://github.com/aspnet/HttpAbstractions/issues/915