C

Leo made his way back to the rooms, his mind still spinning from everything he had just learned. As he turned a corner, he nearly bumped into Brielle. She paused, looking at him carefully.

“You alright?” she asked.

Leo hesitated. The weight of his mother’s words still pressed against his thoughts, but he wasn’t ready to talk about it. Not yet. He took a deep breath and said, “I’m okay.” Then, after a brief pause, he added, “I need a favor.”

Brielle raised an eyebrow. “Oh?”

“I need to program,” he said firmly. “I need to keep my mind busy. Any chance I could take a few programming classes?”

For the first time since she had met him, Brielle genuinely looked surprised. But the surprise quickly turned into something else—pride. She grinned. “Spoken like a true companion.”

She folded her arms. “You’re the son of our commander in chief, and we’re surrounded by the best programmers in the world. I think we can arrange something.”

Without another word, she gestured for him to follow. They walked through the underground corridors of the Senate, turning into an area Leo hadn’t seen before. The lighting was dimmer, the atmosphere quieter but charged with energy. Brielle glanced back at him.

“We’re entering the Bellardian quarter,” she explained. “These are the experts in C, emulation, low-level optimization—everything that will be useful to you right now.”

She pushed open the door to a large common room. Inside, several people sat at workstations, the glow of monitors casting soft blue and green hues on their faces. Some were deep in discussion, others typing furiously. A handful of them looked up as Brielle entered.

She cleared her throat, getting their attention. “Everyone, this is Leo, an apprentice and the son of the commander in chief. He just finished his assembly training and is looking for a C master.”

The room fell silent for a moment. Then, a few of them exchanged knowing glances, smiles forming on their faces. A man who appeared to be their leader stood up.

“I think we can arrange something for our friend Leo,” he said, stepping forward. His eyes gleamed with amusement. “I must confess, I’m a little jealous. I wish I could go back to the days when I first learned C.”

He turned and gestured for someone to come closer. A young man with sharp eyes and a confident stance stepped forward.

“This is Jeremy,” the leader said. “One of our best C programmers. He will teach you.”

Jeremy led Leo to a quiet corner of the room, where an old workstation hummed softly. He pulled up a chair, gesturing for Leo to sit next to him.

“Alright,” Jeremy said, leaning over the keyboard. “The first thing we should start with is a couple of basic UNIX commands.” He tapped a few keys, then slid a device over to Leo. “Here’s a link to get you started: http://closedsourcebook.com/terminal.html.”

“You should be able to do all the exercises using this terminal,” he added, “but you’ll be more comfortable if you install a terminal directly on your machine. It’ll be faster, with a larger screen, and just more convenient overall. It’s quick and easy to set up—just follow the instructions here: http://closedsourcebook.com/docker.html.”

Leo glanced at the screen. “UNIX?” he asked.

Jeremy nodded. “You see, the Bellardians—we have our own system. It’s a Linux system.”

“Linux?”

“Yeah,” Jeremy said, leaning back in his chair. “Unix was one of the first real operating systems. One of the most popular, actually. Then Linux came along—it was the first open-source version of Unix. And that changed everything.”

Leo absorbed the information, intrigued.

Jeremy continued. “A real programmer needs to understand how Unix works. It’s like C—these are the fundamentals. You can learn all the fancy high-level stuff later, but if you don’t know Unix and C, you don’t really know how computers work.”

Leo nodded. He had spent so much time learning assembly and automata, but this felt like the next step—a deeper level of understanding.

Jeremy smirked. “Alright, go on. Try a few commands. Let’s see if you’ve got the instincts of a real Bellardian.”

Jeremy leaned back slightly, watching Leo’s fingers hover over the keyboard. “Alright, let’s start with the basics. Type ls and hit enter.”

Leo did as instructed, and a list of filenames appeared on the screen.

“You see,” Jeremy explained, “this lists all the files in your current directory. These are the files stored on this machine.”

Leo scanned the list. “And if I want to see what’s inside one of these files?”

“Good question,” Jeremy said. “That’s where cat comes in. You type cat followed by the filename, and it will print the contents of that file to the screen.”

Leo nodded. “So if I type cat hello.c, I’ll see what’s inside hello.c?”

“Exactly,” Jeremy confirmed. “Go ahead.”

