One of this week’s opportunities to find humour in
these dark days was the announcement that the US state
of New Jersey despirately
needed COBOL programmers. Of course, this was due to
pandemic mass layoffs overwhelming the neglected state
unemployment insurance scheme so this isn’t really
*that* funny—but pickings are slim at present,
and people take their amusement where they can.

I don’t have any experience with COBOL, alas, but it did remind me of the semi-obsolete language I’ve been meaning to look at for years: FORTRAN, or rather Fortran because I’m not quite yet ready to subject myself to anything older than Fortran90, when they changed the capitalisation.

Fortran was designed for numerical computation, which
is very much my programming jam. I usually encounter it
in (typically older) binary R packages: on Linux R has a
preference for downloading and compiling the source, and
if your system lacks the GNU Fortran compiler
(`gfortran`

) you may get caught out by this!
It’s certainly happened to me in the past, although I
will note that this has not been an issue with
Manjaro.

I won’t pretend to have suddenly become an expert,
but I have played around a bit over the last few days.
My own idea of a “hello world” program is testing
primality, i.e. whether a number has divisors other than
1 or itself. I was obsessed with prime numbers as a kid,
particularly around the time when I learned to program
with `QBASIC`

on an old Windows 98SE, and
used to daydream about disproving the Riemann
hypothesis and cracking RSA encryption. Teenagers
have the strangest life plans.

With apologies for doubtless non-standard and inconsistent coding style, here is my code:

```
!This is file : prime
! Author = petra
! Started at: 06.04.20
!
Program prime
Implicit None
integer(kind = 16):: test
real:: upper
logical:: res
character(100):: cmdtemp
integer(4):: args, itarg
= command_argument_count()
args = 1
itarg
do while (itarg .le. args)
call get_command_argument(itarg, cmdtemp)
read(cmdtemp, *)test
= isPrime(test)
res print "(i30': 'l1)", test, res
= itarg+1
itarg end do
contains
Function isPrime (val)
Implicit None
logical:: isPrime
integer(kind = 16):: val
integer(kind = 16):: counter
real:: upper
if (val .le. 1) then
= .false.
isPrime return
else if (val .eq. 2) then
= .true.
isPrime return
else if (modulo(val, 2) .eq. 0) then
= .false.
isPrime return
end if
= sqrt(real(val))
upper = 3
counter do while (counter .le. upper)
if (modulo(val, counter) .eq. 0) then
= .false.
isPrime return
end if
= counter+2
counter end do
= .true.
isPrime
End Function isPrime
End Program prime
```

This program (compiled with
`gfortran prime.f90`

) takes a list of numbers
and outputs whether they are prime (`T`

) or
composite (`F`

). For example:

```
[petra@inoc fortran-scratchings]$ ./a.out 1 2 3 4 5 6 7 23456789
1: F
2: T
3: T
4: F
5: T
6: F
7: T
23456789: T
```

23456789 is one of my favourite numbers: it’s the largest easy to memorise prime I know. On the graphics calculator I had in highschool this would have taken a while, but with a vaguely modern computer and Fortran it’s as near to instant as I could hope.

I really wish I had a Fortran compiler and manual on my computer as a kid. I’m not sure how much I can really do with it now, but it’s certainly fun!