Chapter 145: Bumps and Thresholds

The long-distance bus jolted ceaselessly along the winding mountain road. Diesel fumes mingled with the smell of cheap synthetic leather seats, slowly fermenting in the sealed cabin. Lin Chen sat by the window, clutching his canvas bag tightly to his chest. His left foot hovered over the edge of the aisle, not daring to touch the floor. Every time the wheels hit a pothole, the vibration from the chassis traveled up his shin to his knee, stirring a dull ache in his numbed nerve endings, like rusted gears being forced to mesh. He kept his eyes closed and breathed slowly, focusing on the rise and fall of his diaphragm. Pain was an objective variable. It could not be fought, only allocated. He adjusted his posture, shifting the weight onto the right side of his pelvis and keeping the muscles in his left leg slightly bent and relaxed.

His phone screen was turned to the lowest brightness, but the black text on the white PDF page still looked harsh in the dim light. The CAP theorem. Partition tolerance. Consistency. He mouthed the three words silently, fingers tapping absently against his knee. Theory was the skeleton; code was the flesh and blood. He needed to build the frame first, even if all he had in hand were a few strips of bamboo. The bus was noisy. A middle-aged man in the front row was shouting into his phone, his voice cutting through the engine's roar. "...this batch has to arrive tomorrow, freight down to eight yuan, not a cent less and I won't haul it..." Students in the back were talking about summer jobs and overnight sessions at internet cafes. Lin Chen didn't catch the details, only a few words—server room, monthly pass, graphics card. He opened his eyes and glanced out the window. The mountains were leveling out. Gray-white concrete roads had replaced the dirt tracks, and the words on the road signs were growing denser. Beyond the morning mist, the outline of the provincial capital emerged in a blurred silhouette. He touched the hard-cover notebook in his pocket. The edges of the cover were already frayed. Inside were the V3.1 logs, the accounts, and the validation results he had finally gotten through last night. Numbers did not lie.

At eight-thirty, the bus pulled into the provincial capital's main passenger terminal. Lin Chen shuffled off with the crowd. When his left foot touched the ground, his center of gravity instinctively tipped to the right, leaving his gait slightly limp. He took a deep breath and adjusted his breathing rhythm. The exit was jammed with people, so he kept close to the wall to avoid being shoved. His phone's navigation showed that the east gate of Provincial Institute of Technology was still two kilometers away. Walking. Taking the bus would mean two transfers, uncertain waiting times, and packed carriages during rush hour—too much risk of twisting his injured foot again. He chose to walk. The two yuan he saved would be enough to buy a bottle of water.

The asphalt road was smooth, but the sun was already merciless. Sweat ran down from his temples, soaking the collar of his faded, repeatedly washed T-shirt. He walked very slowly, planting every step firmly. Passing a convenience store, he went in and bought the cheapest bottle of iced water. He unscrewed the cap, held a mouthful in his mouth first, and only swallowed once the temperature had dropped. The cold water slid down his throat and brought a brief clarity. Then he kept going. The shadows of plane trees from the campus fell across the sidewalk, mottled patches of light swaying with his steps. The gate of Provincial Institute of Technology was an old-style stone archway. Most of the people coming and going wore T-shirts printed with department logos, backpacks slung over their shoulders, their steps light and quick. Lin Chen lowered his head and glanced at his own cloth shoes, the dried specks of mud clinging to the edges. He did not stop. He went straight to the guard room.

"I'm here to register for the practicum camp, low-level architecture group." He handed over his ID card and the screenshot of the text message.

The elderly security guard, wearing reading glasses, checked the list and passed him a temporary access card and a dorm assignment sheet. "Building Three, room 402. The low-level group is in the first-floor lab, Building B, School of Computer Science. Be there before nine. Don't be late."

"Thank you." Lin Chen took the cards, his fingertips brushing the cool edge of the plastic.

Building Three was an old dormitory block, its paint peeling in places, the corridor carrying the smell of disinfectant and old books. Room 402 was a four-person dorm, with three beds still empty. He set his canvas bag down on the lower bunk by the window and took out his laptop, charger, and ibuprofen. He plugged in the power and turned it on. The fan gave off a soft hum, and the familiar command-line interface lit up on the screen. First he ran a local environment check: Python 2.7, basic dependency libraries all present. Last night's script files sat quietly on the desktop. He opened the log. The final entry still read: [INFO] Validation passed. 0 errors.