Leo entered the command, and a few lines of code appeared on the screen. He stared at them, frowning. “This looks nothing like what I’ve seen before.”

“That’s normal,” Jeremy said with a grin. “Welcome to C.”

He pointed to a specific line. “You see this? int main(void). That’s how you declare a function in C. And the part between the curly braces {}—that’s the function’s body, where the instructions go.”

Leo’s eyes widened slightly in recognition. “Wait… so it’s kind of like when I had a label called main in assembly and I was using CALL to jump to it?”

“Exactly,” Jeremy said, pleased. “C has functions, just like assembly has labels you can jump to. The main difference is that in C, functions are more structured—you don’t have to manually store and retrieve return addresses because the language handles it for you.”

Jeremy leaned forward. “You see, C is what we call a high-level assembly language. What that means is that every construction you see here eventually gets translated into assembly—just like the language you’ve been using so far.”

Leo nodded slowly, taking it in.

“But here’s the important part,” Jeremy continued. “With assembly, you’re writing instructions that are specific to a processor. And that’s a problem. Different processors have different numbers of registers, different register sizes, different instruction sets… If you write assembly for one machine, it might not work on another.”

“So C solves that?” Leo asked.

“Exactly,” Jeremy said. “C abstracts away the specifics of any one processor. It lets you write code without worrying about how many registers there are or how big they are. And when you’re ready to run your program, a compiler translates your C code into assembly for the processor you’re using.”

Leo’s mind raced. He had spent so much time working in assembly, thinking in terms of registers and jumps. Now, he was starting to see how a higher-level language like C could make things easier—while still being close enough to the machine to give real control.

Jeremy smirked. “Pretty cool, huh? Now, let’s break down this program and see exactly what it does.” Jeremy tapped the screen. “The first thing you need to know is that every C program has a main function. That’s where execution starts.”

Leo studied the code. “So when I run a program, it always begins in main?”

“Exactly,” Jeremy confirmed. “And see how main returns an integer? That’s because every program has something called a return status. It’s how the program tells the operating system whether it ran successfully.”

Leo raised an eyebrow. “Like… how?”

Jeremy leaned back. “Well, remember when you ran ls or cat? Those are also just programs running in Linux. Every time a program finishes, it returns a status code. A return value of 0 means everything worked fine. If it’s anything other than 0, that means there was an error.”

Leo nodded. “So when this main function returns 0, it’s basically saying, ‘I’m done, and everything went well’?”

“Exactly,” Jeremy said. “Now, let’s look at the first real instruction inside main.”

He pointed at the line:

printf("Hello, world\n");

“This prints Hello, world on the screen,” Jeremy explained.

Leo frowned. “So… it’s like writing to address 232 in the emulator?”

Jeremy smiled. “Not quite. In the emulator, yes, you were writing directly to memory mapped to the screen. But in most real systems, we don’t let user programs write directly to the hardware.”

“Why not?” Leo asked.

“Because it would be way too dangerous,” Jeremy explained. “Imagine if any program could overwrite your screen memory—or worse, if it could start modifying other parts of memory, like your keyboard input, network data, or files on disk. That’s why operating systems have a middle layer: the kernel.”

Leo was intrigued. “So how does printing to the screen actually work?”

Jeremy continued, “Instead of writing to memory directly, programs make a system call—a special request to the operating system. When you call printf, it doesn’t actually print by itself. Instead, it asks the kernel to print something on your behalf. The kernel checks if you’re allowed to do that, and if everything is fine, it prints the text for you.”

Leo sat back, processing the idea. “So… every time a program needs to access something like the screen, or maybe the keyboard, or a file… it goes through the kernel?”

Jeremy nodded. “Exactly. The kernel is in charge of managing all the hardware and making sure programs don’t interfere with each other.”

Leo grinned. “Okay… I think I’m starting to get it.”

Jeremy leaned in. “Alright, remember how I told you that C is basically a high-level assembly language? Let’s see what that actually means by looking at the assembly code that gets generated when we compile a C program.”

He pointed at the terminal. “Type this command:”

gcc -O0 -S hello.c

Leo typed it in and hit enter.

Jeremy continued, “Let’s break that down. gcc is the compiler—it’s the program that translates C into machine code. Everything that starts with - after it is an option. -O0 means we don’t want any optimizations at all, which is useful because optimizations can make the generated assembly harder to read. -S tells the compiler to output the assembly code in a human-readable form instead of directly producing a binary executable.”

