elesiuta

Funny I started with switching my Debian/Ubuntu servers to Fedora coreos first, then that got me installing Bazzite on my gaming PC, and now I have some variant of Fedora atomic on all my machines.

I'm currently working on this [1] and can almost support this exact workflow. However the multiple agent orchestration is a sequential state machine, and other than network which can be set for tool states, filesystem access is still set only for the entire state machine.

[1] https://github.com/agent6-dev/agent6

> sandbox all filesystem operations and strictly limit ANY deletions outside of specified scopes, regardless of operating system

> enforce snapshotting of the entire repo on every operation for easy rollbacks and minimal lost work

These are some of the primary goals I had when creating agent6 [1] although I only plan on supporting Linux, and possibly Mac in the future.

> carefully consider a structure for presenting plans to the user where, rather than provoking immediate alert fatigue by asking for checks on every action, make structured plans which can be submitted to the user as a group of actions and reviewed and approved as a batch

I like this idea and may steal it! I already have something similar where questions are deferred while you're away and can be checked in batch upon return.

[1] https://github.com/agent6-dev/agent6

I'm working on a coding agent with built in sandboxing to restrict network access or filesystem access of commands run. It also has a few other interesting features I haven't seen in other agents and I'm currently focusing on polishing the UX across its cli, tui, and web ui. It's not quite ready for use yet and I've only recently begun dogfooding it. https://github.com/agent6-dev/agent6/

I also recently resumed working on picosnitch, a per executable network monitor for Linux. I rewrote the UI, ported the core from BCC to BPF CO-RE, and used AI to benchmark the completeness and accuracy of it. I let AI decide the tests entirely on it's own to hopefully eliminate any of my bias and published the results here [1]. It identified one gap I'll be fixing in the next release, and is currently the most complete and accurate bandwidth monitor on Linux.

[1] https://elesiuta.github.io/picosnitch/comparison/

Same here, I suspect the majority of people with average to small hands could never really one hand phones (with a good enough screen size) in the first place so it makes less difference to them.

> Otherwise, many of the best games are VR-additional that can be played flat as well, like Elite: Dangerous, DCS, or the racing games.

Also Skyrim VR was breathtaking, especially with mods to improve the scenery and clunky menus.

I really enjoy that roller coaster feeling both in real life, and in VR games like Jet Island and Windlands.

For reference I've been playing VR since my early 20s (now early 30s) and never once experienced motion sickness. I have tried every style of game/locomotion, both well polished and incredibly janky, and have had 6hr+ sessions without interruption.

I'm pretty interested in this and would like to participate in a study as well if given the opportunity. I think one of the potential causes and solutions is it being a self-fulfilling prophecy that may be overcome with self-efficacy as described here [1] for seasickness. My only evidence is that I never knew motion sickness was a possibility when I first tried VR, and my friends with the worst motion sickness were worried about it before they even tried VR, even if they never get seasick or carsick.

From the article and other comments, they also mention figure skating which I never thought of before, and I play ice hockey which is likely similar enough.

[1] https://psycnet.apa.org/doiLanding?doi=10.1037%2F0021-9010.8...

If they're on the same network, cross platform, open source airdrop alternative https://github.com/localsend/localsend

I use python more often than tools like awk, which I often forget the syntax of, so I made pyxargs to quickly run python code in the shell for small tasks like this

  sp current | pyxr -0 -g "(Artist)\s+(.+)\n(Title)\s+(.+)" -p "{3} by {1}"

Are you looking for something like a call graph?

There's pyan3 [1] which although doesn't support python 3.7+, I've still had luck with v1.0.4 which works better for me than its most recent version with python 3.11, but there can be some weird issues though depending on your code style.

A quick search also turned up crabviz [2] which has support for more languages than just python.

[1] https://github.com/Technologicat/pyan

[2] https://github.com/chanhx/crabviz

Great article, I've always been impressed by this too. It's neat that it sounds like even amateurs with nothing but a regular DSLR can contribute to this as well.

> By precisely timing the duration of the occultation from many sites simultaneously, they can refine their knowledge of the size and shape of the asteroid.

> Betelgeuse is the 10th brightest star in our skies (+0.5 magnitude), so observers need only modest equipment to participate.

> the easiest way to capture the event is to use a simple DSLR camera on a tripod ... video frames must have a short (few-millisecond) exposure time ... Millisecond accuracy timing is crucial ... [an app] for timestamping occultation observations is called Occult Flash Tag (Android) or AstroFlashTimer (iPhone)

Yep, and from my experience too (made a tool that monitors network traffic with eBPF [1]) in addition to those issues there is also a sizable latency hit.

[1] https://github.com/elesiuta/picosnitch

I think this is still reasonable, attackers may have a database of leaked keys (e.g. if you ever accidentally commited to GitHub, or ever ran a malicious script which uploaded it), which they then try on random servers.

I require both key and password to login, and have fail2ban rate limit password attempts.

This gives sufficient notice to fix things if a key were to become compromised.

