Chapter 237: Static Compilation and Margin

2:40 a.m. The fluorescent tubes in the office gave off a faint flicker as Lin Chen stared at the slowly scrolling compilation log on the terminal. Every time the clock in the lower-right corner of the screen ticked forward, the dull ache in his left ankle deepened a little. The pain patch had long since worn off, leaving behind a pale ring of adhesive on his skin, like the bed of a dried-up river.

He could not stop. The hospital IT department’s line—“external driver installation privileges are disabled”—meant that every dependency had to be baked into the runtime environment in advance. He abandoned the usual virtual-environment packaging plan and switched to static linking, compiling the CUDA runtime libraries, the core PyTorch modules, and numpy’s underlying C extensions all into a single directory. It would bloat the installation package to nearly two gigabytes, but it would avoid the fatal trap of the target machine lacking administrator privileges.

When conda-pack finished its last line, the terminal popped up with Done. Lin Chen did not relax immediately. He pulled over the secondhand test machine, disconnected it from the network, unplugged all external devices, and inserted only a freshly formatted USB drive. He extracted the packaged environment onto the D drive, created a new run.bat, and wrote the startup command into it. Then he double-clicked.

A black window popped up. The progress bar began to crawl.

10%... 30%... 60%...

The fan speed suddenly surged, and the tower emitted a low, muffled hum. Lin Chen watched Task Manager. GPU usage held at 42%, with 2.8 GB of VRAM occupied. No overflow. No errors.

85%... 98%... 100%.

The terminal output read: Inference complete. Latency: 192ms/sample.

Lin Chen leaned back in his chair and let out a long breath. One hundred ninety-two milliseconds—twelve milliseconds slower than the estimated 180, but still well within the safety margin for a fifteen-minute demo window. He picked up his pen and added a line to his notebook of mistakes:

Item 237: Solidify dependencies for offline environments. Risk: target system permissions locked down, dynamic library loading fails. Countermeasure: statically compile all dependencies, abandon size optimization, ensure standalone operation on a single machine. Execution: local sandbox verification passed, latency controllable.

Su Man looked up from the neighboring workstation. Her eyes were bloodshot, but her voice remained steady. “The frontend package is done. I added guardrails to the input box so it only accepts plain text paste. The log output has a scrolling buffer now, so it won’t freeze the main thread. Want to go over it?”

“No.” Lin Chen stood up, giving the slightest limp when his left foot touched the floor before quickly shifting his weight to his right leg. “You know the logic better than I do. Pressure test it now. Run two hundred anonymized medical records straight through and check for memory leaks.”

Su Man nodded and typed in the command. The logs on the screen began cascading downward like a waterfall. Lin Chen walked to the window and pushed half of it open. Early autumn wind poured in, carrying the city’s familiar mix of dust and exhaust. He pulled out a pack of cigarettes, took one free, but did not light it—just held it between his fingers.

He thought of twelve years ago, in the internet café in that county town, of the off-brand machine that blue-screened constantly. To get even the simplest crawler running, he had had to split the code into more than a dozen segments and stitch the results together by hand. Back then, fault tolerance was zero: one power outage, and half a day’s work vanished. The environment now was far better, but the underlying logic had not changed. The more closed a system was, the less controllable the variables became; the only thing one could rely on was the road one had paved in advance. Technology was not for show. It was a safety net. The eight thousand yuan left in the company account would not last past next month. Xiaoman’s follow-up examination fee, the cloud server renewal, Su Man’s base salary—they were all riding on those two hours on Tuesday afternoon. He could not gamble. He could only calculate.

“The memory curve is stable. No leaks,” Su Man said, pulling him back to the present. “Two hundred records finished in thirty-eight minutes. Average latency is holding around 190 milliseconds.”

“That’s enough.” Lin Chen walked back to the desk and slipped the cigarette back into the pack. “Break the demo flow into three steps. First, import the test data and show the field mapping. Second, click Run and output logs in real time. Third, export the results and compare them with the original annotations. Keep each step under four minutes. If it freezes for more than ten seconds at any point, switch straight to the backup plan and run in CPU mode. No explanations. No apologies.”

Su Man noted the key points, then looked up at him. “What if someone from IT asks about the model architecture?”

“Answer only about inputs, outputs, and the anonymization logic. If they don’t ask, don’t volunteer. If they dig deeper, say it involves trade secrets.” Lin Chen opened the drawer and took out three brand-new USB drives. Two would hold the main package, and one would hold the CPU-only fallback package. Using a marker, he wrote labels on them: A-Main, B-Main, C-Fallback. Then he tore off short strips of electrical tape and wrapped each one over the metal connector, to prevent short circuits during insertion and removal.

