Stavros Korokithakis

Huh, sure, I'll write something up today! You can subscribe to https://stavros.io to get an email (there's a form under each article).

I use Netlify for all my static sites and it's been amazing. All I have to do is push and they take care of everything else, I can't understate how much I love the product. If you want to check out a live deployment, my website https://www.stavros.io/ is on Netlify. I especially like how they provide forms, lambdas and very easy testing by just pushing to another git branch. I don't see why anyone would use Github/Gitlab pages when Netlify exists.

Perhaps, there's a small change that might work better here - if we use a different agent (by creating custom agents) for plan and implementation, then the switch to the implementation agent wouldn't end up re-reading a lot as the new agent would have fresh empty context. I implemented this[1] from one of the posters on HN and I think it'd work well with this problem too. Would be great if you could point out if my understanding is wrong. [1]: https://www.stavros.io/posts/how-i-write-software-with-llms/

Somewhat related is stavros's method to compress 500KB to something like 50 bytes https://www.stavros.io/posts/compressing-images-with-stable-diffusion/ main drawback is that it's not lossless ;-) but this is great. I hope this actually becomes a format that wraps the weights and transformer module (maybe this can also be NAS-optimized too?). Maybe it would even work for video? It's like calling gzip but instead of compression level you choose kolmogorov complexity level

stavros is one of my favourite posters on HN, and the writing on his site is full of beautiful turns of phrase like that. > The Timeframe is a beautiful, battery-powered, high-resolution e-ink device that sits on my desk and reminds me of the inexorable grind that saps my creativity and drains me of the will to live. From https://www.stavros.io/posts/making-the-timeframe/ edit: Ever since I read the Timeframe article I've been itching to do the same thing myself, but I suck at these things so worry that I'm just going to end up with more piles of electronic parts in my cupboard of broken dreams.

I love these sorts of projects. This is a really slick integration. Another similar project: https://www.stavros.io/posts/irotary-saga/

"Can anyone recommend a Linux (preferrably cross-platform) tool like this which is appropriate for use in personal laptops?" I think you should look into the 'borg' backup tool - it has become the de facto standard for remote backups because it does everything that rsync does (efficient, changes only backups) but also produces strongly encrypted remote backup sets that only you have a key to ... the remote has no access to the data. The borg website is here: https://borgbackup.readthedocs.io/en/stable/ and a good description of how it works and why you should use it is here: https://www.stavros.io/posts/holy-grail-backups/

I used the Stavros one: https://www.stavros.io/posts/how-to-configure-wireguard/ Great to see 1.0.0 released. I’ve been using it for a VPN to my home network and have been really impressed with how fast it is (and how fast it connects!). The corporate VPNs I’ve used in the past we’re so much slower that it feels like a completely different league, although they support many more features of course.

I'm probably not the target audience but I'd say that it's usable but still not very straight forward to set up. Yes it has less options than OpenVPN but with a bunch of tutorials I was usually able to get OpenVPN set it up and have my traffic flow through it in 30 min. Following tutorials like this https://www.stavros.io/posts/how-to-configure-wireguard/ (which seems like a good one from a fellow HN user) always seems to work that I'm able to connect to the server but my internet doesn't work after running it. Probably something related to the IP tables rules or firewall I assume? I'm using the official mac client and Ubuntu 18.10 running on a server at OVH.

OP here. Just to clarify, because I see a lot of congratulations. I just shared the project, I'm not the author. Based on the GitLab project, the author seems to be @stavros: - https://gitlab.com/stavros/Spamnesty - https://twitter.com/stavros - https://www.stavros.io/

