"Talatat are stone blocks of standardized size (ca. 27 by 27 by 54 cm, corresponding to ½ by ½ by 1 ancient Egyptian cubits) used during the reign of Akhenaton in the building of the Aton temples at Karnak and Akhetaten.
The standardized size and their small weight made construction more efficient. Their use may have begun in the second year of Akhenton's reign. After the Amarna Period talatat construction was abandoned, apparently not having withstood the test of time."
I came across that by accident, after mistyping "Tlatet" in a search. It comes from http://en.wikipedia.org/wiki/Talatat. But it chimes with something else that I've been mulling over recently.
My programming career started in the days when tools were much less sophisticated, and much less reliable than they are these days. The move from "spaghetti code" to "structured" programming was under way. We were being encouraged to use procedures more, and avoid "goto". But while objects, declarative programming and the like may have been around in academic circles, they hadn't reached the coal face. The big and clever tools weren't as big and clever as they thought they were. It was always helpful to stay close to the underlying components so that when things went awry you could usually figure out why.
I earned my crust programming for a few years, then moved onto other things. By that time things were starting to change, and I've learned about subsequent developments out of interest, rather than for professional reasons.
The point of all this is that since my formative years of programming I've always been more comfortable when I can see how the cogs turn. I'm hugely impressed at the level of sophistication that open software is achieving, and I enjoy learning how to take advantage of it. But often I feel as though I'm dropping things into a "black box" then waiting for the results to appear. When things don't go the way that I expect, I'm inclined to open the box up, take it apart and examine the workings. Normally it turns out that my instinctive approach isn't practical. I know I could get hold of the underlying code, and that's a big advantage over proprietary software. But in practice there's a huge drop down from today's high level of sophistication, to the mass of minute detail that undepins it.
I'm suppose I'm hankering after being able to muck around with building blocks that are smaller than the major software tools, but bigger than the underlying code. We might call them "Talatat". But it seems that they didn't stand the test of time either.