fartsucker69

the current thinking is no because quantum fields still act within spacetime, which is curved by gravity. there could be no particle that exists outside of this, so every particle has to interact gravitationally.

but obviously, this is a concept from general relativity which is currently not compatible with quantum field theory at all. for the purposes of QFT every particle exists within some magical separate space where all those considerations are ignored because nobody really knows how to incorporate them without breaking predictions.

well the correct theory will have to explain what we actually observe, which is going to limit the nature of what these theories can be. I'm not sure if you have an example of something that should be accepted when it's currently not, but usually that's the case when something is clearly broken with regards to basic facts we already know to be true.

I can accept that in extreme cases people just don't run across the trivia of what a modulo operator does by more or less random coincidence (while learning programming that is. I get that most people in general would have no idea).

But for conditionals and related logic in whatever nested form they may appear, I'm afraid my ability to disbelief is stretched a little too thin. It seems too basic an operation that is involved in any kind of program I could possibly imagine.

I get how some boilerplate API glue code that a lot of people write does it via stacked layers of dynamic dispatches instead, but I could not expect a person to write such code at sufficient quality without being able to reason through a bunch of next to trivial conditionals (since that's what these dispatches still are, under the hood).

At some level I feel like we are talking about such an extremely low level of basic ability, even if it's not technically constantly necessary for a specific job, that it's highly worthwhile to disqualify lacking applicants anyways. But I can also see how that might be some form of privileged or elitist thinking. Open to hear counterpoints.

criticism can be positive, neutral or negative.

when did it start that the storytelling around every piece of physics news was framed as a controversy? I know it's been a while, but I feel like it wasn't this way 20 years ago...

my match will get tmi

the sum here is the sum of wins or losses across all players. for you to win, someone else has to lose. in an economy everyone can be a winner.

in the limit the distinction between something that is learned and something that is programmed genetically is somewhat a matter of definitions. if a species genes makes it so they create a complex social web that teaches all its individuals certain skills, is that genetically programmed or not?

free will wouldn't even change that, since it's presumably also given by our genes.

simple nets for sure, but spiders can easily deal with an uncountable number of corner cases, I somehow think it's not reducible to all-too simple rules (in the 'game of life' sense) and more an interaction of several non-trivially complex systems like their various perception systems.

obviously their neural networks are limited in size and therefor complexity has to remain somewhat simple relatively to larger animals).

no idea where you got the idea for that nonsense. there is a ton of selective pressure after reproduction. there are really an uncountable number of mechanics affecting survival fitness of each individual in a group after reproduction.

there would be an absolute small, at planck scales (from what we know)

there's also an absolute big, known in cosmology, far beyond the scales of galaxies, galaxy clusters, etc... it's your mom

it is faster in just about every way. less memory, even the cpu instructions (which are usually not the problem) are faster. there's something fucky going on with code gen here. or it could also simply be the measurement procedure that is doing something weird like working with not properly cold or equally warmed up data or instruction caches.

what's morally problematic about emulating something you already own?

the only pay what you use thing is bullshit. because everything you want to use actually costs something. the point being that a better implementation would give you the same things without a cost...

you're likely not exposing yourself to the root cause of your social anxiety and are only doing practical exposure therapy to symptoms rather than the root causes. here it really depends what the crux is for you personally.

just as an example that may not even apply to you: if you are fundamentally afraid in new and unfamiliar social circumstances because you're fearing whatever type of reasonable or unreasonable/irrational outcome, then just exposing yourself to a series of specific social interaction types will likely not fix that root fear and only allow you to adapt to those specific circumstances.

what you would need to do instead is actively construct a list of situations that are as different as possible from each other, each having uncertainty for you in different ways, and then find ways to expose yourself to many of them as well as as many combinations of their good and bad outcomes in your head as possible, in an incremental way (because diving in naked / cold turkey strategy can not only be ineffective but even further traumatizing in exposure therapy).

veach thesis gives me "damn I wish I could read" moments

that's not true. they only ban ai if you don't clearly have usage rights for the data that the ai was trained on. obviously, this includes basically all of the big and popular available AI APIs at the moment.

that sucks for using AI right now, but it's only a question of time until you get huge models trained on CC0 data imo

those things are not particularly similar. the tree that nobody can hear while it's falling still has a real and measurable impact on its environment in various ways, something where if if not simulated while nobody was around, the simulation would need to catch up on if an observer ever came near. this eventually amounts to processing work that is equal or even worse compared to just simulating it in full detail in the first place.

iq 30 take

iq 30 post

nobody asked. people asked about why specifically japan stands out here, it is a big statistical outlier.

