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.

My problem with how the physics community is having this discussion is actually the converse of what you are suggesting: None of the existing theories explain every observation we have, and yet we are sticking to the same general frameworks that don't work.

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.

Keep in mind that I work in the web world, with small to medium businesses outside of FAANG, so that colors my perspective. But in my career, it's often been a stylistic choice (from me and others) to deliberately emphasize readability and maintainability over than what you might call "efficiency" of code and logic.

That means eschewing things like currying, nested ternaries, deep recursions, etc. in favor of simple, flat switch statements whenever possible, maybe broken out into small pure functions (e.g. isDivisibleBy5() and isDivisibleBy(3)) such that each switch condition could be modularly disabled or swapped in and out, etc. Makes for easier reasoning, unit tests, A/B tests (for users), etc. I think the overall goal is to make each paragraph of code pretty obvious and easy to reason about, without having to click through layers and layers of nested/recursive functions, mutable variables, inherited state, etc.

It's a very deliberate shift away from OOP and huge classes that do everything, in favor of a bunch of micro functions written alongside UI code that looks like declarative PHP. Most often conditionals are used to decide whether to show or hide some UI component based on a var, so that var's lifecycle needs to be simple to reason about. I think a lot of old-school programmers would find that kind of code frankly shitty and terrifying, but it's the normal practice on the web these days, partially as a reflection of how the web frontend world typically works (favoring rapid changes not just in UI code but in underlying frameworks, company priorities, product owners, team makeup, etc... it's all high-churn, low-permanence).

Perhaps that is an idiosyncrasy of the web world, especially in the frontend, where teams are usually made up of less experienced and less formally trained programmers. So the code style adapts to match, becoming more verbose, redundant, and memory-intensive (e.g. rarely do we ever directly mutate something in memory directly, instead copying it to a new var that runs it through a function)... but hopefully more readable, maintainable, and understandable by the next dev to join the team in 6 months. It's a very high turnover field, so being able to quickly get a new member up to speed is more important than writing super efficient code.

Anyway, all that is to say... "programming ability" is not the only consideration. They don't have to be some elite coder to write your basic CRUD app or dashboard UI. Yes, they have to be able to code, but it's easier to teach someone what a modulus is than to try to shape an elite lone-wolf coder into a good team player.

I've spent far more time and energy trying to read, understand, troubleshoot... and then ultimately debug... some mad genius coder's "I am very smart" reimplementation of some common semi-complex pattern, like maybe a hashing function or color conversion system or whatever.

As an admittedly mediocre, self-taught coder (but one with decades of experience), I would typically reach for some popular, well-tested and documented lib for such a use case. But the really good coders that I've met see those situations as a fun challenge and like to write their own implementations that have 90% of the functionality, 3x the performance in quarter of the lines of code... but zero testing and often some edge case bugs. I've had to fix and rewrite a lot of that in my career, usually as the guy who picks up these codebases after the superstar who wrote it has left and moved on to the next startup. So I'm biased against this sort of thinking, instead opting for KISS (keep it simple, stupid) to make my own life and my replacement's life easier.

That's just my perspective though. There are definitely teams and managers who prefer the mad genius lone wolves over run-of-the-mill devs like myself, I just don't particularly like working with them :)

criticism can be positive, neutral or negative.

The framing is not as contrived as you make it seem; the Hubble tension specifically is a genuine mystery and it is unknown why the indirect and direct methods don't corroborate when our theories otherwise indicate they should.

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.

“Survival” and “fitness” of an individual are two separate concepts. The latter is directly related to the amount of potential offspring (and thus reproduction), the former is not.