Leo nodded as he saw that a new file, hello.s, had been created.

“That file contains the assembly code,” Jeremy said. “Now, normally, if you wanted to look at a text file, you’d use cat, but this one is long, so instead, we’re going to use less.”

Leo looked up. “What’s the difference?”

“less is an interactive viewer,” Jeremy explained. “It lets you scroll through the file one page at a time. You can use up and down arrows, press space to go to the next page, and Q to quit.”

Leo typed:

less hello.s

As the assembly code filled the screen, he felt a thrill of excitement. This was it—the raw instructions that made his program run. Jeremy leaned back slightly, letting Leo take in the flood of new information. “Now, it’s not necessary for you to understand every detail of this assembly code just yet,” he said. “This assembly is more complex than what you’re used to, but all the same principles apply. The registers are bigger, the instruction set is larger, but at its core, it follows everything you’ve already learned—jumps, function calls, an execution stack. The basics don’t change.”

Leo studied the scrolling lines of assembly on the screen. “But if C doesn’t explicitly use registers like in assembly, how do we tell it that we want to perform an operation?”

Jeremy grinned. “Great question! In a C program, you act as if you’re directly modifying memory, not registers. The compiler takes care of the details for you.”

He typed on the keyboard, pulling up a simple example. “Let’s say you want to work with a number. Instead of assigning it to a register, you declare a variable like this:”

int x;

“This tells C, ‘I want to use an integer, and I’m going to call it x.’ You don’t need to think about where exactly it’s stored.”

Leo nodded. “So what if I want to put a value in x?”

Jeremy typed another line beneath it.

x = 0;

“This means, ‘Store the value 0 in x.’ Now, behind the scenes, the compiler will translate this into a MOV instruction, just like in assembly. But the beautiful part is, you don’t need to worry about which register x ends up in—the compiler handles all of that for you.”

Leo watched the screen carefully. “So C takes care of the registers, and I just focus on what I want the program to do?”

“Exactly,” Jeremy said. “C is powerful because it gives you control over the machine while making it easier to write and understand your code. And that’s just the beginning.” Jeremy leaned forward, his fingers dancing across the keyboard as he pulled up another example. “And it’s not just basic operations like assignment—everything you’ve learned so far, like branches and loops, has a direct equivalent in C. But instead of writing multiple lines of assembly, you can express the same logic in a much simpler way.”

He typed:

if (x == 0) {
  printf("Hello\n");
} else {
  printf("Hola\n");
}

“You see?” Jeremy said, turning to Leo. “That’s a branch.”

Leo’s eyes widened. “So that’s the same as writing a CMP followed by a conditional jump?”

“Exactly,” Jeremy confirmed. “But it’s a lot more readable, right? Instead of manually handling jump instructions, you just write what you want to happen in each case.”

Leo nodded eagerly as Jeremy continued. “And this—” he typed another block of code, “—is a loop.”

while (x < 5) {
  printf("%d\n", x);
  x = x + 1;
}

“This loop prints the numbers 0, 1, 2, 3, 4 before stopping,” Jeremy explained. “The %d here is a special format specifier that tells printf to print an integer and \n is another special character that means new line.”

Leo leaned in. “So instead of writing a CMP, a conditional jump, and manually updating the value of x, C just… handles it?”

Jeremy grinned. “You got it! I told you, C is just high-level assembly. It’s the same thing—just way more convenient.” Jeremy leaned back, watching Leo absorb everything. “Now,” he said, “it would be nice if you could actually try running the program, right?”

Leo nodded eagerly.

“Well,” Jeremy continued, “before we can do that, you need to learn how to use a code editor. A code editor is the program you use to write and modify your code. Since programming is mostly about working with text, having a good editor—and knowing how to use it well—is crucial.”

Leo listened intently as Jeremy continued. “The most powerful of all code editors is called Emacs. The beauty of Emacs is that not only is it incredibly powerful, but it’s also customizable. You can modify it, extend it, even share your own extensions with others.”

Leo’s eyes lit up. “So I can change my own code editor?”

Jeremy grinned. “Not just change—it’s practically a programming platform in itself. Some people even joke that Emacs is a full operating system. You can do almost anything with it.”

