Indeed.
Most of the important numerical algorithms were obtained by thinking about a problem, writing out the algebra first, and then coding it.
3 Likes
Not that I ever worked on any major problem, but your comment about thinking of a problem
reminded me about something.
Back in the 70’s when I was a programmer / analysis and I ran into a problem, on several occasions
while driving home and just thinking of the problem a possible solution would pop into my mind.
5 Likes
That happens to me while I sleep. I wake suddenly with the solution.
6 Likes
Happens to me all the time too. I’m in the shower or driving or something similarly brain dead and something just occurs to me.
My theory is that my brain is still working on the problem in a background thread and surfaces at some point to become foreground. 
7 Likes
My guess is assembly.
2 Likes
That’s something I can confirm it works.
However, if I don’t note it, and fall asleep again, when I wake up, I remember only there was a solution, but don’t remember the solution itself…
4 Likes
Same with me. If I wake at 3.00am with an answer, I need to
note it down… it will not be there at breakfast.
May be related to short term memory loss .
5 Likes
Good guess. It would have been my guess also, but we both would have been wrong. You got me curious, so I did a little search on the web and I found this.
“The original software for the Voyager probes was written using Fortran 5 then ported to Fortran 77, and today there is some porting in C.”
If anyone is interested in reading more about it, you can find it here.
5 Likes
That’s the thing with most “Advent of code” problems (from day 10 onwards or so). you can quite easily program an algorithm that will solve the test case, but you will run into huge problems, once you use the real input data, so you will have to put real thought into it.
In reality, all problems can be solved on a C64 or a ZX Spectrum with the right algorithm or you’ll need a CERN supercomputer with Terabytes of memory.
I participated twice and had to give up around day 20.
Now imagine, doing Assembler programming on Voyager 1. These guys are total cracks.
4 Likes
They do it in pure machine code. The people at NASA are the absolute best.
3 Likes
So they might initially compile it with Fortran, then operate on the binary to shift memory allocations around?
1 Like
As far as I know, they write the code in Assembler and “compile” it by hand.
2 Likes
So what are these references to Fortran
What you are saying sounds more likely.
Maybe that reference is about some of the original code before launch?
1 Like
This is very probable.
However: I didn’t get my knowledge from any official NASA source, but from a Youtube video, so it might be complete bs.
3 Likes
It seems the most likely scenario is they use Fortran build tools on the ground, but the stuff uploaded is , as you say,
hand crafted binary.
4 Likes
I believe you are correct for the patches that are being sent. The original code probably was Fortran which was compiled here on earth, but only the binary code was loaded into the space craft.
Just a side note,
Way back in the 70’s sometimes at work we would use a “Rep” card. Yes, an old 80 column card.
It was called rep which stood for replace meaning replace code and was done in binary.
It would give the hexadecimal address of the code to be replace and then the code being replaced.
4 Likes
Posting a few months late, but better late than never, I hope!
Voyager’s flight computers were originally and are now programmed in assembly language. There are 3 pairs of computers onboard each spacecraft: primary/backup CCS (command computer), primary/backup AACS (attitude control), and primary/backup FDS (science and engineering flight data handling). The 3 types of computers have different CPUs, so there are 3 different assembly languages.
One of the Voyager 1 FDS computers suffered a complete memory failure in 1981. The remaining FDS computer is the one with the memory block that failed last fall. In addition to the FDS being programmed in assembly, JPL has no assembler (!) and no simulator, so software changes must be hand-translated and “testing” is accomplished via inspection by many eyes!
The All About Circuits lists in its sources a 2013 Wired article from which it derives some mistaken information. The Wired article was based on an interview with Suzanne Dodd, the Voyager project manager, and the article says the “control and analysis software” was written in Fortran 5, etc. The original ground-based mission control and analysis software was mostly written in Univac Fortran V (Fortran “five”) and ran on Univac mainframe computers. Dodd worked on Voyager in the 1980s using these computers and tools written in Fortran V to design and develop command “sequences” for upload to the spacecraft. (Sequences are interpreted by the CCS command computer to perform sequences of planned, scheduled operations on the spacecraft. The actual CCS flight software is like a bash executable and sequences are like bash scripts, except that they aren’t text files and instead are tables of binary data and, if necessary, normally non-resident code needed to perform some operations.)
The Fortran V software would have gradually migrated to Fortran 77 during the 1980s. After the last planetary encounter in 1989, Voyager operations were moved off the mainframes to Unix workstations and substantial parts of the software would have been ported to or reimplemented in C.
This isn’t necessarily germane to this discussion thread, but another mistake in the Wired article, that is repeated in the All About Circuits article and elsewhere, is that an onboard computer has ~69k bytes of RAM. That’s the total equivalent in bytes for all 6 computers on a spacecraft. Each of the 4 CCS/AACS 18-bit computers has 4K 18-bit words of memory (equivalent to 9KB) and the two FDS 16-bit computers have 8K 16-bit words of memory each (equivalent to 16KB). 4 * 9KB plus 2 * 16KB gives you 68KB (69,632 to be exact, or lower-case-k 69.63k bytes per the Wired article). To sum up, memory was even more constrained than the Wired article suggests and Voyager’s flight software engineers worked miracles with what little memory they had on each computer. (At launch, each AACS computer had only two words of free space out of its 4K words of memory! - from the Chapter 6-2 source in the All About Circuits article. The launch-specific code could be deleted after the spacecraft were on their way, thus freeing up space.)
A recent presentation by JPL’s Bruce Waggoner provides details about the FDS memory anomaly, gives a glimpse of FDS assembly language code in the failed memory block (23 minutes into the video), and describes the many-eyes testing and just plain hoping the changes work: https://www.youtube.com/watch?v=dF_9YcehCZo (“Saving Voyager 1! - Bruce Waggoner at !!Con 2024”). I’ve written about the Fortran 5 meme in more detail at http://www.geonius.com/writing/other/voyager.html (“Voyager and Fortran 5”).
7 Likes
Indeed, that clarifies a lot of things.
It is amazing how limited those onboard computers are
Thanks, Alex
1 Like