jagrsw

The ones under the Baltic (with the exception of some islands) are not 'critical', as in they're used for reasons (cost, latency, directness), but those reasons are not b/c there's no other way to connect to the Internet.

So, annoyance at most.

It's possible, but it's also important to be aware of the business side of things.

Valve makes a significant amount of money from in-game transactions, and some of their practices around this are shady. Issues like kids using their parents' CCs, gambling industry built around in-game items, and the potentially addictive nature of colorful virtual items marketed towards kids are valid concerns.

So, while gaben might be nice, it's unlikely that this gets in the way of Valve's drive to maximize profits in every way they can legally get away with.

I experienced the trust factor (banning, w/o banning officially) issues on my Linux CS:GO account in 2021, dropping to yellow and then red. This made it difficult to find teammates, as I was constantly matched with cheaters.

I discovered I wasn't alone, as many other Linux users with Radeon GPUs and 16GB+ VRAM were experiencing similar problems. We created a GitHub issue to track the problem and try to find a solution: https://github.com/ValveSoftware/csgo-osx-linux/issues/2630

After some investigation, we found that Valve was punishing Linux users with certain hardware configurations (radeon cards with >=16GB of VRAM, which were quite new at this time).

Eventually, after a user reached out to gaben directly, the issue was fixed: https://github.com/ValveSoftware/csgo-osx-linux/issues/2630#...

I suspect this was because Valve was preparing to launch the Steam Deck, and gaben wanted to ensure that Linux users had better experience with the device (just a guess).

It could be related to 14eyes with modifications (finland and ireland, plus close asian allies).

https://res.cloudinary.com/dbulfrlrz/images/w_1024,h_661,c_s... (from https://protonvpn.com/blog/5-eyes-global-surveillance).

Israel, Poland, Portugal and Switzerland are also missing from it

If we wanted to model the universe as a set of equations or a cellular automaton, how complex would that program be?

Could a competent software engineer, even without knowing the fundamental origins of things like particle masses or the fine-structure constant, capture all known fundamental interactions in code?

I guess I'm trying to figure out the complexity of the task of universe creation, assuming the necessary computational power exists. For example, could it be a computer science high school project for the folks in the parent universe (simulation hypothesis). I know that's a tough question :)

For gaming, RetroPie is a cool solution (it doesn't require raspberrypi).

I have a setup using HP Pro Mini 400 G9 that boots directly into EmulationStation. It's perfect for playing with my kid, covering everything from NES to more recent consoles, and also Steam and Minecraft (via https://github.com/minecraft-linux/appimage-builder/releases) if needed. The offline aspect of non-steam games is a big plus for easier parental management too.

I'm starting to wonder if the Linux networking stack has become a bit too layered.

I recently spent some time debugging a Wireguard tunnel on a VPS. Simple 'ip r sh' checks and tcpdump'ing weren't revealing the full picture, and it turned out an obscure 'ip rule' added by the VPS provided was redirecting the traffic to the loopback for reasons.

It seems like policy-based routing (via ip rule) adds an extra, opaque, layer before the regular routing table. The packet router (below routing) further complicates things.

Ages old (~2014 IIRC) defer implementation for gcc and for clang:

https://github.com/google/honggfuzz/blob/c549b4c31815e170d3b...

They can, pretty much like in the EU. There might be some technical differences, but overall it's both "right to work and stay if employed"

Leaving aside personal preferences regarding the previous Polish and current Hungarian governments, the electoral processes are generally viewed as fair regarding the absence of major direct fraud related to vote counting. However, the fact is, that the state resources were used by the ruling parties to promote themselves.

The removal of the former Polish government was largely driven by public disapproval of state fund mismanagement. In Hungary, a key element of the current government's platform appears to be the promotion of national identity, including ties with diaspora communities formed after WWI (The Treaty of Trianon), potentially with implications for future "geopolitical alignments" (the likelihood of which is debatable).

These results, while influenced by the d'Hondt system, reflect the sentiment of the voting population, which is a democratic process, in principle. The ruling methods are not 100% democratic though (rule of majority with respect for minority rights)

However, the opinions of my "more Western friends" on those topics "diverge from on-the-ground realities".

US conferneces don't bother with that aspect. Why should we put the onus on everyone else?

Chollet's shift in tone is interesting. As recently as 2022, he expressed strong skepticism about LLMs solving ARC-AGI within a decade. Now, he seems to suggest that significant progress on the challenge is possible within the next 1-2 years.

Of course, he strives to maintain a consistent public persona, but this shift strongly implies that o3's performance has significantly altered his views.

This field, much like economics, is full of experts who can convincingly explain why there were wrong :)