Leo was intrigued. “Alright, let’s try it.”

Jeremy nodded. “Type this command: emacs hello.c.”

As Leo pressed enter, Jeremy added, “The first time you launch it, it might take a bit longer—there’s a lot of code being loaded. But don’t worry, it’ll be much faster the next time.”

A new interface appeared on the screen. Jeremy pointed at it. “Now, let’s modify your program. Replace the body of the main function—the part inside the curly braces—with this:”

x = 0;
while (x < 5) {
  printf("%d\n", x);
  x = x + 1;
}
return 0;

Leo carefully typed it out, making sure it matched exactly.

“Alright,” Jeremy said, “now you need to save and exit. To do that, type: Control-x followed by Control-c. In Emacs, you’ll be using the Control and Meta keys a lot. The Control key is usually written as C-, so for example, C-x C-c means hold Control and press x, then hold Control and press c.”

Leo repeated the sequence in his head before pressing the keys.

Jeremy continued, “The Meta key is usually written as M-, and in most cases, you access it by pressing Escape first. So when you see something like M-x, it means press Escape, then press x.”

Leo nodded, starting to get the hang of it. Jeremy handed him a reference card. “You can find a full list of commands here: http://closedsourcebook.com/emacs.html. Study it. Knowing Emacs well will make you a much better programmer.”

Leo glanced over the reference list. There was a lot to take in.

“Now that we’ve modified the program, let’s compile it,” Jeremy said. “Type:”

gcc hello.c

“This will translate your C program into an executable file. By default, the output file will be named a.out. To run it, type:”

./a.out

Leo did as he was told. The screen printed:

0
1
2
3
4

A smile spread across his face.

Jeremy clapped him on the back. “Congratulations! You just wrote, edited, compiled, and executed your first real C program. Now, keep practicing—open your Emacs, experiment with different commands, and make sure you learn the shortcuts. They’ll be second nature before you know it.”

Leo walked back to his room, his mind still buzzing from the C lessons with the Bellardians. As he strolled through the dimly lit corridors, a strange sound echoed in his head.

“I am the mooonster of the caaaveee oooohoooo,” a voice wavered theatrically, like a child trying to sound spooky for Halloween.

Leo stopped in his tracks, his heart pounding for a split second. Then, at the end of the eerie sound, the voice let out a giggle.

He immediately recognized it. “Jasmina?” he said aloud, unsure.

“Yes!” came the excited response inside his head.

Then, another voice joined in. “I’m here too!”

Sebastian.

Leo spun around, his eyes darting down the hallway. “What the—? How are you—?”

Jasmina laughed. “We got implants, dummy!”

Leo was completely baffled. “What?! An implant? Why? How?”

Sebastian’s voice carried a playful tone. “Did you really think we’d let you have all the fun?”

Still stunned, Leo rounded a corner and nearly walked straight into them. They were grinning from ear to ear, clearly amused by his reaction. Jasmina took a few exaggerated steps toward him, curling her fingers like claws. “The monster of the cave is here!” she growled playfully.

Leo rolled his eyes, but he couldn’t help but smile. They all burst into laughter.

Then Sebastian’s expression turned mischievous. “Check this out.” He flicked his wrists, and two drones shot out from his sleeves.

Leo watched as the drones zipped into the air with astonishing precision, moving so fast they were almost blurs, weaving between each other in perfect synchronization. They would dart toward one another as if about to collide, only to twist away at the last possible moment.

Jasmina smirked. “Not bad! But I don’t think you’re going to impress Leo with your drone skills.” She nudged Sebastian teasingly.

Leo shook his head, still watching the drones in fascination. “No, this is great, guys! But… why? You didn’t have to.”

Jasmina and Sebastian exchanged a glance before Jasmina said simply, “Because we’re in this together.”

They made their way back to their rooms, but as they turned a corner, they ran straight into Brielle. She stood with her arms crossed, her expression unreadable—except for the way her gaze lingered on Sebastian, heavy with disapproval.

Sebastian met her stare without flinching. He already knew why she was upset.

“Is it true?” Brielle asked, her voice low but firm.

Sebastian nodded. “It’s true.”

Brielle exhaled sharply, studying him. “You know what this means, right?”

