Alien Artefacts

Nearly passed based on title alone, was very glad I clicked in. Just the first paragraph alone sets up this excellent & useful neologism, Alien Artefacts:

> The purpose of this blog post is to introduce the concept of alien artefacts1, a subcategory of legacy code. I use the term to describe particularly complicated and important pieces of software written by very smart engineers that are no longer working for the company—and thus not available to support it. The software works really well for what it was designed to do, but it is highly resistant to change.

We have some very wild search code that I think of that qualifies. I also recently added tests & typescript then slowly expanded some really neat code that takes Immutable.js, maps the entities, then caches the result in WeakMap to be re-resolvable latter- sounds simple but there was enough extra stuff also going on & happening that it took some putting heads together to decypher the true inner-workings. Both very distinct features which hadn't had the typical accrual of cruft, mostly untouched since inception, off in their own area. Alien Artefacts feels like a great term.

(BTW what spelling is this? Same word as artifact or no?)

Probably the most alien artefact I ever created was the core abstraction of a C++ game engine that used the curiously recurring template pattern in combination with multiple inheritance.

The idea was to be able to switch between DirectX and OpenGL renderers, or restart the renderer from scratch on failure (i.e.: recoverable GPU driver crash, GPU unplug, restore from sleep, etc...). The problem with using a naive OO v-table based abstraction for this is that it incurs indirect call overheads on every call, including calls that are internal to each implementation. So with some clever template programming and multiple inheritance, I got to have my cake and eat it too: calls within a hierarchy of classes specialised for one back-end were always direct inline-able calls, but you could have shared code that was abstracted across different back-ends.

I opened that source file about a decade later and thought: "What crazy person came up with this madness!?" and then saw my name in the commit history. I was the mad one. The call was coming from inside the house.

I remember writing this kind of stuff. Couple years after I left they'd re-written it, just so they would have somebody who understood it. My friend reported their engineer visiting his office often to exclaim over something he now understood!

It helps to rewrite something with example code in hand. You end up understanding everything.

(I did not mean to be opaque; we were a startup and it was hurry-up-and-be-done-yesterday code)

The main problem is that no one gets rewarded for maintenance. You might as well be invisible like facilities staff. The exception may be if it’s something that’s on the verge of breaking the company. Of course, in that case people will note that it was due to the lack of maintenance, but everyone will eventually ignore it again because most companies do not reward maintenance vs creating something new.

Google is good example of this culture.

This reminds me of the famous "you are not expected to understand this" comment in the UNIX V6 context switch code.

https://community.cadence.com/cadence_blogs_8/b/breakfast-by...

The months spend on building these, are often spent on becoming domain expert of one or several sub domains, build into the artifact. Which is not visible to the outside world. Its similar to hiring one or several consultants, but the consultants were that one person, digging into fluid dynamics and what not to write that one system. The problem is often not in the software, but in the "domain" self-schooling one has to go through, to understand the process happening. Like sending a person to university again, but on the clock with a deadline.

https://en.wikipedia.org/wiki/Fast_inverse_square_root

Best example of an alien artifact i could come up with on the fly: The using parties do not understand it, but can reuse it. They will have a hard time modifying it. To understand the properties, a deep understanding of math is needed, and how the inverse square root can be mapped to the binary properties of a float.

One of the systems I've had the honor of inheriting and building upon, I've described as originally gifted to humanity by Ancient Astronauts.

If you told a new-grad about how it was built, they might have a kneejerk reaction, since it went against some of the conventional wisdom they'd heard, in school or in blog posts, such as avoiding Not-Invented-Here Syndrome.

You'd have to find a way to convey to the new-grad that, in some situations, a few programmers can consistently accomplish big things that 10 or 100 programmers operating with the usual parameters could not.

But maybe, if we're a new grad, it's a disservice to us to hear that, just yet. Once we're out of school and in industry, there's a phase of really learning and appreciating the conventional wisdom in practice. Much of the wisdom is also a great default for most situations.

But later on, with experience, there's some point at which we can become a curmudgeonly enforcer who insists that a particular subset of wisdom always applies. Or we might be open to recognizing a situation in which the wisdom actually doesn't apply, or doesn't have to apply. Occasionally, there are huge wins from that.

SolveSpace is an alien artifact. I can safely say that because I've spent months working on it, porting it to Haiku OS. It is validating to know that this phenomenon is real enough to justify a name for it! https://github.com/realtaraharris/solvespace/tree/realtaraha...

We used to call that kind of code hemoglobin, or hemo for short. Hemoglobin is a molecule that's barely changed over hundreds of millions of years, is extremely complicated and does one thing really well -- bind to oxygen and carry it around. Change one or two proteins and it stops working.

Another colloquialism for this kind of code is "happy fun ball". do not feed or annoy happy fun ball...

So... Alien artifact = legacy code written by competent people. Got it!

> Thanks to ChatGPT for valuable feedback and editorial input on early drafts of this post. It was a joy collaborating with it. It provided consistent and helpful feedback, and was always available to assist with any changes or questions I had during the collaboration process2.

That kind of things will for sure go into my domain's blacklist

I remember such a piece of code, perhaps the shortest ever created! It was 4 instructions in the machine language of ancient British ICL1900 computers. I - together with my colleague - spent some hours to understand it - firstly, what it does and then how and why it works! The problem was that ICL1900 had a rather obscure method of storing 6-bit characters in its 24-bit words (yes, bytes were unknown in ICL computers). To copy character strings indexing was used but character position was stored on the first two bites of the index word while the word address offset on the right part of the index. Since memory was extremely valuable, the rest part of the index word was used for the counter. Thus fetch and store instructions were working such that after a character was accessed counter was decremented and 1 was added to the 2-bit character position subregister with overflow used to increment address offset every 4th character. Very clever solution because the string copying loop was very tight! The 4 instruction sequence we tried to interpret turned out to be a macro modifying character index register backward allowing to use of an almost identical loop for copying a string starting from its end... It was using arithmetic overflow in a way we had trouble understanding and we hadn't access to hardware :-)

I remember such a piece of code, perhaps the shortest ever created! It was 4 instructions in the machine language of ancient British ICL1900 computers. I - together with my colleague - spent some hours to understand it - firstly, what it does and then how and why it works! The problem was that ICL1900 had a rather obscure method of storing 6-bit characters in its 24-bit words (yes, bytes were unknown in ICL computers). To copy character strings indexing was used but character position was stored on the first two bites of the index word while the word address offset on the right part of the index. Since memory was extremely valuable, the rest part of the index was used for the counter. Thus fetch and store instructions were working such that after a character was accessed counter was decremented and 1 was added to the 2-bit character position subregister with overflow used to increment address offset every 4th character. Very clever solution because the string copying loop was very tight! The 4 instruction sequence we tried to interpret was a macro modifying character index register backward allowing to use of an almost identical loop for copying a string starting from its end... It was using arithmetic overflow in a way we weren't able to understand, and we hadn't access to hardware :-)

This is a great metaphor. I'm familiar with it, both stuff I've inherited and (unfortunately) stuff I've written myself.

I do try to write a wall of comments for each hard-to-understand abstraction I'm introducing, including the rationale for the design, and why I haven't chosen the alternatives. This has been useful mostly for myself, as I'm still maintaining the same code after 12 years (or more, in some cases).

so to be clear, having such an artifact is better than having classical legacy code, because it shares all the same downsides but has a unique upside, being “well tested, well documented, and elegant”

“Programs must be written for people to read, and only incidentally for machines to execute.” -- Hal Abelson