Solid State Rhyme: A Novelette (Mandate) (6 page)

Chapter 8

Daniel wasn't sure what to do next. Should he leave the system alone to see what happens? Should he create some new programs for the system? It was only Monday night, but he had no intention of going out. Actually, he wouldn't mind playing InterWorld again at the arcade to see what his fellow Knights of Honor were up to, but he was just too excited about his artificial life forms. Daniel examined one of the most recent generations by capturing a micro as it came out of Memphis, before it passed into the quad pool where Pharaoh would eventually pick it up.

Daniel sent the micro to the printer. It was less than a page in length, spilling out its guts to hard copy. It was definitely unreadable in machine language. He would need to see the micro-program source code. Daniel sent the micro's code through a translator. It was similar to a disassembler but based on his emulation engine. The micro's quad-functions were converted into human-readable instructions. Daniel sent it to the printer. The disassembled code listing was ten pages in length.

Daniel wasn't prepared for this revealing discovery. His three programs were designed to create simple, basic micros. This micro was complicated! It fascinated him that the listing he held in his hands represented a functional program, evolved over a stretch of uncounted billions of generations. He wasn't even sure what this micro could do. He transferred the micro to an isolated copy of the simulation and ran it.

It didn't do anything. At least, nothing Daniel could see. He ran a debugger and watched the micro running through its instructions. Some of them made sense, in a logical way. But, overall, Daniel just couldn't comprehend it. Compared to a quad, it was incredibly complex. He recognized sections of code that appeared to jump back into the program in certain places. This seemed to indicate that the program was capable of recursion. There were sections of code that could modify properties inside a quad-function, but he couldn't find any references outside the scope of the program itself. In other words, it was self-contained. It did not call upon the resources of the operating system or any external functions. Daniel couldn't tell how any of the code could possibly work. It was just so convoluted, so complex. It looked like random nonsense to his trained eyes.

Daniel continued to watch it run through the debugger for a while. It seemed to be doing things at times: counting, looping, comparing, and copying bases. Of course, running at such a slow speed, in order for Daniel to watch through the debugger, meant that he couldn't see what the micro-code was trying to do. It would have to run at full speed in order to reveal its functionality.

Daniel turned off the debugger and let the micro run naturally. In a period of about ten minutes, as Daniel watched, it gradually slowed its activity (whatever that was), until it finally came to a disturbing halt. Then, it either just stopped all activity or it might have
died
.

Daniel frowned. Perhaps this one was a bust. The Pharaoh program only guessed at correct instruction processes when producing offspring. However, it could not validate the function of each one. How was he to know if, among the countless generations, any single program was working properly?

Daniel ran the micro once again. It wouldn't run. As soon as it started, it died. This meant that somehow, during the first run of the program, it had modified itself so that it no longer functioned. Daniel scratched his head in puzzlement.

Daniel gave up on the a-life project and moved on to other interests. He was still curious enough to let the kernel programs (Nile, Memphis, and Pharaoh) continue to run, but he didn't monitor them. They were set to a low-priority thread on his padd and set to pause during heavy use, but that proved to be a nuisance in time due to memory consumption. He moved everything in the project over to the home server. As a home maintenance computer, it was not superserver class, but Daniel tapped into it from time to time to store backups and run processes when he was too busy with his padd. Before shutting off the system on his padd, he logged into the home server and gave the simulation higher-than-normal priority.

*

Days turned to weeks and Daniel all but forgot about the project. He might not have touched it for the rest of the school year if the home server hadn't started acting up—missed alarms, misreading the thermostat, not opening the garage door when asked, losing voicemails, and similar disruptions. Dad wasn't concerned because it was just a little black box in the study, but Mom was upset with all the problems, so Daniel promised to take a look at it.

Daniel discovered with a shock that the home server was out of memory. He had never heard of such a thing, with the phenomenal memory capacity of a server. Even a year-old padd had more memory than anyone could reasonably use. He couldn't believe the memory was full, but if that was the case, he was pretty sure it was his old experiment gone awry.

There were probably trillions of quads wasting space. Daniel decided that the system would have to cope with the problem of limited memory. There was no way for him to remove the living from the dead, since he had no idea what they were doing any longer. He couldn't tell active micros from inactive ones. This would be the first major obstacle for the micros to overcome, and would either “make 'em or break 'em.” So, he wrote a helper program to assist with cleaning the pool of unneeded—well,
bodies
.

The next day, everyone was pleased that the home server was working again. Daniel discovered that, not only was a huge percentage of the server's memory freed up, but his little critters had more than quadrupled in number. He checked out the memory status: 75 percent free.

Daniel tested the kernel programs—all three checked out. He hadn't touched the programs in months but was glad that he could let it run—just to see what might happen. Probably nothing would come of it, but he was curious to see what might develop over a very long-term run. He decided to take a peek into the environment to see what the latest generation looked like. How many billions of generations did this now represent?

Human civilization was not more than 20,000 generations old.

To his surprise, there were not nearly as many micros as there were before, from millions in the pool to just . . . a few
thousand?

A subtle itch formed in the back of Daniel’s mind, of which he was only vaguely aware. Was there something he had not considered, something he had forgotten? He sat back in his chair and rubbed his eyes, which burned from staring at the screen. He looked at his watch—he had been sitting at his desk for four hours already, and it had felt like only a few minutes.

Something was bothering him, a subtle nagging at the back of his mind. What had he missed that his subconscious was trying to tell him? He checked for messages and browsed the social pages for a while to give his mind a break. A thought was lingering at the edge of his consciousness, tantalizing him.

