Intralexical

This is concerning to hear. What do Protobufs accomplish, that requires them to be a constantly moving target?

Virt manager drives me crazy because it hides the VM files in its own directory with permissions that aren't yours forcing you to use sudo to manually manage your own fucking vm files.

I just checked my `~/.local/share/libvirt/`. It doesn't do this for me, and I don't think it ever has.

I do remember having to set this up at some point. Looks like this is it:

https://unix.stackexchange.com/questions/799034/whats-the-di...

There are some limits around network ports in User Sessions, but it should suffice for anything you'd use Vagrant for.

Creating a new VM? You're forced to pick an OS by typing the name of your OS into a search box which is tedious and doesnt give you an option for generic x86 machine.

...There is though? It's in the dropdown under "Generic or unknown OS. Usage is not recommended (generic)". Here it is in the code if you don't believe me:

https://github.com/virt-manager/virt-manager/blob/c3df2ba/vi...

And a random tutorial which makes use of it:

https://cyberlab.pacific.edu/courses/comp178/resources/virtu...

By... plugging and unplugging antenna elements?

No. The antenna elements are always plugged in the same way. By sampling/introducing the signal at a different physical position on the lens (or multiple positions simultaneously), you create different physical distances and phase shifts for each element, and therefore a different beam direction.

...Apropos of nothing, this reminds me that a long ago, I played on a Minecraft server where one of the boys made a piston display with controlled by a pressure plate array. I was shocked by how he managed to transmit the signal with a simple wire. Maybe it was a similar idea, using the propagation distance...

Would capabilities enable granting access to specific programs and not just users? Like using AppArmor profiles. So QEMU, gVisor, Docker etc. can still use KVM for unprivileged users, but malware wouldn't be able to access it directly.

Because if /dev/kvm isn't accessible to unprivileged users, then people will start using `sudo` to run anything involving virtualization, which would be much worse for security overall.

If you monitored all the inputs simultaneously instead of switching, you could make a low-tech radio-wavelength camera. Presumably with less SNR per "pixel" than you'd get from monitoring just one input though.

It does do directional steering. No active array components or physical movement are needed.

If the output ports are connected to individual antennas in an antenna array, this allows shaping the beam in different directions by switching which input port the signal is sent to.

From TFA.

Presumably the geometrical shape of the lens is dictated by solving for useful phase shifts for different input points. Otherwise you could just use a bunch of delay lines.

I wonder if anybody's ever designed a 3D version of this. You might get a wider range of inputs, or more precise steering, by shaping the delays on a non-Euclidean (curved) surface (like a sphere or a saddle).

Plus heat dissipation is a limiting factor, which scales with area.

Literally none of the examples of large companies using it in the comment I replied to are game companies or using it for game debug menus.

Literally all of them are using it as part of non-user-facing debug tools for 3D graphics:

https://github.com/ocornut/imgui/wiki/Software-using-dear-im...

Meta as part of their VR/gaming division, Google in their VR division and 3D rendering engine, Ikea in a 3D material editor, and Intel in a 3D SDK.

And again, the intended use is immediately explained on the project repo no matter what the comment you were replying to said.

Looks like the rendering functions used in the demo are doing antialiasing without font hinting?

Additionally the developer of this library is active in the indie game scene, so "twelfth member of the team" is hardly a relevant issue.

I find it so unfortunate how many of the criticisms raised here are mooted by simply glancing at the README.

There's an interesting conversation that could be had about the needs and limitations for debug UIs, and how to balance that with minimal code. (E.G. Would feeding this library's text-and-rectangles output into an accessible renderer be enough?) But blanket rejections and reflexive judgement aren't helpful.

Any project that uses Dear Imgui for end-user applications has already made a bad design choice.

Note that any project using Dear ImGui will presumably have read the README for it, the second paragraph of which starts:

Dear ImGui is designed to enable fast iterations and to empower programmers to create content creation tools and visualization / debug tools (as opposed to UI for the average end-user).

