In other words, I never thought it was just you.
Apologies. Years of marital training/brainwashing must have kicked in. Everything that went wrong was my fault, especially when it involved the computer and was caused completely by her refusal to learn how do it right (eg, "What did
your stupid computer do with my Word document?" which she couldn't find because she never named her documents nor gave any thought to where she was saving it).
Back in the day the computers of science fiction were frequently non-deterministic, unlike real-world computers of the time that given the same inputs always delivered the same outputs.
I graduated high school in '69. Around that time the percentage of the US population that had any experience with computers (even just looking at one through a window) was extremely small. When I was a paperboy around 1964 our newspaper "computerized" and we were given a tour of their computer center. Remembering back, I think it was just data processing equipment (which had been around since the 1920's or earlier) without an actual CPU (post-WWII) -- the card sorter was programmed with a patch panel, the first time I had seen that technology (in my active duty shop, our test set was programmed with patch panels).
And in movies and on TV, computers were depicted as magical devices with capabilities far beyond actual computers (as you just pointed out). Around 1970, I encountered my first two YEC claims: the living fresh water mollusks carbon-dated to be thousands of years old (the old
reservoir effect issue) and
the NASA computer that found Joshua's Lost Day (that link is to an essay about that claim):
quote:
After my grandmother went to be with the Lord in 1996, it fell to several of my cousins and me to sort through her belongings in the apartment where she had spent the last 19 years of her life. Grandmother owned several Bibles, tucked inside which one could often find a little treasured poem, an old note from my grandfather, or perhaps a program from a funeral. This was quite moving for me, so you can imagine my surprise when, in the midst of all that, I found a few pages of lies.
Most of us have seen the story in some form or another. It starts off something like, "Did you know science proves the Bible?" and goes on to tell the story of how NASA astronomers were puzzled to find almost a day "missing" in some "calculations," and how a Christian showed them how it corresponded to the Biblical stories of Joshua and Hezekiah. An inspiring story, except that it is completely false (I mean the NASA part is false, not the Biblical stories themselves). This lie had been made into a tract, and that tract had made its way into my grandmother's Bible.
...
By the way, the story is nonsense on its face. There is no way computer calculations could detect a "missing" day. All they could do is take the current positions and motions of the planets and the laws of physics and calculate backwards to determine where objects were at some time in the past. But this would always give an answer -- the only way one could find a day "missing" would be if the results of the calculations were compared with some precise (and precisely dated) astronomical observations prior to the missing day and the positions did not line up. There are no such recorded observations from the time of Joshua.
Basically, the NASA computer story is that NASA had this lunar orbit prediction program which they decided to test by running it back in time a long, long ways (many thousands of years if not millions of years). Imagine their astonishment when the program abruptly stopped around 23 Oct 4004 BC with the error message: "Nothing existed before this." Then they reran the program forward from there and when it got to the present it was off by one day. A Christian (who had somehow slipped past the "atheist scientists" running the place) opened his Bible and found the answer: that missing day corresponded to when Joshua had commanded the sun to stop.
I didn't earn my BS Computer Science until 1979, but even in 1970 I knew that was nonsense and that that claim imbued computers with magical attributes that they simply cannot possibly possess. That claim alone told me that creationist claims are nothing but bullshit nonsense, which is why, when I learned that creationism was still around in 1981, I was surprised and decided to look into their claims; still bullshit nonsense.
Now, that halt at 4004 BCE would make sense
if a programmer had put it in as a joke. As for it being off by one day, I would be extremely surprised that it was off by so little. The problem with using floating point numbers (eg,
IEEE 754) is that most floating-point numbers cannot be expressed exactly, but rather you will always have some small amount of round-off error. More round-off error accrues with every floating-point operation, which will accrue even more as you iterate through do-loops.
For example,
Simpson's Rule is an iterative method for approximating the area under a curve (AKA a definite integral). The smaller you make the Δx (ie, the more sub-intervals) the more accurate your approximation. However, having more sub-intervals means that many more iterations
with each iteration accruing more error. Our numerical methods textbook had a graph of the error in Simpson's Rule (ie, how far off the approximation was from the actual answer) with relation to the number of sub-intervals: as the number of sub-intervals increased, error decreased rapidly, but then so much
round-off error had accrued that it completely swamped out any benefit.
The lunar orbit prediction program obviously used iteration, so the effect of so many iterations would have been the accrual of round-off error swamping out those results. And since mathematicians would have very involved with that program and since mathematicians know about error and round-off error,
they would have known better than to have agreed to such a stupid test. And if that test had actually been run, then every mathematician there would have immediately realized what had caused that error.
If you Google on that NASA claim, you will find several web pages discussing, most of them on Christian sites
and most of them denouncing that claim as false (at least that's what I found a decade or two ago). It also made Answers in Genesis' 2002 article listing "Claims We Wish Creationists Would Not Use" along with "so why are there still monkeys?" and "men have one fewer rib than do women."
Even programs with random number generators would provide the same outputs if initialized with the same seed.
I learned that lesson the hard way in 1978. Our university used an IBM mainframe which had an "interactive" module,
Virtual Storage Personal Computing (VSPC). Since it included VS BASIC, I decided to teach myself BASIC, there being no class offered in the subject. I bought the VS BASIC handy-dandy (USAF term for a quick-reference card) as a syntax reference and David Ahl's books,
BASIC Computer Games and
More BASIC Computer Games, for coding examples.
My first test program was
Hamurabi. When I ran it, I noticed something rather odd: plague struck the city every single year. I turned out that the syntax for Microsoft BASIC's RND() function was different than for VS BASIC and that using the MS syntax (RND(1)) resulted in running the VS function
with a seed of one. Changing my VS code to RND(0) cleared up that problem.
... , but other times it definitely feels like the program has been routed down a meaningfully different decision path.
Yes, the bane of software debuggers. We would refer to an unexpected result as being due to it "finding a different sneak path", which is why a gorilla is so vitally important during software testing. Remember the classic Samsonite luggage commercial where the suitcase is put in the gorilla cage and it remains intact and closed despite being thrown around and stomped on by the gorilla. A software gorilla plays with the program and tries to break it by doing totally unexpected things to it, things that the programmers would never have considered (and hence would never try to do when testing it themselves).
Talking about sneak paths, on NPR's
All Things Considered I listened to an interview with RADM Grace Hopper, I think on the occasion of her retirement from the Navy in 1986. In talking about her work which led to COBOL, she described a feature they had put in the compiler which would trace through all the execution paths in the program in order to ensure that there were no "dead ends", places where the program gets caught in an infinite loop. In my school programs, we always knew when we had an infinite loop because the ABEND message would be that the program used up its entire time allocation. That interview was the only time I ever heard of such a test feature in a compiler and it sounds like a useful feature to have.
Also on the subject of sneak paths was a bug discovered in a piece of medical equipment. The device was used to administer radiation treatment of a cancer. It had been "thoroughly" tested and had been in use for years without a problem. Then one day the technician started punching in the settings, then changed some of the settings that he had done wrong. As a result, the patient received bad radiation burns (it's been decades, so I forget whether that was fatal). Somehow, those settings corrections went through a sneak path that nobody knew about despite all the testing it had gone through and its years of flawless operation. One programmer I worked with absolutely refused to ever take a job working on software for medical equipment for precisely this reason.
™ Version 4.2
(1)