*

The next morning, Daniel awoke still pondering the problem, and felt at once some clarity. The micros must be reproducing without the use of the Pharaoh program. What else were they doing on their own—and
how
was that even possible? Were they also killing each other? Perhaps that was too harsh a word. It was analogous to clearing a forest for use as building materials. He imagined the micros waging enormous, fantastic wars for control of resources. The change had begun as soon as he had installed the cleanup program.

Daniel figured the Nile program was no longer needed, and neither were the other two programs. Shutting them down would not make much difference to the server, and the micros seem to have had adapted to over-crowding before the memory problem was resolved. Daniel had no way of knowing, short of trying it out, what would happen if he were to remove the kernel.

Hold on! There is a way.
I can take a micro from the server and run it in the empty padd.

Daniel tried it. This time he removed an active, “wild” micro from its environment, rather than a newborn from the kernel stream. It was difficult to distinguish one micro from another. He had a difficult time tracking one long enough to grab it. It was like using a bucket to remove one water molecule from a bathtub. Each time he tried to copy a micro from the pool, it would change, move, and blend with the countless others.

Daniel realized he didn't have the right tools for the job. His utilities were designed for standard, predictable programs and files. He needed to build some new utilities to track and copy these micros. He realized the task was just too difficult, and he didn't feel like writing the code to do it anyway.

No, that’s not right. I don’t know how to do it! I’ll have to compromise.

Daniel paused the environment and copied an entire section from the environment to his padd. Then, he had it resume running again.

Daniel was able to isolate one micro on his padd and brought it into the debugging software, which displayed an active memory map. At first, it did nothing. (The shock, Daniel imagined). After a couple of minutes, it moved! He watched it move, right there on his screen! Daniel was ecstatic. This was extraordinary!

Wait, where did it go?

Daniel scrolled the memory map, and found the micro. It was just sitting there in one spot. Daniel looked at the area around the micro, and his mouth dropped open with shock. Right there, next to the micro, was the old specimen he had taken months ago.
The one that had died.
He increased the detail of the display in order to see what was happening. The micro was . . . messing with the old one. He could see the code in his debugger tool window.
The micro was . . . looking at the code of the dead micro?

Daniel shook his head in wonder, trying to rationalize what he was observing. But, it was really happening. He had a computer program that was acting on its own, without a predefined set of instructions.

Daniel couldn't follow what was happening. The instructions flew by in the debugger window too fast, and he couldn't make sense out it anyway.

Only a few seconds had passed when the micro moved again. Somehow, it was taking the old one with it. Daniel laughed aloud. To him, it looked like a soldier ant carrying a fallen comrade to safety. He wasn't even sure if ants did such a thing, but the thought amused him just the same. He followed along, scrolling the memory map when the micro moved.

Daniel wondered how this was even possible. Having a program act on its own wasn't
that
amazing. Even writing a program with behaviors he was witnessing was feasible. Consider, for instance, an anti-virus search and destroy program, which looks for viral marker codes in program files. The difference here, however, was simple: this program was not designed! It was a mutation, an evolved set of highly complex instructions. This was no virus.

But it was ridiculous! There were billions of generations separating the two, and yet, the modern micro saw something familiar, a kind of ancestral mark or algorithm. Daniel considered the situation. If a single individual micro could display such advanced behavior, what about the group as a whole? He couldn't shake the impression of an ant farm from his mind.

Daniel started the debugger on the server, and again opened the memory map window. Everything was moving! He couldn't find individual micros. It looked like currents and streams of bytes moving, stopping, like city traffic—only faster, more efficient. What could they be doing? Suddenly, his debugger was terminated, without explanation or remorse.

“Hey, what the . . . .” He waited a few seconds for a familiar female image to appear on the screen to explain the problem. Nothing of the sort happened. Daniel lifted his hand from the input panel, as if the keys were about to bite him. He watched in utter amazement as the screen contorted, flashed, and then went completely blank.

It had been quite a while since Daniel had seen a computer crash like this. He feared a virus, then laughed at the ridiculous thought. Virus code was a problem of the past—the ancient past when computers couldn't take care of themselves. Besides, viruses had been rendered sterile when operating systems designers began encrypting their executable modules. It was still possible for a virus to infect the core operating system, but what would that accomplish? It would be unable to do anything, and it would have to be written for specific hardware. There were just too many different processors now, so that was unlikely.

Seconds later, the screen returned to the debugger window. Daniel tested the keyboard and screen, skeptically. He half expected it to shock him. It seemed to respond more quickly. He experimented with the screen, scrolling and zooming in and out. The padd was behaving like a next-gen model! (His was two years old). It was easier to use, smoother, more dynamic—as if the padd was
eager
to help him, trying to anticipate his needs. After a few minutes, the screen became more intuitive. As he was about to tap an icon, it opened automatically.

Daniel spent a half hour opening apps and testing their basic operation with the help of this
new padd
. On occasion when the padd anticipated wrong, the action was quickly reversed and the mistake rarely made again. Daniel shut off the debugger and loaded his favorite text editor.

Nothing unusual happened for about a minute. Then, the editor closed by itself—the way the debugger had been closed. This time, however, the whole computer didn't crash. It looked the same, but acted very differently than it was supposed to. It seemed . . . eager to help. Almost too eager. The slightest hint of input caused triggered actions, based on context. For instance, if he was sending a text, and paused after typing, it would send itself.