I had the same issue and found floss picks worked well, but after a while the pins just became too worn. Thankfully my new phone has wireless charging.

You have to factor in the remaining life, so let's say 6 years since that's about how long they get updates for and are usable for most people.

$450 / (6-2) = $113

$1200 / 6 = $200

So you're paying 1.75x more for a better device, and without any unknown damage or wear. Migrating less often to a new device is also a small time saver.

Where I am the prices of used iPhones make no sense.

$1000 / (6-2) = $250

$1450 / 6 = $242

You are paying more for an old, used phone, and I don't see enough people using phones at the 7+ year mark for this pricing to make sense.

I thought the biggest issue wasn't with the models themselves, but how Zillow decided to apply and act on them, which is why it didn't work in practice.

So on average their predictions may have been pretty good, but since each transaction also depends on the other party to accept their offer, and whether they get outbid, most of their predictions where the offer actually goes through would be on the tail end of where they slightly overestimated the price.

This tweet from the article summed it up nicely

> Zillow made the same mistake that every new quant trader makes early on: Mistaking an adversarial environment for a random one. https://twitter.com/0xdoug/status/1456032851477028870

I was lucky to make and learn from that mistake pretty quickly with some algorithmic trading on much smaller amounts. With housing transactions being much larger and slower, you wouldn't learn this lesson until it was too late. Models never perform as well in practice as they do in theory, and you need to remember to account for both known unknowns and unknown unknowns.

> I too can never remember jq syntax when I need to. I usually just end up writing a Python script

Same here! That's why for small things I made pyxargs [1] to use python in the shell. In another thread I also just learned of pyp [2] which I haven't tried yet but looks like it's even better for this use case.

[1] https://github.com/elesiuta/pyxargs

[2] https://github.com/hauntsaninja/pyp

Thank you! My original use case was for running ffmpeg in directories with encodings that broke xargs, and later added the py/pyev flags which basically swapped subprocess.run() with exec()/print(eval()).

I didn't really highlight it in the documentation but it can also run commands in parallel as multiple windows in a multiplexer so it's easier to checkup on their progress or interact with them.

I have never heard of pyp before, looks neat!

I made something similar myself, pyxargs [1], which doesn't have all the magic of pyp, but although being geared towards more xargs like usage, it also functions somewhat similarly.

For example, although not as clean as the magic variables x, l or line, you can use '{}'

  ls | pyp 'x[:3]'  ==  ls | pyxargs --pyev "'{}'[:3]"

Overall the syntax of pyp looks much better, and the --explain feature is nice since pyp seems to do a little more for you under the hood (the closest pyxargs equivalent being --dry-run). I think I'll start using pyp myself when not running commands over multiple directories of files or in parallel.

[1] https://github.com/elesiuta/pyxargs

> weights of a model, that a domain expert can tweak by hand

This sounds similar to how image recognition was done before deep learning [1]

[1] https://www.youtube.com/watch?v=8SF_h3xF3cE&t=1358s

> "Games for Windows Live", which was so bad I don't even try replaying the games that still require it

If it's even still possible to install/activate them. Whenever any of them became available on Steam I would rebuy them there just for the convenience.

Similar to bandwhich, I recently created a snap of my own bandwidth monitor, picosnitch [1]. However I was only able to get it working with classic confinement due to there being no snap interfaces for fanotify or BPF kfuncs. Unfortunately this meant it couldn't be published on the store.

I already packaged it for nearly every distro, but unfortunately most don't have dash [2] in their repos so the user needs to install it separately, and I was hoping that snap would be an easier solution for that.

[1] https://github.com/elesiuta/picosnitch/blob/master/snap/snap...

[2] https://repology.org/project/python:dash/versions

Just added one now!

> ostree is what everyone should be using

I currently use Ubuntu for my server, and I see there's ostree in my repos, I haven't gotten around to trying it yet but I'd like to just start versioning my system as is with it. If that's too difficult/not possible to do, then I intend to switch my server over to Silverblue at some point because I really like the idea behind ostree.

Thanks!!! It'll probably still be a while till I can get started on this (if I do), but I just created a new repo for this here if you (or anyone else) wants to get started before me! https://github.com/elesiuta/conways-game-of-chess

That sounds like it could be fun! The multiple turn delay I used for this may help solve some of the problems of the pieces dying immediately at the start, and for the end game where too many deaths would cause the game to drag on. Births could probably have a smaller delay than deaths. I could see this make for interesting plays by opening holes in your opponent. There's also the choice of whether births/deaths take into account all neighbours or just your own pieces.

Probably, but if I continue this I'd add it to an existing chess client, or at least use something better than curses. I was actually planning to do this before sharing, but after sitting on it for a while I figured it was better to just get it out there.

I used curses simply because it was quick to experiment with since I had some similar code from another game I could reuse.

Thanks you're right, I am pleased this seems to be getting more attention than I expected so I moved it here https://github.com/elesiuta/conways-game-of-chess