Where did the 46 Years come from?

You didn’t become Facebook friends 46 years ago. So, where does the number come from. It isn’t random. It is a result of how time is calculated in computing.

Unix Time is how most programmers calculate and store time. It is the number of seconds (not counting leap seconds) since the Unix epoch, January 1, 1970, 00:00:00 UTC. Unix time is incredibly useful on the Internet because it allows you to store time independent from timezones. (If you are not sure why timezones strike fear into the hearts of programmers, watch Tom Scott explain why on Computerphile.)

So, say you want to see exactly how many years it has been since two people became friends on Facebook. Instead of trying to subtract dates like this (shudder):

Now: December 31, 2015 13:00:00 EST
Date Friended: June 14, 2008 8:00:00 EST

December 31, 2015 13:00:00 EST minus June 14, 2008 8:00:00 EST =

¯ \ _(ಠ_ಠ) _ / ¯  Years

You would use a programming function that some other wonderful programmer (or team of programmers) has painstakingly put together and maintained to convert these messy times into Unix time stamps to store and use throughout your website or application. In PHP the function is strtotime(), string-to-time. You put in an English date and it gives you the number of seconds since the Unix epoch (January 1, 1970 00:00:00 UTC).

Now: strtotime( 'December 31, 2015 13:00:00 EST' )
Date Friended: strtotime( 'June 14, 2008 8:00:00 EST' )

Now: 1451584800 seconds since Unix Epoch

Date Friended: 1213448400 seconds since Unix Epoch

1451584800 - 1213448400 = 238136400 Seconds 238136400 ÷ 31557600 (seconds in a year)  = 7.54608715492 Years

You have been friends on Facebook for 7.5 years!

That’s much easier. And, this works no matter what timezone the user is in as you can use client-side scripting like Javascript to convert the Unix timestamp into the user’s local time. All this is great, but how did you end up getting the notification that it has been 46 years since you became Facebook friends with your friend? Most likely this bug is caused by a programming error that caused the friended date to be replaced by the Unix epoch, which would return 46 years ago for dates in 2015. Some date functions will return the Unix Epoch anytime a mistake is made in the function, like if a typo adds a non-number character to the timestamp.

“Go home, Facebook. You’re drunk.” vs. “Nerd Fact: Unix Epoch is a Thing”

The most common reaction of people on Facebook has been something along the lines of “Go home, Facebook. You’re drunk.” and for the aging Facebook population worry about time passing too fast. This sentiment has been picked up by online media leading to click-bait titles like: Are Facebook memories now travelling to the future? Tech glitch has some thinking “yes” and Facebook teasing the old people with their official comment on the matter, “We’ve identified this bug and the team’s fixing it now so everyone can ring in 2016 feeling young again” (Time).

Perhaps most interesting to me, however, has been the dialogue between those who didn’t know where the 46 years came from and those that instinctively did (as opposed to those who read about it in the TechCrunch article). Most of the non-media posts, early on were either people laughing at Facebook and chalking it up to a “glitch” that provided a random number of years and people correcting them by pointing out the number’s relation to the Unix epoch. (I definitely fell in the latter category.) Other than as a dubiously interesting fact, what purpose does reporting the cause of the bug have? I don’t think it was so much about correcting those “n00bs” and “muggles” who don’t understand how the backends of the technology they use work. It is more about sharing a how their experiences of technology are different from those around them.

Programmer Experience

For anyone who has ever programmed using Unix timestamps, running a script and unexpectedly receiving a return value of January 1, 1970 is a clue to what is wrong with the script. Although most of us would prefer to think of ourselves as code wizards who write perfect, functioning code every time, this rarely happens. Instead, programming is mostly writing code, running code, getting errors or unexpected results, interpreting the results, fixing the code, and repeating ad nauseam. Therefore, programmers amass large knowledge sets on how to debug code in their memories, scribbled in notebooks, or stored in personal knowledge bases. Although we are not Dumbledore whipping up code with a flick of a magical wand, we are Sherlock Holmes solving mysteries by glancing around the scene of the crime noticing minute details that others mistake as random or coincidence. And, that feels pretty awesome.

So, when people in our Facebook feeds were posting about their 46 year old friendships, we saw a date error and quickly subtracted the years and concluded that it was an error related to Unix timestamps. Sherlock-ed!

This reaction isn’t just showing off. It’s about sharing our life experiences. After all, that is what Facebook is supposed to be about. How one experiences technical difficulties has much to do with your broader experiences with technology. Those with a background in programming or other IT experience (for fun or for wages) experience technical difficulties as solvable challenges with concrete answers (even if we don’t know them—”The truth is out there.”) that can be found through our analytic toolkit. This makes us great at solving technical problems. But, it also changes the way we experience the Internet, separating us (although not detaching us) from a common Internet aesthetic that views these kinds of bugs and glitches as serendipitous opportunities to reflect on the roles of technology in our lives and relationships. This separation comes largely from the distance between the reflection and the reality that caused the bug.

This isn’t to say that programmers and other techies are incapable of such reflection, rather, we tend to temper these reflections with our own experiences and knowledge, complicating the often simplistic rhetoric that pops up around these bugs. While our friends use the 46-year-friendship bug to poke fun at Facebook’s general inability to accurately encompass the nature of their relationships or to wag their digital fingers at another of Facebook’s failures, we consider how common mistakes with Unix timestamps are and how easy they generally are to fix. We know Facebook can’t accurately encompass the nature of human relations (even if they really really want to). But, we also know that if the bug hadn’t appeared, these same friends would have integrated the “On This Day…” feature into celebrating their friendship-versaries. We know that Facebook has had a lot of bugs, glitches, and failures. But, we also know that code is buggy and the larger and more complex the application the more buggy it is. Buggy technology isn’t bad technology; it’s just technology.

So, we don’t find the quips quite as poignant as everyone else and we corrected our friends and taught them a little bit about time and computing, hoping that it might let them see how we experience the 46-year-friendship bug, and technology generally, just a bit differently from everyone else.¹

¹ You anthropologists reading this should find this feeling very familiar as complicating things and sharing it is pretty much what we do. We just use a different knowledge set. In sharing this with you I hope to spark some thought into the way that anthropology often engages technology and technologists. We love to use the bugs and quirks of technology as metaphors and provocations to discuss the social implications of technologies. But, how might these alter (or even hinder) our ability to communicate with people with more complex experiences of these technologies?