Just a quick sanity check on performance.

```
/** primes.rexx */
/* Created 2019-09-26 */
/* Copyright © 2019 by Mark Damon Hughes. All Rights Reserved. */
PARSE ARG primeCount
IF \ DATATYPE(primeCount, "W") THEN DO
SAY "Usage: primes.rexx N"
EXIT 1
END
CALL clearPrimes
CALL sievePrimes
CALL printPrimes
EXIT 0
clearPrimes: PROCEDURE EXPOSE primes. primeCount
primes. = 1
primes.0 = primeCount
primes.1 = 0
RETURN
sievePrimes: PROCEDURE EXPOSE primes. primeCount
DO i = 2 TO primeCount
DO j = (i * i) TO primeCount BY i
primes.j = 0
END
END
RETURN
printPrimes: PROCEDURE EXPOSE primes. primeCount
DO i = 1 TO primeCount
IF primes.i THEN CALL CHAROUT , i || " "
END
RETURN
```

```
# REXX: 0.8% C
% time rexx primes.rexx 1000000 >~/tmp/primes-rexx.txt
rexx primes.rexx 1000000 > ~/tmp/primes-rexx.txt 6.43s user 0.36s system 99% cpu 6.831 total
# Regina: 1.53% C
% time regina primes.rexx 1000000 >~/tmp/primes-regina.txt
regina primes.rexx 1000000 > ~/tmp/primes-regina.txt 3.25s user 0.26s system 99% cpu 3.521 total
# Python: 4.8% C
% time ./primes.py 1000000 >~/tmp/primes-python.txt
./primes.py 1000000 > ~/tmp/primes-python.txt 0.75s user 0.02s system 68% cpu 1.123 total
# Julia: 1.4% C
% time ./primes.jl 1000000 >~/tmp/primes-julia.txt
./primes.jl 1000000 > ~/tmp/primes-julia.txt 0.45s user 0.35s system 21% cpu 3.797 total
```

Most of REXX's bad time can be attributed to using stem variables in a tight loop, effectively string-keyed hashtables, so I'm sure an ooRexx Array implementation would be significantly faster. But stems are what you'd use in "real code", so caveat coder. In a long real-world program I don't think it's as big an issue, but it's definitely not received the kind of optimization love that newer languages have. Aesthetically, the REXX source is a little wordier and more explicit about globals access, but not hard to write or read.

I went ahead and grabbed Regina, and it doubles the speed of ooRexx. I'm still wary of it, but that's a big win.

Python's not terrible at anything; it's within a stone's throw of a compiled language at this point. Competent mediocrity has really made Python the new dynamic Java of our time. But you still can't do multithreading in it.

Julia's slow because the startup time is just atrocious; if I timed it internally after startup it'd be as fast as a compiled native program, but as a scripting language Julia's bad news.

(I do have real work to do, but I'll keep playing with REXX more over the next few days)