finger: The Internet’s First Social Network and IoT Pioneer

How a simple Unix command connected vending machines to the internet, created the first .plan files, and pioneered community networking decades before Facebook

---

I’ll never forget the first time I discovered what finger could really do.

I was maybe thirteen, hunched over a borrowed terminal account at some university computer lab, when someone showed me the legendary command: finger coke@cmu.edu. The response that came back stopped me cold:

[cmu.cs.coke]
Coke machine status for Sun Jun 28 14:22:17 1987

M & M     /  7.0C/  99 /  100 /   CCCC
Coke      /  5.0C/  13 /  100 /   CCCC  
Diet Coke /  5.0C/  21 /  100 /   CCCC
Sprite    / 12.0C/   1 /  100 /   C---

Key: C = cold, 7 = very cold
Queries: 847 today, 1671 yesterday

A Coke machine. With its own internet presence. In 1987.

In that moment, I realized this wasn’t just a network utility – this was the birth of something revolutionary. Carnegie Mellon had connected a vending machine to the internet before most people knew what the internet was. Students could check if the machine was stocked and whether the drinks were cold, all through a simple Unix command.

This was the Internet of Things before anyone knew what the Internet of Things was. No mobile apps, no cloud services, just ingenious engineering and a community that understood technology should be both useful and delightful.

What Made finger So Special

The .plan File Revolution

The coolest part about finger was the .plan file. This was your chance to leave a message for anyone curious enough to finger you. But what started as simple status updates quickly evolved into an elaborate creative arms race.

People would put:

• Witty quotes and philosophical musings that rotated daily
• ASCII art masterpieces (this was serious business - some took hours to perfect)
• Serial stories updated in installments to keep people coming back
• Interactive choose-your-own-adventures using finger as a primitive hypertext system
• Technical tutorials and code snippets for the community
• Social commentary and inside jokes that became legendary
• Contact info for other networks and systems

Your .plan file was your digital personality before anyone knew what that meant. But more than that, it became a competitive art form. Every lab had that one person whose .plan file was so elaborate, so creative, so perfectly crafted that checking it became a daily ritual for everyone else.

I remember one user whose .plan file was a different haiku every day, each one perfectly capturing some aspect of computer science frustration:

Segmentation fault
Core dumped, dreams shattered again  
Recompile my soul

Another person maintained a running ASCII art animation that told an ongoing story about a knight’s quest, updated every few hours. People would finger their account multiple times a day just to see what happened next.

The really ambitious ones would create .plan files that responded to who was fingering them, or that changed based on the time of day. Your .plan file wasn’t just a status message - it was your digital art gallery, personal newsletter, and social media feed all rolled into one.

But people got seriously competitive about it. The finger community developed distinct personality types, each with their own approach to .plan file mastery:

The Daily Updaters would change their .plan files constantly - rotating quotes, countdown timers to major events, weather reports, or serial stories updated in installments like a primitive blog.

The ASCII Artists treated their .plan files like galleries:

Plan:
Currently debugging the universe...
Please stand by.

    ╔══════════════════════════════╗
    ║  "Code is poetry."           ║
    ║  "Debugging is being the     ║
    ║   detective in a crime       ║
    ║   movie where you are also   ║
    ║   the murderer."             ║
    ║                              ║
    ║  - Unknown Programmer        ║
    ╚══════════════════════════════╝

Status: Caffeinated and dangerous

The Philosophers used their .plan files for manifestos, political commentary, or deep thoughts about technology and society. Reading someone’s .plan file could give you a window into their entire worldview.

The Social Coordinators turned their .plan files into bulletin boards for their friend groups - announcing parties, coordinating study groups, or just keeping people updated on campus drama.

The Minimalists went the opposite direction with cryptic one-liners that became legendary:

• “Gone fishing in cyberspace”
• “Reality is for people who lack imagination”
• “Currently: Existing”
• “42”

There was genuine social pressure to have an interesting .plan file. A boring or empty .plan file marked you as either new to the system or fundamentally uncool. Your .plan file was your reputation in the community.

Network Transparency That Would Horrify Modern Privacy Advocates

finger was beautifully transparent in ways that would make today’s privacy experts break out in hives:

• Real names tied to usernames
• Login patterns visible to anyone
• Terminal information showing exactly where you were
• Idle time revealing how long you’d been away