I guess a lot of folks consider games exclusively for folks without those accessibility needs, so maybe that's why something like Dear ImGui can live for years in thousands of projects without anyone complaining about accessibility. But, I wouldn't consider it for anything that isn't specifically about graphics and I don't think anyone else should either. (No one has to listen to me, but I think less of them.)

Immediate mode UIs are mostly for debug menus, not even gameplay/graphics. It doesn't need to be accessible to anyone except for the developer(s) choosing the library and making the game. (If the developer has different needs, obviously they can choose another library, unlike users who must live with the developer's choice.) The fourth sentence in the linked ImGUI repository explains this intention very clearly.

You can spend all this energy imagining malice and thinking less of others, but doing so does not add merit to your critique. Nor does it advance the cause of software accessibility.

You've cherry picked a very specific example that is designed to run in 3d engines.

This post is about a minimal immediate mode library made by a game dev, most suitable for debug menus.

It's unreasonable to treat it as a platform for soapboxing about "the vast majority libs" that are unrelated.

The whole thing's less than 2kLoCs. If it needs ongoing maintenance, something's gone wrong IMO.

I think it's reasonable to just patch it yourself if it doesn't work with your other tools (Zig). Though thank you for sharing the heads up.

PNG compression is just DEFLATE. For archival storage, I've been expanding PNGs with `precomp` [0] and then running modern compression algorithms on them.

[0] https://github.com/schnaader/precomp-cpp

What's surprising is that while many submitters take that fairly well, some people get really indignant, essentially calling the maintainers ungrateful.

Why is it surprising that some people who expect results without spending any effort also feel entitled to receiving gratitude without putting in any thought?

They're basically light fields, so even though they don't represent any geometry, you could easily integrate them into the rendering pipeline at the path tracing/rasterization stage for Cycles/EEVEE.

I think the "right" way to do it without forking Blender would be to write an OSL shader. Though the way I personally would have done it would be to convert the splat into an angle-dependent Math Node tree for an Emission shader, probably automatically with a Python script.

Trouble is light fields don't block geometry, so they would effectively blend additively and you would see right through them like a hologram. Easy enough to fix though, with a dummy mesh to composite out the background. Or you could just render the splat separately outside Blender, and composite your scene on top of it.

I'm not sure why you would want to, though. The splats couldn't be lit by any of the lights in your scene, nor can they receive shadows cast by any objects in your scene, because they're precomputed light fields. Objects in your scene could be lit by the splats, but it's not immediately clear to me that it would be much more useful or better than just having photos on billboard planes.

I think there might be a misunderstanding that splats provide a way to compute realistic lighting. In reality, they're only a way to store and sample pre-computed or measured lighting AFAIK, hence the need for OP's big camera rig. So integrating them into scene lighting or skeletal animation doesn't really apply.

Since splats sample the light field after surface reflection, you can't do realtime shading with splats the way you can with raytracing and rasterization. I guess it could be animated like a holographic movie, but not like a video game and not like a 3D editor, because the light for all angles in all frames has to be precomputed.

With the obvious caveat that low-level game engine, image/video processing, numerical code etc. isn't really viable in Python. But outside of that, it's fast enough for gluing together other code that's doing the heavy lifting.

Generally you choose Python for the conciseness you mentioned, and then move the performance-critical functions into another language like C or (I find to be easiest) Cython. Ideally most of your code stays Python, and you either optimize self-contained pieces, or find library bindings that have done it for you.

A profiler like this can be used to identify which parts to rewrite in a faster language. Sometimes it's easier to write everything in Python first, then measure, than guess at the start which parts need to be fast.

You can also get gains by switching algorithms, both in pure Python and when using a compiled library like `numpy`. And there are also some operations, like string manipulation or the `sqlite3` module, where the Python runtime's implementation has already been optimized in a compiled language.

I have no idea if this is true, but I remember seeing in a Kurzgesagt video that developing phage resistance reduces antibiotic resistance, and vice versa. So you might corner bacteria by using both.

https://www.youtube.com/watch?v=YI3tsmFsrOg&t=5m18s

