lvxferre

joined 3 years ago
[–] lvxferre@lemmy.ml 8 points 10 months ago

Damn, that's sad. Thank you for the info.

[–] lvxferre@lemmy.ml 28 points 10 months ago

Worst hypothesis they just need to mess around a bit. For example I don't think that queerasfu.ck would be registered.

[–] lvxferre@lemmy.ml 44 points 10 months ago (10 children)

They could get a .ck domain instead and move to queer.as.fu.ck, no?

[–] lvxferre@lemmy.ml 1 points 10 months ago* (last edited 10 months ago)

That's surprisingly accurate, as people here are highlighting (it makes geometrical sense when dealing with complex numbers).

My nephew once asked me this question. The way that I explained it was like this:

  • the friend of my friend is my friend; (+1)*(+1) = (+1)
  • the enemy of my friend is my enemy; (+1)*(-1) = (-1)
  • the friend of my enemy is my enemy; (-1)*(+1) = (-1)
  • the enemy of my enemy is my friend; (-1)*(-1) = (+1)

It's a different analogy but it makes intuitive sense, even for kids. And it works nice as mnemonic too.

[–] lvxferre@lemmy.ml 8 points 10 months ago (4 children)

Another important detail is that Digg v4 pissed off most of the userbase, so the impact was pretty much immediate. Reddit APIcalypse pissed off only power users instead; the impact will only come off later (sadly likely past IPO).

[–] lvxferre@lemmy.ml 2 points 10 months ago

Lunix sucks so much that it got stuck into the version 2 for years.

[–] lvxferre@lemmy.ml 2 points 10 months ago

