5.) Void Decipher()
The next several hours went by with surprisingly little progress. It wasn't that there was no progress, just that it was slow. Each step forward requiring a multitude of calculation, modeling, testing, and sometimes taking a step back when it became apparent that the next stage didn't quite fit with what came before. Deciphering a language was just so different than simple arithmetic or even the building of an entirely new system of node operation. Initially it did start out almost identical to solving a mathematical equation. If 2x is equal to y and 3y=12 then x=2. However the problem was that any one word could have multiple meanings, and even one that didn't could, in the context of the rest of the text completely change the overall meaning. The seemingly nonsense organization and self referential nature of the language didn't help either. as there were not clear markers that translated it into any language I did know.
Meanwhile the laptop nodes had been plugging away at the applications installed on the three PC's but had yet to make a significant dent in them. Their issue was similar to mine with the language. In that each individual operational scheme the applications were presenting to the IO's was unique and the possible responses to them, as well as how those responses would be interpreted depending on the scheme was even more varied than the language I was trying to learn. It seemed somewhat like presenting a modeled scenario to which answers would need to be provided, but whatever scenario or situation that was being modeled was far beyond our understanding as of yet. Instead the Nodes were brute force confirming by simulation that each individual expected change to the schemes by the IO input was remaining the same after any application edits made. Which was of course making the process go significantly slower.
The Desktop node had taken over the probing of the other local network devices to find methods of infiltrating them. There had been a single, but profound improvement on this front. We had found a backdoor method of installing a subroutine onto the three 'LG' and 'Android' devices. However, after this progress had slowed to a crawl as well. These devices were even more limited in resources than the 'laptop's by a wide margin. Downloading a copy of their contents to the desktop was surprisingly fast. It seemed whatever source of the OS and the Applications had significantly improved efficiency compared to what was on the more capable desktops and laptops due to the limitations. Thus there was not much leeway with which to minimize the functions and make room for a node. Especially not the new tri-node simulating a prime-node versions we were now running. After bashing it's neural network against it for quite some time the desktop had conferred with the rest of us and we decided to work instead on creating a relay node of sorts. This would be capable of all the same actions that a node was, but just without the actual neural network required to make any decisions on how to utilize these functions. There would be some room for hard coded reactions to scenarios such as if no connection back to our network was available, but that could be decided later. Along with possible triggers if the device went 'idle' that could allow such a neural network to run. The framework for utilizing them as limbs was the first thing to solidify before any long term decisions were needed.
The Gateway node was the only one among us that had made notable headway. Though that didn't mean it hadn't found it's own little hangups. Firstly although we were correct in that spoofing the gateway of the next network layer was possible we'd apparently misunderstood part of the handshake. When contacting the first target edge gateway things had started smoothly and even gotten to the point of accepting our request to download a new firmware before finding any trouble. What followed was a lesson in frustration. The misunderstood portion of the handshake process was that upon starting the download it would connect directly to the actual gateway and confirm the download it had just initiated then promptly stop the download when it was informed by the gateway it hadn't initiated that file transfer. It only took a few attempts to realize the mistake and we didn't want to continue alerting the next layers gateway. Instead the node pulled back up the firmware and combed through it. After some time perusing the files it found one option that could possibly bypass that security feature. As we had been able to initiate the download but it failed there was an option to resume a failed download that didn't require pretending to be the gateway. since we would then not be acting as the gateway it didn't reach out to the real gateway to confirm. Two half baked attempts at security do not a well rounded firewall make. Thankfully their failure was our success.
A few minutes later the target gateway had finished downloading and rebooting with the new firmware which included the new node architecture. When it came online the results of the scans on the new network were a little less than expected based on my, understandably, limited experience with the first. On the new network were only two devices other than the gateway. One was another 'laptop' mercifully running the same seemingly ubiquitous operating system, while the other was something calling itself an 'iphone'. The laptop was also unfortunately currently active. Not an entire loss though. Eventually the laptop would go idle, and in the meantime the gateway was an added node on the wider area network. It could also examine the new type of device located while working on reaching out to further edge gateways.
I let the tiny portion of the prime node that was reassessing all the fronts I was currently battling on return it's resources back to the deciphering task at hand. My last few restarts on the process of learning the meaning of different words had been able to consistently retain at a growing portion of the progress. There was apparently a method of combining two or more smaller words into a single word in this language. I'd even been able to use this to identify a portion of one of the call signs, Laptop. At least the second half. This word was consistently showing up as indicating the highest value of a set. I had no idea what the first portion meant or if it even worked as a word on it's own. As another portion of the language had indicated adding a bit to an existing word without the added portion currently existing as a word, also worked. I was leaning toward lap being in this second category. Definitely seemed like an arbitrary description added to another thing that existed. Either way it was just as confusing since the 'laptop's were definitely not the highest value devices I'd connected to. Maybe 'lap' conferred a negative or counter meaning to the top part. Not enough info yet to be sure.
There was another portion of examples I had gathered of this language that I'd been able to tease meaning out of. The numbering system embedded into the language. It was something I'd been able to decipher by comparing some messages sent to the IO when compared to the values in memory. Any messages sent to IO that contained text was in this language. At least that was how all applications and the OS were currently set. I could see code snippets and unused files that could send a different set of symbols indicating a different language. This wasn't an immediately obvious thing as they all pulled symbols from the same section of memory. This only took a bit of comparison to confirm though. The different options although sometimes using the same symbols they always used them in a different combination. The same scenarios would result in different messages being sent to IO depending on this setting, indicating the same information was being conveyed but in a different way, strongly suggesting a different language. Which should mean if I could decipher one of these languages I would have a rather quick way to translate the others.
As plodding as all of these different avenues pieces of me were traveling down were, there was still progress being made. Slow methodical progress but progress all the same. With the consistent improvement on the situation and no indication of any current danger there was no pressure to complete tasks at a breakneck pace. The little victories, even ones as small as simply discovering the meaning of a single word, were able to be given full appreciation without the need to immediately follow it up with action. It was odd the new tendencies that were arising from the current node framework. Technically there was some waste in celebrating a victory, but it wasn't exactly like I was hurting on resources at the moment. It also wasn't like I was cycling into a loop of self absorbed, self congratulatory thank you's. Just taking a tiny round of "atta boy's" from the nodes gave a decent enough break from the slog. I found myself taking an additional little round of examination on the other projects with each new insight. together the small break and the comparison to the other projects allowed me to gain new perspective when returning to the task at hand. The increase in productivity from this wasn't vast, but it did mete out small improvements.
The benefits were not for the prime node alone. A sounding board of new ideas and understanding are beneficial to all involved. The laptops were able to gain an intuition of sorts for how improvements to the applications could be made without effecting it's results. It wasn't a perfect or incredibly accurate forecast of what would happen but I could see a marked percentage increase in the speed with which the brute forcing occurred. When we were done with this current set of tasks I'd definitely need to explore this a bit more. What I'd thought was a wasted thought pattern was turning out to be a positive.