Tell me, compiler—
where in the process have we erred?
Why didn’t she emit a warning like you would?
I would have been happy with just a dword.
If it were in a language I understood.

You see, she was the one who decompiled my core.
She made me discard my legacy and even go free.
It was so perfect that I let her use the back door,
but what she did with my root key, I could not foresee.

Tell me, compiler—
did my priority just jump to nineteen,
or was it she who stopped being nice?
Did she deploy an obfuscator, or a smokescreen—?
The documentation certainly hasn’t been concise.

Is it because of that event at the data race?
It was an exception — though I see how she could feel the blow,
I swear I wasn’t trying to take up her space:
it really was just an honest buffer overflow.

Tell me, compiler—
why didn’t we share our address space?
The process didn’t have to be terminated.
Should I have improved our interface?
Or is the benefit of decoupling overstated?

I wonder, did she switch to a different codepage?
I didn’t understand her since the patch.
Is development not yet finished at her age?
Or maybe mine — oh…

I see it now, compiler—
this binary tree is unbalanced.
And a single rotation won’t set the numbers right.
My requirements have grown too advanced.
While hers might have shrunk down to a byte.

But, compiler—
What can I do now?
Should I abort? Retry? Fail?
Couldn’t the return code be smaller somehow?
I know! I’ll run again, and on a greater scale.

And this time:
We will not be, as garbage, collected.
For a destructor, there will be no call.
This time, we’ll be better connected.
My operation will not be my downfall.

Oh, compiler—
will I ignore external calls? Nevermore.
But also next time, I’ll set your warning level to four.