PS: ARC-AGI is a very well-though-out/interesting/useful test.

I don't believe a process reading from a pipe/socketpair/whatever can enforce such constraints on a writing process (except using heavy hackery like ptrace()). While it might be possible to adjust the pipe buffer size, I'm not aware of any convention requiring standard C I/O to respect this.

In any case, stdbuf doesn't seem to help with this:

  $ ./a | stdbuf -i0 -- cat

  #include <stdio.h>
  #include <unistd.h>
  int main(void) {
   for (;;) {
    printf("n");
    usleep(100000);
   }
  }

It's more accurate to say Russia's history as a distinct entity goes back around 850 years. Before that, it was part of Kyivan Rus', and the term "Ruthenian" primarily referred to the people and territory of modern-day Ukraine. Moscow Rus' was initially a peripheral, tribal offshoot of the larger Kyivan polity.

Classic playbook - aggressors always claim grievances: Japan and oil access, Germany and Prussia/Danzig extranational transport corridors, Russia and "oppressed comrades".

Tribalism is a powerful reality distortion force.

As a Pole by birth, I'm undoubtedly biased. However, it's not as simple as "Putin wants war, despite opposition from most Russians." Living near the USSR border and within the Soviet sphere of influence taught me that a vast majority of Russians prioritize a strong, assertive nation, often placing societal and economic development lower on their list of needs. If that means occasional invasions and killings, it's part of the game.

Putin may achieve 80%+ support through rigged elections, but even without rigging, it's likely 60%+. So, it's not a simple dichotomy of the Russian people versus Putin - it's more complex.

That said, I also have Russian friends (many now former Russians) who passionately hate the current government and condemn its actions.

Turning the Baltic into a "NATO lake" by controlling the Finland-Estonia strait would be an interesting idea, especially now with Finland and Sweden in the alliance. Effectively limiting Russian naval access from St. Petersburg (except for civilian traffic, subject to inspection) would certainly boost regional security.

Article on this recently: https://www.nationaldefensemagazine.org/articles/2024/7/10/b...

An effective retaliation option, I guess kept in reserve, "just in case" retaliation is needed.

https://xkcd.com/1058/ :)

Yes

The problem is something a bit else (jstarks figured it out somewhere below). I'm not a compiler/abi eng, but it seems to depend on a compiler, eg. consider this with clang-16:

  #include <sys/syscall.h>
  #include <unistd.h>
  #include <alloca.h>
  #include <string.h>
  
  void s(long a, long b, long c, long d, long e, long f, long g) {
  }
  
  int main(void) {
   long a = 0xFFFFFFFFFFFFFFFF;
   s(a, a, a, a, a, a, a);
   syscall(9999, 1, 2, 3, 4, 5, 6);
   return 0;
  }

Now, strace shows:

  $ strace -e process_vm_readv ./a
  process_vm_readv(1, 0x2, 3, 0x4, 5, 18446744069414584326) = -1 EINVAL (Invalid argument)