But here’s the thing: nobody really minded. This was a community of people who wanted to be found and wanted to share information. The internet felt small and friendly.

The Accidental Data Science of Human Patterns

Here’s what made finger fascinating from a technical perspective: it accidentally created one of the first behavioral analytics systems.

You’d start using finger to check if friends were online, and without meaning to, you’d begin to recognize the digital rhythms of your community. Sarah from the computer science lab logged in every day at exactly 3:17 PM – that must be when her Advanced Algorithms class ended. Professor Johnson’s account showed late-night sessions that stretched until 2 or 3 AM, revealing the dedication that came with research deadlines.

finger accidentally turned login data into community awareness.

You could see the pulse of the lab: when people arrived for work, when they took breaks, when they pulled all-nighters before deadlines. The network felt alive with human activity in a way that modern social media, with its algorithmic feeds and delayed notifications, somehow never quite captures.

The Community Dashboard

The real magic happened when you realized finger wasn’t just about individuals – it was a real-time window into the entire academic community:

• Lab activity patterns showed when the best discussions were happening
• System load information helped you find quiet machines to work on
• Project rhythms became visible through .plan file updates and login patterns
• Research cycles revealed themselves through late-night coding sessions

finger became an informal coordination system for academic life. You knew when to show up for the best conversations, when to avoid the crowded terminals, when your advisor was likely to be available.

The Accidental Community

What finger created, without anyone planning it, was radical transparency that built community. When everyone’s digital life was visible, when you could see who was around and what they were working on, the network felt alive with human presence.

But it also created its own intricate social mechanics that we had to figure out as we went along:

The Art of Finger Frequency: How often you fingered someone became a form of communication itself. Finger someone once a day? That was friendly interest. Multiple times an hour? That was either romantic obsession or creepy stalking, depending on the context. The perfect frequency showed you cared without being overwhelming.

The Unspoken Etiquette:

• Don’t finger someone immediately after they log out (it looked desperate)
• If someone’s .plan file said they were busy, fingering them repeatedly was rude
• Commenting on someone’s login patterns in person was a social faux pas
• Sharing someone else’s .plan file contents without permission violated trust

The .plan File Response Protocol: If someone mentioned you in their .plan file, you were expected to acknowledge it somehow - either in your own .plan file or by talking to them next time you saw them online.

The Idle Time Respect: If someone showed as idle for several hours, it was considered polite to wait before trying to contact them directly. Their idle time was telling you something about their availability.

The Login Time Awareness: Regulars developed an intuitive sense of each other’s schedules. If someone was usually online evenings but suddenly appeared during the day, something interesting was happening - maybe they were sick, or had a deadline, or something worth asking about.

The Social Hierarchies: Some accounts became celebrities just because their .plan files were so good. Everyone would finger the same few legendary accounts daily, creating an informal finger fame system. These weren’t famous people - they were just regular students and staff who happened to be creative with their .plan files.

But sometimes, genuinely famous people used finger too. The most legendary example was John Carmack’s .plan file during the development of Doom, Quake, and other id Software games. Carmack would post incredibly detailed technical updates about 3D graphics programming, OpenGL optimization, and game development challenges. For gaming enthusiasts and programmers, fingering carmack@idsoftware.com became a daily ritual. His .plan files were like getting insider access to the future of gaming - dense technical dissertations that would later become foundational knowledge in 3D graphics programming.

You can even read his original 1997 .plan file (PDF) to see exactly what these legendary updates looked like - pure technical brilliance mixed with the casual intimacy that made finger so special.

Your .plan file became a bulletin board for your friend group. The lab’s shared accounts developed personalities through their .plan files. Someone would always be the one to maintain the elaborate ASCII art that rotated daily, another person would leave philosophical quotes, someone else would keep a running commentary on campus politics.

finger made the network feel like a neighborhood where you could walk down the street and see lights in windows, glimpse people going about their lives, wave hello. But more than that - it was a neighborhood where everyone’s curtains were always open, and somehow, that made everyone feel more connected rather than more exposed.

These unwritten social protocols emerged organically from the community using the tool. finger wasn’t just revealing technical information - it was creating a shared social space with its own culture and customs.

How finger Actually Worked (The Technical Magic)

The finger protocol (RFC 1288) was beautifully simple, but to a thirteen-year-old kid discovering it for the first time, it felt like pure magic.

