I, Hacker: Chapter 3, Part 3: “Doors Without Keys”

 The first time I connected to ARPANET, it was by accident.  Or that’s what I told myself later. It started as a maintenance test — a routine connectivity check between the COMSAT relays and the external gateway. I was supposed to ping a few registered nodes, log response times, and close the connection. Simple. Uncreative. Safe. But curiosity has a way of whispering louder than orders.
The terminal window blinked open:

> CONNECT GATEWAY NODE.004
> AUTH: ?

I paused, staring at the prompt. The question mark wasn’t a denial. It was an invitation. A door half-open. I typed a test credential — one I’d found in a forgotten configuration file:

 guest
 Password: guest
The cursor hesitated. Then:
> ACCESS GRANTED.
> WELCOME TO DCA NETWORK GATEWAY.
> CONNECTED: ARPANET.NODE.004 (DCA-CENTRAL)

The hum of the mainframe seemed to deepen, as if the room itself were exhaling.  Lines of text scrolled past — host listings, network directories, system banners.

> MIT-MULTICS.
> SRI-KL10.
> BBN-TESTBED.
> NSA-GATEWAY (RESTRICTED).

Each one was a heartbeat, pulsing in phosphor light. I sat there, frozen, feeling the gravity of what I’d just done. This wasn’t the campus mainframe anymore. This was something older, bigger, alive. I could almost hear it breathing through the static. I told myself I was exploring for work. That it was reconnaissance. A systems survey. That’s how it starts for all of us — curiosity dressed as professionalism. I justified it with technical jargon and caffeine. But in truth, I was drunk on the same thing I’d felt when I first connected to that BBS years earlier.

Wonder. Power. The quiet thrill of trespass. Over the next few nights, I mapped the network. I did it methodically — like a cartographer tracing a continent no one else could see. Each node was a city, each link a road. I built my own directory tree in a hidden workspace, labeling connections, logging response times, tracing topologies.

The structure was fascinating: universities, military labs, contractors — all interlinked through primitive routing systems. Every packet that passed through the Army’s communications servers was a breadcrumb, leading me to new places.

At two in the morning, with the building empty and the lights low, I would trace those routes like a diver exploring an unlit cave.

Sometimes, I’d find active users logged in — scientists, engineers, bureaucrats — working late just like me. I’d watch their terminal sessions scroll line by line: equations, data sets, fragments of memos. Always public, never classified. But it didn’t matter. The magic wasn’t in what they said. It was in where I was.

One night, I discovered a directory that didn’t belong — or wasn’t supposed to.

NODE: LANGLEY-GOV-05.

It didn’t respond to standard pings. Didn’t reject them either. Just ignored them, like a door pretending not to exist. So I built a knock. A few harmless packets with altered header sequences — malformed enough to make the system reply out of habit. And reply it did. The screen flickered.

> PING ACKNOWLEDGED.
> USER: UNKNOWN
> TERMINAL: CLASSIFIED

That was all. Just two lines.  But it was enough to make my pulse quicken. I logged it. Named it The Silent Node. Days passed like this. Work by day, exploration by night. The official tasks grew easy, automatic. I debugged code in minutes that took others hours. Walters stopped hovering. He thought I was a model soldier — efficient, compliant, boring. That suited me fine.

At night, the world opened. I began keeping a second notebook, written in small, precise handwriting, documenting every node, every access code, every discovery. The first page read simply:

PROJECT: NOMAD.

Because that’s what I’d become — a traveler between worlds. There were rules I built for myself. Not moral rules — practical ones.

1. Never change anything.
2. Never leave evidence.
3. Never access classified directories.
4. Never log in twice from the same terminal.

Rule #4 saved me once. A week after I found The Silent Node, I returned to explore again. But the gateway didn’t respond. The connection stalled, then spat out a message:

> CONNECTION FLAGGED - DUPLICATE USER ROUTE DETECTED
> ACCESS TERMINATED.

Someone had noticed the first connection. Maybe not me — but the anomaly. For a moment, my stomach turned cold. Then I smiled. If someone was watching, they’d taught me something: this wasn’t an abandoned relic. It was a living network, guarded by unseen hands.

I wanted to meet them. One night, while tracing through a relay node at Stanford Research Institute, I found something I hadn’t seen before. A small message file, barely a kilobyte, tucked inside a public bulletin directory. Its name: “r0bert.msg.” I opened it.

> TO WHOEVER IS OUT THERE:
> YOU ARE NOT AS INVISIBLE AS YOU THINK.
> - R0BERT

Just that. No timestamp, no reply address. For a long time, I stared at it, half expecting another line to appear. Nothing did. I deleted my shell history, closed the session, and sat back in my chair.

Someone else was in the system.
Someone who could see me — or at least sense me.
And they knew how to talk without talking.
For the first time since stepping off that bus months ago, I felt something I hadn’t felt in years.
Not fear.
Not guilt.
Recognition.

Somewhere out there, another mind was watching the same network shadows I was.
And that made the whole machine feel less like a labyrinth — and more like a conversation.

I, Hacker: Chapter 3, Part 2: “The Code Room”

 “Welcome to the nerve center of the free world,” Sergeant Walters said, deadpan, as we walked through the double doors.

 The room was long and rectangular, every surface beige or steel. Rows of metal desks sat in perfect lines, each with a humming terminal and a soldier hunched behind it, faces lit green by phosphor glow. The air was thick with the smell of ozone, machine oil, and weak coffee. Somewhere behind the walls, the mainframes exhaled in rhythmic bursts — a mechanical heartbeat. This was the Code Room, the Army’s idea of digital sophistication.

“You’ll work from this terminal,” Walters said, tapping a desk with a clipboard.

“Your first task is to go through legacy message-handling code, clean up the syntax, and make sure it compiles under ADA. We have systems running half a dozen languages — LISP, COBOL, whatever was fashionable before I could shave. We’re consolidating.”

I nodded. “Yes, Sergeant.”

He dropped a binder the size of a dictionary on my desk. “Learn the syntax. No creative liberties. The machines are not your canvas, Private. They’re your orders.”

He walked away, boots echoing off the tile. The Army was terrible at programming, which, in hindsight, made perfect sense. The military ran on command structures and absolutes. Computers ran on precision and logic. The overlap between those two philosophies was narrower than a transistor.

The code I inherited was a disaster — recursive functions with no exit conditions, memory leaks like sieves, comments written by people who either didn’t understand what they’d built or didn’t want anyone else to. Half of the ADA programs had been patched with LISP macros; the other half were missing entire libraries.

The first time I compiled one of the communications relays, the screen filled with red text like a crime scene report. I stared at it, hands poised over the keyboard, and smiled. They’d handed me a living, breathing catastrophe. And I loved it.

