machine-independent cost
If you measured an algorithm by seconds on the clock, your answer would change every time you bought a faster laptop, switched programming languages, or ran on a busy server. That is a useless way to compare algorithms, because it measures your hardware more than your idea. Machine-independent cost is the fix: instead of counting seconds, we count abstract steps, so the answer describes the algorithm itself rather than the machine that happened to run it.
The standard way to make this precise is the RAM model: we assume a small menu of 'basic steps' (an arithmetic operation, a comparison, reading or writing one memory cell, following a pointer) and pretend each one costs one unit of time. Then the cost of an algorithm on an input is just the number of basic steps it performs. A real machine runs some constant number of these steps per second, so wall-clock time is roughly (that constant) times (our step count). Because asymptotic notation already discards constant factors, the unknown machine constant simply disappears: an algorithm that takes c times n^2 steps is reported as Theta(n^2) on every machine.
This is what lets a textbook claim 'merge sort is O(n log n)' without naming a computer, and have it remain true decades later on hardware no one had imagined. The honest limit is that the RAM model assumes each basic step really costs about the same and that numbers fit in one cell; for huge numbers (where addition is not constant time) or memory-hierarchy effects (where a cache miss is far slower than a cache hit), this abstraction can mislead, and more refined models exist.
Counting the maximum of an array of n numbers: we do one comparison per element, so n - 1 comparisons. We do not say '4 microseconds'; we say 'about n basic steps', i.e. Theta(n). On a machine ten times faster the microseconds change but the step count, and hence the Theta(n), does not.
Counting steps, not seconds, gives an answer that outlives the hardware.
The RAM model assumes each basic step costs one unit; this breaks for arbitrarily large integers and ignores cache effects, so it is an idealization, not literal truth.