bare bones correlation study

comments like this really make me smh. what's wrong with some lucky people getting rich off of this? you do realize they financed that research for the past 20 years, and if it's actually an investment group instead of a few passionate individuals I can guarantee you they also financed a shitload of other endeavours that went nowhere and ate the losses, lol.

you could do the same, get together with a group of other people and invest in something using your disposable software eng income (maybe you already are). or you could just complain when someone else takes the risk and reaps the rewards because you apparently have no concept of things like jealousy, envy, or basic economics lol.

You just have to get an understanding of how an if(...) is different from a compile-time #if and where they end up costing you time or memory:

- if(...) has a small runtime cost for literally executing the comparison instruction. very small but there nonetheless. if you have a shader that would otherwise be a handful of instructions, but it's blasted to a couple of dozen by runtime-toggling of various features, you will notice a difference!

- if(...) needs more registers, also to perform the instruction, and potentially to store the result for longer if you reuse it (e.g. to check a feature activation with if(a && b) where a and b are also individual features). but this is only relevant if the extra if is added on the already 'most register hungry' path, since registers are allocated statically so only the most complex path in your shader determines how many registers your gpu program needs in its entirety. after the result is used it is discareded and the register can be reused. also on archs that have scalar and vector registers (most of them by now), this is only relevant for the scalar part since the instructions will likely work on uniform values.

- if(...) has a small instruction cache penalty, obviously, because your code has more instructions. not often talked about but can be relevant if you are running a really large program where different subgroups might be operating in completely different places in the code regularly. adding even more instructions can make it worse. I have not actually seen this in practice but I've seen people claim it exists as an issue :-P

- if(...) implies that you have more uniform data to pass to the program (you need some way to decide which features are enabled...). besides the extra cpu side API overhead for setting those values, making your constant/uniform buffers larger and for example crossing the threshold where it's larger than 1 cache line size can have an impact on small shaders, as this data has to be fetched per thread group, at least once. I've observed ~5% overall performance differences before due to immediate constant cache misses on nvidia on very small programs that needed to operate on a lot of elements but didn't do much per element. there are ways around that obviously (like operating on more data per thread) but as a ground truth you are fetching more data than you otherwise would. it's unlikely to have an effect on large programs, they are bottlenecked by other stuff.

- if(...) can potentially create some optimization weirdness by your drivers. drivers reorder things like data accesses statically in order to optimize for the latency in accessing that data. you would want to fetch a value from some buffer as early as possible so it's already available when you actually want to use it, and do some other stuff in between. this means your driver can pull memory fetches out of an if, put it as close as possible to the start of your program, and do them anyways so they are ready by the time you need the data. however it might also decide to leave it in there and skip the read entirely if the branch isn't taken. now think about what this means when you have like 32 feature enable if checks each of which the compiler technically can't know where the branch is gonna go unless it does some static recompilation of code depending on uniform values. such an issue doesn't exist when the code is statically enabled or not.

those are the things that come to my mind. obviously whether it will make a difference always means some manner of profiling. you should never blindly use one version or another based on intuition, though this intuition can tell you whether it might be worth to spend the hours to try it out. I'd argue because of how much complexity runtime if saves on the CPU side it's always worth at least investigating. with some minimal abstraction it's also not a huge pain to implement...

in permutations the ordering of the individual elements is important (a different order of exactly the same elements is a different permutation), but it's irrelevant in uber shaders. they should just say combinations (different elements are toggled on and off).

all quantities in virtual worlds are always quantized.

imagine downloading a tv show and it turns out its shit

Nothing is really necessarily being deprived here. Society could just decide to pay for those expensive engineers and then some, take the purely economic loss, and enjoy relatively clean energy. have fun with that though

seems like a really bad introduction if you don't already know what a fourier transform is

no offense to nintendo and fans, but fidelity wise the game looks like an early ps3 game and runs at 30 fps with dips in certain areas and very regular dips when using certain game mechanics.

I can count the triangles on a lot of geometry visibly, and the textures are so blurred it looks like you take any modern PC game and only render the lowest available level of detail of all the textures. I can count the pixels in the shadows on the floor and lighting wise the game is extremely basic (it doesn't need to be more because of the art style). most effects you see in the game are literally blurry billboarded (but granted alpha blended) sprites, including the clouds that are so important in this games visuals.

and to top it off we're in 2023 with half the people or more on 4k screens and the game doesn't even manage native 900p most of the time.

the art design of the game is just designed well around those constraints. very well. but the devs likely did nothing super special to make it run well.

except its not consistent with all the observations, which is why it's not accepted consensus.