Thunder has an option to dim read posts.

Xournal++

If nothing else, I would recommend Firefox over Brave for the sole reason of it being yet another Chromium browser. It would be nice if we could eat away some of the marketshare from Google.

It is.

Its not used with e2ee, is it though? At least it’s not the default and I doubt it can even be enabled.

It depends on what the defaults are for the client that you are using. Element, for example, defaults to E2EE.

Another thing is that e.g. spammers might choose to use a misleading preview. Though I suppose that’s a minor point, probably server-side previews can be tricked as well.

In my opinion this isn't a huge deal, but you do have a point in that it could be an attack vector for phishing.

What is the security/privacy flaw if the server does it? No point thinking a non-encrypted would be very secret in the first place.

What do you mean? Matrix supports E2EE.

I guess the idea is that this works with simpler clients as well. Other nessaging networks with initiator-side previews usually have single-provider clients, as far as I know.

I mean, it's up to the client to implement URL previews, anyways; if the client is simple, then the client wouldn't implement them. Unless you mean that the simple client should still provide other people that have non-simple clients URL previews, which would only be accomplished if the server generated them.

I certainly could link my server into play as well just to keep an always online device in the mix

Yep! That should work perfectly fine.

Neat idea! Although, it would probably be more practical to use a centralized model since if one peer is offline, then the syncing would not occur. That is, if my assumption is correct that you are thinking of directly syncing between 2 devices.

Have you posted a suggestion on github?

There are existing issues on GitHub:

• Option to generate URL previews at the receiving client, not the server
• Consider making the sender generate url previews, as with e2e thumbnails

OmPLoYXUOIPhnGr5krVHtCI4knI0pbb4zO/7u4iEWtsBXQbEFOJQITsUYRtvd+9lQvbuKYgEF8tip5O7mZcvgFRNdE2jUR+IE9ewoi5prn7pNTx4+xKR5vgVpXYaixpLI1qMMA+iXD+XobZJRGz9nHi+vzcTMkyHD0X6UpS2GVYztqgghxyxkMhvneR2PtwnjJo/KUi5KAtD4Le/p6wAxS/SZHSzKJIS4vflTayYU/zfZhlc/ElDPy/hoZAeLmq3fWJDMQN5ZPIyS9/mMp+/CkIfRj/GvkDfI2+OdHW23WACezuMHBnvO4w2LPakLDasUKpeUx7bJrNdC1qBcDIDAg==

If you look at this documentation it outlines various methods of generating URL thumbnails. Essentially, a separate request from the client for only the URL is made to the server which then returns a thumbnail. It's an absolutely moronic design choice, if you ask me.

EDIT (2023-10-02T01:35Z): Do note that the link that I provided is for Synapse v1.37 -- Synapse is currently on v1.97. Curiously, the documentation for the new versions of Synapse have removed the sections talking about URL previews. I'm not sure what's up with that.

RT373YSQwMB+y28d7xm/Xybihcmx9jgkd4RskvPuoFQ3hapIv4exdmtMe+QxsVqos5odxTVuKAftj53zXFFQyD7MK0985zDvfKYjIj+b+8rNSAG0fArG2SXVBW0mLXqRnXiZXiknoPekyu7MKr1aD8k9DMQzCap60oNWmOLoCQXdmEetiEnhGL8zW2KR9P4MxtzxMzLzPWJyLmpLbXVJdxTmHFN32IvMHiyY29iJqZegmIuav0+IP2c3leGrJs75eGW2uWoj8J8VWWzflWfRRO3FwzJFRIvrptPN0osD0wMrgLJ4FYwXZQetIEJ99TxWvxqTYak90q6HxvVygOyHPw==

Indeed, it does. It can be overlooked, however. I added that info to my post, though. Thank you for the note.

