That's because declaring several variables on the same line is syntactic sugar, although I agree it makes little sense this way

That's why you write

int *x, y, **z;

C doesn't write like "x is an int-pointer", rather it says "dereferencing x will get you an int".

The word is bikeshedding.

It does kiiiiinnnnda matter, but I just don't care and it doesn't affect me. Problem solving and remaining mentally flexible and able to switch gears is just kind of part of the field. But yeah, it feels like the "tabs or spaces" thing, in that, I have a preference, but I'm so used to encountering way, way dumber and worse bs that I don't even care about tabs v spaces.

The choice doesn't matter - consistency does a bit.

As other users have said, we aren't compilers.

Types are important for type safety, so you don't access properties that don't exist, can use polymorphism etc. However, having worked in both duck-typing and hard typing languages, I believe the most important part of a type is it's name.

Classes are are arbitrary constructs we create to help us understand and manage code. They are inherently organisational structures.

That may sound like an argument FOR putting the name of the class first. "If I know it's a ConnectionCredentialsQuery, I don't need to know it's name, the use-case is evident!" Classes often get reused though, like a CartesianPoint. You may create several instances of them. Which of the name and type below are more indicative of use?

CartesianPoint PlayerPosition; 

Types are, to some extent, implementation detail. The name tells you what the variable is for, which is more important.

Another point: You will always need to name variables well, because after declaration, whenever you see a variable, you will only see its name. You want to be able to fully understand what you are looking at without having to mouse over or go back to the declaration of a variable.

Additionally, many typed languages will allow you to use a syntax to altogether avoid declaring the type of a variable if derived from somewhere else.

var result = a + b;

var customer = new Customer();

Given that the type can be inferred, and therefore specifying it explicitly is optional, why make it the first thing you see? That means you need to move your eye back and forth when looking for the names of things. Which of these two are better for legibility:

var result = a + b;
CartesianCoordinate playerPosition;

const result = a + b;
let playerPosition: CartesianCoordinate; 

Finally, you say that types are more important because they are important to the compiler, but compilers don't care about the order of these definitions. Compilers exist to allow us to write easier to read code. They exist to convert high level languages to low level byte code. They exist to enable more readable code.

Thank you for coming to my TED talk.

Controversial take: it doesn't matter in the slightest.

Type is more important? So if the first argument of a function is minAge, which is an int, the important part is that it is an int? Just feed it any int?

No, the important part is the meaning, what the variable actually is, if you use a compiled language the compiler will handle types for you anyway. You'll get a error if you feed it a string, or an water heater object, no surprises.

Leave the machine work to the machine (compiler in this case), and concentrate on the real work, which is the meaning here.

Are you a compiler?

Maybe this comes from a non-typed language perspective... As someone who learned in Java, I do not like it because yeah, type is way more important. If someone was coming from Python, I can see why they might think this...

a lot of modern languages explicitly disagree, eg Kotlin and Rust

sorry, I'm not a compiler, so no

Say what you like about that gang, it definitely makes lexical sorting of dates easy.

That's year-month-day hour:minute:second.millisecond +/-TZ, you heathen!

This is my take as well. I will add that I think I'm more likely to notice an issue with the type if the type is first though since it preps me to expect a certain thing after it.

int firstName will likely trigger more alarms than firstName int but maybe thats just my perception due to familiarity. I feel like once I see the type my mind is looking to make the next part make sense whereas if I see the name first then I just assume what comes next makes sense and mentally move on.

If you think of int as an adjective, the whole situation changes. It makes sense to an English speaker, but is backwards to a Spanish speaker.