Social Distancing for Your Filesystem

Level 1: Keep Your Hands to Yourself

Imagine you’re at school and there’s a new rule that says “No touching” because everyone is worried about catching germs. Your teacher might warn you: “Don’t touch your friends or their stuff, or you could get sick.” Now picture your computer acting like that teacher! In this joke, the person tried to make a new file on their computer (kind of like trying to pick up a toy), and the computer responded, “Nope, you can’t touch that – you might spread COVID!” 😂 It’s funny because computers can’t actually catch or spread human germs. The computer is pretending to follow the same safety rules humans had during the pandemic. In real life, we were all told to keep our hands to ourselves for safety. The meme makes us laugh by showing a computer taking that very human rule way too seriously. It’s basically a computer saying, “I won’t let you do that, it’s for your own good, no touching!” We all know that’s a silly reason in the computer world, and that silliness is the whole joke.

Level 2: No Touching Allowed

Let’s break down what’s happening in plain terms. We’re looking at a text console (the CLI, or Command Line Interface) where a user can type commands to interact with the computer. The prompt admin@desktop ~ % is telling us the user’s name (admin), the machine (desktop), and that they’re in their home directory (~). The % sign is just the prompt symbol used by the zsh shell (commonly the default on Mac). Now, the user enters the command touch test. In Unix-like systems, touch is a simple command that either creates an empty file named “test” if it doesn’t exist, or updates the last modified time on that file if it does exist. It’s basically a quick way to make a new blank file. If you have the right permissions to create files in the current directory, touch will quietly succeed with no fanfare. If you don’t have permission (for example, if you’re in a folder that’s marked read-only for your user), the system will refuse and typically output a short error message like “touch: cannot create file ‘test’: Permission denied”. In other words, “Sorry, you’re not allowed to do that.”

But in the meme’s screenshot, instead of a normal brief error, we see a much longer, tongue-in-cheek message:

Permission denied: touches are strictly prohibited due to the risk of COVID-19 infection

Whoa! Computers don’t usually talk about infections and COVID risks when you try to create a file. This is definitely not a standard error message – it’s a joke. Here’s why it’s funny: the word “touch” in the command is being treated like the word “touch” in real life. During the COVID-19 pandemic, everyone was being told not to touch things (or each other) to avoid spreading the virus. Signs saying things like “Touching surfaces is prohibited due to infection risk” were common. In the tech world, though, the touch command has zero to do with physical touch – it’s just unfortunate naming from an English perspective. The person who crafted this prank harnessed that coincidence. The computer responds as if the user literally tried to “touch” something in a no-touch zone! It’s pretending that creating a file is akin to physically touching a potentially germy surface, and it humorously “denies permission” for safety reasons. In reality, you can’t catch COVID from a file on your disk, of course. That’s the absurdity that makes it a pun (a joke based on a word with two meanings). The phrase “touches are strictly prohibited” is exactly the kind of serious wording you might see on a public health poster, which makes it extra funny coming from a usually terse computer.

So, what’s actually happening behind the scenes? It isn’t that the operating system suddenly became health-conscious. Instead, someone deliberately customized their terminal to display this message. Developers have the freedom to create aliases or custom functions for commands. It looks like whoever set this up decided that whenever they or someone else runs the touch command, the terminal should output this humorous warning. In simpler terms, the computer is not truly enforcing a COVID rule – a programmer told it to say that line as a prank. This is part of programmer culture: we often inject playful easter eggs or jokes into our tools for a laugh. The red text indicates it’s an error (it was likely printed to the error stream). So the sequence is: the user tries to touch a file, the custom alias prints “Permission denied: …risk of COVID-19 infection,” and nothing actually happens to the filesystem. The file isn’t created, but not because of any real virus concern – it’s just because the joke command deliberately didn’t create the file.

If you’re new to the command line, rest assured: your computer won’t normally scold you about pandemics! This meme is a playful crossover between tech and real life. In April 2020, COVID-19 was the big topic everywhere, and even coders made jokes about it in our domain. The humor here comes from a very human rule (“don’t touch, you might spread germs”) appearing as a computer rule. It’s the kind of thing that makes a programmer giggle and maybe groan at the pun. In summary, the user tried a simple file creation, and the terminal replied with a pretend “permission denied” citing a COVID safety policy. Silly? Absolutely. And that’s why developers find it amusing – it shows our beloved command-line being cheeky and culturally aware, if only for a moment.

Level 3: Terminal Gallows Humor

As experienced developers, we recognize this immediately as a bit of cheeky command-line fun. The user types touch test – a mundane attempt to create a file named "test" in the current directory. Under normal circumstances, either a new file would quietly appear or you’d get a plain Permission denied error if your user account lacked the rights to write there. But here, what pops up is a full-blown pandemic safety directive! The error says you can’t “touch” because of COVID-19. This mash-up is equal parts absurd and relatable. It’s a prime example of developer humor: blending our coding world with current events to produce an inside joke. The result is a terminal message that reads like a public health announcement.

For seasoned devs, it’s clear that this isn’t a real operating system complaint – it’s a setup for a pun. The humor hinges on the double meaning of the word “touch.” In the Unix command, touch has nothing to do with physical touching; it’s about updating file times or creating files. But in everyday language, to touch something (or someone) was suddenly a dangerous act in early 2020 due to the pandemic. By citing “risk of COVID-19 infection,” the error message pretends that the computer is enforcing the same no-contact rules humans had to follow. It’s the shell practicing social distancing! The phrase “touches are strictly prohibited” is phrased exactly like the official warnings we saw everywhere at the time. That familiarity is what makes it so funny — the terminal is parroting a stern real-world tone, but in a completely inappropriate context.