AcN4ig5AQaP5RPDXd4zDkAmFvg+Xp65zI6i5ossToWdpV7Ad2r7s0UAn6TRKG5NbiBOvr+ZWk8fVS8abFcXGEmEp9axEG/BOxJVSMteDTjhf74fVmRbIxik8EpYR2FA5DXTK/r6nrxxiuTTak5kNUrSi2Bb4ebdFEEhrdikuDm68jjHiXsqOS2O4JYxUhhd0qrjnzaCAtiCr1KnqyR+9eEtUDv8nx8IvAnk/9EmzSnPxn5BinJYFjM3qEh3KYyqfY//d0brUQFkbKJmqn1KGdhmzZG7SUtZPsAozJSrVFHynavEwx6SIhxAbJYojQ10RjkYYXVQ10RNmB+NiPs1Zgg==

I was more referring to what entity is forming the request, not how the preview is generated from a technological standpoint.

I found this documentation which outlines the possible methods, but, from what I can see, it doesn't specify what one is actually used in practice. I was also unable to find any information in the Matrix spec.

Perhaps the next emergent entity is not corporeal, but, instead, of the collective. A good example could be similar to what @kozy138@lemm.ee stated about how the movements of people in crowds are, on the "microscopic" scale, seemingly random, and unpredictable, but, on the "macroscopic" scale, can be predicted quite accurately. One could look at economies, traffic flow, entire nations, etc. as emergent entities that rely on our individual, autonomous interaction. A very interesting such example is outlined in this paper which explains how "Online communities featuring ‘anti-X’ hate and extremism" can be accurately modeled using "novel generalization of nonlinear fluid physics".

The first two lines of the for loop,

byte upper_byte = input_bin >> 8;
byte lower_byte = input_bin & 0x00FF;

don't really accomplish anything. The first line is bit shifting to the right 8, and then you just bitwise and it resulting in the same thing. For example, starting with input_bin:

1000 0000 0000 0000
>> 8
0000 0000 1000 0000
& 0xFF
0000 0000 1000 0000

So, every time you go through a cycle of the for loop, you'll just start with the same values in upper_byte, and lower_byte. To sequentially output each shifted value, you'll instead want something like:

output_value = 0b1
for i = 1 to 16:
    latch(low)
    shift_out(output_value)
    latch(high)
    output_value = output_value << 1

That is, if I interpereted correctly that you want the shift registers to output the following:

output_count, upper_shift_register, lower_shift_register
1, 00000000, 00000001
2, 00000000, 00000010
3, 00000000, 00000100
.
.
.
16, 10000000, 00000000

Note: Lemmy has a bug where it doesn't format some symbols correctly, so the left angle bracket gets formatted as <. The same issue exists for the right angle bracket, the ampersand, and I would presume others.

Would you not want to shift out the upper byte first? I could be misinterpreting your setup.

It’s very very useful when looking for bugs to at the very least have a central search, I’ve encountered issues before which are filed against a completely different app than the one I’m encountering it in (usually because the issue is actually in a library that both use), which I would have missed otherwise. Having a single database also allows then moving bugs between projects in cases such as that without having to recreate it and linking the old one to the new one.

Perhaps a middle ground would be to organize individual repositories under an organization, like on github, where the organization has a global bug tracker, as well as each project.

Im generally on the side of reposting for archival and continuation.

Unless an instance has been built with the intention of archiving information, I don't think that it should be automatically expected that an instance would be in favor of archiving posts from other platforms -- there already exists services that archive internet data, and they are better equipped to do so. An instance should outline in their rules whether or not they support such types of posts.

This is Techrights (But with Jews!) – a satire site based on Techrights (But with Jews!)

It looks like the site is satire. But, I'll be honest, it initially had me fooled. How have we gotten to the point in society where one could come to the conclusion that it is perfectly possible for such an article to be unironically written?

I would vote nay for defederating from them. While I personally found their content annoying, someone else may actually find it uesful. I blocked the users, and the problem was solved. This issue may arise again, however, if more spam users pop up on these instances than a single user could reasonably be expected to deal with. This could possibly, again, be fixed by the user blocking the instance, but this would have to wait for user-blocking of instances to be implemented.

What bugs are you encountering with KDE Connect?