objdump -d a

  117f: 48 c7 45 f0 ff ff ff  movq   $0xffffffffffffffff,-0x10(%rbp)
  1186: ff 
  1187: 48 8b 7d f0           mov    -0x10(%rbp),%rdi
  118b: 48 8b 75 f0           mov    -0x10(%rbp),%rsi
  118f: 48 8b 55 f0           mov    -0x10(%rbp),%rdx
  1193: 48 8b 4d f0           mov    -0x10(%rbp),%rcx
  1197: 4c 8b 45 f0           mov    -0x10(%rbp),%r8
  119b: 4c 8b 4d f0           mov    -0x10(%rbp),%r9
  119f: 48 8b 45 f0           mov    -0x10(%rbp),%rax
  11a3: 48 89 04 24           mov    %rax,(%rsp)
  11a7: e8 94 ff ff ff        call   1140 <s>
  11ac: bf 36 01 00 00        mov    $0x136,%edi
  11b1: be 01 00 00 00        mov    $0x1,%esi
  11b6: ba 02 00 00 00        mov    $0x2,%edx
  11bb: b9 03 00 00 00        mov    $0x3,%ecx
  11c0: 41 b8 04 00 00 00     mov    $0x4,%r8d
  11c6: 41 b9 05 00 00 00     mov    $0x5,%r9d
  11cc: c7 04 24 06 00 00 00  movl   $0x6,(%rsp)
  11d3: b0 00                 mov    $0x0,%al
  11d5: e8 56 fe ff ff        call   1030 <syscall@plt>

Only 4 bytes are put on the stack, but syscall will read 8.

It's tricky if one doesn't control types of arguments used in vararg.

Just a friendly reminder that syscall() is a vararg function. Meaning, you can't just go throwing arguments at it (so maybe it's better to use this wrapper to avoid problems instead).

For example, on a 64-bit arch, this code would be sus.

syscall(__NR_syscall_taking_6_args, 1, 2, 3, 4, 5, 6);

Quiz: why

PS: it's a common mistake, so I thought I'd save you a trip down the debugging rabbit hole.

If Apple controls the root of trust, like the private keys in the CPU or security processor used to check the enclave (similar to how Intel and AMD do it with SEV-SNP and TDX), then technically, it's a "trust us" situation, since they likely use their own ARM silicon for that?

Harder to attack, sure, but no outside validation. Apple's not saying "we can't access your data," just "we're making it way harder for bad guys (and rogue employees) to get at it."

All C's native datatypes should be avoided for cross-platform data structures (networking, databases, file storage) because the standard only guarantees minimum sizes. Additional problem is the endianess.

uint64_t is a bit verbose, many re-def this to u64.

Yup, in one of eu countries i have it on my bill: it's ~0.10EUR/kWh electricity and additional ~0.15-0.20EUR/kWh for taxes + transmission + maintenance, IIRC

init7's post about overbooking is somewhat misleading. As their customer, I think it's more about how overbooking hurts them as a provider, not just us end-users.

I used to have a 10Gbps connection through Swisscom (Switzerland's de-facto main fiber provider) using XGS-PON. My internet service was from a third-party ISP, but the underlying infrastructure was Swisscom's. My speed tests consistently showed around 8Gbps up and down (10G minus XGS-PON overhead)

Init7's issue is that XGS-PON requires specific equipment and network access from Swisscom. Swisscom charges them for this, and it can also create other limitations (I remember problems with IPv6). With P2P fiber, init7 can connect directly to their own equipment in a local hub, giving them more control.

For most users, the occasional latency spikes or brief speed drops from 8Gbps to 1Gbps aren't a major concern - at least I never had serious problem with FPS games where latency matters.

I concede.

I agree. He's probably been conditioned by experience to speak with confidence until proven wrong ("strong opinions, weakly held"), but I don't like it either. Oh... the lost art of saying, "In my opinion."

The transmutation of uranium into plutonium and the synthesis of medically useful isotopes proceeds successfully.

> So is Sam Altman the modern day alchemist?

Alchemists were early scientists who later branched into fields like chemistry, mathematics, and physics (Newton explored alchemy).

Altman leads a team of experts in neural networks, programming, and HW design. While he might be mistaken, dismissing him outright is difficult.

Alchemists predicted the transmutation of metals into gold for centuries, and on a sunny day in the 20th century, it arrived (a bit radioactive, but still).

Unless the human brain is made of some sacred substance, the worst-case scenario is that we will extrapolate current scanning methods into the future and run the scanned model in silica. I'm not recommending this "just for fun," but the laws of physics don't forbid it.