Except that's not from the frame of reference of the photon. At the speed of light, the Lorentz transform shows that 1) Time stops completely, 2) All distances in the direction of travel collapse to zero. So in a very real sense, "from the photons perspective" it never exists and the point it is emitted from and the point it is absorbed at, are the same point.
Experiencing time and having mass are linked in a very deep way. Objects that experience time, i.e. have some kind of state evolution, must have mass, this is how we know the neutrino has mass even though it's smaller than we can measure, because we measure them oscillating between the various flavours of nutrinos.
This is also how the Higgs mechanism gives rise to "rest mass" in most particles, by constantly exchanging weak hypercharge with them. This oscillation back and forth gives them mass.
I participated in the most recent Bevy game jam and the community has a new tool that came out of Dioxus called subsecond which as the name suggests provides sub-second hot reloading of systems. It made prototyping very pleasant. Especially when iterating on UI.
Try writing Go without generics. No typed maps, arrays, slices, channels or function types. Only `interface{}`. Go always had generics, you just weren’t allowed to write your own until recently.
Because go doesn’t have exhaustiveness checking when initialising structs. Instead it encourages “make the zero value meaningful” which is not always possible nor desirable. I usually use a linter to catch this kind of problem https://github.com/GaijinEntertainment/go-exhaustruct
Nix has two types of derivations (builds). Input addressed, and content addressed.
An input addressed derivation’s hash is based on the the hash of all its input derivations and its own derivation. Therefore trusting the association between the cached binary and the derivation requires trusting the builder and a signature. All non-derivation inputs like source code, must be content-addressed.
A content addressed derivation can then be produced easily by rewriting all the derivations with `nix make-content-addressed`. This doesn’t require trust / signatures as every stage of the build is now content-addressed. The final hash could be confirmed through social consensus of multiple distrusting parties.
There’s nothing in theory stopping you from starting with a content addressed derivation other than it being a pain in the ass as you’d have to know the output hash before you built it, or TOFU (trust on first use) it which is then just the same as using the `nix make-content-addressed` approach.
I’m not sure why you think commit signatures are required. Git is content addressed, you can’t tamper with the derivations without changing the hashes and nixpkgs is primarily developed through GitHub. If someone has access to your SSH keys or GitHub account password it stands to reason they’d have access to your GPG keys too.
You’re confusing Outer Worlds with Outer Wilds, both confusingly released around the same time.
Outer Wilds is an indie game where exploration and knowledge is the entire point of the game. It unfortunately has zero reply value as once you’ve pieced together the mystery and how to end the game it’s over. I say unfortunately because it’s honestly the best game I’ve ever played and I sometimes wish I could receive just enough blunt force trauma so I could experience it for the first time all over again.
I really hate this kind of micro-analysis when it comes to health. The human body is really really complicated and getting fixated on things like oxalates is in direct contradiction to longer term studies on overall health that show that eating mostly plants is a good thing.
Go functions are coloured as well. context.Context proliferates everywhere IO takes place to handle cancellation / short circuiting because goroutines can’t be sent signals to die like threads. They have to exit themselves.
Folding Ideas released an excellent video essay recently examining the concept of the metaverse and how it suffers from somewhat of a “No True Scotsman Problem” https://youtu.be/EiZhdpLXZ8Q
That attitude assumes that the go standard library is the global maximum for Getting Stuff Done, and because of backwards compatibility guarantees ensures that it’s difficult to innovate on.
I think having a small standard library is actually a good thing because it encourages exploration of the space of possibilities.
For example Go’s stdlib http.HandlerFunc sucks, people instead opt for leaving it behind entirely in favour of Gin or trying to work around it with bad patterns like interface smuggling.
Not OP but at least for me, over time meat, dairy, etc become so deeply associated with the nightmare of industrial scale animal agriculture that they loose their aesthetic appeal. I know it’s surprising, and it happens slowly, but it happens.
Meaning is use. “Milk” is a fuzzy collection of properties and use cases. Which is why when you say “coconut milk” or “oat milk” people aren’t confused.
Hell, cows aren’t magic. Even “real milk” is just a collection of sugars, proteins, etc. If there’s no difference between the two then what’s the distinction?
> Go keeps my coworkers from writing code that's too clever for me to understand
Until someone whips out `import “reflect”`.
I’ve always found it confusing that people claim Go is simple when it contains runtime type reflection, which is hiding just under the surface of lots of the standard library like `json.Marshall`. Trying to explain to a new Go developer why []int isn’t assignable to []interface{} is always fun.
The phenomenon of “coloured functions” is usually derided because of the way it infects the call tree. In this sense context proliferation is the same phenomenon. Otherwise no one would really care about coloured functions.
> There has to be a better solution other than needlessly copying data.
Sorry I don’t think I explained myself very clearly.
What I’m saying is Rust allows you to optimise FP style patterns by replacing copying data with in place mutation because the control flow required for handling the flow of immutable data is also well suited to satisfying the borrow checker i.e. explicitly returning the data back to the caller. Because FP patterns can’t automatically communicate through shared mutable references they also lend themselves well to Rust but without the overhead of copying data because an in place mutation can be used instead.
> Not true in my experience. You would use context.Background in a test situation. It's also commonly used for short-lived applications like a CLI. You can see kubectl uses context.Background quite a lot:
My experience with Go is entirely within the context of API and microservice design where circuit breakers are very important which is why my experience with context propagation may be different than your own.
It’s also not surprising to see context.Background() used within tests because it’s being used precisely as I described above to “discharge the constraint” because you can’t propagate the constraint to the caller because test functions in go can only take one parameter `*testing.T`.
You’re correct that they’re fundamentally different things, I didn’t mean to draw a false equivalence between them.
The comparison I was trying to draw between them was the way they infect the call tree and usually demarcate impure functions.
When I said that context.Background() discharges the constraint I meant in the sense that the caller doesn’t need to propagate that argument to its caller as it can just pull a context out of thin air.
However I’ve seen a lot of new go devs confuse context.Background() for forking things into the background.
For what it’s worth, I think coloured functions are actually a good thing. If you’re following clean architecture or something similar coloured functions help you easily distinguish what layer in your application something belongs to.
Experiencing time and having mass are linked in a very deep way. Objects that experience time, i.e. have some kind of state evolution, must have mass, this is how we know the neutrino has mass even though it's smaller than we can measure, because we measure them oscillating between the various flavours of nutrinos.
This is also how the Higgs mechanism gives rise to "rest mass" in most particles, by constantly exchanging weak hypercharge with them. This oscillation back and forth gives them mass.