Currently my kids can only watch YouTube on a shared account on the TV. They haven’t been exposed to any of the gift stuff as far as I can tell but we do regularly weed the history and subscriptions to keep it vaguely on track. While each of the kids have their own favourite creators we also have found a number of educational and comedy channels we’ll watch with them on the account.

The bigger challenge comes with homework as once in secondary school the teachers regularly link to YouTube videos as an intro to a particular homework topic. Although their accounts are registered as kids accounts under our indirect control I keep having to move their pc out of the restricted group on the router because for some reason Eero prevents some videos from playing which from my point of view are fine. I dread to think what parents who aren’t comfortable debugging network failures do, probably drop restrictions all together in frustration.

I’ve got an Ampere workstation (AVA) which from a firmware point works fine. They may even fix the PCIe bus on later versions.

Asahi is a powerful example of what a small well motivated team can achieve. However they are still face the sisyphean task of reverse engineering entirely undocumented hardware and getting that upstream.

If you love Apples hardware then great. Personally when I have Apple hardware I just tweak the keys to make it a little more like a Linux system and use brew for the tools I’m used to. If I need to I can always spin up a much more hackable VM.

Arm has been slowly pushing standardisation for the firmware which solves a lot of the problems. On the server side we are pretty much there. For workstations I’m still waiting for someone to ship hardware with non-broken PCIe. On laptops the remaining challenge is power usage parity with Windows and the insistance of some manufacturers to try and lock off EL2 which makes virtualization a pain.

You have to ignore the obsequious optimism bias LLM’s often have. It all comes down to their training set and if they have seen more than you have.

I don’t generally use them on projects I’m already familiar with unless it’s for fairly boring repetitive work that would be fiddly with search and replace, e.g. extract the common code out of these functions and refactor.

When working with unfamiliar code they can have an edge so if I needed a simple mobile app I’d probably give the LLM a go and then tidy up the code once it’s working.

At most I’ll give it 2 or 3 attempts to correct the original approach before I walk away and try something else. If it starts making up functions it APIs that don’t exist that is usually a sign out didn’t know so time to cut your losses and move on.

Their real strengths come in when it comes to digesting large amounts of text and sumerising. Great for saving you reading all the documentation on a project just to try a small thing. But if your going to work on the project going forward your going to want to invest that training data yourself.

They can be helpful when using a new library or development environment which you are not familiar with. I’ve noticed a tendency to make up functions that arguably should exist but often don’t.

Sometimes I get an LLM to review a patch series before I send it as a quick once over. I would estimate about 50% of the suggestions are useful and about 10% are based on “misunderstanding”. Last week it was suggesting a spelling fix I’d already made because it didn’t understand the - in the diff meant I’d changed the line already.

What do the inputs and configuration drop down menus say?

I thought CoPilot was just a rebagged ChatGPT anyway?

It’s a silly experiment anyway, there are very good AI chess grandmasters but they were actually trained to play chess, not predict the next word in a text.

I remember the old ADSL modems where effectively winmodems. I had to keep a Windows ME machine as my household router until the point the community had reversed engineered them enough to get them working on Linux.

At least they where usb based rather than some random card. I think the whole driver could work in user space.

Seems fair enough, these things cost money and the #BBC is in a race to diversify it’s income in preparation for the license fee going away. The dynamic description sounds like they want to preserve the casual visitors experience of an open site.

I get ads on my BBC podcasts when I’m abroad. I assume that’s all part of it.

VirtIO was originally developed as a device para-virtualization as part of KVM but it is now an OASIS standard: https://docs.oasis-open.org/virtio/virtio/v1.3/virtio-v1.3.html which a number of hypervisors/VMM’s support.

The line between what a hypervisor (like KVM) does and what is delegated to a Virtual Machine Monitor - VMM (like QEMU) is fairly blurry. There is always an additional cost to leaving the hypervisor to the VMM so it tends to be for configuration and lifetime management. However VirtIO is fairly well designed so the bulk of VirtIO data transactions can be processed by a dedicated thread which just gets nudged by the kernel when it needs to do stuff leaving the VM cores to just continue running.

I should add HVF tends to delegate most things to the VMM rather than deal with things in the hypervisor. It makes for a simpler hypervisor interface although not quite as performance tuned as KVM can be for big servers.

No the Apple hypervisor is called hvf, but projects like rust-vmm and QEMU can control and service guests run on that hypervisor. No KVM required.

virtio-gpu with Vulkan pass through for the VM with a Vulkan to Metal translator in host user space. There are various talks about this including at KVM forum: https://kvm-forum.qemu.org/2024/The_many_faces_of_virtio-gpu_F4XtKDi.pdf

Minecraft bedrock edition. There is a native project called mcpe loader but that does break occasionally because of the way it’s done. The waydroid approach is pretty rock solid.

Care needs to be taken with big orgs like the NHS to not try and boil the ocean with massive IT systems. Concentrating on open interoperability standards allows for smaller more flexible contracts and the ability to swap out components when needed.

Open source licences would be the ideal default although at a minimum the purchasing org should have a licence that allows them (or subcontractors) to make fixes without being tied to the original vendor.

The other option is to use VirtIO with Native Context support as a software based partitioning scheme that is relatively lightweight compared to the mdev approach.

The kernel on GitHub is just a mirror - the primary source is on kernel.org

Not just that - modern Androids compile apps in a VM these days to reduce the attack surface of the compiler. You can also push other services into VMs that support the main image. You could even push some vendor drivers into VMs and help keep the main kernel less of a vendor fork fest.

FLOSS projects can only be sustainable if their are enough shared interests able to support it through contributions of all kinds. Fortunately the code is free so that constellation of support can change over time. It’s a shame this particular line of government funding is coming to an end but others can help.