Think about it: you could type a single command and instantly reach across continents to touch someone else’s digital life. This wasn’t email that sat in a queue somewhere - this was real-time connection to a person sitting at a terminal thousands of miles away. The fact that it worked at all seemed miraculous.

The Query

finger user@hostname

That’s it. Seven words that could connect you to anyone, anywhere in the networked world.

What Happened Behind the Scenes (The Magic Revealed)

1. TCP connection on port 79 (finger had its own dedicated port!)
2. Send the username across the internet in plain text
3. Server responds instantly with everything it knows about that person
4. Connection closes when done - clean and simple

As a kid, I didn’t understand how any of this worked. I just knew that typing those few characters could:

• Reach into university computer labs in different time zones
• Connect to research facilities I’d only dreamed of visiting
• Touch the digital lives of graduate students and professors doing incredible work
• Bridge continents with nothing more than a phone line and a modem

The speed was intoxicating. No waiting, no delays - just instant access to human presence across the network.

The finger protocol in action - showing how that simple command could reach across continents to glimpse someone’s digital life

Sample Output (Prepare for Nostalgia)

$ finger bob@cs.university.edu

[cs.university.edu]
Login: bob        Name: Robert Johnson
Directory: /home/bob               Shell: /bin/bash
On since Mon Jun 28 08:15 (PDT) on pts/1 from workstation.cs.edu
Last login Mon Jun 28 08:15 (PDT) on pts/1
Mail last read Mon Jun 28 09:30 (PDT)

Plan:
Working on my TCP/IP stack implementation.
If you need me, I'm probably in the lab
debugging packet loss issues. Again.

   _______________
  < TCP is hard >
   ---------------
          \   ^__^
           \  (oo)\_______
              (__)\       )\/\
                  ||----w |
                  ||     ||

$ _

A real finger response showing Bob’s TCP debugging struggles - complete with ASCII art cow wisdom

The Cultural Impact: More Than Just a Command

Academic Network Culture

finger became central to university computing culture:

• Finding collaborators for research projects
• Checking if professors were available
• Campus social networking before Facebook existed
• Technical discussions through .plan files

The Art of the .plan File

People got seriously creative with their .plan files:

• Animated ASCII art that changed daily
• Serial stories updated in installments
• Technical tutorials and code snippets
• Philosophical manifestos and political commentary
• Social calendars and event announcements

Your .plan file was your personal homepage before the web existed.

The Legendary Easter Eggs

But the real magic happened when institutions got creative with finger. Universities started setting up Easter egg accounts that weren’t attached to real people but served the community in delightful ways.

The most legendary was finger coke@cmu.edu at Carnegie Mellon. This would tell you the status of the Coke machine in the computer science building - how many bottles were left in each slot, which ones were cold, even when it had last been restocked. This wasn’t just useful (no more walking three floors to find an empty machine), it was pure digital poetry: a vending machine with its own online presence before anyone had conceived of the “Internet of Things.”

The legendary CMU Coke machine interface - 847 queries in a single day! This wasn’t just useful, it was the birth of the Internet of Things.

Want the full story? Check out the official CMU Coke machine history - it’s a fascinating deep dive into how a simple student project became internet legend.

You can also visit the web version that died around 2006 (still preserved for posterity) and this fun retrospective from UCSD about the cultural impact of the world’s first internet-connected appliance.

Other universities followed with their own creative accounts:

• Weather services (finger weather@wherever.edu) that gave local forecasts
• Quote machines that dispensed daily wisdom or humor
• Event calendars for campus activities and lab schedules
• System status accounts that reported server uptime and network health
• Joke accounts that would respond with puns, riddles, or rotating comedy

These weren’t official services - they were love letters to the community, created by sysadmins and students who understood that technology should be both useful and delightful.

Some of the best Easter eggs were completely unauthorized creations by clever students:

• Accounts that told elaborate jokes in installments
• Fake celebrity accounts with creative .plan files
• Interactive fiction games played entirely through finger commands
• Hidden message systems for sharing information

Finding these Easter egg accounts felt like discovering secret passages in a video game. You’d share the good ones with friends, and soon everyone would be fingering the campus weather account or checking the Coke machine status.

It was crowdsourced information services decades before we had terms for that concept.

The Security Reality Check

Of course, finger had some interesting security implications:

Information Leakage

