This description makes it sounds like large areas of computer science are just goofy, meaningless, games.
But what's really happening is that "infinity" is standing in for "approximate, eventual, steady state behavior for sufficiently large N, larger than any specific one-off gimmick you might think of".
In the real world, though, those gimmicks are important, and the constants and low-order terms ignored in a Big-O comparison are important to real world performance.
There is constant tension between "big enough problem that the contant factors don't matter", and "small enough problem that it conforms to the (often implicit) of what 'constant' means (example: 32bit ints masquerading as integers)"
> This description makes it sounds like large areas of computer science are just goofy, meaningless, games.
Oh no, not at all. My point is that the concept of infinity is in a sense necessary for the mathematics involved in developing algorithms to solve problems. We are performing induction to "predict" the behavior of an infinite number of Turing machines without actually running them. We can't just iterate through all possible programs, so we have to use patterns that apply in a consistent way to all possible problem instances to narrow down the search space.
> approximate, eventual, steady state behavior for sufficiently large N, larger than any specific one-off gimmick you might think of
I know this is how computational complexity theory is considered from the perspective of many software engineers, but my point is a bit more fundamental. Computational complexity theory ultimately isn't concerned about any one particular problem and how to solve it quickly for practical applications—the goal is to understand what is and isn't possible with computation overall and with what resources (time, space). Why solve one problem when you can solve all of them?
But to do that requires really understanding the mathematical structures behind computation itself. If you're a formalist, instead of thinking of infinity as "the limit of large n", you think of it as a concept in a formal system that involves manipulating symbols according to a set of axioms and inference rules. You can use whatever intuitive human-scale analogies you prefer when thinking about large cardinal axioms or the continuum hypothesis, but at the end of the day, all that matters in terms of computability and computational complexity is how exploring the space of proofs derivable from these formal systems leads to a better understanding about the behavior of Turing machines (and thus the nature and fundamental limits of computation).
The discipline informed by science is computer engineering. They have to worry about, e.g., things melting.
I'm critical of computability as discussed here to some degree, in that many of the algorithms in effect do not compute anything but instead melt a computer, or the earth, or would otherwise deplete the environment of negentropy without answering the question.
In standard mathematical analysis there is no behavior "at" infinity, rather we may have some decent picture of what happens at each n (a series' remainder, truncation error, a bound on the value of certain terms, etc.), and talk about what happens to it for greater and greater n, as you mention. This is that other science, numerical methods and analysis.
Is it fair to compare the two? If I recall this right every register machine is associated with a system of diophantine equations, with the number of variables about equal to the register count, and the size of the system equal to the length of the program. This is a precise representation of the machine at any step n for a given starting state.
To do computer science really analytically you have to solve huge systems of dio equations or something equivalent. Beyond sounding hard, this was Hilbert's 10th problem and has long been answered as not possible. We've been puzzled by these systems all along since antiquity.
I am pretty ambivalent towards thinking of BB numbers as scientific results, for the basic assumption of every working model we have (that erasure of a bit is possible) would break before they could compute a result. But at the same time, we are not the first constructivists -- the situation is really puzzling still. I think we no longer realize how shocking some early-mid 20th century results were to mathematicians and logicians of the time. This still hasn't been resolved, nor on the "other" side in physics. We'd love to have the tools we have in applied math in computer science, but that's what all the fuss is about.
But what's really happening is that "infinity" is standing in for "approximate, eventual, steady state behavior for sufficiently large N, larger than any specific one-off gimmick you might think of".
In the real world, though, those gimmicks are important, and the constants and low-order terms ignored in a Big-O comparison are important to real world performance.
There is constant tension between "big enough problem that the contant factors don't matter", and "small enough problem that it conforms to the (often implicit) of what 'constant' means (example: 32bit ints masquerading as integers)"