I have never really worked with pytorch professionally, but it feels to me a lot of the open source, especially generative oriented projects, just use pytorch like this. It makes hacking on the models a whole lot easier.

comfyui is a good example of a project like this.

Its original name was WanX, but the gen ai community found that to be too funny / unfortunate, so they changed it to just Wan.

It’s probably a more appropriate name to be fair.

game math libraries often have this (and glsl gpu shader language), like "2 * vec3(1,2,3)" results in "vec3(2,4,6)"

There are other cases like adding vectors to matrices and so on, but in the end this logic is defined in some custom add operator overload on a class or object in the language.

(I had no idea what it meant either until i searched for examples..)

I've been using it for a few years now and I still feel a little confused, but asking llms explain nixos has been immensely helpful.

If I'm feeling really lazy, I just ask claude to generate the specific nix code for whatever I need that doesn't work or exist in nixpkgs.

Yes, nix + LLM solves all the issues i had with it.

When I wanted to get into aquariums, I stumbled upon some old man calling himself "father fish"

Basically his take on the whole hobby is that we should stop measuring, changing water and generally stressing about keeping the system as is.

Instead you create a good substrate, add lots of plants and just watch how life will evolve. Fish and plants might die, but that's ok because it's part of the natural process.

I've seen countless analogies that explain the size of space, but this was really something else. Especially how frustratingly slow the speed of light felt.

This is my experience too most of the time. Though sometimes it does work, and sometimes a solution is found that I never thought of. But most of the time I have to change things around to my liking.

However, a counter argument to all this;

Does it matter if the code is messy?

None of this matters to the users and people who only know how to vibe code.

> Does it matter if the code is messy?

It matters proportionally to the amount of time I intend to maintain it for, and the amount of maintenance expected.

I find that these complex types often reflect the underlying complex code. This usually happens when you interact with something that is explicitly written for javascript and takes advantage of its dynamic nature. (usually the base javascript api)

window.addEventListener(event, callback), dispatchEvent(event) and removeEventListener(callback) is a good example. In a dynamic language, this api is at least unsurprising. It's easy to understand.

In a typed language, although strategies could vary, one would probably not write the api like that if you prefer to have simpler types.

Something like this would make more sense in a typed language:

import { onChange } from 'events'

const event = onChange.Add((event) => {

})

event.Remove()

// ..

event.onChange.Dispatch({value: "1,2,3"})

I guess some people just want to doom, but after getting into stocks late in life, I can't shake the feeling that some do it for a purpose.

I was trying to find out of this is still the case.

How did you reach that conclusion?