Days fell into rhythm. Breakfast. Work. Lunch. More work. Sleep. Repeat. The rhythm wasn’t unpleasant — just endless, predictable, and quiet. I liked the quiet. I liked the feeling of command over chaos. The machines didn’t yell, didn’t threaten, didn’t judge. They just waited for instructions.

Sometimes I’d watch the data traffic in real time — encrypted messages pulsing through the lines. Orders. Reports. Command sequences. All the chatter of a giant, invisible army. The world’s secrets reduced to glowing characters moving faster than anyone could read them.

My job was to keep it running. To make sure the channels stayed open.
But that wasn’t enough. The night shift was my favorite. By midnight, the Code Room emptied out. The fluorescent lights hummed overhead, the only sound besides the steady whir of cooling fans. I’d sit there with a cup of instant coffee, watching the logs scroll, thinking about how much trust these people placed in the invisible.

Everything — command, coordination, intelligence — all of it ran on a language most of them couldn’t read. That bothered me. Because the longer I stayed in that room, the clearer it became: no one really understood how the system worked. Not the officers, not the tech sergeants, not the engineers who wrote the specs. They treated it like a vending machine. Input command, get output. If it jammed, call someone like me.

I started cataloging bugs that weren’t in my orders — problems buried so deep no one had noticed them yet. Subroutines that failed silently. Message queues that overflowed under certain conditions. A misaligned encryption handler that could expose entire command channels under the right circumstances.

I documented everything. Not in the official logs — those were for show — but in a notebook I kept folded inside a manila envelope, tucked behind the back panel of my desk. The first page read:

SYSTEM: COMSAT/ADA-LISP HYBRID
NOTES: BUILT WRONG FROM THE GROUND UP.

Sergeant Walters stopped by occasionally to “check progress.” His checks consisted of looking over my shoulder, not understanding a word of what he saw, and nodding sagely.

“You’re efficient,” he said once. “The other guys take three days to fix a compile error. You do it before lunch.”

“I read the comments,” I said.

He grunted. “What comments?”

Exactly. I wasn’t the only one who noticed the cracks. There was a civilian contractor named Raines who handled network maintenance on the older machines — a balding man with nicotine-stained fingers and a dry sense of humor. He caught me one night rerouting test data through a backup terminal.

“Curious type,” he said, watching the screen.

“Just testing latency,” I lied.

“Latency my ass. You’re mapping the system.”

I froze. “Am I in trouble?”

Raines chuckled, lighting another cigarette right under the NO SMOKING sign. “Kid, the Army doesn’t even know half the stuff it’s got connected. If you want to learn, learn. Just don’t break anything I’ll have to fix.”

That was all the permission I needed. Under Raines’ half-hearted mentorship, I started poking deeper into the infrastructure. The communications hub wasn’t isolated — it was part of a sprawling internal network connecting bases, labs, and civilian contractors. Each node had a name, an address, a personality.

I found directories labeled DEFNET, MILNET, and something called ARPANET. That last one caught my eye. The documentation was sparse, half redacted. But I recognized the structure — open protocols, data packets, message relays between research institutions and government agencies. A network built for redundancy, not secrecy. A system older than everything else, but still alive. Still pulsing.

I didn’t try to connect that night. Not yet. I just stared at the terminal listing, watching the line of text:

GATEWAY: ARPANET.NODE.004 :: STATUS: ACTIVE

It sat there, quiet, waiting. Sergeant Walters’ voice echoed faintly from earlier that day: The machines are not your canvas, Private. They’re your orders. He was wrong. The machines were doors.
And I had just found one that didn’t have a key.

I, Hacker: Chapter 3, Part 1: “Basic Training”

 The bus rolled into Fort Leonard Wood before dawn, its headlights carving weak tunnels through the Missouri fog. A long, low building sat ahead — beige concrete, windows blacked out, the kind of place that looked like it had never laughed.

The doors hissed open. The smell hit first — wet asphalt, diesel, and the unmistakable sting of bleach. Then came the yelling.

“MOVE, MOVE, MOVE!”

Drill sergeants don’t speak; they detonate. Every word a concussive blast. Forty of us stumbled off the bus, duffel bags slung over shoulders, trying to look invisible. I remember thinking that invisibility was the one thing I was already good at.

They herded us into a formation that was more statistical than geometric, barking names, counting heads, separating the loud from the quiet, the useful from the hopeless. I landed somewhere in the middle — too scrawny to impress, too composed to antagonize.

A sergeant with a voice like a chainsaw and a jaw you could hang laundry on paced in front of us.

“You belong to me now,” he said. “The government owns you. You’re property. You’re inventory with legs. You understand?”

We yelled “YES, DRILL SERGEANT!” in a single, ragged chord.

He smiled without humor. “Good. Property that answers back.”

The next weeks were noise, motion, and repetition. Wake at 0500. Run until your lungs turn inside out. Chow at 0630 — powdered eggs, fake bacon, coffee that could dissolve paint. March until the sun stopped pretending to care. Repeat commands until the words lost meaning.

I followed orders because it was easier than fighting them. My body learned what my brain already knew: systems reward compliance. The trick was to obey just enough to stay under the radar.

My bunkmate was a guy named McBride — tall, red-haired, from Tennessee, with a voice that could sing even when he talked. He called me “Professor” after I corrected his math once during a navigation drill.

“You look like a guy who sleeps with a dictionary,” he said. “What the hell are you doin’ in the Army?”

“Judge’s idea,” I said.

He laughed so hard he nearly choked. “Hell, that makes two of us.”

We bonded over mutual resentment — his for authority, mine for inefficiency. McBride had a knack for radios. He could strip and reassemble a field transceiver blindfolded, and he understood the poetry of static. 

“Noise,” he said once, holding a headset to my ear, “ain’t random. It’s just information you don’t understand yet.”

That line stuck with me. I started thinking of the Army that way: a wall of noise. My job was to find the pattern underneath.

They put us through aptitude testing halfway through basic. The kind of thing designed to slot you into a MOS (Military Occupational Specialty): language, logic, mechanical reasoning. I went through the motions, half-asleep, filling in the bubbles mechanically.

Two days later, I was called into an office. An older officer sat behind a steel desk, tapping a pencil against my file.

“You aced the electronics and coding sections,” he said, half-accusation, half-curiosity. “You have prior experience?”

“A little,” I said.

He grunted. “How much is a little?”

“Enough to fix your typewriter,” I said before I could stop myself.

He didn’t laugh, but he didn’t kick me out either. Instead, he flipped a page in the file, scrawled something in red pen, and said, 

“You’re being ssigned to the Signal Corps. You’ll be working with communications systems. Computers. Programming. Stuff above my pay grade.”

I nodded, keeping my face blank, though inside I felt the smallest flicker of triumph. Every system has a way in.

Six weeks later, they put me on a bus again — smaller, quieter. We drove through a drizzle that turned the world to static. McBride was reassigned too, different unit. We shook hands at the gate.

