Skip Navigation
InitialsDiceBear„Initials” ( by „DiceBear”, licensed under „CC0 1.0” (
Posts 1
Comments 217
France Is Headed Towards Its Most Feral Right-Wing Regime Since the Nazis
  • Isn't "turning right" the main political theme across the world now? It's not just France.

    But I will still put a disclaimer here that I am not French, just sharing my view since it seemed to be that most countries including mine are, ultimately, having the same problem. Feel free to correct me! Here goes:

    I think, the general reason for this right-wing surge ultimately boils down to economics. People are obviously not satisfied with their current quality of life - see e.g. housing prices. Many blame it on things such as outside migrations or the geopolitical enemy of their country, etc etc. This is a hotbed for conservative-leaning mindsets.

    Those factors I mentioned could have played a hand in this problem, but my opinion is that the biggest issue lies in unequal wealth distribution across the globe. That's why the GDP is growing, but people's standard of living (except for a minor few) is not. People directed their unhappiness at the wrong thing.

  • Basically the extent of my IPv6 knowledge
  • I use IPv6 exclusively for my homelab. The pros:

    • No more holepunching kludge with solutions like ZeroTier or Tailscale, just open a port and you are pretty much good to go.

    • The CGNAT gateway of my ISP tends to be overloaded during the holiday seasons, so using IPv6 eliminates an unstability factor for my lab.

    • You have a metric sh*t ton of addressing space. I have assigned my SSH server its own IPv6 address, my web server another, my Plex server yet another, ... You get the idea. The nice thing here is that even if someone knows about the address to my SSH server, they can't discover my other servers through port scanning, as was typical in IPv4 days.

    • Also, because of the sheer size of the addressing space, people simply can't scan your network.

  • JavaScript
  • This is why I try my damnedest not to write in weakly typed languages.

    string + object makes no logical sense, but the language will be like "'no biggie, you probably meant string + string so let's convert the object to string"! And so all hell breaks loose when the language's assumption is wrong.

  • It's easier to remember the IPs of good DNSes, too.
  • I have a 64-bit computer, it can address up to 18.4 exabytes, but my computer only has 32GB, so I will never use the vast majority that address space. Am I "wasting" it?

    You are using the addressing bits in the form of virtual memory. Right now. Unless you run a unikernel system, then in that case you could be right, but I doubt it.

    Anyway, this is apples and oranges. IP addresses are hierarchical by design (so you have subnets of subnets of subnets of ...), memory addresses are flat for the most part, minus some x86 shenanigans.

    Yes they are all "used" but you don't need them. We are not using 2^128 ip addresses in the world.

    But we do need them! The last 64 bits of your IPv6 addresses are randomized for privacy purposes, it's either that or your MAC address is used for them. We may not be using those addresses simultaneously but they certainly are used.

    Despite that, there still are plenty of empty spaces in IPv6, that's true. But they will still be used in the future should the opportunity arise. Any "wastage" is artificial, not a built-in deficiency of the protocol. Whereas if we restricted the space to 40 bits, there will be 24 bits wasted forever no matter how.

  • It's easier to remember the IPs of good DNSes, too.
  • You're not "wasting" them if you just don't need the extra bits

    We are talking about addresses, not counters. An inherently hierarchical one at that (i.e. it goes from top to bottom using up all bits). If you don't use the bits you are actually wasting them.

    you can gradually make the other bits available in the form of more octets

    So why didn't we make other bits available for IPv4 gradually? Yeah, same issue as that: Forwards compatibility. If you meant that this "IPv5" standard should specify compulsory 64-bit support from the very beginning, then why are you arbitrarily restricting the use of some bits in the first place?

    If you're worried about wasting registers it makes even less sense to switch from a 32-bit addressing space to a 128-bit one in one go

    All the 128 bits are used in IPv6. ;)

  • It's easier to remember the IPs of good DNSes, too.
  • Every time there's a "just add an extra octet" argument, I feel some people are completely clueless about how hardware works.

    Most hardware comes with 32-bit or 64-bit registers. (Recall that IPv6 came out just a year before the Nintendo 64.) By adding only an extra octet, thus having 40 bits for addressing, you are wasting 24 bits of a 64-bit register. Or wasting 24 bits of a 32-bit register pair. Either way, this is inefficient.

    And there's also the fact that the modern internet is actually reaching the upper limits of a hypothetical 64-bit IPv5: Do we want to spend yet another two decades just to transition to a newer protocol?

  • It's easier to remember the IPs of good DNSes, too.
  • Tell that to your ISP which has fucked their IPv6 deployment up. In my experience IPv6 is actually faster since it bypasses the IPv4 CGNAT.

    On busy days my IPv4 connection can get as slow as 15KB/s, now that's trash.

  • It's easier to remember the IPs of good DNSes, too.
  • Our network architecture has the tendency to waste IP addresses. A subnet may have 10 devices but have 256 IPs (e.g. a /24 network like to - that's 246 wasted addresses. This wastage is kinda unavoidable since we'd need to keep our routing tables from being too fragmented.

    With that in mind it is entirely possible for 64-bit addressing space to not be enough, unless we revert to methods like NAT which come with their own disadvantages.

    We have already used up about one /11 block of the IPv6 internet. That's 128-11=117 bits. If we replace the standardized /64 subnets of IPv6 with old /24 subnets typical in IPv4 networks, you get 61 bits. That's dangerously close to the upper limit of a hypothetical 64-bit IPv5 internet.

  • Today, it has been 6 years since The Elder Scrolls 6 teaser
  • Indeed. I would love to have a "modernized Morrowind" experience -- an RPG game that really nails the role-playing part of RPG, but without the cheesy parts of Morrowind like the unintuitive combat system -- but all of us know that it's just not gonna happen.

  • Roses are red, violets are blue, everyone is using IPv6, why aren't you?
  • Were I really strawmanning you? Is "I never even implied the opposite" really true? Quote:

    So, really, you were "correcting" me for you and your specific setup

    Yeah, my "specific setup"... which can be found in virtually all routers today.

  • Roses are red, violets are blue, everyone is using IPv6, why aren't you?
  • Oh come on, are you seriously suggesting that default-deny stateful firewall is not the norm??

    Holy. Fucking. Shit. Indeed.

    You keep on suggesting to me that you really have no idea how networking works. (Which is par on course for people thinking NAT == security, but I digress)

    Let me tell you: All. Modern. Routers. include a stateful firewall. If it supports NAT, it must support stateful firewalling. To Linux at least, NAT is just a special kind of firewall rule called masquerade. Disregarding routers, even your computer whether Linux (netfilter) or Windows (Windows Firewall) comes built-in with a stateful firewall.

  • Can I make Result<T, E> an integer?

    For context: I am trying to write a Rust wrapper over a C library.

    Like many C libraries, most of its functions return an int. Positive return values are meaningful (provides information) and negative values are error codes.

    To give an example, think of something like int get_items_from_record(const struct record *rec, struct item *items). A positive value indicates how many items were returned. -1 could mean ErrorA, -2 ErrorB, and so on.

    Since this is Rust, I want to represent this kind of integer as Result<T, E>, e.g.:

    ```rust enum LibError { A = -1, B = -2, // .... }

    // LibResult is ideally just represented as an integer. type LibResult = Result<NonNegativeInteger, LibError>;

    // Then I can pass LibResult values back to the C code as i32 trivially. ```

    Is there a way/crate to do this?