• 8 Posts
  • 171 Comments
Joined 2 years ago
cake
Cake day: December 24th, 2023

help-circle

  • That’s fair. There are other ways to show emphasis, tone and stuff like that, but it requires text styling. Either way, there’s a fine balance to get between readability and writing style, but you can ditch either, depending on what you’re going for. Good luck!




  • The reason it’s like that is because if people want to use the same machine, but store different sizes of information (ex someone wants to store 5 bits, while another wants to store 24), 2^n is the best way to fetch that information quickly.

    For example, let’s say you have a memory that has as many sets as you want, but with only one bit in each set. I store information that is 2 bits of size. I can split the 2 bit information into two and store each bit in a set that’s one index appart. So if I wanted to read the information, I’d just read 0 and 1, 10 and 11, 100 and 101. This follows a rather simple pattern, where the leftmost bit to the one before the rightmost is the index of each information packet, and the rightmost just signals if it’s the first or the last bit of the packet.

    For example, if I have 11 01, the memory would look a bit like this:

    00: 1

    01: 1

    10: 0

    11: 1

    If I want to get the first packet , I just have to ask: what data has the leftmost bit to 0? We can add as many more information as we want, and it would still follow.

    If you were to send information with 3 bits of size, or any that isn’t a power of 2, you wouldn’t get an easy adressing pattern. If I were to send, for example, 101 110, I would get something like this:

    000: 1

    001: 0

    010: 1

    011: 1

    100: 1

    101: 0

    There is no pattern I can take out of the indexing of the memory to access the information. Where when I send an information that is 2 bits of size, I can take n-1 bits from the left and index it, I can’t do that for information that isn’t sent at 2^n (3, 5, 10, etc.)

    The sollution, of course, would be to have the memory sets be of size 3, but we’d run into the same “problem” if the information received is not base 3. Heck, we’d run into another problem that is similar, but is more hidden in the sets themselves rather than the indexing.

    Let’s say we want to put information that is 1 bit lenght in memory that has infinite sets that are 3 bits of length, and i put in 1 0 1 1

    0: 101

    1: 001

    I can’t easily put in a pattern either. If I want to get the second information ( index 1), I would have to do 1 / 3 to check if it goes in the first or second memory adress, then, i would have to do 1 % 3 to check what position it’s at. If I wanted to get the 4th information (index 3), for example, I would get 3 / 3 = 1, then 3 % 3 = 0, so second set, index 0. Granted, both operations are done in one division operation, but it’s still slower than just shifting bits.

    One could also just skip one bit if they receive 1 bit information with 3 bit sized sets. The memory would then look like this:

    0: 001

    1: 101

    You could then just access the nth information by taking the leftmost bits for the index of the memory, then the right most bit to see if you should take the first or the third bit. For example, I want to take the 4th information (third index, 11). 1, the left bit, is the index of the set, and 1, the right one, says we need to take the 3rd bit.

    This is better, but then we’d need to calculate how much space is given for different sizes of information. Four bits would have 2, 5 bits would have 1, 1 bit has 1. The formula here would indicate 3 - (n % 3) bits. That needs another modulo for it, so while accessing it is less of a problem, determining what space it needs requires another weird computation.

    A final example, putting 1 bit information in two bit sized sets gives us this ( with the same input as before )

    0: 01

    1: 11

    The third bit (index 10) can be accessed by taking set 1 (leftmost bits) at the position 1 (rightmost bit), which does give us the bit 1, the third bit of 1011.

    Now if we were to store information of size 3, we’d have to use the same technique as with storing 2 bits in 3 bits: adding spaces.

    Let’s say we want to store 011 101 in 2 bit sized sets:

    00: 01

    01: 01

    10: 10

    11: 01

    To determine the numbers of space, we have to do 3 % 2, but the operation % 2 is very easy to do for computers, since you just take the last bit (the rule follows for % 2^n: you take the last n bits). Next, if I want to access the second information (index 1), I just mutliply the index by 2 (easy to do for computers, since it’s just a bit shift), then take the current block and the block right after it. So 10 and 11, which give me 101.

    Keep in mind, this is only for machines that are made to use, as optimally as possible, any information at any bit sizes. If you have only 5 bit size information, there is no use for you to stick to a 2^n size, as you figured.

    This explanation was also me just pulling out counter-examples on the fly, and I’m not in the best of states, so if there are passages that seem a bit weird or don’t explain things very well, please let me know.

    Edit: formating








  • it’s close, but what your observation actually shows is their hypocrisy.

    most transphobia is caused by bioessentialism. people think that there’s something “inate” to you assigned gender/sex at birth. to them, that makes them special and fitting of a certain role.

    when you tell people that you can change genders, they freak out, because that means that the traits they think they have isn’t inherent to their gender at birth (being assigned a man at birth doesn’t make you manly inherently).

    this is why when you see a lot of terfs, for example, justifying why trans women aren’t women, they use things like the ability to give birth, having to take care of the household, primary/secondary sexual characteristics to justify themselves. they cling to the idea that afab people have something inherent that amab people don’t, so that they feel like they have those traits, and that it makes them better.

    Taking the example of a cis man that has feminine features and that hides it, because they feel insecure and need to prove their masculinity. There is nothing wrong with that, admit that you don’t lie to yourself, by saying that your “inherent masculinity” gives you more masculine traits that someone who’s afab could never have.

    TLDR: people who are insecure about their gender prop themselves up by attaching themselves to inherent traits that they think others could never have. anything that goes against that breaks their mind.