“Keep your head down, Professor,” he said. “And don’t rewire the Pentagon.”

“No promises,” I said.

The facility they sent me to wasn’t much to look at — a low brick building surrounded by chain-link and barbed wire. A sign read U.S. ARMY COMMUNICATIONS CENTER — AUTHORIZED PERSONNEL ONLY.

Inside, the air was cold and dry. The floors hummed with fluorescent buzz. Rows of metal desks lined the floor, each with a terminal, each terminal with a man in uniform typing quietly like an obedient machine.

I was introduced to Sergeant Walters, a man carved entirely from procedure. His haircut looked regulation down to the molecule.

“You’ll be assigned to systems maintenance,” he said, handing me a stack of manuals thick enough to stun cattle. “ADA and LISP. You’ll learn both. You’ll debug our communications protocols and keep the message relays clean. You’ll log everything you do. No exceptions.”

“Yes, Sergeant,” I said.

He looked at me, squinting like he was trying to see what kind of soldier I was. “You a fast learner, Private Smith?”

“Yes, Sergeant.”

“Good,” he said. “Because the machines don’t tolerate slow learners.”

That night, I sat at my assigned desk, staring at the terminal. Green letters blinked against a black screen. Lines of code scrolled by as I ran diagnostic checks, correcting syntax errors in old relay programs. The sound of the mainframes in the next room filled the air — a deep, steady thrum, like a pulse you could live inside.

Walters walked past behind me, muttering something about schedules and reporting chains. But I barely heard him. My hands were already moving, translating commands into shapes, shapes into systems. The old logic came back instantly — loops, conditions, recursion. Clean. Perfect.
And when I hit ENTER, the terminal responded with a calm, obedient prompt:

> OK

No yelling. No orders. Just acknowledgment. Immediate, precise, honest.

I, Hacker: Chapter 2, Part 5: “The Deal”

The watchers didn’t stay quiet for long.

Two weeks after the hearing, a letter arrived at my mother’s house — the one address I hadn’t given them but that lived in every database tied to my name. She called me that night, her voice trembling through the receiver.

“Danny,” she said. “There’s a letter here. From some... office. I think it’s court-related.”

I told her not to open it, though of course she already had. Inside was an official summons from the county prosecutor: State of California vs. Daniel A. Smith — unauthorized access to restricted computer systems, data tampering, and misuse of telecommunications equipment. They had decided to make it real.

Courtrooms are the most analog places on Earth. Wood paneling. Brass fixtures. Yellowed paper everywhere. A calendar from 1978 still hanging behind the clerk’s desk. The only technology in the room was the microphone, and it didn’t work half the time.

The judge was older than the courtroom, and twice as tired. His nameplate read Hon. Raymond K. Tilling, but everyone in the room called him “Your Honor” with the fearful reverence of people hoping not to be noticed.

The prosecutor was young — maybe late twenties, eager and smug. He had a stack of papers two inches thick and the gleam of someone who’d just discovered a new toy called “cybercrime.”

They’d even brought Morales from the university as a witness. He looked uncomfortable in a suit, clutching a folder like it was a life raft.

When they read the charges, I almost laughed. They made me sound like a Bond villain. “Gaining root-level access.” “Unauthorized privilege escalation.” “Insertion of malicious code.” The terms sounded menacing when spoken aloud, but what I’d actually done could barely dent a high-school firewall by today’s standards. Still — 1983 was new territory. They didn’t know what to do with people like me. So they guessed.

The prosecutor did his best to paint me as a danger to national security. “He could have accessed any system,” he said. “He had the means to alter data, destroy records, or steal sensitive information. It’s only by sheer luck that he chose a university instead of a bank.”
He said it like luck had anything to do with it.

My lawyer — a court-appointed one, gray suit, coffee stains, kind eyes — countered with something halfway between apology and admiration. “My client is not a criminal, Your Honor. He’s a young man with unusual technical skill and poor judgment. He didn’t destroy anything. He didn’t steal. He didn’t profit. The university overreacted.”

He said unusual technical skill the way some people say gifted child. Like I was a stray dog that could play piano.

Judge Tilling watched me the whole time. He didn’t take notes. He didn’t interrupt. Just sat there, leaning back, eyes half-lidded, as if trying to decide whether I was worth the trouble of a full moral opinion.

Finally, after two hours of posturing and paper-shuffling, he spoke.

“Mr. Smith,” he said, “you’re a bright young man. But you’re not as bright as you think you are.”

I opened my mouth to reply, but the look he gave me froze the words midair.

“I’ve seen your type before,” he continued. “Too smart for your own good. The world gives you a toy, and you think it’s a weapon. You want to see what happens when you pull the trigger. And when someone gets hurt, you call it an accident.”

He flipped through the file, scanning the printouts of my code like a priest reading a confession.

“Now,” he said, “I could send you to jail. I could make an example of you. But frankly, I don’t think that’s going to help anyone. Least of all you.”

He leaned forward, elbows on the bench.

“I happen to know the Army’s looking for people with your... talents. They’ve got computers now, too. Big ones. Maybe they’ll teach you what it means to follow rules.”

The room went silent. Even the prosecutor blinked. He wasn’t offering leniency. He was offering a trade.

“If you enlist,” he said, “I’ll suspend sentencing. You’ll serve your country, learn some discipline, and stay the hell away from university networks. Refuse, and I’ll make sure this follows you for the rest of your life. Understood?”

My lawyer leaned close. “Take the deal,” he whispered. “It’s the best offer you’ll ever get.”
He was right.

I signed the paperwork the same day. Deferred prosecution in exchange for enlistment. The judge even smiled when I did it — that weary, bureaucratic smile of a man who’s solved a problem by moving it somewhere else.

My mother cried when I told her. I think she was proud, though she never said so directly. I let her believe it was voluntary. That I’d woken up one morning and decided to serve my country out of some noble sense of duty. We both knew it wasn’t true.

The bus to Fort Leonard Wood left at dawn. Gray sky, gray uniforms, gray faces staring out the window like passengers on a train to a life they hadn’t chosen.

I sat by the window, duffel bag between my knees, and watched the city shrink behind us.

No computer. No terminal. No blinking cursor waiting for me. Just the low hum of the engine, the smell of diesel and wet wool, and the thought that maybe — just maybe — I could survive four years of following orders. But somewhere in the back of my mind, beneath the fear and exhaustion, a small voice whispered: Every system has a way in. And I smiled.

I, Hacker: Chapter 2, Part 4: “Root Access, Root Consequences”

That made the fall harder. You get comfortable with anonymity the same way you get comfortable with a chair — you stop feeling the edges. You stop looking for them. Months of careful work had taught me how to move through the system like a ghost: aliases, rotated passwords, clean login timestamps, mimicry of normal user behavior. I had routines that looked boring by design. I left the logs with plausible noise. I never edited files in place; I made copies and left originals untouched. I never ran anything noisy in system directories. I was surgical.