This kind of pun-based error message is a form of gallows humor, and boy, did developers embrace that in 2020. We were all inundated with serious alerts and new rules during the COVID outbreak, so injecting those phrases into a normally dry tech scenario was cathartic. It’s the terminal itself cracking a dark joke. Consider how we usually react to seeing “Permission denied” in red text: typically with a groan, since it means something’s wrong with file permissions or we forgot to use sudo. But when the reason given is a pandemic precaution, it flips our script. Instead of frustration, it draws a laugh. It’s so out-of-place that you can’t help but imagine an overly cautious computer saying, “Nope, I won’t even create a file for you — it’s not safe to touch!” This alignment of a routine terminal command with a global crisis catches us off guard, which is exactly why it elicits that “haha wow” reaction from developers.

The timing of this meme (around March/April 2020) is no coincidence. That’s when COVID-19 concerns were at a peak and phrases like “due to the risk of infection” were on everyone’s lips (and every website’s pop-up banner). For a developer seeing this screenshot, it instantly recalls that era. Many of us were working from home, maybe a bit on edge, and a joke like this cut through the tension. It wouldn’t even surprise us if this were originally an April Fool’s Day prank on a dev team – the kind where a sysadmin alters the motd (message of the day) or aliases a command to raise collective eyebrows. In fact, experienced engineers might chuckle and think, “Okay, who set the alias this time?” We’ve seen similar stunts, like custom fortune messages, funny 404 pages, or the classic “alias sudo="echo 'sudo: permission denied, have you tried giving the cat a treat instead?'” gags. This particular joke stands out because it mixes two worlds: the insular world of the command-line, and the global experience of the pandemic. It’s a reminder that dev humor often mirrors real life. We joke about what’s impacting us — even if that means the serious notion of a contagious virus gets spoofed as a fake error message on our screens.

Not to mention, there’s a delicious irony in the details: the prompt shows the user as "admin", implying they’re a superuser. Typically, an admin bypasses most permission issues (root can usually touch anything, anywhere!). Yet here even “admin” is told a firm “NO” by the computer, as if to say no level of privileges can override COVID safety rules. It pokes fun at the idea that some rules (in real life, the laws of nature and disease) can’t be sudo’d away. In summary, this meme tickles developers because it takes a very familiar frustration (not having permission) and gives it a completely ridiculous twist (a computer worrying about a biological virus). It’s a shared wink among coders, saying “we all need a laugh, even our shell knows that.” And for once, a dreaded Permission Denied error actually makes our day a little better instead of worse!

Level 4: System Call Sanitization

Under the hood, the simple touch command triggers a low-level file operation in the operating system. Normally, touch test will instruct the OS to create an empty file named "test" (if it doesn’t already exist) or update its last-modified timestamp (if it does). This involves a system call (like open() or utimes()) that asks the kernel to modify the filesystem. If the user doesn’t have the right file permissions (for example, trying to create a file in a directory you’re not allowed to write to), the kernel returns an error — specifically, an error code for “Permission denied.” In Linux/Unix, this is typically the EACCES error code. The touch utility (part of core CLI tools) detects that failure and usually prints a standard error message (to stderr) that includes the text “Permission denied,” letting you know the OS refused your request.

In the meme, however, the error message we see is anything but standard. It reads like an official health notice! This suggests that the usual error handling was hijacked by a custom tweak. The comedic output "touches are strictly prohibited due to the risk of COVID-19 infection" is not something any stock Unix system would ever say — it had to be injected by the user or a prank program. How could that be done? One likely method is using a shell alias or function that overrides the touch command. In a Unix shell like bash or zsh, a user can create an alias so that when they type touch, it runs their custom code instead of the real touch. For example:

# A mischievous alias overriding 'touch' to output a COVID-themed error
alias touch='echo "Permission denied: touches are strictly prohibited due to the risk of COVID-19 infection" >&2; false'

In this snippet, we alias touch to first echo our joke message to the error stream (>&2 ensures it’s colored as an error in many terminals), then use false to return a failure status. The result? Every time someone tries to touch a file, the shell prints the custom warning and reports the command as unsuccessful – convincingly imitating a genuine permission_denied_error. The operating system’s actual permission system wasn’t involved at all; our alias “faked” the denial.

What’s interesting from a tech perspective is how this plays on the mechanism of error messages. Typically, when a syscall fails, programs retrieve a generic error string (like "Permission denied" or "Access denied") from the system’s C library (strerror(errno) in C). Those messages are predefined and certainly don’t include contemporary references like COVID-19. By intercepting the command at the shell level, the prankster bypassed the normal error string and supplied their own humorous text. It’s a clever injection of real-world context into the sterile world of system errors. The kernel itself has no concept of pandemics, of course – it isn’t actually enforcing a “no-touch policy”! But this alias trick makes it appear as though even the OS has adopted quarantine rules. It’s a nerdy reminder of the times: an error message wearing a face mask, so to speak. And given that this meme emerged in early 2020, it wouldn’t be surprising if it started as an April Fool’s hack or a lighthearted patch someone shared to cope with the grim news. Even at the level of system calls and error codes, developers found a way to weave in a bit of pandemic-related dark humor.