From part one[1] (which I'd recommend reading): > Sometimes it will miss a number, as these phones aren’t 100% accurate, and there’s no way to know what you dialed, because there’s no screen. I know, how did we even manage to stay alive back then? If you botch a number, you’ll have to hang up and redial. Does anyone remember this with rotary phones? I was pretty young when they were still in use, but I don't remember this being an issue. [1]: http://www.stavros.io/posts/irotary-part-one/

This is great need to figure out a good way to do request verification maybe to ensure the request it properly signed. Update: this looks like a good article describing a verification scheme http://www.stavros.io/posts/writing-an-nginx-authentication-module-in-…

These are fantastic! I'll add two that I have learned from wiser people, and that have paid out again and again in my life. 1. It's better to target an interesting constellation than one specific star. If you're pushing yourself reasonably hard, you're working close to the limits of your ability, and so there's some chance you will fail. If you go all out to hit an ambitious goal and don't succeed, you're likely to feel burnout [1]. This is much less likely if you make moves in the direction of an interesting area using a cluster of subgoals instead. This diversifies your risk, plus it's easier to adjust as you move in that direction and learn more. (For people in ML there's some clear parallels with the gradient descent process) 2. A twenty minute walk in the park with no music or media makes all kinds of useful stuff naturally fall out of your brain, and you get some light exercise and sunlight / vitamin D at the same time - which also helps improve your mood and flush out anxiety etc. [1] https://www.stavros.io/posts/comment-causes-burnout/

I don't currently see a 500 ms difference, so maybe they figured something out. From my shell, I see about 35 ms to http://www.stavros.io/404 and about 85 ms to https://www.stavros.io/404 (the HTTPS site serves actual content and the HTTP a redirect, which confounds the numbers). The HTTPS server is currently offering me a 4096-bit-RSA certificate, signed by the 2048-bit-RSA StartCom class 1 intermediate CA. There's no security benefit in a 4096-bit cert signed by a 2048-bit one, since any attacker capable of breaking 2048-bit RSA but not 4096-bit is just going to attack the CA cert and sign their own forged cert (and any attacker sorta capable of breaking 2048-bit RSA will dedicate their brute force effort to CA certs). And to my knowledge, all current CA intermediate certs are 2048-bit. Meanwhile, because of math, 4096-bit certs take a lot longer to handshake: see e.g. https://certsimple.com/blog/measuring-ssl-rsa-keys CertSimple's data indicates a 25 ms difference between 2048-bit and 4096-bit keys on their server, so I'd expect that the 4096-bit key is responsible for at least most of the performance difference here. A few years ago I screwed this up on a production shared web host, and I believe we saw a greater than 50 ms difference. (While we're at it, that cert is SHA-1, so it's possible they can get a reissue for free.) Were you able to replicate the 500 ms (!) performance difference on your own server? Are you using a 2048-bit cert and reasonable cipher suites?

I'd say this is more up to date: https://www.stavros.io/posts/u2f-fido2-with-ssh/ We've got private Git repos only accessible through ssh (and the users' shell is set to git-shell) and it's SSH only through Yubikey. The challenge to auth happens inside the Yubikey and the secret never leaves the Yubikey. This doesn't solve all the worlds' problem (like hunger and war) but at least people are definitely NOT committing to the repo without physically having access to the Yubikey and pushing on it (now ofc a dev's computer may be compromised and he may confirm auth on his Yubikey and push things he didn't meant to but that's a far cry from "we stole your private SSH key after you entered your passphrase a friday evening and are now pushing stuff in your name to 100 repos of yours during the week-end").

Jujutsu comes in handy here for the same usecase: https://github.com/jj-vcs/jj https://www.stavros.io/posts/switch-to-jujutsu-already-a-tutorial/ Also found https://github.com/gitbutlerapp/gitbutler

The "GSM shield" (https://www.stavros.io/posts/irotary-saga/#:~:text=GSM%20shield) link target was likely hijacked, you might want to replace it with a snapshot (https://web.archive.org/web/20150524if_/www.gsmlib.org/).

Passkeys are stored within your device, iPhone, Android, browser, or system keychain. https://passkeys.directory/ https://www.stavros.io/posts/clearing-up-some-passkeys-misconceptions/ https://support.apple.com/en-us/102195

Yup, this is a bit of a battery hog... another person posted a similar project using epaper, this should be able to get you days of battery life https://www.stavros.io/posts/making-the-timeframe/

Since OpenSSH >=8.2 you can use FIDO2 and security keys. See https://www.stavros.io/posts/u2f-fido2-with-ssh/

https://www.stavros.io/posts/u2f-fido2-with-ssh/ goes over using FIDO2 devices with ssh, including storing the secret keys on the hardware. In that sense the passphrase becomes the second factor I guess.

This one had quite a lot of background, but also the needed commands: https://www.stavros.io/posts/u2f-fido2-with-ssh/ With a properly set-up token, basically you only need 2 commands: ssh-keygen -t ed25519-sk -O resident -f ~/.ssh/id_mykey_sk ssh-add -K I used a Yubikey and needed also to install 'ykman' to set a PIN for my token, otherwise ssh-add kept failing. Dunno if I omitted something for a proper setup for my token initially, but I don't think that was a problem with OpenSSH in particular. Apart from the small headache with the PIN, the whole thing was almost magical in its simplicity.

Another happy rsync.net/borg customer here, found through a blog post [1] which also contains some quick instructions. [1] https://www.stavros.io/posts/holy-grail-backups/

My guess is that the project he's referring to is IMGZ (found via his HN profile then his twitter) You can read more about that here: https://imgz.org/ In addition, he has a page on his site with some really cool personal projects: https://www.stavros.io/projects/

I mean still do the long exposure as you're doing for your stills. And use say, 25 long exposure photos per second for the video. But make the patterns animated, so for example with https://www.stavros.io/posts/behold-ledonardo/maria-small.jpg you could have the light appear to rotate around the lady. I imagine it'd be extremely slow work, creating enough photos though!

Stavros' original discussion that lead him to start this: https://www.stavros.io/posts/towards-more-collaborative-oss-model/

https://www.timdoug.com/log/2018/08/04/#wireguard_macos https://www.stavros.io/posts/how-to-configure-wireguard/ should be sufficient to help you set it up.

While it works well, Duplicity is rather slow and only supports expensive full-incremental-full backup cycles. Modern incremental-forever backup tools like borg[1] (fork of Attic[2]) are much faster since they are based on block hashing, which also gets you deduplication for free. Basically, a backup is a set of hashes - this means that you can selectively delete or retain old backups without having to merge them. I built a >50 TB enterprise backup cluster with borg and it works extremely well. [1]: https://borgbackup.readthedocs.io/en/stable/ [2]: https://www.stavros.io/posts/holy-grail-backups/

The API gateway approach has a lot of the upsides you mention: 1. http://microservices.io/patterns/apigateway.html 2. https://getkong.org/ (a few auth plugins) 3. https://github.com/auth0/nginx-jwt / https://www.stavros.io/posts/writing-an-nginx-authentication-module-in…

If you really wanted it to work like a file system, you could write a passthrough FUSE module which pipes files through GPG before writing to the underlying file system. This seems like a good start: https://www.stavros.io/posts/python-fuse-filesystem/