Then, one idle night, tired and overconfident, I grew careless. It was the sort of mistake that wears the face of boredom. A grad student – an actual person, not one of my ghost accounts — had left a file in /tmp with the permissions set to 777. The name was test_build.tar.gz. Because I was human, because the night was long and my coffee was weak, I couldn’t resist. I untarred it in my own workspace just to see what someone else was doing. The archive had a few test binaries and a script that referenced an absolute path I didn’t recognize.

I thought nothing of it — until I ran the script to see if it did anything interesting. It did. It spat out a log entry into a global log because the author, bless him, had hard-coded /var/log/compile.log for debugging and forgotten to remove it. The log entry contained the hostname of my terminal. Just my hostname. Only a hairsbreadth of proof. But logs are like DNA: small, stubborn, and keyed to a place.

The next morning the campus systems phone rang at 8:03 a.m. It was the network admin — a guy named Morales — his voice low and careful on the line. He asked whether anyone else had access to my terminal. I lied. Smoothly. Too smoothly, maybe. I said no.

By noon, Morales had a pattern. Over the last three weeks there had been a cluster of odd cron runs at 2:00 a.m., originating from different user IDs but all inheriting the same PATH quirks. He pulled the headers, grepped the audit logs, and found the duplicates. Duplicates led to a shared HOME folder. The HOME folder led to a list of small scripts with weak obfuscation — nothing complex, but enough to show a human hand. Which is how they found me.

They didn’t show up with handcuffs or drama. They sent one of the grad student sysadmins first — a kid named Allen with wire-frame glasses and the kind of casual cruelty you only find in architecture students. He came by the lab and watched me type for a while, making small talk about compiler versions while his fingers hovered over a terminal. He nodded at nothing and left.

That night, I slept badly. Not because I thought they would find anything — my routines should have covered it — but because I’d felt, for the first time in months, the cold breath of scrutiny. It’s a discrete thing: a cursor that isn’t yours, a keystroke you can’t explain. It makes the edges of the world sharp.

On Thursday, I sat in Dr. Harkness’s lecture on UNIX scheduling — the kind of class where the professor makes padding sound like a thesis — and halfway through his anecdote about AT&T’s early misadventures, two men in plain clothes appeared in the doorway.

At first I didn’t notice them. They were unremarkable: blue suits that had never seen a darts night, shoes shined the way men who don’t do dishes shine shoes, hair cut in sanctioned shapes. One of them scanned the room like a man making a shopping list, then his eyes landed on me.

The professor stopped mid-sentence. The class quieted, as if every student had simultaneously remembered they were in a building with real rules. The men walked down the aisle. One of them had a badge, small and discreet, clipped inside his jacket where no one could easily read it. The other smiled like a man arranging a surprise party, but his smile didn’t reach his eyes.

“Daniel Smith?” the taller one asked, as if reading my name from a script.

Heads turned. Nobody had called me Daniel since orientation. The room smelled suddenly like stale chalk and fear.

I stood slowly. “That’s me.”

“You need to come with us,” he said. No explanation. No malice. No performance. The words were like blueprints: precise and final.

I caught sight of Morales near the back, holding a printout like a rosary. Allen was next to him, looking triumphant and fifteen. There was a small, clinical look on Morales’s face — the face of someone who’d solved a math problem and wanted to put the answer on the board.

I left my stuff, walking past the rows of students who gave me looks that were curiosity and accusation braided together. Someone whispered, “What did you do?” and another said, “He’s that Dent42 guy, right?” Someone else laughed, like the sound of a bubble popping.

Outside the lecture hall, the cold air hit me like reality. The taller man led; the other watched. They didn’t touch me. They didn’t have to. They took me to a small windowless room in the administration building. The chairs were hard. The table had a blotchy veneer. A fluorescent light hummmed overhead with the patience of bureaucracy.

“Do you know why you’re here?” the tall one asked.

“Yes,” I said.

They put printouts on the table. Lines of cron output. IP headers. The hostname that had leaked. A timestamp. A spiral of evidence that built to an ugly little tower.

“Where did these scripts originate?” Morales asked, not unkindly. It was almost pity. He wanted an answer.

I could have lied. I could have fumbled. Instead I did the worst thing I could have done: I smiled.

“Curiosity,” I said. “Testing the system.”

Testing. The word sounded childish in the room. The tall man’s jaw tightened a fraction.

“You understand this looks like unauthorized access?” he asked. “Tampering with administrative scripts. Root-level implications.”

“Yes.” The truth: I did understand.

I also understood the calculus of their options. Expulsion. Criminal charges. Public university, public embarrassment. The administration did not want that. They wanted containment, minimal spectacle.

Instead of immediate legal action, they called the police. Not campus security — the actual local force. Two officers arrived, polite and perfunctory. They asked me the same questions Morales had asked, but with the added weight of law behind them. I tried to answer as little as possible, which is what you do when you don’t know what they can prove.

They took me to a holding room for questioning. The detectives were more patient than the officers — they asked about motives, about whether I’d shared the tools, about whether anyone else had access. Their voices were soft, civilized. They listened to my answers and wrote them down in a way that made them look like facts.

When they showed me the evidence printouts, I noticed something else: a line of notes in Morales’s handwriting. 

“Possible student misuse. Recommend referral to judicial.”

 The words were a polite litany for escalation. I was aware, in a slow, awful way, that this was no longer just a technical problem — it was a career event. My freedom hinged on a conversation on a different floor, between men who wore different coats.
 
They didn’t read me my rights. Not yet. It was all procedural. We were all performing the right choreography: the sysadmin found the anomaly, he alerted administration, they contacted the police, the detectives read the printouts, and I sat in a chair and tried not to look like I loved the smell of money in the bursar’s logs.

“You should have reported this, Daniel,” one of them said finally. “If you saw something insecure, report it. Don’t take it upon yourself.”

“I reported things to the lab,” I said. “I reported bugs. I told them about the cron job months ago.”

“No record,” Morales interjected. “No report. We found scripts and code in user space. We found evidence of deliberate path poisoning.”

The word “poisoning” sounded theatrical. It was theatrical. They wanted the story to be criminal, not curious. Crime makes eyes look away. Curiosity makes them look inside. I suppose I couldn’t blame them.

After hours of questioning that felt like being moved through a sequence of gates — watchful face, stunned silence, the politely delivered threat — they let me go. No handcuffs. No arrest. Not that night, anyway. They wanted my cooperation, or at least my silence.

“You’ll be hearing from Judicial Affairs,” Morales said as they handed me back my jacket.

“And the campus will be… handling this internally. If we decide to press charges, that’s on the record.”