They've been constantly trying to set up P2P solutions. Torrents, DWEB, IPFS, Filecoin, WebTorrent, YJS, whole bunch of tech acronyms. I'm not sure much of it has really caught on?

https://blog.archive.org/tag/decentralized-web/

https://github.com/internetarchive/dweb-transports

Third-party attempt:

https://wiki.archiveteam.org/index.php/INTERNETARCHIVE.BAK

Turns out it's hard! Or maybe just too niche. But you can also help them today, by seeding some of collections that are available as torrents.

Can you share more about your time at the Canadian one? I feel like there was a big hullabaloo about it years ago, but it's not really clear what they do.

Do you know how examples work? Or methodology? The claim I made is that statistical accuracy percentage ≠ healthcare outcomes, and you will mislead yourself in dangerous ways if you believe a headline that implies they're interchangeable. Not that the model literally guessed common colds when the patients had... boneitis...

The lupus anecdote on its own is irrelevant to the whether the statistics are being interpreted in valid ways or not. Also, I said nothing about luck.

One experiment focused on 76 patients who arrived at the emergency room of a Boston hospital.

In one case in the Harvard study, a patient presented with a blood clot to the lungs and worsening symptoms.

That's a single anecdotal fluke from the study, which is misleadingly used to represent the headlining percentages.

If you read the linked paper, it says the LLMs did not outperform any group of doctors in the most important cases:

The median proportion of cannot-miss diagnoses included for o1-preview was 0.92 [interquartile range (IQR) 0.62 to 1.0], although this was not significantly higher than GPT-4, attending physicians, or residents.

And again, the bigger issue is that skimming nurse's notes and predicting the next tokens, as the study made the doctors do, is not how doctors diagnose medical conditions.

Not only is the study testing something which only vaguely resembles how doctors diagnose patients, but isolated accuracy percentages are also a terrible way to measure healthcare quality.

If 90% of patients have a cold, and 10% have metastatic aneuristic super-boneitis, then you can get 90% accuracy by saying every patient has a cold. I would expect a probabilistic token-prediction machine to be good at that. But hopefully, you can see why a human doctor might accept scoring a lower accuracy percentage, if it means they follow up with more tests that catch the 10% boneitis.

The search APIs are separate from the repository URLs, and the different distros' APIs need to be parsed in different ways. And before you ask, the search APIs have to be separate from the repositories, if you don't want to waste disk, network, and time keeping hundreds of local index files up-to-date every week.

They can't just be "configured" by changing a URL. I guess maybe you could self-host the search page for some of the distros, and reuse the parser, but are people really doing that? Otherwise, you'd have to write new code to parse the results, at which point you might as well soft-fork the script anyway.

Generally I advice against hard doing stuff that changes often and may need to be adjusted for different users or organizations.

YAGNI. And if your org does need it for some reason, you're probably better off running something specifically tailored for your own needs instead of whatever implementation makes it in.

The whole script's only 1300 lines. Would adding spending 150 lines on configuration and littering the user's dotfiles be worth it? Now what happens if the configuration's missing/corrupted? When you update the script, do you keep the old dotfile that might be using a deprecated API, or do you replace the old configuration and clobber any customization the user's done? Oops, there go another 1,000 lines, on edge cases, option flags, conf merging, warning messages... And good luck getting bug reporters to explain their configuration changes!

Also, this stuff doesn't "change often". The distros literally can't change it often, because doing so might break LTS stability. I know it's fun to point out perceived flaws in other people's work, but in this case, the URLs are tightly bound to the parsing logic, which is the right place to put them IMO.

Does it still work, though?

Where else would you put the repository domains?

I like the idea of fuel cells, but hydrogen's going to have an image problem as soon as people see the failure mode, if it's just being stored as H2 in compressed tanks. Liquid fossil fuels and electric batteries burn with a gradual flame. Hydrogen suddenly detonates, with a supersonic, shattering shockwave, if it's mishandled.

Even with Cold War money, Lockheed's famed Kelly Johnson couldn't make the logistics work for the CL-400.