Persuasion itself goes from neutral to negative, depending on your moral standards. (They're partially individual, partially cultural.) Because at the end of the day it boils down to "I want you to believe in this, because I benefit from your belief."

And you definitively see some backslash against this aspect of advertisement; same deal with personal communication, a person being excessively rhetoric for their own benefit is immediately labelled distrustful.

Then over that propaganda adds further layers of nastiness, like:

  • Often, the one doing propaganda is supposed to defend your interests. Not their/its own.
  • You'll usually need to omit and lie far more for propaganda than for other things. Because it's usually a complex matter that involves society as a whole, not just your personal decision.
  • Since the political landscape changes, the discourse being propagated may flip 180°.
[–] lvxferre@lemmy.ml 15 points 10 months ago* (last edited 10 months ago)

Let's go simpler: what if your instance was allowed to copy the fed/defed lists from other instances, and use them (alongside simple Boolean logic plus if/then statements) to automatically decide who you're going to federate/defederate with? That would enable caracoles and fedifams for admins who so desire, but also enable other organically grown relations.

For example. Let's say that you just joined the federation. And there are three instances that you somewhat trust:

  • Alice - it defederates only really problematic instances.
  • Bob and Charlie - both are a bit prone to defederate other instances on a whim, but when both defed the same instance it's usually problematic.

Then you could set up your defederation rules like this:

  • if Alice defed it, then defed it too.
  • else, if (Bob defed it) and (Charlie defed it), then defed it too.
  • else, federate with it.

Of course, that would require distinguishing between manual and automatic fed/defed. You'd be able to use the manual fed/defed from other instances to create your automatic rules, to avoid deadlocks like "Alice is blocking it because Bob is blocking it, and Bob is blocking it because Alice is doing it".

[–] lvxferre@lemmy.ml 4 points 10 months ago* (last edited 10 months ago)

The source that I've linked mentions semantic embedding; so does further literature on the internet. However, the operations are still being performed with the vectors resulting from the tokens themselves, with said embedding playing a secondary role.

This is evident for example through excerpts like

The token embeddings map a token ID to a fixed-size vector with some semantic meaning of the tokens. These brings some interesting properties: similar tokens will have a similar embedding (in other words, calculating the cosine similarity between two embeddings will give us a good idea of how similar the tokens are).

Emphasis mine. A similar conclusion (that the LLM is still handling the tokens, not their meaning) can be reached by analysing the hallucinations that your typical LLM bot outputs, and asking why that hallu is there.

What I'm proposing is deeper than that. It's to use the input tokens (i.e. morphemes) only to retrieve the sememes (units of meaning; further info here) that they're conveying, then discard the tokens themselves, and perform the operations solely on the sememes. Then for the output you translate the sememes obtained by the transformer into morphemes=tokens again.

I believe that this would have two big benefits:

  1. The amount of data necessary to "train" the LLM will decrease. Perhaps by orders of magnitude.
  2. A major type of hallucination will go away: self-contradiction (for example: states that A exists, then that A doesn't exist).

And it might be an additional layer, but the whole approach is considerably simpler than what's being done currently - pretending that the tokens themselves have some intrinsic value, then playing whack-a-mole with situations where the token and the contextually assigned value (by the human using the LLM) differ.

[This could even go deeper, handling a pragmatic layer beyond the tokens/morphemes and the units of meaning/sememes. It would be closer to what @njordomir@lemmy.world understood from my other comment, as it would then deal with the intent of the utterance.]

[–] lvxferre@lemmy.ml 3 points 10 months ago

Soap and water do wonders for 90% of the restroom cleaning.

The problem is that the other 10% are important too.

[–] lvxferre@lemmy.ml 5 points 10 months ago (2 children)

Not quite. I'm focusing on chatbots like Bard, ChatGPT and the likes, and their technology (LLM, or large language model).

At the core those LLMs work like this: they pick words, split them into "tokens", and then perform a few operations on those tokens, across multiple layers. But at the end of the day they still work with the words themselves, not with the meaning being encoded by those words.

What I want is an LLM that assigns multiple meanings for those words, and performs the operations above on the meaning itself. In other words the LLM would actually understand you, not just chain words.

[–] lvxferre@lemmy.ml 1 points 10 months ago

Yup, that's the stuff. It's mostly a finishing touch, to get rid of bacteria.

 

Disclaimer: I like the Fediverse, Lemmy, and the concept of federation, I've been here for two years, and I feel grateful towards people working on this platform - devs and admins and mods and everyone else. As such, I hope that what I'm voicing is interpreted as constructive criticism and food for discussion.

TL;DR: I'll list some issues with Lemmy, how they relate to Reddit, and a few proposals on what should be done to address them.

The issues

When you're posting/commenting you're supposed to acknowledge and follow up to three independent sets of rules: of the comm, of the comm's instance, and of your instance. This is a burden for good users, and yet another excuse for bad users to ignore the rules.

There are also up to three groups of rule enforcers, in any situation: two admin teams and a mod team. If any of those goes rogue (greedy pigboy or powerjanny style), you got a problem.

Usually the ones enforcing the rules - the mods - are the group that, by design, lacks access to user info like IPs. So they either play whack-a-mole with old trolls under new accounts, or they rely on assumptions (i.e. stupidity) to keep control of their comms.

Your feed depends on which instances yours is federated with. So you either deal with the fact that you won't get content that you'd otherwise want, or you register into multiple instances to check multiple, partially overlapping feeds. One by one.

Federated instances mirroring content from each other causes sync issues (got removed from A, but not B? You'll still see it in B), storage issues (raising the requirements for people to create their own instances), and it's a big liability (cue to CP being posted to LW, and every single admin team removing it from their own instances).

The biggest instance (by MAU) is as large as the seven following instances combined. This sort of demographic concentration is bound to defeat the advantages of a federation (sharing the burden, sharing the power) without alleviating its cons (added complexity).

The top 10 instances is mostly populated by general purpose instances, doing redundant efforts to provide the same content to the users.

What do those issues have to do with each other?

Look at Reddit.

  • Users want their own Reddit communities, but they can't build new "Reddit instances". So they create their communities as "vassals" (subreddits) of the single Reddit instance.
  • Since you always post in the same Reddit instance as you registered to, there are no federation woes like "I want content from instance A, but I'm in instance B and they don't federate", or "admins of my instance vs. admins of the instance where I'm posting".
  • Reddit cannot rely on other instances to provide content for its users. As such, it hosts all its content in a single, general-purpose instance.

I believe that, once you apply those three aspects of Reddit to a federation, you get the issues that I mentioned.

In other words those issues are born from trying to replicate a non-federation into a federation.

So, what should be done in your opinion?

I'm no coder, nor I want to pretend to be one, and I'm aware that some of those might not be viable. Still, if I had to propose something...

First of all, a change of paradigm: we (users: including mods, admins, developers, everyone) should see Lemmy first and foremost as a federation of forums and advertise it as such. Similarities with Reddit should be only secondary.

People who code in Rust would do an amazing job if they focused on instance creation and management. Ideally, it should be feasible even for a tech-illiterate granny running a potato computer to spin up her own instance.

I think that content mirroring needs to go away, with the users pulling the content straight from the instances where it's created.

Interface developers should expect users to have 2+ accounts, and to log into all their accounts at the same time. The resulting feed should be a combination of the feed of those instances; handle this through the interface/front-end. And when the user is posting/commenting, ideally they should be able to choose which account to use, on a per-community basis.

Desktop users should be encouraged to migrate from "my instance's website" to instance-agnostic front-ends, such as Alexandrite and Slemmy. [This doesn't affect mobile users, I believe.]

We should be contributing more to specific-purpose instances (for example: mander.xyz, ani.social, etc.), at the detriment of general-purpose instances (for example: lemmy.world). Perhaps, at the start even migrate our comms to those instances.

Eventually [in the far, far future] I think that the concept of subreddit-like communities should be deprecated, with communities becoming simple sub-forums of the instance where they're hosted.

By default, admins should focus mostly on the activity inside their own instances. Let the behaviour of their users in other instances up to those admins; a dog with two owners ends either overfed or starved.

When possible/reasonable, admins should be moderating more communities in their own instances.

 

I often switch between phones and speakers, but I'm too lazy to do it through the sound preferences window. So I came up with this script*, and I'm sharing it here as others might find it useful.

You'll need to tweak it a bit to work in your machine, but once you do it you can run it from a launcher or a keyboard shortcut, it's really comfy.

Okay, here's the code:


#!/bin/bash

# You'll need to swap those four values with the ones that work in your machine.
# Check the rest of the post for further info.
mainCard="pci-0000_06_00.1"
mainProfile="hdmi-stereo-extra1"
altCard="pci-0000_00_09.2"
altProfile="analog-stereo"

# If the current default source is main, your new source is alt. Else, your new is main.
if [[ $(pactl get-default-source) == "alsa_output.$mainCard.$mainProfile.monitor" ]]
then declare -g newCard="$altCard" newProfile="$altProfile"
else declare -g newCard="$mainCard" newProfile="$mainProfile"
fi

# Tells PulseAudio to shift the card profile and default sink to the new.
pactl set-card-profile "alsa_card.${newCard}" "output:${newProfile}"
pacmd set-default-sink "alsa_output.${newCard}.${newProfile}" &> /dev/null\

# Tells PulseAudio to shift the currently running programs to use the new output.
for i in $(pacmd list-sink-inputs | grep index | awk '{print $2}')
do pacmd move-sink-input "$i" "alsa_output.${newCard}.${newProfile}" &> /dev/null
done

# Optional text notification.
if [[ $(pactl get-default-source) == "alsa_output.$mainCard.$mainProfile.monitor" ]]
then notify-send -t 500 "Main sound output on!"
elif [[ $(pactl get-default-source) == "alsa_output.$altCard.$altProfile.monitor" ]]
then notify-send -t 500 "Alt sound output on!"
else notify-send -t 2000 "Something weird happened."
fi

# Optional audio notification. It runs VLC but it's easy to adapt or remove if you want.
cvlc --play-and-exit /usr/share/sounds/freedesktop/stereo/message-new-instant.oga


Check the first four lines of code. You'll need to replace that "pci.blahblah" and "audio.stereo.whatever" junk with the ones from your machine. To know them, run pacmd list-sources | grep name: in a terminal. The output will look like this:

name: ⟨alsa_output.pci-0000_06_00.1.hdmi-stereo-extra1.monitor⟩
name: ⟨alsa_output.pci-0000_00_09.2.analog-stereo.monitor⟩

Ignore ⟨alsa_output and monitor⟩. The second-to-last chunk (e.g. hdmi-stereo-extra1) is the profile. The rest (e.g. pci-0000_06_00.1) is the card. Now replace those in the script.

*credits: this script is partially inspired on this AskUbuntu comment.

 

EDIT: I was able to solve this by going into the "change password" screen, right-clicking the "old password" field, clicking "inspect", and changing maxlength="60" minlength="10" to maxlength="60" minlength="1", thanks to the tip provided by Dandroid in the comments.


When I try to login, the following message appears: "Please use at least 10 characters (you are currently using # characters)." Ditto when I try to change my password.

This issue affects me when trying to log in from Firefox and Chromium, in Linux. When trying to log in from Firefox in Android, I can't but no message is given. It does not affect Jerboa or Voyager, but I can't change my password from either.

Any idea on how to solve this? When I created this account 2y ago I was just checking Lemmy out, so I didn't bother with a strong password back then, but this has become a ticking bomb. I'm currently able to access Lemmy from Firefox due to saved credentials, but I'm worried about them eventually expiring.

Pictures showing the issue:


(My actual password isn't 6 chars long, but the error message is the same.)

 

If you want, please add your tips to the comments.

Here are mine - just a bunch of opinions/suggestions from someone who used to be a forum mod, then a subreddit mod.

As this is a rather big wall of text, I'll split it into sections, contained within spoiler tags.

Mindset and duty.

A happy mod is a good mod. Take care of your personal life first.

Your comm[unity] is not your personal possession or project, it's a collective effort. You're just its representative - be humble but proud about it.

Use your comm as any other user would. Be active in it, interact with other users, discuss, learn, have fun.

If you don't enjoy your comm any more, for whatever reason, pass the torch to newer mods.

Check your comm at least a few times per day. A quick peek is fine for slower comms.

It's useful to follow the RSS feed of the comms that you moderate, as it'll be quicker to spot rule-breaking posts. You can do it here:

In days that your comm is too slow, specially at the beginning, it's your job to provide content for your comm.

Recruitment

Avoid recruiting mods who:

  • never post/comment in your comm, or only did it after you announced "we want new mods"
  • asked over and over to be a mod
  • already mod lots of other comms
  • claim to have a "vision" about your comm, and propose 9001 drastic changes for it*.
  • rush towards certainty on things that they cannot reliably know (intrinsically unfair)
  • cannot reasonably infer things from context (ditto)

*Major exception: if your comm got some biiiig problem, and nobody seems to be able to solve it.

If you get multiple people willing to mod, you can be a bit pickier. Use open-ended questions to trial them. Ideally new mods should:

  • be active members of the comm
  • work well alongside the rest of the mod team. (are they strict rule enforcers, or more on the "let users have fun" side?)
  • active in different hours than the rest of the mod team. (e.g. night owls, different longitudes, etc.)

A lazy mod is less worse than a well-intentioned but dumb mod.

Rules and their enforcement

You do not know the users' intentions, thoughts or beliefs. However, you do know how they behave and what they say. Use the later, not the former, in your rules.

If a rule cannot be enforced, it is not a rule. It's at most a request.

Enforce rules by spirit, but the letter should follow fashion. There's some room to be sloppy with this with smaller comms, but not the bigger ones.

Do not enforce "hidden rules". If there's some shitty behaviour that needs to be addressed, do it in the open.

Do not enforce new rules retro-actively. You're just creating more work for yourself and pissing off users, for no good reason.

Be succinct when phrasing the rules. If necessary/desired, write down two versions of it:

  • short version - addressing what users can/can't/need do in broad strokes, without "why". Keep it in the side panel, visible at all times.
  • long version - addressing specificities of each rule, as well as reasoning. Keep it in a post or similar.

Synchronise changes in all versions of your rules. Few things confuse users the most than rule disparity.

If your comm got more than seven rules, it's probably already too much. Consider merging them.

It's fine to use imperative in the rules ("do this", "don't do that"), as it's succinct and you're in a position to do so.

Every rule has a grey area, of things that are only arguably rule-breaking content. Try to minimise the grey area when possible, but keep in mind that you'll never get rid of it.

Beware the fluff principle: voting alone will allow only the lowest common denominator content to the top, and shove down well thought content that is hard to judge. Take that into account when creating rules.

Handling other users

Ask community input periodically. Don't use votes for this, let other users speak their mind.

Input from rule-lawyers is surprisingly useful to find issues in your rules. And a few people will be abler to phrase your own rules better than you do.

Even then, asking community input is not an excuse to relay responsibility. You're still the mod.

It's useful to keep notes of a few users from your comm:

  • notes about good, specially engaged and helpful users might be useful later on, as you're recruiting newer mods
  • notes about bad users are useful for rule enforcement. Certain types of bad behaviour are only revealed in long-term tendencies.

Activity of your comm's users outside your own comm should be only taken into account as much as it might predict their future activity in your comm. There are a few corner cases to do so, but by default you're better off not doing this.

Don't feel afraid to upstream reports of specially problematic users to the admins of your instance. Specially if they're more on the stricter side.

This is debatable, but I personally believe that a few types of users, regardless of their intentions, should be handled as you would handle trolls and shitposters. They are:

  • witch hunters: users who point fingers at other specific users without rational grounds to do so
  • entitled, bossy or whiny users: users who are eager to tell other users what to do, for their own sake
  • obtuse users: users who "conveniently" pretend to not read or understand counter-arguments of other users in discussions
  • assumers: users who are prone to say things that they cannot reliably know, specially about other users. (A superset for witch hunters.)

This sort of user is prone to piss off other users, specially the most contributive ones.

When there's a fight between users, typically, at least one of them is stupid. Make sure to know which one (or if both) before intervening.

 

I just deep-fried and filled a batch of the thing above. They turned out delicious, so I'm sharing here.

Here's a link for the recipe for the dough; I followed it closely, the only thing was that I subbed the butter with veg oil. The recipe yielded ~20 of them, but this depends a lot on the size that you cut them.

Recipe for the custard filling:

  • 300g sweetened condensed milk
  • 300g 20% fat milk cream
  • 300g whole milk
  • 2 eggs
  • vanilla essence
  • [optional] 1/2 tsp cornstarch

Just mix everything together until homogeneous, then heat it on low fire, while stirring constantly, until it thickens. I didn't use the cornstarch because I wanted it slightly runnier, but do add it if you like a thicker custard.

 

I'm serious. Specially, the community - you folks, no matter the instance, you rock. You're amazing.

In Reddit it's always a struggle to word your posts/comments in a way that it won't trigger

  • unwarranted assumptions popping out of nowhere
  • "I dun unrurrstand" meaning "I disagree but I'm pretending that you aren't following any logic"
  • "You're saying that because..." [insert insane troll logic] everywhere
  • "U think dat 50 is not 100? Than u think 50 is 0! Dats stupid lol" tier oversimplifications all the fucking time.
  • insert random distortion of what you said, either due to malice or stupidity

Here though? People actually disagree with each other on rational = human grounds. They aren't attacking each other, they're agreeing or disagreeing with what is said!

It's specially noteworthy that even Lemmygrad's community specifically tailored for Leftist infighting is more wholesome than non-discussion subreddits. Like, it's a server made for people with strong political opinions, a community made to let them fight, and yet they can reason better than Reddit.

Please keep being awesome.

view more: next ›