When a COBOL codebase is inherited from your mum’s 90s commits

Level 1: It Runs in the Family

Imagine your mom hands you her old cookbook from 30 years ago, and now you have to cook using those exact recipes. Usually you’d just learn her style of cooking (like picking up a family trait), but here you’re literally using her recipe book word-for-word. In this meme, a programmer ends up with his mom’s 1990s code kind of like inheriting a vintage recipe. It’s funny because in programming, “inheritance” is normally like a child getting some traits from a parent – it doesn’t mean your mom gives you her entire old project to use! The idea of working on the exact same creation your mother made decades ago is both sweet and a bit absurd, and that twist is exactly why it makes people smile.

Level 2: When Code Runs in the Family

Let’s break down what’s happening in this meme. A developer shares that a friend of theirs learned COBOL and was given a codebase to work on. A codebase is the complete collection of source code for a software project. Here, it’s an old COBOL project that hasn’t been changed since the 1990s. The shocking twist: the last person who touched that code was the friend’s mum (mother), back in the '90s! In other words, the friend is literally maintaining his mom’s old program. This is a prime example of legacy code – software handed down from an earlier era, written with older technology, yet still running today. Legacy code often comes from developers who have long since moved on or retired, and working with it can feel like reading a diary written in an old language. In this case it’s quite literally a family diary in code form, which makes it both a legacy system and a family legacy.

Now, what is COBOL? COBOL stands for Common Business Oriented Language. It’s a programming language first designed in 1959 (over 60 years ago!) and it became very popular for business applications like bank systems, insurance, and payroll programs. Tons of big organizations wrote critical systems in COBOL during the 60s, 70s, 80s, and 90s. Believe it or not, many of those systems are still running today on large mainframe computers. If a codebase’s last update was in the 90s, that’s not too surprising for COBOL – these programs were built to last (or at least, nobody wanted to risk changing them if they were working). By the 1990s, COBOL programming was common in enterprise IT departments, so it’s entirely possible the friend’s mother was a programmer who contributed code back then. Fast-forward to now: fewer people learn COBOL these days, but occasionally companies urgently need to update those old systems. That’s probably why the friend had to learn COBOL – to step in and maintain one of these aging but important applications. It’s a bit like learning Latin to decipher an old document because your job suddenly depends on that old text.

The punchline comes from the reply tweet: “that's not how inheritance is supposed to work in programming.” This is a play on the word inheritance. In everyday life, inheritance means you receive something from your parents (like inheriting a family treasure or property). In programming, inheritance has a more specific meaning: it’s a feature of object-oriented programming (OOP) where a class (think of it as a blueprint for objects) can inherit characteristics from another class. For example, imagine a general class Vehicle and a class Car that extends Vehicle – the Car class automatically gets all the features that a Vehicle has, without you having to rewrite them. That’s inheritance in coding: a way for one thing to reuse code from another, as if the “child” class takes on traits from a “parent” class.

Here’s why the joke is clever: COBOL is not an object-oriented language in its classic form. COBOL from the 90s doesn’t use classes and inheritance the way languages like Java, C++ or Python do. So normally, if you’re working in COBOL, you wouldn’t even be talking about inheritance in the OOP sense. Yet in this story, the friend “inherited” a COBOL codebase in the real-world sense — from his mother. The reply jokes that this isn’t how programming inheritance works, highlighting that the situation has flipped the terminology on its head. Instead of a class inheriting code, a person inherited an entire code project. For developers, that twist is funny because it mixes a technical concept with a real-life family situation. It’s like saying, “I didn’t just get my coding style from my mom, I got her actual code!”

This scenario also highlights the generation gap in technology. The friend is dealing with a piece of software that was written long before he started coding, possibly before he was even born. It’s a real slice of tech history living in the present. The meme strikes a chord with programmers because we often joke about “inheriting someone else’s old code” when we join a new team or project — but usually that just means taking over maintenance, not discovering your mom wrote the code! It adds a uniquely personal touch to the usual tale of legacy system maintenance. It also shows why working with legacy systems can be surprising and kind of cool: you never know what backstory a decades-old program might have. In this case, it’s a family story. So the meme is funny in a wholesome way: it reminds us that programming is a field young enough that two generations (parent and child) might end up working on the same code. The idea of calling up your mom to ask why a line of code was written a certain way is both heartwarming and a little mind-bending. No wonder this little Twitter exchange made so many developers chuckle.

Level 3: COBOL Family Heirloom