They dropped me off at the dorm. The street was the same as when I had left it, but the air tasted like metal. My roommate asked if I was okay. I said “Fine,” which was a mutation of the truth.
That night I lay awake listening to the radiator clank and the distant clatter of the vending machine. I had been careful for months, and a single boredom-driven run had handed them a breadcrumb. It was almost laughable. You spend so much time avoiding the obvious that you miss the obvious sitting in front of you.

Within a week, an official letter arrived: summons to a campus hearing. The language was neutral, the font neutral.

“Allegation of unauthorized access to university computing resources. Hearing scheduled.”

Hearing. They did not say “criminal.” They did not say “jail.” They left the teeth unsaid.
But the implication was there. They could expel me. They could press charges. They could call the police and hand the case to the county prosecutor. The choices hung just out of sight like storm clouds.

I sat with my mother one evening and watched her sew a loose seam on a dress she kept for church. I thought about telling her everything. I thought about telling her that this was my life now, that the blinking cursor was the only place that made sense. But I didn’t. You don’t tell the people who love you the parts that will make them worry. You protect them by keeping secrets.

On the day of the hearing, I walked into a small committee room smelling of cheap coffee and dust. Two administrators sat on one side, their faces a judgmental symmetry. On the other side, there was a clerk and Morales with his stack of printouts. I had a single sheet of paper — a typed statement I had practiced to sound contrite but reasonable.

They asked me to explain. I explained that I’d been experimenting, that I hadn’t stolen anything, that I understood security. I pointed out the weaknesses, the sloppy scripts, the overbroad permissions. I thought perhaps an appeal to professionalism would make them step back. Instead, they read the official manual language about unauthorized access and network integrity. Manuals are blunt instruments. They like to close the aperture tightly.

When the head of the committee — a gray woman whose name I still remember simply as Dean Ellis — looked at me with the small, precise pity of someone who has had to discipline a problem child for the umpteenth time, I felt the chill. She told me what I already knew: that the university had to be seen to act, that outsiders would not understand if they did not, that precedent had to be set.

“You need to understand the consequences,” she said. “This is theft of resources. This is unauthorized use of staff accounts. We have obligations to our funders.”

Obligations meant publicity. Publicity meant lawyers. Lawyers meant jail was an option on the table.
They recommended suspension pending further review and hinted, carefully, that criminal referral was possible. 

“You’ll have a chance to respond,” Dean Ellis said, “but let me be clear: the university will not be lax.”

I walked out with a campus restriction and the feeling that the world had drawn a line in the sand and I had placed my foot on the wrong side.

That night, I started packing a small bag. Not to run. Not yet. But to prepare. The realization had arrived like a spectral ledger: there are consequences to touching root. There are consequences to waking systems that are meant to be asleep.

As I folded a T-shirt, I felt something else settle in my chest — a strange, quiet excitement. The same part of me that loved breaking into systems loved the idea of solving problems under constraints. If the university wanted to muscle me out, the world beyond the college gates might have other, darker doors to open.

I slept badly again, that night, but I didn’t regret it. Regret is a thing that comes later, with the bills and the phone calls and the people you hurt. Right then I felt only the prickling, nervous energy of a man who had been seen and who had, in turn, glimpsed the faces of the watchers.

I, Hacker: Chapter 2, Part 3: “Catching Fire”

It’s funny how quickly fear turns into confidence.

The first time you cross a line, your hands shake. The second time, you justify it. The third time, you start to wonder why there was ever a line at all.

By the spring semester of ’83, I’d stopped thinking of the university network as a place I visited. It had become something closer to a second home — an invisible city that stretched beneath the physical one. The dorms, the classrooms, the cafeteria — they all had their reflections in the machine: files, permissions, names, commands. Each login was a door. Each directory was a room.
And I had the master keys.

I’d built myself a new set of accounts — four in total — all disguised as forgotten grad students from the previous year. I generated fake shell histories, planted old homework files, even left the occasional half-finished paper to make them look inhabited. They were ghosts with alibis.
With those accounts, I could move freely. Observe without being seen. And I did. Constantly.
I’d log in under a faculty account just to watch what they were working on. Lesson plans. Exam drafts. Department memos. It wasn’t even about cheating; I didn’t care about the grades anymore. It was about access. The feeling of being in the same room as the people who thought they ran the world and realizing you were standing behind them, unseen.

One night — late April, I think — I found a directory belonging to one of the senior professors, a guy named Harkness. He taught Operating Systems, though “taught” is generous. He mostly recycled slides from the previous decade and talked about punch cards like they were still a thing.
Inside his home folder, he had a subdirectory called /notes/1982_archive/. Inside that:
 final_exam_draft.txt. I opened it.
 
Thirty-five questions, half of which were copied directly from the previous year’s test. I stared at them, smiling. Then I did something stupid — or maybe brilliant, depending on how you define either.
I added a question.

36. What happens when the system administrator forgets who really runs the system?
Hint: check your PATH variables.

I saved the file and logged out. No damage. No stolen data. Just a ghostly fingerprint in the code.
I didn’t hear anything about it for weeks. Finals came and went. I half-expected a knock on the door, or an email from IT, but nothing. I passed the classes I still bothered to attend. I failed the rest. My mother called to ask if I was coming home for the summer. I told her I had a “research internship.” She didn’t ask where.

Then, one day in June, while cleaning up my files, I stumbled across a system bulletin. Just a small text message posted to all users from the head of IT.

TO ALL USERS:
There has been an incident involving unauthorized access to faculty directories. The issue has been resolved. Please do not tamper with system scripts or cron jobs. Lab privileges will be temporarily restricted after 10pm.

Resolved.  Sure it was. They hadn’t resolved anything. They’d just noticed the smoke, not the fire. I’d already moved my backdoors, changed my scripts, rotated through new accounts. I could see every move they made, every attempt to fix the system I already controlled.
And that’s when the thrill changed.

It wasn’t about curiosity anymore. It was about power. Some nights, I’d log in just to watch. Faculty typing memos. Admins running maintenance scripts. Grad students writing code. I could see their mistakes in real time, their typos, their backspaces, their sighs hidden in pauses between keystrokes. It was intimate in a way that felt almost indecent — like reading someone’s thoughts through the sound of their typing.

Once, I watched the bursar’s office update financial records. The transaction logs were just numbers, but I could see the entire machine of the university grinding away: money moving, approvals granted, fees assigned. The invisible economy beneath the surface.

I realized something then — a truth that would follow me for the rest of my life: Every system is just people pretending it’s not made of people. And people make mistakes. I started cataloguing vulnerabilities the way a birdwatcher keeps a list of sightings. I found patterns, habits, the same errors repeated by different hands. No one was malicious. Just careless. Lazy. Predictable.
I didn’t tell anyone what I found. Not because I didn’t want to help, but because I didn’t think they deserved help. They’d built the locks, after all. I was just testing the hinges.

