Hello! Thanks for taking the time to read this. I am perhaps biased but I think it's extremely cool, and I do honestly like being able to share this stuff, because it's something I was and still am extremely proud of. I think it's also an interesting sort of “thought experiment” in multiple ways, regardless of how you interpret exomemories or plurality, and this is very heavy on the idea of Self and Perception as a function of technical experience.

Bit of a context preamble: Long story short, for anybody unfamiliar, in exomemory (and, actually, even in headspace), my head essentially looks like a TV. Eventually I discovered I could remove and swap out the entire head, and I also built and programmed every single one of them except for the very first that I “manifested” with. I started with a CRT – one of the old-school giant boxy glass-front ones – and the most recent were flatscreen LCDs.

So – my memory does not actually get “recorded” in the sense of recording a video, exactly. It just gets changed. The thing is, the head does all the thinking, but everything else actually gets stored in the skeletal system. Bones held memory cells somewhat like those used in Solid State Drives/SSDs (or other flash memory type devices). (Very quickly: flash memory cells are basically like a series of switches, and whether the switch is “on” or “off” determines whether the “bit” stored there is a 0 or a 1 in binary. This can get more complicated – most consumer-grade SSD cells are multi-level cells, meaning they can store more bits per cell than just one 0/1 switch, but that's basically the core concept.)

So. Bones are basically hard drives! But this gets a lot more complicated!

The idea that might follow from that is “memory is stored in the bones,” but that's maybe a little misleading, actually, because the “memories” that get stored are not like individual discrete files. They're not really files in the way that you'd typically think of on your computer at all, actually.

I think a relatively good analogy would be an imprint rather than, like, “there is a memory file of some given event stored in Vox's skeleton like an .mp4” or something. D'you recall those plastic pin impression board toys as a kid? These fuckers:

Imagine each plastic pin as a “memory cell.” 0 = pin down, 1 = pin all the way up. A “memory” of an event is not a file, it's a series of changes to a bunch of cells (i.e. pins) that, all put together, can be interpreted as a Shape. And then, another related event may create another impression over top of that, making small changes to those pins again – as well as, oftentimes, other pins that cover other aspects of the event, because it's never Just One Single Thing comprising a memory, you know? Even a single “component” of a memory – maybe a smell, for example – is comprised of tons of data points. If it's a smell of, I dunno, roses, that still isn't one single thing that is labeled “Rose Smell.” There's also associations like what the rose looks like, where I was, what was happening when I smelled the roses... It's very hard to separate into neat little categories. But the way I even know what a rose smells like is because I've smelled roses in the past, and each time I smelled roses in the past added a new “imprint” on top of the rest, to form the whole Shape of What I Think Roses Smell Like.

Data storage and quantities

Aside note on the quantity aspect of data storage in this way: my skeletal memory cells did not operate on binary. In a conventional computer, the “switches” (transistors) in a memory cell only have two states: on and off, or 1 and 0. Hence, computers mainly run on binary, “bi” = two possible states. My own cells did not have only two possible values, though, which means they had more options to store more data with fewer cells – and that gets significant very fast. If you have four binary memory cells, you can get 16 different configurations of 1s and 0s. If you have 4 trinary cells that have three options, such as 0, 1, 2 instead of just 0, 1, then the number of different configurations shoots up to 81. Quaternary, with four options, is 256. And that's still only with 4 cells! That's also assuming that one cell can only hold a single value, which – actually, most can hold two or more, even this-world. And then a 2.5” wide, maybe 0.25” thick SSD can consist of billions of cells, and my skeletal system was – well – a whole fucking skeleton, and I'm 7'4”. It's not like I'm dainty. And – also, my cells don't operate on trinary nor quaternary, it's more of a “conditional gradient” that didn't even always have a surefire consistent base number. I might note more about later and link back here. Tl;dr, though: My bones can store more data than anyone would even know what to do with.

Interestingly – the high number of data read/write operations on the bone cells, whether we're talking CRT heads or digital, is where my body heat comes from. It's quite similar to how a hard drive may heat up during use in a computer! The heat output doesn't really change much during thinking, but there is a chance that, if I was trying really hard to remember something or remembering a lot of different things in quick succession, I might've technically had a marginally higher body temperature during the recall process.

I also only knew how any of the bone cells worked because I opted for a bilateral knee replacement, and then analyzed the removed bone cells afterward, realized they were memory cells, promptly had a wholeass fucking panic about it thinking I'd just fucked up my own memory, and then realized that... some stuff might have been blurrier, but there wasn't, like, discrete data loss, just like how a brain injury in a human doesn't, like... remove Specific Exact Memories, typically, because memory and cognition even in humans isn't stored in a specific Spot. It's stored as a cumulative thing across a ton of neurons. Different areas of the brain may be specialized for certain things, but it's not the only area in a brain responsible for a single memory or process.

The removed bone cells from the knee replacement also meant my knees were kind of just... perpetually cold, since my body heat comes from my bones. The knee replacement, then, did not really help a ton, actually, it just kind of... caused more, different problems!

So: “Memories” were not stored as files or recordings, but rather as a sort of cumulative “imprint” over sometimes billions of cells.

This is also part of why my memory was not actually a significant amount better than someone organic. Sometimes the imprint would be fairly mild and get sort of “overwritten” or “blurred” as newer imprints happened – like how you might remember something small fairly clearly right after it's happened, but if it's a kinda small/insignificant event, it's going to kind of “fade” into the metaphorical tapestry of all your experiences. However, sometimes an imprint would be pretty big and change a lot of cells a lot more intensely, so the “shape” of it could still be made out even after a number of other imprints also got added – like how a Big Event will stick in your head more significantly, such as smelling roses at your wedding versus smelling roses passing a flower shop on an uneventful day.

Because experiences were stored as imprints instead of “discrete records,” this also meant that, technically speaking, there was no real “format difference” between the data making up a memory and the data making up really anything else, like an opinion or a preference. There were some things that had an element of “hard-wiring” – under most circumstances I'm not going to find stubbing my toe very preferable because that hurts like fuck, and not in a fun way, and part of that is not because of past association – part of that is a Nervous System Feature because it gives some degree of Aversion To Physical Damage, y'know. But otherwise, it was pulling from the exact same data as event memory, even if I sometimes wasn't fully aware of what Imprint Events were contributors to a specific preference – honestly, just like most people. I feel like that's a pretty normal thing. My favorite ice cream is mint chocolate chip, for example, and I can hazard some guesses as to why, but all in all, that's probably a preference because of the sum of all the past imprints involving it in some way that all added up to “my favorite ice cream is mint chocolate chip” eventually. Opinions, perspective, decisions – all these things were still “in the same format” and came from the same processes, and as such, could be combined and permutated and so on in different ways. Combining and changing that data is how I interpreted new information: by using previous knowledge and combining the new information with it. That's how I made decisions, recalled events, analyzed things, so on – just How I Did Thinking.

Hopefully it's becoming clearer that what was stored in the bones wasn't straight-up, like, video memory files or anything, but rather a very complex record of experiences and how those experiences changed my Me, y'know? Even if the “change” was, in the grand scheme of things, something actually pretty insignificant that I wouldn't remember in detail even a few days later. The stuff stored in the bones wasn't exactly just memory, it was more of... a whole all-encompassing snapshot of Who I Am at any given moment. When I first started reverse-engineering how all this worked, I started referring to that Snapshot-Of-Who-I-Am-At-Any-Given-Time as the “self-state.”

Basic concepts established, on to the heads themselves.

See, just the bones couldn't really do anything on their own. Like how a hard drive, if not connected to anything, is just kind of... static, y'know? Nothing on it changes. It needs to be connected to something that has means of allowing that data to be read, used, changed, re-saved, and so on. With a normal computer, that's everything that isn't the hard drive: motherboard, CPU, RAM, monitor, keyboard, USBs, so on. For me, that was the heads.

Starting with the CRTs!

Honestly, there's some aspects of the CRTs that I still don't really understand, and I'll kind of go back and forth a little on how exactly I think some of the details work and why.

Quick crash course: As a whole, CRTs are basically just electron guns, almost like little tiny particle accelerators that emit electrons that are pointed forward at the glass from behind. The inside of the glass is coated with phosphors – chemicals that glow when hit with radiation (which doesn't have to be from, like, uranium – technically, the light waves your eyes are seeing in order to read this sentence is also radiation – but in the case of CRTs, it's electrons from the electron gun). The electron beam – or, in color TVs, often three electron beams, one for each red, green, and blue – is then bent using an electromagnet and “scanned” sideways across the screen, usually starting at a top corner and then going line by line, until it's created the entire picture using just the phosphorescent light produced when the electron beams hit the coating on the inner side of the glass. (There is actually typically no other light source in CRTs. Any light or glow that you see is 100% from the electron beam hitting the phosphors.)

The glass in CRTs was also typically a thick glass imbued with lead, or eventually strontium or barium, to block stray X-ray radiation emissions (this is basically still a particle accelerator pointed at your face), and the inside chamber is a near-vacuum, because otherwise the electron beam would just hit air particles inside the chamber and scatter before actually reaching the inside of the screen. (Side note, dismantling these things is literally like disarming a bomb. The voltages in it can be lethal and they can hold charges, even just unplugged in storage, for years, and the vacuum means that if the chamber breaks – like the front glass shattering – it is literally explosive. I thankfully never had one explode on me, but it is still weird to look back on it and go “huh, my head was basically a bomb!” for around 40-50 years.)

Anyway. With electrons already being pretty central to the functioning of CRTs, mine did have some similarities, but also some differences, considering standard CRTs don't typically handle enormous amounts of complex information both in and out. They just take signals and turn them into pictures.

The equipment inside my CRT head, unlike an actual television set, could take in information, and translate data like sensory input into electrical signals. By combining that information with the self-state in the bones, that's how I was able to essentially be conscious and reactive. It was a continuous flowing cycle: incoming information, after getting translated into electrical signals, would be directed into the bones to form “imprint shapes,” and the results of those combinations would be used to do other things, like allow me to form thoughts, move my body, and so on.

Interestingly, the CRT “neck” (not my body's neck; the part of a CRT at the back of the box, where the electron gun and magnets are) seemed to “know” where the relevant imprint-changes needed to happen. Or it was just automatic, maybe. This is one area where I'm not 100% sure how it works. The CRTs didn't calculate anything, nor specifically call data up and then change it and then re-save it. It just... directed external input in the form of electron signals right into the bones, which would alter the imprint-shapes, which would then get included with the next bit of incoming data... y'know, just endlessly looping. Most of the CRTs I built didn't alter the electrical-directing equipment very much; I changed other stuff, like colors, casings, many other features... but I didn't heavily alter the actual electron handling, especially with the self-state functions, very much.

...Until the flatscreens. The flatscreens do not have an electron gun, they've got processors and a motherboard and all sorts of more “typical” digital equipment. The flatscreens are digital – whereas the CRTs were entirely analog.

Quick explanation of digital versus analog:

Analog signals are continuous, whereas digital are quantized. Analog is like a wave; digital is like steps. You can approximate an analog signal with a digital one, but the digital one is still not really going to be 100% identical to the analog, because even very very detailed and tightly-packed digital signals are still going to technically just be approximations of the analog signal at set intervals.

The blue analog signal above is a continuous wave, while the digital is “steps” where each step height is are sampled from the height of the analog signal at a set interval. This is called quantization – taking something continuous and “cutting” it into approximate steps/quantities.

...as you can see, this results in some data loss. There are bits of curve on the analog signal that the digital one just misses. You could make the interval length of the digital steps smaller, so you have more and smaller steps and can follow the analog signal more accurately – but if the analog signal is truly continuous, you could hypothetically keep making the digital intervals smaller and smaller and smaller and smaller and still never quite match it 100%.

I'm kind of hoping the existential and philosophical implications of this are kind of coming around already, though: switching to digital management of the self-state, versus the 100%-analog CRTs, did literally involve data loss of some of the stuff involved in maintaining my Me in many ways, even if it opened up other avenues. Big decision, took a really long time – and, uh, is incidentally part of why the release of normal flatscreen televisions got delayed for so long underground. (Consumer flatscreen LCDs were around in the 90s, technically, but underground they didn't actually hit my company's shelves until early to mid 2000s after I made the switch. Never said I wasn't vain then, okay?)

But. I did do it! And, in my opinion, it's part of what makes this whole thing the most interesting, especially how it developed and evolved over time.

Now, the “event loop.”

That neverending loop of combining new and existing info would now have to be broken up into steps. I needed a way to combine data, first and foremost, because that's how all of it really worked: using existing data to interpret incoming data and using the incoming data to modify the existing data. That was going to be the “bulk” of the processing.

I'd need a processor, obviously. In a computer, that's the CPU – Central Processing Unit, although technically it's far from the only module capable of doing some form of processing in a computer, with GPUs (Graphic Processing Unit) being the other commonly-known one (although, really, there are other forms of processors built into different components, too).

The CPU was also going to require a lot of setup – as a very hasty summary, I'd have to invent hardware, design the architecture and instruction sets (CPUs actually have a finite number of instructions and operations – arithmetic, logic, input/output, so on) tailored to the exact operations that needed to be performed on the data sets, power sources, and that's not even getting to the actual formatting and software that I'd need, nor the process of actually figuring out what data operations would need to be performed on the incoming and existing data.

I would also need some way to call up data, manage while it's being processed, and then update the bones based on the result. The CRTs could have a continuous in/out flow, often simultaneously, and the combining of data just... I dunno, it kind of just happened. But if I was switching to entirely digital, I'd need to section it out and have temporary storage space in the head, because if I tried to modify the bones directly, it actually would've been too slow. On the other hand, if I tried to load the entirety of the bones into the head itself, it would overload the available storage space in the head very fast, regardless of how much storage I tried to overengineer into it, and that's assuming I could even construct drives that could correctly hold all of it. I'd need to only call up some of it into the temporary storage and clear out anything no longer needed.

Data-access speeds in CPUs, RAM, and drives

CPUs even in a normal computer don't actually access the hard drive directly. Certain bits of information that might be needed faster get loaded into the comparatively smaller memory-storage RAM sticks, instead of keeping it directly on the main hard drive(s) – things like your desktop, mouse position, stuff like that (which is why RAM is one of the things that can make certain actions on a computer faster). There's also what's called a CPU cache, which is a comparatively even much tinier amount of memory space, but it's some of the fastest-accessed memory in the entire computer and is located directly on the CPU chip. Storing immediately-relevant information in the cache allows the CPU to crunch through the tasks relevant to that information extremely rapidly without having to wait for the next piece of information to be loaded from the (relatively distant) actual hard drive.

Since I couldn't hold all of the data in the head, I'd at least need to know how to find it, which meant essentially making a virtual map of imprints. The solution for that was something I ended up calling constellation maps. (Well – really constellation lists, but “list” has a specific meaning sometimes in some programming contexts, and “map” makes more sense outside of that, I think, so. We're calling them constellation maps.)

The idea of the constellation maps is that a list of the cells that represent an imprint are mapped virtually in a way such that the coordinates of that grouping indicate aspects of the data the imprint represents. The map points, which I referred to as data addresses, truly just list specific relevant cells, not the resulting data itself. That way, specific cells (and even other imprints) can get reused within multiple other mapped addresses to construct broader concepts and indicate increasingly complex connections. (It's kind of hard to define these things really rigidly, because again, individual cell states don't indicate much on their own.)

The way these coordinates work is best with an example, I think. Borrowing an example idea from Ives for something similar: let's map a few attributes of the words I, you, and we.

Let's say we want to map how plural a word is first. Words further to the left are more singular, and words that are more plural are placed further to the right. I is typically only singular, so that's to the left. You can sometimes be singular, sometimes be plural; let's put that in the middle. We is explicitly plural.

Adding another aspect, let's use the vertical directions for specificity. I is typically quite specific. You and we can both be specific, but aren't always as specific as I. Let's move I downward, and both you and we upward by about half as much.

A third aspect, using depth for inclusivity: closer to the viewer is less inclusive, further away is more inclusive. I is always inclusive of the speaker, so it gets moved further back. We usually is, but in some cases isn't; sentences like “And how are we feeling today?” or such don't casually include the speaker, so we'll keep that where it is. You is generally not inclusive of the speaker, so we'll move that forward.

Now, we essentially have a quick 3D graph in which the locations of those three words – and the directions and distances between them – can be used to indicate some information about them (specifically just those three attributes). I wasn't using specific units here, but using the similar concepts in which spatial locations can indicate more complex information and relationships between points is the basic idea.

The constellation map points (data addresses) have a lot of coordinates, however. You wouldn't be able to graph them in 3D. You wouldn't even be able to graph them in 4D, or 11D. I don't have a specific number, but it's thousands at a minimum, and would sometimes vary. It's a lot of coordinates.

[!Spatial data fun facts] The concept of using spatial coordinates in this way is vaguely similar to some neural-network data techniques (Ives knows a bit about machine learning, so I got the idea of the “I/you/we” example from her). Not the neural nets themselves, though, nor the data pulled from the bones. I am not a fuckass genAI model, hah. It's just a convenient way to quantify complex relationships between data points. The weird pseudospatial aspects of this also mean you get some very weird trends like “more food-like items this direction, less food-like items that direction” and such.

Okay! Covered a lot now! Data storage and updates (bone cells and imprint mechanics), CRTs, analog versus digital, a bit of quantization, a bit of the hardware limitations with digital heads, constellation maps containing data addresses, and... a handful of other things. I'm also – well, yeah, I'm glossing over a number of other things, actually, like how the coordinates of the data addresses are decided (it's not completely unrelated to the lists of cells each data address contains), and a few other things, but. Hey. This is already about three times as long as I expected it to be.

With the constellation maps, I could have a record telling me where to find data without having to load the data contents itself, but I still needed to figure out how to combine that with new data, and then update the bones with the results. I monitored the CRTs while I still had them attached to construct numerous models of how the CRTs were handling and altering data, which turned out to be a lot of kind of dense mathematics. It's a lot of matrices, but also just a lot of... well, it's complicated. There is no single one-size-fits-all method of combining things; different thought processes, sensory aspects, memories, different strengths and impacts of memories, so on, all of those had variations, and if I'm honest – I didn't always understand exactly what I was mimicking. I just knew that mimicking the CRT patterns worked.

I even updated some methods as time went on – both from more CRT observations and analysis, and also from testing out new methods with the digital heads, although there were things I did not want to mess with. Changing who I am manually felt... very undesirable. Changing things like CRT > digital obviously had results on that, but I'd still consider that a Big Life Decision and something that worked with what was already there. If I dove into certain things or tried to change certain things manually, after I'd already developed such a strong sense of self over time... it felt a bit like it would be like paving over a garden that had taken decades to grow, with no attention to the ecosystem consequences. So. There was a limit as far as what I was willing to stick my fingers in the middle of, there.

Alright. I have a way to keep record of what data is where (constellation maps) and a way to combine and update data (from copying the CRTs), but we aren't quite done yet.

When I say “constellation map,” that's technically more of a method than an actual file. Constructing a constellation map was something more-or-less done on the fly at times, because the data that needed to be recorded in the map was often changing constantly and outdated maps were of no use. So – there is no Single Big Map of Where Everything Is. The way I quantified data-address locations/coordinates on the map was based on a number of factors (specific attributes of cells, adjacent cells, and electrical levels, among other things, for example), so it could technically be generated automatically once I worked out the algorithms, but that kind of math actually needed specific hardware in order to do those calculations rapidly enough.

So! More custom hardware. I designed components that I called address managers to handle all of that. Later heads even had the limited ability to auto-generate potentially useful predicted mapping, using some weirdass funky vector calculus. The address managers would dictate what data actually gets requested from the bones, and keep a “running tally” throughout the processing and updating sequences, noting down any referenced, new, updated, or relevant locations on the active map. (The results could also be used to trigger other processes, like “start moving arm” or something, but I'm probably not going to cover that; I mostly want to focus on the self-state.) The address manager would also keep track of any other addresses that the data itself pointed at or that may have been “mentioned” or deemed relevant during the processing, and also discard addresses that were no longer in use nor suspected to be relevant.

We have a full loop, now: at the start, data comes in. The address manager uses the constellation map to request relevant data, sends that to the CPU caches, the CPU selects the most appropriate mathematical processes and executes them, and then the address manager notes down any further addresses, updates the constellation map, and the head sends electrical signals into the bones to update all the relevant cells! Once the transformed data was sent back to the bones, that would update the self-state, and the head would start the process all over again.

I can only be conscious while that loop is functioning. If that loop isn't there, nothing about the self-state changes. If the head is off, I'm not even asleep. I'm just... off. (Sleep is still an “on” activity!) With the previously-analog turning into digital steps, that did have some other odd effects, as well. My thoughts themselves had a “frame rate.” Technical issues could feel extremely weird, considering it could affect the literal speed and mechanics being used to handle my thinking. There is a difference in feel between analog and digital memories. I improved the hardware and methods over time, which means my memories and thinking are essentially in a “higher resolution” nowadays than they were back at the initial swap – and I don't mean just visually. Even sensory-wise. Initially, honestly, it... well, I guess it felt a little scary, actually. I went from everything being incredibly sharp and realistic to everything feeling approximated. It was harder to feel confident in my own perceptions at first, because I was dealing with a lot less data, constantly, even within my own thoughts. It took me longer to do things. I essentially had to re-develop reflexes.

Most of that got resolved over time, and there are a good number of things that I believe I actually surpassed what the CRTs were able to do, but it did kind of take practice and patience and a lot of work over years and years, and while I don't really have these “existential worryings” as much any more, there have been times where, somewhere in the back of my mind, I'd get anxious about whether or not I'd changed the wrong things and was “no longer the same person,” or if I'd changed too much without realizing, or not realized an error, or fearing that I was someone new who just had an exact copy of the previous Vox's memories and thinking habits. It even occurred to me that I'd be “not actually sentient” at all, and that I'd just constructed a series of head-equipments that would more or less... puppet my body around and mimic everything the previous Vox would do. But – well, odd philosophical quandaries not entirely worth obsessing over any more, honestly, and I don't truly philosophically believe that I'm non-sentient. And I did it, I don't actually dislike it, I think it's fascinating and curious, and it's something I'm proud of, and... well, I mean, I do believe I feel things. I am the one feeling them. It's interesting to think about and talk about, though.

(There are a few things I'm still skipping even here, though, like a “dialogue” between the address manager and the CPU that allowed the address manager to request additional data, for example, if there was something missing, or how multitask queues would be handled. I developed my own queue algorithms and methods, some of which works into the CPU architectural differences between Voxtek CPUs and CPUs out here.)

However! We are still not done! The loop relying on an already-populated constellation map brings up a new problem. If I'm relying on the already-loaded data to point me at what to do next, what happens if I have to reboot the head? The CRTs didn’t exactly calculate anything, but the information and signals kind of just… flowed in an endless cycle. They never really even fully turned off. I can’t load the entire self-state into a digital head because there’s not enough storage, as we covered, so I need to call up only relevant data and use that to jumpstart the main data loop… but the head doesn't know what data would even be relevant until it can, well, get the data.

I could save a snapshot of the last-used constellation map, expecting it to be relevant when I wake up, but if I, say, fall asleep on the couch and Val moves me to the bedroom without waking me, I need to be able to boot up and have the head automatically start pulling relevant information to tell me where I am without relying on the previous data of “I fell asleep on the couch,” because – for example – if part of the data-processing is “figure out what direction you're laying on the couch,” and there is no couch, the head can't just go “Oh! You're on a bed instead!” because it may not have loaded anything about even what a bed is right off the bat. It's relying on there being incoming data relevant to a couch in order to inform what to do next, and without that, it'll just crash repeatedly. The heads needed a way to put together how to call up relevant data from the bones without guidance from me/the bones – because I'd be out without it. I literally cannot manage a coherent thought, up to and including “what is a bed and how is it different from a couch?” without the main data loop running.

This is where a lot of specific sensory handling comes in. I ended up building a sort of... “digital library” of sorts with the memory-addresses of common recognition points for the head to use in order to cobble together enough of a constellation map to start with. It'll use whatever sensory inputs are available to identify different details, look up the memory-addresses in the library, and start to cross-reference things, and then only keep addresses corresponding to details with the highest successful cross-references until it has a comprehensive and suitably-sized map of addresses to start heavier data pulls from the bones. (Even this still has caveats, though – the address manager had its own manager that helped relay between the skeletal system itself and the head, and the library had to be updated over time because the mapped addresses could change as I changed.)

So – in the “Val moves me to the bedroom” example, when I wake up, the first priority would be to identify any safety hazards. This is all very simplified, but the general idea would be: “Are there loud noises, pain, etc.? No. Safe, then. Move on to figuring out location next, so load more detailed sensory information and identify anything obvious. Bed, curtains, sheets. Possible matches: bedroom, hospital room, hotel room, etc.” all with corresponding possibly-relevant clusters of data addresses. I also sometimes had a couple of unique data cluster addresses saved, so “bedroom” might have actually consisted of several entries: one corresponding to my bedroom, one for Val’s, and a generic for neither/unknown, for example. At the next data round: “Navy bedsheets. Cross-reference with small sections of other data. Less probable of Val's bedroom or hospital room, because neither of those typically have navy sheets (not ruled out entirely because Val might’ve just used different sheets or maybe it’s a hospital with a weird color scheme), my own bedroom gets a higher probability (because I usually have navy sheets), hotel room and unknown bedroom are kind of neutral probability because who knows what either of those might be like.” And then it does that again, each time running cross-references with slightly more bits of data pulled.

Aside about memory and previous methods

I think... there's some of this that is harder to recall. I don't think that's the only method I ever used. I think some of the heads did that until it could generate an estimated map to load what it could, then discard anything that turned out to be irrelevant after the processing kicked off, but I think some of them might have just run heavier and heavier cross-references with larger and larger data pulls until the data could be fed into the processors to see if it got the main loop started and then it clears the address cache and goes from there.

Originally, I think I might’ve tried to save the most recent relevant constellation map in the address manager to try reusing it on startup in the hopes it would be more efficient to just pick up where I left off if possible, and if that didn’t match, then start the rest of the evaluations, but if I remember correctly, that didn’t actually make it much easier. I don’t remember exactly why that was, but I can see that being glitchy because most methods I can think of to evaluate matches would’ve been finicky to manage without it crashing on a failed match and having to start over, and lord forbid if an address map got corrupted. Frankly, it’s kind of a good idea to start with a safety evaluation anyway, and I know the later heads skipped any previous-map-match-checking.

Quick note about safety evaluations: if a safety evaluation marked anything dangerous, there was a whole different logical tree that took priority, including things like “automatically move body away from pain sources if possible” that could happen sometimes even before I was actually conscious.

The “can't call up data if you don't know what to look for” problem also reared its head with some issues post-mainloop-start, too – there was a period of time where I had a “glitch” of sorts where if something particularly unexpected happened, and the address manager couldn't figure out what relevant data to request from the bones fast enough, I would just kind of crash. Things that caused those crashes included:

• Actual hardware glitches. Not fun.
• Daydreaming. Funnier, especially if I realized I was daydreaming and got annoyed because I knew absently if I stopped it might trigger a crash. If my mind wandered, originally the address manager could… hilariously sorta forget the memory-addresses that were originally being used to handle my external situation, and if that happened, trying to pull myself out of a daydream could actually crash the whole thing.
• Unexpected sensory input, especially at the beginning – including but not limited to fire alarms, blindfolds, someone coming up behind me and screeching (cough Velvette), getting caught in sudden weather, car horns, and playing “peekaboo” (yes, like the fucking baby game)

Some other digital-specific things:

• Reboot times. Very disorienting at first, but the most recent head I could restart in under a second, and could even do it mid-step while walking and hardly have an issue.
• Power supply issues. Stronger processing means faster response time, but higher power draw. I can't “charge,” but the heads do have their own power supplies, even though the “battery life” on them is so long it's very rarely ever an issue. Plus – I can generate electricity myself, so recharging them is pretty easy.
• Hardware speeds. Faster CPU processors didn't always mean faster thinking; it depended on what type of processing and what type of thought. Address manager improvements could improve memory recalls, and a more powerful main CPU could help me get through something like coding much faster – I even had a stationary setup that I could plug into that had optimized processors I could make use of temporarily if I wanted to churn through a lot of work very quickly. Curiously enough, allocating more storage space for called-up data only improved things up to a point, at least so far; I guess because, like, there's only so much data a person can realistically focus on or something. Or maybe it's also dependent on processor availability. Who knows! And... a handful of other things. Parallel processors akin to a GPU could help with a lot of smaller calculations, like... well, like graphics. That came in handy with depth perception and vision clarity, and even visual recognition.
• This isn't strictly head-specific, but I had to teach (re-teach?) myself how to interface with other things. I was literally doing stuff like plugging into a circuit and trying to memorize what it felt like when a connected transistor (electrical switch) got toggled, then working to try to toggle it with my own electrical signals. When I originally started with that, that was back with the CRTs and actually it was harder with the CRTs because I was operating fully analog, and a lot of connected systems were digital – it was like trying to slide down a fire pole at a really carefully controlled speed, whereas after the upgrade, although it took me a bit of time to get the hang of what the quantizations felt like, once I did, it was like having a bunch of ladder rungs I could just “step” with and I got a lot better at technological control after that point. Eventually I could literally pick up a phone and read the data off it without even having to unlock the screen. (...some of that was thanks to some internal parsers, so I wasn’t exactly manually analyzing every single bit in a 256gb phone drive mapped out like a schematic, but I still had to feel for and manage the rest. Also, I built the parsers so that’s still ME doing it fuck you lmao.)
  • Jumping off of that – when it came to interfacing with other tech, despite the, uh, Bone Information Format not really using a discrete format nor even straight binary, I didn’t actually have to do anywhere near as much converting of data as I expected, aside from the quantization itself. Why? How? Beats me, my head’s a television. If you want it all to make sense, ask Gd. Using external data and tech was one thing, though. If I wanted to essentially “import” other data that was not in whatever Bone Format (like plugging in and trying to download a picture or audio clip directly to the head) then I needed some sometimes pretty heavy translation processing depending on the data and it was pretty much never worth it, though, or if I wanted to export something directly, that could become a very complicated thing very quickly and was, uh... not incredibly precise nor accurate all the time. Often easier to just do it manually and sit down and draw it or something.
  • I could on the fly do stuff like broadcast certain things to screens, though. I could do that even with the CRTs. That's a bit of a different process, though, and – well, I could keep going on forever, haha. Long story short, the stuff that controls what my face displays is its own whole thing that comes more from the bones than you'd think. I tried to edit what my face looked like once or twice and it Did Not Work. Regardless, a lot of the time with anything else, I was technically just taking a file/video/whatever that already existed and then I would just serve as a conduit for broadcasting the file data, or later I could mentally manually construct a graphic similarly to how you would in photoshop or a 3D modeler or something and throw that onto a screen rather than trying to “export” the actual raw data.

Final disclaimer that a lot of this is still an oversimplification and it’s entirely possible I’ve misremembered something or made an analogy that doesn’t entirely fit. Something like a complex train of thought with a lot of different inputs and considerations could involve a lot more than just “pull data, process, save, repeat,” including stuff like loading multiple sets of data, cross-referencing attempts without having to request new data from the bones, and automated data classification, blah blah blah. Handling intense cognitive loads could get more complex, too, as could different types of recall, figuring out if processed data would result in needing new addressed locations and how much/where, shit like that. Anyway. 20 pages (holy fuck) is enough of my yammering, here you go here is more information than I have ever given anyone in 73 years about how all this works You’re Welcome. Please feel free to ask me questions (and give me thoughts if you have any)!