A codebase last touched in the 1990s is practically a digital fossil—except this one isn’t just any legacy project, it’s a family heirloom in code form. In the realm of legacy systems, inheriting a decades-old COBOL codebase from someone else’s commit history is already a rite of passage for many enterprise developers. But inheriting it from your own mother’s commits? That’s the kind of tale only TechHistory could cook up. This meme highlights a scenario where a developer friend had to learn COBOL to maintain a system untouched since the '90s, only to discover the last person to modify that code was his mom. The humor resonates on multiple levels with seasoned devs: it’s an unexpected collision of personal life and professional legacy code, and a clever play on the word inheritance.

COBOL (Common Business Oriented Language) itself is a blast from the past. Invented in the late 1950s and booming through the 1980s, it's the backbone of countless banking and government systems even today. These applications often run on old-school mainframes and have been humming along for decades with minimal changes. If the last change to this particular codebase was in the 90s, that suggests a system so stable (or so scary to touch) that no one dared to modify it for ~20+ years. Perhaps the only tweak was around the late '90s, quite possibly a fix for the infamous Y2K date bug. It’s not uncommon: many large organizations back then froze feature development and only patched year-2000 issues. So picture it: the friend’s mom might have been part of that Y2K remediation effort, updating date logic so the program would handle the year "00". Once that succeeded, the code was left in peace — and now her child is the brave archaeologist carefully brushing the dust off those ancient lines.

Maintaining such legacy code is both a marvel and a headache. Marvel, because that code has effectively been doing its job for a generation without falling over. Headache, because decoding the logic from an older era takes patience (especially in a language that predates many modern conventions). If something in it is confusing or suboptimal, normally you'd curse the unknown developer from long ago. But here, that “unknown developer” is literally Mom. It adds a surreal new dimension to debugging. Imagine finding a weird business rule in the code and then being able to call up the original author over Sunday dinner:

Dev: “Mom, why does this COBOL program add an extra 0.5 before rounding the interest rate?”
Mom: “Oh! That was a quick fix I did in '98 when the bank insisted on rounding up savings interest. I'd forgotten about that.”

Not many devs can ask the previous maintainer directly, let alone have them on speed dial as a parent. It’s a mix of sweet and bizarre — a niche form of nepotism in the software world, where the hand-off wasn’t through official documentation but through family lineage.

The kicker, of course, is the punchline from the reply: “that’s not how inheritance is supposed to work in programming.” This is a classic programmer pun. In software design, inheritance is a feature of object-oriented languages (like Java or C++) where a child class automatically receives methods and properties from a parent class. It’s a way to reuse code and model real-world hierarchies — for example, a Car class can inherit from a general Vehicle class, meaning it gets all the base Vehicle features by default. But here we’re dealing with COBOL, a language that isn’t typically object-oriented (especially not back in the 90s). Traditional COBOL has no concept of classes or inheritance in the code sense at all; it’s procedural. So the only inheritance happening is the real-life kind — a son literally inheriting the code his mother wrote. The joke thrives on that double meaning. It tickles experienced developers because it subverts a core technical term with a real-world scenario. It's as if the universe said, "You wanted inheritance in your project? Here, have your mom’s code!"

Beneath the humor lies a grain of truth about LegacySystems in industry. Knowledge transfer in tech can sometimes feel like a family story passed down through generations. Maybe not parent-to-child literally, but certainly senior devs passing the torch to juniors can resemble oral history. In the world of aging enterprise software, companies often end up scrambling to find people who understand decades-old technology. (In fact, there was a real scramble for COBOL programmers as recently as 2020 when state systems needed urgent updates.) This tweet hits a nerve because many organizations are one step away from having to dust off 30-year-old code and beg someone to understand it. In this lucky friend’s case, they didn’t have to look far — the original programmer was at a family reunion the whole time. And hey, at least he knows who to blame at Thanksgiving if the system ever crashes! The entire scenario is a perfect storm of developer humor: an improbable overlap of personal life with the stubborn longevity of old tech, wrapped in a pun that software folks love.

IDENTIFICATION DIVISION.
PROGRAM-ID. GENERATIONAL-APP.
AUTHOR. MOM.
DATE-WRITTEN. 1994.
*> Imagine opening the source file and seeing your own mom's name as the AUTHOR.
*> COBOL code from that era often includes metadata like author and date.
*> This brings "family legacy code" to a whole new level.

That little COBOL snippet above is a tongue-in-cheek illustration. Many COBOL programs start with an identification section that might literally list the author and date. If our friend opened the source file and saw his mother’s name in the AUTHOR field, it would really drive home how directly he’s stepping into her shoes. It’s a moment that blends nostalgia with the absurd continuity of enterprise software. In summary, this meme is a multi-layered joke — technically rich with its contrast of inheritance meanings, historically grounded with a nod to old-school COBOL, and emotionally funny because it humanizes the otherwise dry task of maintaining legacy code. It turns out sometimes Mom actually wrote that messy old system you’re now responsible for!