I stopped thinking of it as hacking. I started thinking of it as… maintenance. And somewhere in the middle of one of those long, silent nights in the lab, surrounded by the low hum of a dozen terminals, I realized something else: I’d stopped feeling lonely.

I, Hacker: Chapter 2, Part 2: “Shell Games”

 The first door I found wasn’t locked. That’s what surprised me.

I was poking around my home directory, getting familiar with the shell commands — ls, cd, grep, the usual — when I discovered a script buried in one of the shared folders for the computer science department. It was called grade_report.sh. No password. No encryption. Just sitting there in a directory labeled /usr/local/share/scripts. The script pulled data from a CSV and generated formatted grade reports for the entire CS101 class. Instructor comments included.

I stared at it for a long minute. Not because I cared about the grades — I wasn’t even in that class — but because it was like someone had left a loaded revolver on a park bench and just walked away.
That was the moment I realized something fundamental:  The real system didn’t trust itself.

There was no security training back then. No firewalls. No intrusion detection. The campus sysadmins were graduate students who barely understood the systems they were running. Most of them were just happy if the printers worked. But I paid attention. I watched. I noticed that student login IDs followed a predictable pattern: first initial + last name + year. Mine was dsmith82. The system didn’t force password changes. It didn’t limit login attempts. It didn’t even mask password input — it just asked politely:

> PASSWORD:

I tried logging into a dormant student account — mjones81. I guessed the password.

 password.
 Access granted.
 
Just like that, I was someone else.

From there, it wasn’t hard to map the userbase. I built a crude script that pinged every possible ID in a given range and logged whether the login succeeded. I didn’t use brute force — that was noisy. I used logic.

I knew dorm floors, class rosters, lab schedules. If someone didn’t log in for more than a week, odds were good they weren’t paying attention.

I avoided anything that would generate noise in the logs. Never edited files. Never deleted anything. I just read. I wanted to see the skeleton beneath the skin.
I started finding breadcrumbs.

.bash_history files showing recent commands — some of them typed by faculty. Configuration scripts with commented-out admin tools. A text file in one user’s directory labeled staff_memo_draft.txt, which included a line about “budget reallocations due to misuse of lab time.” (That one made me laugh.)

I made copies of everything I found and stored them on an encrypted partition of my own account — not standard encryption, of course. I wrote my own XOR-based scrambling tool in C. Weak by today’s standards, but good enough back then. I called the tool “Whisper.”

The breakthrough came when I found a misconfigured cron job. It was a script that ran every Sunday night to clean temp files in a shared folder. But whoever wrote it forgot to use absolute paths — which meant it relied on the PATH variable to find executables. And the PATH variable included /home/shared/bin/ — a folder I had write access to. So I tested a theory.

I created a dummy script called rm.sh and placed it in that folder. Instead of deleting files, it just logged the action to a hidden file and exited silently. Then I waited.

Sunday night, 11:59 PM:  The system executed my fake rm.sh script, as root.

I didn’t get a shell — not yet — but I got something almost better: proof. They’d run my code. Blindly. With full privileges. All I had to do now was ask for more. By the end of my first semester, I had:

A growing archive of system documentation and internal memos.

Access to multiple student and faculty accounts.

An entire folder of tools I’d written myself — some crude, some elegant, all effective.

A map of the entire file system, including admin directories I wasn’t supposed to see.

And a creeping sense of detachment from the real world.

I stopped going to class. Stopped returning calls from home. My roommate dropped out sometime around midterms and I barely noticed. The system was more real to me than anything outside. And the more I understood it, the more I realized how little anyone else did.

I, Hacker: Chapter 2, Part 1: “Not Built for Classrooms”

 By the fall of 1982, I was enrolled at a mid-tier state university nobody outside the county had ever heard of. I won't name it — not out of loyalty, but because it doesn’t matter. The kind of place where football was more important than funding, where the professors had long since stopped caring, and the students never started.

I moved into the dorms two weeks before classes began. My roommate was a lacrosse major, or maybe marketing — I forget. He played Journey too loud and smelled like chewing tobacco. We coexisted like poorly written subroutines, each looping around the other without ever colliding.
College, I quickly learned, was not about learning. It was about ritual. You showed up to class, pretended to take notes, nodded at the right times. In return, they gave you a letter that supposedly meant something. The real lessons were found in fluorescent-lit hallways and vending machine alcoves — whispered shortcuts and survival strategies passed down like oral tradition from one dazed freshman to the next.

I sat through Econ 101 and Intro to Western Civ with the attention span of a broken timer interrupt. The professors droned from yellowed notes they'd recycled since the Nixon administration. Everything felt like a copy of a copy of a copy.

But there was one place — one shrine to actual purpose — that felt alive: the computer lab.
It was tucked away in the basement of the engineering building, down a concrete stairwell that always smelled faintly of mildew and burnt coffee. The sign on the door said AUTHORIZED STUDENTS ONLY — which, ironically, only made it more appealing. Inside, the room hummed with electricity and fluorescent light. Terminals lined the walls like soldiers, each one connected to a DEC mainframe that lived in a locked room on the floor above, humming like a god behind glass.

This wasn’t a toy anymore. No more blinking blue cursors. These machines ran a time-sharing system that let multiple users log in simultaneously, executing jobs in shared bursts of CPU time. It was elegant, efficient, and — most importantly — alive.

I got access through a class that technically didn’t start until second semester, but no one checked credentials. The lab monitors were grad students too sleep-deprived to care. I walked in, claimed a terminal, and never left. The interface was primitive — no GUI, no mouse, just a black screen and a white prompt:

> LOGIN:

My student account was limited to a personal directory and some coursework folders. But even then, I could tell the real system was much bigger — multiple users, shared memory spaces, nested file trees. There were directories I couldn’t access, commands that gave only denial messages, tools hidden behind layers of user permissions. It was like staring at the surface of an ocean and knowing, instinctively, there were depths below.

I started staying late. Sometimes past midnight. The janitor would mop around my feet. I slept through classes and read UNIX manuals printed on fanfold paper. The terminal didn’t blink. It pulsed. And I wanted in.

I began learning C first, then Pascal, and a little FORTRAN just to round it out. The university had lecture slides, but they were outdated, dry, and hopelessly sanitized. I taught myself from source code — from the comments of long-departed engineers who spoke like poets between the lines.

/* This hack fixes a buffer overflow if the student input is too long.
   Why are they always trying to break the input box? */

Back in the dorms, my roommate would ask what the hell I was doing down there every night.

“Homework,” I’d say.

“Homework doesn’t make your eyes look like that,” he said once.

He wasn’t wrong. I looked like I was mainlining caffeine through my corneas.
But what he didn’t understand — what nobody did — was that I’d found something real. Something alive. Beneath the layers of course requirements and student accounts, there was a structure — a system. A world of rules, gates, locks, and keys. It wasn’t about breaking anything. It was about understanding everything.

