Micropython is really interesting. Haven't felt this memory-constrained since I was writing software for 8-bit home computers.

I have become extravagant in my use of large buffers and just reading in whole files all at once from programming servers all the time.

It's nostalgic being back to trying to eek out each byte and resuse all the variables and refactor code so it'll fit in RAM.

Here's the surprising thing: every variable in Python is like 28 bytes of RAM.

You think you're just storing a switch that turns a thing on and off, a 0 or a 1. A bool.

But no. You're storing a Bool object, which has a type and a reference-count and overhead to represent it's structure.

Which means the most RAM-saving thing I've been able to do is basically replace all the variables with pointers into a byte-array.

Like back when programming the old Dos machines: basically just allocate your memory block and organize it yourself.

Fight the OS. Fight the Micropython.

It wants to turn your flag bits into 28 byte macro objects.

I may yet end up pushing multiple flags into one byte.

Like, a date-object is a tuple of 7 variables for year, month, day, hour, minute, second, fraction.

You store one of those in memory, it's an array of 7x28 byte numbers!?

You want a week's worth and you're just doomed.

FacK!

This machine only has 32k and the system takes up 2 thirds of it.

Store it as a timestamp in an array of longs and it's 32 bits. That's it.

I'm used to optimizing for throughput and latency, so this micro-environment where I'm happy to waste a few cycles to spare the bytes is a really different type of challenge.

Way more like the old Spectrum days.