Anders Pitman @anderspitman

@mitsuhiko @MoulikTweets With broad support for WHATWG streams in browsers these days, it's pretty straight forward to build your own websocket replacement. Just open long lived HTTP streams and implement a little framing. I believe this addresses most of your issues.

Rust is easy to learn. I've done it 3 or 4 times now

Some people might read this and think, that's just not my world, I am stuck in this world where software breaks all the time and everything I build is disposable. Even if that is kind of the case for you, there is still good news, because this isn't an all-or-nothing problem. It's a dial that can be turned; you can turn that dial in a direction that reduces flailing and results in more-stable long-term progress. You don't have to remove all the dependencies, because every dependency you remove contributes to stability. Even getting rid of 1/3 of your dependencies can do amazing things. You can look at all the things you depend on and divide them into two categories: major and minor. Major dependencies are things that, realistically, you are never going to have your own version of. I am never going to make my own graphics API, so those count as major dependencies for me (DirectX12, Vulkan, Metal, etc). I am not going to write my own CPU-side font rasterization, so anything I choose to use there (FreeType, stb_truetype) goes in that category. With Major Dependencies, you limit your contact surface with them: You call only the functions you really need, and you do this only from the surface of your program -- you don't build data structures deep into your program that propagate the particular data structures or API decisions of any of these systems. A good API author will help you do this (stb_truetype), a bad API author will be trying as hard as they can to screw you up and force you to become tied to their system forever (anything from Microsoft or Apple). Understanding that many API authors are hostile can cause a big change of perspective here, and once you see it, the correct tactics become much more obvious. So, that's the major dependencies. Minor dependencies are things that are smaller, and that you want to use much more thoroughly throughout your program: for systems programmers this might be a data structure like an expanding array or hash table, for Web, maybe there are some string or file operations that you like to do. Minor dependencies can be eliminated and it's not even hard. You just do one at a time: hey, I need this data structure, I have been importing this other code to provide that functionality, I have suffered X, Y and Z problems because of this, how about if I just implement my own simple version of this one thing? People can get scared of implementing core stuff like this, because they look at the implementation they are using now, and it looks huge and complicated and hard to reproduce. But the thing to realize is most of this implementation is spam. It is mostly doing things for people who are not you, for reasons you don't necessarily agree with, chosen by a decision-making method that is deeply flawed. Your own implementation can be cleaner and smaller, and it can give you good feelings when you go look at it. You don't need all the functionality of the thing you are importing; you only need 8% of the functionality. Implementing that is easy. Once you do this a few times, you have your own stable body of code that you bring with you from project to project. It won't break unless you mess with it. You can keep improving it if you want, incrementally over time, but the cost of this is small because this code represents stable algorithms that don't change with fashion, so work on this is never forced. Every big company has their own internal version of this, but the problem in that scenario is that a big company is full of people who want different things, and have varying levels of decision-making skill, so these usually end up not so good. But when it's your own personal thing, it can in fact be very good, and help make you happy on a daily basis. And, your software will break much less often. Which is great. @NotAShelf @ThePrimeagen x.com/Jonathan_Blow/…

@Hasen_Judi The sliding window is maddening. If you want to compile even a simple program that will work on relatively old systems, you have to compile on an old system. But if you go back too far your dependencies (including your compiler) are likely to not work.

Pre-configuring a Linux distro with good defaults is not going to save Linux. This is what Ubuntu was, and it worked for a while until it didn't. The problem with Linux desktop is API stability. It's not a proper OS because you can't just install and run programs on it unless you compile them from source along with all of their dependencies which you can only obtain from the blessed distro repository. Now if you had a way to build desktop programs that work on major distros as stand-alone binaries, then maybe, maybe, you can save Linux. Would be interesting if there was a GUI library in a language that can easily produce self contained binaries .. wink wink

@Hasen_Judi Oh interesting. Gio is my go-to for Go GUIs, but I didn't realize it was a good target for building other frameworks on top of.

@Hasen_Judi Nice! How's it compare to Gio?

@craigsdennis Thanks, it's back up now. What type of similar are you looking for. I've been working on more tunneling related stuff the last few years: github.com/anderspitman/a…

@alexellisuk @Hetzner_Online Are you running inlets on Hetzner?

I've been doing simulation and vfx studies for years and I must say, Bifrost MPM is just mind-blowing. The simulation quality and performance are on another level. and Yes, I think it's better than Houdini. Made in @AdskMaya and Bifrost, rendered with @arnoldrenderer

@deedydas The saddest thing to me about this is that chili chicken isn't a top 20 Indian food

Now you know why

Rclone is 12 years old today! Happy Birthday! Thank you to the whole rclone community for wonderful support over the years, and here is looking forward to lots of exciting new things coming to a release near you.

@forgebitz Why bother with google-auth-library? Doing full OIDC isn't much more code (or any more if you use a library) and lets you add other providers easily.

Didn’t expect Ben Affleck to have the most articulate and realistic explanation where video models and Hollywood is going

@johnrushx @dannypostma It is awful UX. But passwords are insecure and using social login sells your users out to big tech. Fortunately decentralized OIDC is becoming a thing and we might actually be able to have our cake and it it too in the near future.

@dannypostma Do you feel the same way about Email OTP or Magic Links specifically?

It's fascinating that one of the best libraries for implementing user authentication, Lucia, in the latest "release", turned out to be a guide on how to implement authentication from scratch. As the author (Pilcrow) explains, it's better to write it from scratch, which is not that hard, and use the guide as a reference. This way, you can build a highly customizable authentication that fits perfectly into your app. I'm building a dashboard with auth for @LocalCanApp, and I'm doing just that. It's a bit of a steep learning curve, but I'm absorbing a lot of knowledge and I'm sure understanding fundamentals like auth will pay dividends in the future. Plus, it's super interesting. Links below.

Video game logic 😭