4:00 a.m. Packaging, verification, and backup were all complete. Lin Chen packed the hard drive and USB drives into a shockproof hard-shell case and snapped the latch shut. He turned off the main lights, leaving only a desk lamp on. Su Man had already fallen asleep facedown at the desk, breathing evenly. Lin Chen did not wake her. Quietly, he tidied the desktop, lining up the notebook of mistakes, the spare Ethernet cable, and the printed manual one by one. Finally, he glanced at his phone. The screen lit up, showing a 7:30 a.m. alarm for Tuesday morning.

He sat in the chair and closed his eyes to rest. In stillness, the pain in his left foot gradually ebbed, turning into a familiar, heavy soreness. He knew that at two o’clock tomorrow afternoon, that isolated terminal would be like a gate. Behind it lay the eyes of the hospital administrative board, the red line of compliance review, and the line between life and death for the company’s last eight thousand yuan. There was no way back, and none was needed. He only had to make every step land solidly.

7:20 a.m. The alarm rang. Lin Chen opened his eyes on time.

Su Man was already awake, splashing cold water on her face in the restroom. The two exchanged no unnecessary words and checked their gear separately: shockproof case, printed manual, spare Ethernet cable, ID card. Lin Chen put on his jacket and tied the left shoelace half a notch tighter than usual, using the extra pressure to stabilize the joint.

8:40 a.m. They arrived at the City First People’s Hospital. The IT department was on the third floor of the administrative building, with strict access control. After checking their appointment slip, the security guard at the front desk handed them temporary visitor cards. Lin Chen swiped upstairs. The hallway smelled of disinfectant mixed with old carpet. The IT office door stood ajar, and the sound of typing came from inside.

When they pushed the door open, a young engineer in black-rimmed glasses sat at his workstation without looking up. “Mr. Lin? The terminal is in the back room. Put your things through the security scanner first. Phones and personal USB drives aren’t allowed inside. Use the dedicated drive we provide.”

Lin Chen nodded and placed the shockproof case on the scanner belt. The engineer handed over a dark blue industrial USB drive, with a tamper seal over the connector. “The intranet machine only recognizes this one. It’s formatted FAT32, maximum supported file size is 4 GB. If your package is larger than that, figure out how to split it yourselves.”

Lin Chen took the USB drive, his fingers sinking slightly at its weight. A 4 GB limit. Their statically built environment package plus the test data came in at about 3.8 GB. But with the frontend interface and the log cache added, it could easily exceed the threshold. He ran through the file structure in his head. Frontend assets could be compressed. Redundant fields in the test data could be trimmed. But the core model weights could not be touched.

“Understood,” Lin Chen said. “We’ll split it on site.”

The engineer finally looked up at him, expressionless, his eyes carrying only the detached scrutiny of routine work. “It starts at exactly two. The director and the vice president will both be there. Don’t run over.”

Lin Chen said nothing. He took the blue USB drive and went into the back room. The isolated terminal was already on, showing a gray-blue Windows 10 desktop. He inserted the drive; the system recognized it normally. He opened File Explorer and began copying the files. The progress bar crept forward.

Halfway through, a system dialog suddenly popped up on the terminal:

Group Policy Restriction: unsigned executable files are prohibited from running.

Lin Chen’s fingers stopped in midair. The screen’s cold light reflected on his face. He stared at the line, breathing evenly. No panic. No complaints. He quickly pulled up the packaging configuration file and found the signature verification setting. To save time during static compilation, he had skipped the code-signing step. Under a strict intranet policy, that had become the fatal weakness.

He glanced at the time. 9:15 a.m. Less than five hours remained until the demo.

Lin Chen unzipped his backpack and took out the old laptop. With no internet access, he could not apply for a certificate online. He had only two options: manually work around the policy or recompile everything. He opened a terminal and typed regedit. Insufficient permissions. He switched strategies: disguise the executable as a script invoked by a system-whitelisted host, using pythonw.exe to bypass signature verification.

Su Man stood at the doorway, watching him work without saying a word.

Lin Chen’s fingertips flew over the keyboard. Command after command dropped into place, like the way he had once worked through math problems with a pencil on discarded newspapers in a leaking front room. There was no magic in it—only decomposition. He redirected run.bat, wrapped the core logic into a .py, and loaded it through the interpreter built into the system. Save. Replace. Run again.

The progress bar began to move once more. This time, nothing intercepted it.

Lin Chen closed the laptop and reinserted the blue USB drive into the terminal. File copy complete. He stood and rolled his stiff neck. The pain in his left foot had already gone numb, but he stood perfectly steady.

“The environment is ready,” he said.

Su Man nodded and placed the printed manual beside the terminal.

Outside the window, sunlight shifted across the lattice and fell onto the desktop. Dust floated slowly through the beam. Lin Chen watched the cursor on the screen and knew the real test had only just begun. At exactly two o’clock, the gate would fall on schedule. And they were already standing inside it.