There were still forty minutes before nine. He swallowed two ibuprofen tablets with the remaining half-bottle of water. As the pills dissolved in his stomach, they brought with them a dull, heavy warmth. He opened his hard-cover notebook and quickly reviewed the fault-tolerance logic he had organized the previous night: hash mapping for primary-key conflicts, linear interpolation for missing timestamps, foreign-key validation for broken cross-table links. He sketched them into a flowchart and taped it beside his screen. Then he opened the PDF Zhou Yan had sent him and flipped to the section on "consistent hashing." Virtual node rings, data mapping, uneven load distribution. He didn't understand all of it, but he could grasp the core: the essence of a distributed system was to break up the pressure concentrated on a single point and spread it across multiple nodes. His script was single-machine, but the logic could be reused. He created a new file: hash_ring_mock.py. Then he began writing pseudocode. He wasn't trying to make it run—only to clear his thinking.

Eight-fifty. The lab door opened. Seven or eight people filed in one after another. Most wore sportswear or polo shirts, carrying brand-new backpacks and holding MacBooks or slim laptops. They nodded to each other in greeting, their voices low but easy, familiar. Lin Chen didn't look up. His fingers kept moving over the keyboard. He heard someone pull out the chair beside him and sit down, bringing with it the faint scent of laundry detergent. The newcomer glanced at his old notebook computer and said nothing.

Eight-fifty-five. The room fell quiet. Only the clicking of keyboards and the hum of cooling fans remained.

Then the door opened again. A man in a gray shirt and black-rimmed glasses walked in, holding a USB drive and a stack of printed papers. Zhou Yan. Thinner than in the photo on his blog, with slightly sunken eye sockets, but bright eyes. He scanned the lab once, his gaze lingering for half a second on Lin Chen's old notebook computer, then walked to the front.

"I'm Zhou Yan. Head of the low-level architecture group." His voice was not loud, but it was clear. "We're changing the format of the nine o'clock review. No reports. No PowerPoint presentations. We run code directly."

He plugged the USB drive into the podium computer. The projector came alive. A terminal window popped up on the screen.

"Last night's baseline dataset was just a warm-up. Now I want all of you, in your local environment and in any language you choose, to implement a simple distributed cache eviction strategy. LRU. Requirements: support concurrent reads and writes, memory usage under fifty megabytes, response time under ten milliseconds. In one hour, I'll review everyone's code one by one. If it doesn't run, or if the logic has fatal flaws, you'll be auditing the fundamentals class this afternoon."

He paused, sweeping his eyes across the room. "The practicum camp doesn't keep idle people. Code does not lie. Begin."

A collective intake of breath swept through the lab. Some people opened their IDEs immediately; others started flipping through books. Lin Chen's fingers stopped on the keyboard. LRU. Least recently used. He had heard of the concept before, in an operating systems textbook, but had never written a concurrent version by hand. The fifty-megabyte memory limit meant he couldn't rely on a ready-made heavyweight framework. A ten-millisecond response time meant the data structures had to be stripped to the bone.

He glanced at the clock in the lower right corner of the screen. 08:58.

His left foot began throbbing again. The ibuprofen had not fully kicked in. He took a deep breath and closed every unrelated window. New file: lru_cache.py.

First line: import threading Second line: from collections import OrderedDict

When he typed the third line, his fingers trembled slightly. Not from nerves, but from muscle fatigue. He forced himself to slow down. At the core of LRU was a doubly linked list plus a hash table. OrderedDict was a doubly linked list underneath. Concurrency needed locks. A read-write lock would suit it better than a simple mutex; in a read-heavy, write-light scenario, it could reduce blocking. He began sketching the structure on scrap paper. Nodes, pointers, lock granularity, edge cases. The logic gradually took shape in his mind.

The boy beside him was already hammering away at his code, keystrokes falling as dense as rain. Lin Chen was not distracted. He stared at the screen, the cursor blinking in the blank space.

Nine o'clock.

He pressed Enter. The terminal printed the first line of comment: # LRU Cache with Read-Write Lock

Outside the window, the cicadas suddenly shrilled louder. Sunlight filtered through the blinds, cutting the desktop into alternating bands of brightness and shadow.

He did not know what auditing the afternoon class would mean.

He only knew that for this one hour, he could not stop.