He didn’t hesitate. “I know.”

She held his gaze for a long moment, her expression unreadable. Then, finally, she nodded, her tone unwavering. “Very well then.”

Without another word, she turned on her heel and gestured for them to follow.

They walked in silence through the winding corridors until they reached the chamber of the Senate. The great hall was filled, the air heavy with tension. Senators from every faction were present, seated in curved rows that overlooked the central platform. The weight of history pressed down on the room.

The chairman stood at the podium, his voice steady as he addressed the assembly. “The question before us: Should the Companions wage war against the machines?”

He scanned the room before continuing, “Those against, raise your hand.”

A sea of hands rose into the air—many of them from the Lecunist side of the chamber. Their expressions were firm, their resolve clear.

Then, the chairman took a breath and spoke again. “Those in favor.”

Across the hall, hands shot up—more than before. A wave of movement rippled through the chamber as the Catonians and many others signaled their decision.

The result was undeniable.

For a moment, there was silence as the weight of the decision settled over the assembly.

Then, the Catonians erupted in thunderous cheers. They jumped to their feet, pounding their fists against the tables, chanting in unison.

“War! War! War!”

The sound echoed through the halls, growing louder and louder, until it felt like it was shaking the very foundation of the Senate itself. Leo stood outside the Senate chamber, his eyes fixed on the large doors as they finally opened. But this time, he wasn’t waiting for his mother—he was waiting for Chancellor Aldor.

As the Catonian leader stepped out, flanked by members of his order, Leo took a deep breath and approached. “Chancellor, may I have a word?”

Aldor glanced at him, his expression unreadable. He looked at Jasmina standing beside Leo, then gave a small nod. “Make it quick.”

Leo didn’t hesitate. “Now that war has been declared, maybe we could plan an attack on the Inquisitor’s main office. If we strike fast enough, we might be able to save Elias and the Rector.”

Aldor’s expression remained firm. “Impossible,” he said without a moment’s pause. “The best course of action is to evacuate the NYC headquarters. They are gone.”

Leo tightened his grip. “How can you be so sure? We don’t even know if—”

Aldor cut him off. “We do know. The Inquisition doesn’t keep prisoners alive for long. You must understand, this war isn’t about one man. We must act strategically, not emotionally.”

Leo’s frustration burned, but he forced himself to stay calm. “But what if—”

Aldor shook his head. “And even if it were possible, the decision isn’t mine to make. Your mother is the one who would have to give the order.”

Leo’s shoulders tensed. He had expected resistance, but hearing it so bluntly made it worse. He turned away sharply, walking off down the corridor, Jasmina and Sebastian following closely behind.

Once they were out of earshot, Leo let out a sharp breath. “We have to do something,” he muttered. “If nobody else is going to try to save Elias, then we have to.”

Sebastian sighed. “Leo… it might already be too late.”

Leo exhaled through his nose, nodding. “Maybe. But I need to know.”

Jasmina tilted her head. “How?”

Leo’s mind was already racing ahead. “If I could connect to the outside network in a way that’s secure, I could try to reach Marcus. If Elias is still alive, Marcus would know.”

Sebastian and Jasmina exchanged skeptical glances. “And let’s say you manage to do that,” Sebastian said. “Then what? Are you going to attack the Inquisitor’s main office alone? If everyone—including the Senate, the Lecunists, and the Catonians—says it’s impossible, maybe there’s a reason for that.”

Leo’s frustration boiled over. “Then what’s the point?” he snapped. “What’s the point in having the powers I have if I’m not going to use them? I can do things no one else can. If I just sit here and do nothing, then what am I even fighting for?”

Jasmina placed a hand on his arm, her voice steady. “We’re with you,” she said. “But we have to be smart about this.”

Sebastian exhaled, nodding reluctantly. “Alright. Let’s see if we can even get a secure connection first. If we can’t, then this is over.”

Leo took a breath. It wasn’t the plan he wanted, but at least it was a start.

Leo, Sebastian, and Jasmina made their way to the high command, their footsteps quick and determined. As they reached the entrance, they asked to see the Commander in Chief. The guards hesitated at first, but after a brief wait, the doors opened, and Leo’s mother stepped out.

She crossed her arms, studying them. “What is it, Leo?”