And every locked door only made me more certain: I wasn’t here to get a degree. I was here to get in.

I, Hacker: Chapter 1, Part 5: “Hello, World”

 
It was a Tuesday night. I remember that clearly — because Tuesday was trash night, and I had to drag the can to the curb before my mother got home.

The air was sharp, biting, that mid-autumn cold that smells like wet leaves and car exhaust. I hauled the dented trash can out front, stared up at the orange glow of the streetlight buzzing overhead, then hurried back inside. I locked the door behind me, out of habit more than fear.
Back in my room, the glow from the TV cast everything in soft blue shadows. The Commodore hummed faintly. The cassette drive clicked as I loaded my new program from tape — a tiny game I’d built the night before.

Simple premise: You’re an “X” on one side of the screen. An “O” bounces from the opposite end, slowly, and you have to catch it before it crosses a boundary. One button to move. One button to catch.

It was dumb. But it worked.

I stared at the blinking cursor and thought: This is mine. No one told me what to build. No class assignment. No tutorial. Just me and the machine, speaking in code.
I saved the game to a clean tape, labeled it with a marker:

 Catch_O v1.0 – Dent42
 
Then I connected the modem. The tones chirped and screamed through the phone line like possessed dolphins. Static flared. Then:

> CONNECT 300

The familiar welcome scrolled past:

> WELCOME TO THE WIZARD’S LAIR
> A BULLETIN BOARD SYSTEM
> (C)1981 PHREAKERJACK
I logged in. The handle appeared:
> Welcome back, Dent42.

There were new uploads in the Games section. A Zork clone. Some kind of Star Wars trivia thing. A utility that said it “confused phone traces” (it didn’t).

I clicked “Upload New File.” It asked for a title.

> CATCH_O

I attached a short note:

> Basic game. I built it myself. Arrow keys + spacebar.
> Feedback welcome.
> -D42
I hit ENTER.

For a few seconds, nothing happened. Just the loading screen, the blinking light on the datasette, the whirr of the drive.

Then: Upload Complete.

And then the strangest thing: I felt exposed. Like I’d just left my journal open in the school hallway. Someone could see it now. Judge it. Laugh at it. Copy it. Break it.
I almost logged off right then. But I didn’t. Instead, I clicked into the “Messages” section and left a short note on the public wall:

> Anyone try Catch_O? It’s dumb, I know. But it’s mine. -D42

I waited. Maybe ten minutes. Nothing. Fifteen. Then a reply:

> It’s not dumb. Add levels. Make it faster. Good bones.
> — Jack

PhreakerJack, The sysop. I stared at it, heart skipping. Not dumb. Good bones.

In the real world, I was a nobody. Skinny. Quiet. Good at math, bad at girls. I wore too-big jeans and hand-me-down sneakers with duct tape over the toes. I smelled like solder flux half the time and talked too much about starships and neural nets. But here? I was Dent42.

Someone saw what I built and said: Good bones.

I didn’t sleep that night. I sat up tweaking the game, adding a timer, adding lives, making the O’s speed up with each round. At one point, around 3:00 AM, I remember laughing to myself — actual laughter, the kind you can't fake.

I re-uploaded the new version. I called it Catch_O v1.1 and left another note.

That night, as the sky began to lighten and my eyes started to burn, I finally lay back on my bed. I stared up at the ceiling, the faint electric whine of the monitor still tickling my ears. The world hadn’t changed. But I had.

I, Hacker: Chapter 1, Part 4: “Offline Shadows”

 
The cursor was still blinking when I heard her again — just a knock, light and tired, against my bedroom door.

I minimized the terminal, even though I didn’t have to. Habit, maybe. Or guilt. Or the unspoken agreement between mothers and sons not to show each other the things that kept them awake at night.
She cracked the door, leaning her shoulder against the frame like she didn’t have the energy to stand upright anymore. Her uniform was wrinkled, stained near the hem with something that looked like pasta sauce. Her eyes were dull behind her drugstore glasses.

“You're actually gonna eat tonight?”

I blinked. “I thought I did.”

“You thought wrong,” she said. “Come on. Before I fall over.”

We ate in the kitchen — just the two of us, like always. Spaghetti again, made with discount-brand tomato sauce and dollar-store noodles. The garlic bread was toast with butter and a sprinkle of salt.
I picked at it with a fork that had one bent tine. She ate in silence, her legs crossed under the table, one foot tapping a tired rhythm on the linoleum.

“So,” she said finally, “that modem thing work?”

I looked up, trying to gauge whether the question was curiosity or suspicion. Her expression gave me nothing.

“Yeah,” I said carefully. “It... connects to stuff. Kind of like... message boards. People talking.”
“Anyone I know?” she said, half-smiling.

“No.”

She nodded like that was the answer she expected. Not a follow-up, not a lecture. Just silence again.
She took a long sip of iced tea and set the glass down with a clink.

“Your father used to disappear into things, too,” she said suddenly. “Not computers, though. His thing was a garage. He’d go out there, pretend he was fixing the car. Most of the time he was just hiding from me. Or you.”

I didn’t say anything.

“Thought he was building something once,” she continued. “A cabinet. Took six months. Came out like a leaning pile of garbage. Didn’t even have doors. Just stood there in the garage until it fell over one winter.”

“I didn’t know that.”

“Lot you don’t know about him. Probably better that way.”

I scraped my fork against the plate, pretending to chase sauce.

“Do you ever hear from him?” I asked quietly.

She looked at me — really looked, like she was weighing something.

“Sometimes,” she said. “A letter every few years. No return address. Just ‘hope you’re doing well’ and a hundred bucks.”

“Do you write back?”

“No,” she said. “I already wrote him off.”

We sat in silence again, the kind that fills a room like smoke. She eventually stood, grabbed her plate, and ran water over it in the sink.

“You keep your head straight, okay?” she said without turning. “I know you like that machine, but don’t let it swallow you whole.”

I nodded. “I won’t.”

She didn’t answer. Just finished the dishes, dried her hands, and went to her room.
Back in my own room, I flipped through my notebook — the cheap spiral-bound one I’d repurposed from biology class. Inside were command notes, scraps of code, BBS numbers, random ideas for programs. I’d drawn a diagram the night before: a flowchart mapping how to build a login screen that locked users out after three wrong tries.

At the top of the page I’d scrawled:

> SECRETS NEED DOORS

Below that:

> DENT42 – PRIVATE – DO NOT READ

I knew it wouldn’t stop anyone. Not really. But writing it felt like something. Like a declaration. A little fortress in ink and intention. I tucked the notebook under my mattress. Not the best hiding spot, but good enough for now. I sat back down at the machine and stared at the blue screen.

> READY

