zgs

I don't the fanaticism around memory safe languages. We've had memory safe languages for a very long time. Algol-60, the granddaddy of many modern languages, had it sixty-five years ago. Algol-60 also had other safety features that modern languages don't have - for example integer overflow safety.

The real issue is that we came to accept unsafe languages and are taking a really long time to put such features back.

I've still got mine. It's been well used but is hanging together still.

Seems like another way to deliver nukes to targets...

Under uClinux, executables can be position independent or not. They can run from flash or RAM. They can be compressed (if they run in RAM). Shared libraries are supported on some platforms. All in all it's a really good environment and the vfork() limitation generally isn't too bad.

I spent close to ten years working closely with uClinux (a long time ago). I implemented the shared library support for the m68k. Last I looked, gcc still included my additions for this. This allowed execute in place for both executables and shared libraries -- a real space saver. Another guy on the team managed to squeeze the Linux kernel, a reasonable user space and a full IP/SEC implementation into a unit with 1Mb of flash and 4Mb of RAM which was pretty amazing at the time (we didn't think it was even possible). Better still, from power on to login prompt was well under two seconds.

It might be shorter to do some multiplications:

0x08C0C166 = 2⁴ × 3 × 5⁵ × 11 × 89 + 1 = 10⁴ × 3 × 5 × 11 × 89 + 1

Plenty of values that can be reused (11 = 10 + 1 and 89 = 10² - 11).

Still, there is quite a bit of manipulation required and only 17 instructions to do them in.

The initial XOR instruction isn't required, registers are zeroed as per the problem statement.

Better check his pockets on the way out :)

I think there is a spurious "and H" in the title :)

Later uClinux was available on m68k platforms without memory managers. The approach taken doesn't seem close to the one in the article.

I managed to put in shared execute in place library support, the limitation being the number of shared libraries rather than what they supported.

My favourite mathematical problem looks to have been solved.

There is a second issue with the code. The calculation of the mean isn't numerically stable. Instead use:

mean_power = mean_power + (power - mean_power) / count

Algol 68 was to Algol as C++ is to C: trying to do too much resulting in over-complexity.

The two page spread showing a graph of the implicit type conversions was a masterpiece.

Kind of like the "install this software" as part of the interview process.

"My hourly rating for figuring out your bug is $X".