• User enumeration (who has accounts here?)
• Login pattern analysis (when is the sysadmin usually around?)
• Real name mapping (connecting usernames to actual people)
• System information (what kind of machines are these?)

The Double-Edged Sword

This transparency was both finger’s greatest feature and biggest vulnerability. It made systems more human and approachable, but also more exposed to reconnaissance.

Most sysadmins eventually disabled external finger access, but kept it running internally for the community aspects.

Enter Webfinger: The Modern Resurrection

Fast-forward to today, and we have Webfinger (RFC 7033) - a protocol that captures finger’s discovery spirit while addressing modern needs.

How Webfinger Works

Instead of finger user@domain, we now have:

GET https://domain/.well-known/webfinger?resource=acct:user@domain

JSON Instead of Plain Text

Instead of human-readable text dumps, we get structured JSON:

{
  "subject": "acct:ryan@ryanmalloy.com",
  "links": [
    {
      "rel": "http://webfinger.example/rel/profile-page",
      "type": "text/html", 
      "href": "https://ryanmalloy.com/about"
    },
    {
      "rel": "self",
      "type": "application/activity+json",
      "href": "https://ryanmalloy.com/users/ryan"
    }
  ]
}

The Modern Applications

Webfinger powers a lot of decentralized web technology:

• Mastodon uses it for user discovery
• Matrix for finding chat servers
• Email clients for configuration discovery
• OAuth for identity provider discovery

Why This Matters: Decentralization vs Corporate Silos

The finger → Webfinger evolution shows something important about how the internet has changed:

The Original Internet Spirit

• Open protocols anyone could implement
• Decentralized discovery across different systems
• User control over their own information
• Community-driven standards and culture

The Corporate Web Reality

Today, most “discovery” happens through:

• Google search (centralized index)
• Social media platforms (walled gardens)
• App stores (gatekeeper-controlled)
• Corporate directories (closed systems)

Webfinger’s Promise

Webfinger represents a return to decentralized discovery:

• No single point of control
• User-owned identity
• Cross-platform compatibility
• Open standards anyone can implement

The Technical Deep Dive: From Port 79 to HTTPS

Original finger Protocol (RFC 1288)

• TCP port 79 for communication
• Plain text requests and responses
• No encryption (everything in the clear)
• No authentication required
• Simple query format: just send the username

Modern Webfinger (RFC 7033)

• HTTPS for security (port 443)
• JSON for structured data
• Encrypted transport by default
• Extensible link relations for different types of resources
• Standardized endpoints (/.well-known/webfinger)

The Evolution Makes Sense

Both protocols solve the same basic problem: “How do I find information about this person/resource on the network?”

But Webfinger does it with:

• Better security (encryption, authentication)
• More structure (JSON vs plain text)
• Greater extensibility (link relations, multiple resource types)
• Web integration (HTTP-based, works with existing infrastructure)

Why I Still Love the finger Spirit

There’s something beautiful about the original finger philosophy:

• Information wants to be shared
• Networks should be transparent
• People should be discoverable
• Community builds on openness

Sure, we’ve learned about privacy concerns and security implications, but the core idea remains powerful: the internet works better when people can find each other.

Webfinger takes that spirit and makes it work in our modern, security-conscious world. It’s finger for the HTTPS era.

The .plan File Lives On

While we don’t have .plan files anymore, the spirit lives on in:

• GitHub profiles and README files
• Mastodon bio sections and pinned posts
• Personal websites and about pages
• Social media profiles and status updates

The human desire to share information about ourselves hasn’t changed. We just have better tools now.

Conclusion: Finger Pointed the Way Forward

Looking back, finger was more than just a network utility. It was an early experiment in networked social interaction that predicted many features we take for granted today:

• User profiles and status updates
• Presence information (online/offline status)
• Cross-network discovery and communication
• Decentralized identity and information sharing

Webfinger is finger’s spiritual successor - keeping the best parts (discovery, openness, decentralization) while adding modern necessities (security, structure, extensibility).

So the next time you see a Mastodon handle like @user@instance.social and wonder how the software knows where to find that person, remember: it’s using Webfinger to do essentially the same thing we were doing with finger 40 years ago.

Some ideas are just too good to die. They evolve.

The finger protocol: proving that sometimes the simplest ideas have the longest lasting impact.

---

Want to explore more early internet protocols that shaped our digital world? Check out my deep dive into DNS evolution or learn about the BBS culture that ran parallel to these academic networks.