I typed in a few test lines, then deleted them. I opened the modem software again but didn’t dial. Not yet. Outside, the streetlights flickered once, then steadied. Somewhere far away, a siren wailed and faded. Inside, I sat with my fingers hovering over the keyboard, the weight of my father's silence still lingering in the room like secondhand smoke. And still, the cursor blinked.

I, Hacker: Chapter 1, Part 3: “Ghosts in the Wires”

 
The cursor was waiting. I didn’t know what for, but it was there, like a door that wouldn’t open until you found the right key.

The key came two weeks later, secondhand and scratched, wrapped in a plastic grocery bag by a guy named Tom who hung around the Radio Shack on Park Avenue. Tom was twenty-five, smelled like solder smoke, and always had the latest rumors about hardware that “fell off a truck.” He sold me a 300 baud modem for twenty dollars cash.

It looked like a beige ashtray with rubber cups on top. A direct-connect acoustic coupler. You set your phone handset into the cups like it was being tucked in for the night. It came with no manual, just a sticky note that said:

ATDT 555-xxxx

“I don’t know if it works,” Tom said, already backing toward the door. “If it fries your line, you never saw me.”

I biked home with it balanced on my knees. My mother was at work, as usual. The house was quiet, except for the refrigerator’s wet, rattling hum.

I cleared space on the desk next to the Commodore, coiled the phone cord, and plugged the modem into the wall. The handset barely fit in the rubber cups. The whole setup looked like a ransom note made of electronics. I typed:

> ATDT 5551234

The modem emitted a click and then a string of noises I’d never heard before: a squeal, a hiss, a burst of tones like an alien warble. The TV screen flickered, then filled with a single line:

> CONNECT 300

Then more text:

> WELCOME TO THE WIZARD’S LAIR
> A BULLETIN BOARD SYSTEM
> (C)1981 PHREAKERJACK

I blinked. The cursor blinked back.
It wasn’t like television. This wasn’t a show being broadcast. This was a tunnel. Somewhere, in another house, another person had a machine waiting for mine. The text wasn’t prerecorded. It was alive. I typed something stupid:

> HELLO?

A pause. Then text appeared:

> WHO’S THIS?

I hesitated. For a moment, I felt like I was trespassing, like I’d cracked open a secret door and stepped into someone’s locked room. Then I remembered the handles I’d seen scrawled on BBS numbers in the back of BYTE magazine. People didn’t use real names here. I needed one. My eyes landed on a copy of The Hitchhiker’s Guide to the Galaxy lying face-down on my bed. The spine was cracked. The page number folded. Chapter “Dent.” I typed:

> DENT42

Another pause. Then:

> WELCOME DENT42
> NEW USER DETECTED
> TYPE HELP FOR COMMANDS

The air in my room changed. I don’t know how else to describe it. The faint smell of hot plastic and dust mixed with something sharper, like ozone before a thunderstorm. My heart was pounding. The world outside — my street, my school, my mother’s double shifts, my father’s absence — all of it fell away.
I was in a room I couldn’t see, with a person I didn’t know, inside a network no one understood.
I explored until my eyes hurt. Message boards. Text files. Lists of other BBS numbers. Programs you could download — crude games, utilities, encryption scripts with names like “LOCKJAW” and “NOVA.”
Every time I pressed RETURN, something new appeared. Every command was a door. Every door led to another corridor, and somewhere at the end of one of them was another door marked “PRIVATE” with a digital padlock. And I wanted in.

At some point, my mother’s key rattled in the lock. She called my name. I ripped the phone handset out of the modem like I’d been caught with contraband. The screen blinked back to READY.
She opened my door a crack, still in her uniform, her eyes lined with exhaustion. “You eat yet?” she asked.

I nodded too quickly. “Yeah.”

“Don’t stay up all night with that thing,” she said. “You’ll fry your brain.”

“I won’t,” I lied.

She closed the door. I set the phone back in the cradle, the rubber cups still warm, and stared at the screen.

> READY

The cursor blinked. Waiting. Always waiting. Only now I knew what it was waiting for: me.

I, Hacker: Chapter 1, Part 2: “Booting Up”

The cursor blinked at me like a dare.

I leaned closer, elbows on my knees, my breath fogging the screen. The little 13-inch TV hummed with a static that felt alive, like a distant signal from something buried under the floorboards. The words in the manual spread out on my desk — thick, cream-colored paper, diagrams of memory maps and flowcharts I couldn’t stop staring at. I typed the first thing the manual suggested.

> PRINT "HELLO"

I jabbed RETURN. HELLO appeared. My pulse jumped. Stupid. It was just text on a screen. But it was also something else — a voice from the void. I typed again.

> 10 PRINT "HELLO WORLD"
> 20 GOTO 10
RETURN.

The screen filled with a waterfall of HELLO WORLD HELLO WORLD HELLO WORLD until it blurred into an unreadable smear. My mother’s voice from the kitchen called, “You okay in there?” and I shouted back something like, “Yeah, just testing.” But I didn’t move. My hands were trembling on the keys.
This was mine.

Not a TV program. Not a movie. Not a radio station. Not something built by someone else. This was me, telling a machine to speak, and it obeyed.

Hours passed without me noticing. Pancakes turned to rubber on my plate. Tang grew a skin. My mother left for work and called out something about locking the door. The house grew quiet except for the rhythmic tick-tick of the cursor when I paused to think.

I worked through the manual line by line. Loops. Variables. IF-THEN. PEEK and POKE commands that let me prod memory directly like a surgeon poking at a brain. Each new command opened a hidden door.
I discovered how to make the screen flash. Then how to make it beep. Then how to draw crude shapes in blocky pixels. The smell of heated plastic filled the room — that faint electronic scent like hot dust and ozone. It was intoxicating. I wanted more.

By late afternoon, I was building my first game. Nothing fancy — a little program where a letter “O” moved across the screen like a ball and you had to catch it with an “X.” But when it worked, when the thing actually moved and responded to my key presses, I felt a jolt of adrenaline so pure it left my mouth dry. I was inside.

It wasn’t just code. It was a language, a conversation. The machine didn’t talk back — but it answered. And the answers were precise, uncompromising, logical. Nothing like the messy contradictions of people.

My father’s voice crept into my mind — something he’d said once before disappearing again: “You’ll never amount to anything messing with toys.” I smiled at the thought. This wasn’t a toy. This was a weapon. He just didn’t know it.

The sun dipped low outside the window. The streetlights flickered on, casting sodium-yellow bars across my desk. I still hadn’t left my chair. My stomach growled, but I ignored it.
I wrote my first password file — a little BASIC routine that encoded a string with a simple substitution cipher. Totally pointless. But it felt secret, like scribbling a diary in invisible ink.
I closed the notebook, capped my pen, and stared at the screen.

> READY

The cursor blinked. Waiting. Always waiting.

I didn’t know it yet, but that blinking cursor would be the backdrop to my life. The steady heartbeat of a new world opening — a world I’d never really leave.