Leo stepped forward. “I think I can use my abilities to see what’s happening with the Inquisition.”

She didn’t answer immediately. Her gaze was thoughtful, calculating. Then, after a moment of silence, she nodded slightly. “That might not be a bad idea.” She glanced at the others. “If we establish a secure connection, we can monitor everything. If the Supreme AI—or the Inquisitors—try to breach your mind, we’ll disconnect you immediately.”

Leo exhaled, relieved that she was at least considering it.

“Follow me,” she said, turning sharply on her heel.

She led them through a set of reinforced doors and into the high command’s central command room. The space was vast, its walls lined with massive computer terminals arranged in a circle, forming a ring around the operators working at their stations. Dim lights from monitors reflected off metallic surfaces, casting a faint blue glow across the room. The air was filled with the quiet hum of machines and the low murmur of strategists coordinating operations across the world.

The Commander in Chief stopped beside one of the operators, who immediately straightened at her presence. “Establish a secure connection to the outside on this outlet,” she instructed, pointing at a specific terminal. The operator nodded and quickly got to work.

She then turned to Leo, gesturing toward the outlet. “Put your finger close to this port. Don’t worry—it’s completely safe. We will know exactly what’s going in and out. If there’s even the slightest attempt to compromise your mind, we’ll shut it down immediately.”

Leo nodded, taking a steadying breath. He extended his hand and placed his fingers just above the outlet.

Jasmina and Sebastian watched closely, tension written all over their faces.

Leo closed his eyes, focusing. The connection was about to begin.

Leo’s mind was flooded with images. At first, they were blurry, shifting like static on a broken screen. But then, they became clearer. He could see Elias—his body restrained in a heavy chair, metal clamps binding his wrists and ankles. His face was pale, twisted in agony.

Leo’s breath caught in his throat. “I see Elias,” he murmured aloud, describing what he saw for the others in the room. “He’s tied to a chair… He’s in pain. A lot of pain.”

Then, suddenly, another presence entered his mind. A voice, smooth, taunting.

“How nice of you to come and say hello,” Marcus said, his tone laced with amusement.

Leo tensed. The voice was inside his head, invading his thoughts like an unwelcome guest.

“I was starting to worry that you wouldn’t show up at all,” Marcus continued. “That would have been disappointing.”

“So,” Marcus went on, his voice turning sharp, “are you coming or not? If you’re hesitating… well, let me give you a little extra motivation.”

The scene shifted abruptly.

Jenny.

Leo’s heart pounded. She was in a small, cold interrogation room, her hands resting tensely on the table in front of her. She wasn’t restrained, but she was trapped nonetheless. The dim light above her flickered.

Marcus’s voice slithered back into his mind.

“So… are you coming to save your little girlfriend?”

Leo gasped and tore his hand away from the terminal, disconnecting instantly. His breathing was heavy, his pulse racing. He looked at the others, his face pale.

“They have Jenny.”

Leo’s hands were still shaking as he pulled away from the connection, his mind reeling from what he had just seen. The room around him felt distant, muffled, as if he were still caught between two worlds.

His mother’s voice cut through the haze. “Who is Jenny?”

Leo swallowed hard, still trying to steady his breathing. “She’s my friend. From school.” His voice was tight.

His mother’s expression darkened. She exhaled, then spoke carefully. “Leo, listen to me. They are doing this because they want to get to you before your training is complete. This is a trap.”

Leo’s jaw clenched. He knew she was right. But it didn’t change the fact that Jenny was in danger. That she was there, waiting, terrified.

His mother stepped closer, her voice softer now. “I know this is difficult. But you have to understand—this war is bigger than us. Your mission is bigger than us. We cannot risk everything for one person.”

Leo’s frustration boiled over. “And what do you suggest I do? Nothing?” His voice was sharp, laced with disbelief.

His mother didn’t flinch. “That’s right.” Her tone was steady, unwavering.

Leo felt like the air had been knocked from his chest. “Elias?” he said bitterly. “Sure. He chose to be a Companion. He knew the risks. But Jenny? What did she do? How can we just leave her to die?”

His mother’s gaze didn’t waver. “Every war has collateral damage.”

Leo stared at her, unable to believe what he was hearing. His stomach twisted. The words made sense, but they felt unbearable. He turned away, his mind racing.

There had to be another way.