It was the second semester of my teaching career, and I still remember the chaos in the computer lab. We had just wrapped up a collaborative C programming project a simple text based quiz game. Nothing fancy. Just a few menus, questions, scoring logic, and file handling. But what should’ve been a one day debugging session turned into a three day expedition through code that felt like it was written in alien hieroglyphs. 

Why? 

Because one of the students let’s call him Raj decided to name every single variable in the program like this: x, a1, z2, tt, aa, q1, q2. That’s it. That was his entire naming variables strategy. 

I still remember standing at the whiteboard, marker in hand, and asking the class: “Okay, anyone here knows what z2 stores?” Silence. Eyes blinking. No clue. Raj himself took a few minutes flipping through printed code to check. 

That day, I didn’t just teach the class about variable names. 

I made it a religion. 

What’s in a Name? Everything. 

C gives you power. It’s raw, close to the metal, and expects you to take full responsibility for how you name your variables, manage your memory, and write your logic. There are no training wheels in C. And when it comes to naming variables, the language gives you freedom but also enough rope to hang yourself if you’re careless. 

So what is a variable name? 

At a technical level, it’s a label. A reference to a memory location. You’re telling the compiler: “Hey, this spot in memory stores a value, and I’ll refer to it as ‘totalScore’.” It could have been ‘ts’ or ‘a1’ or even just ‘x’. But naming is a contract not just between you and the machine but between you and every human who’ll ever read or touch that code again. That includes future you. 

Trust me future you does not like deciphering code with variables like val1 and zzz.

Rule #1: Be Kind to the Future You (and Your Teammates) 

Back in that same semester, I had a student named Aditi. She always wrote her code like she was documenting it for someone who knew nothing. Her variables were full sentences: total_score_of_the_student_after_three_attempts. Yes, a mouthful but crystal clear. 

Of course, I had to ask her to shorten it to something manageable, like finalScore, but her intention was spot on. 

And I tell every class this: naming variables is like leaving breadcrumbs for your brain. Make them easy to follow. 

The best variable names strike a balance between clarity and conciseness. 

Let me show you two versions of the same logic. 

int ts, a1, x; 
ts = 75; 
a1 = 25; 
x = ts + a1; 
 

And now: 

int totalScore = 75; 
int bonusPoints = 25; 
int finalScore = totalScore + bonusPoints; 
 

Which one would you rather debug at midnight after a long day? 

Exactly. 

The Official Naming Rules in C (The Ones The Compiler Cares About) 

While humans need clarity, the C compiler just wants you to follow a few simple rules. Break these, and your code won’t compile no matter how smart your variable name sounds. 

Variables Must Start with a Letter or Underscore 

int age;       // valid 
int _height;   // valid but discouraged 
int 2value;    // invalid 
 

I once asked a batch of students to guess why a variable name like 2score throws an error. One bright kid in the back yelled, “Because C thinks you’re trying to multiply 2 and score!” 

He was close. The C compiler sees the digit first and assumes it’s a constant not a name. 

Variable Names Can Include Letters, Digits, and Underscore 

int total_score_2023;   // valid 
 No spaces. Ever. 

One of my newer students once wrote: 

int my name = 5; 
 

It broke the compiler, and he looked at me, puzzled. I asked him, “Would you ever name your son ‘my name’ with a space?” That cracked up the class and he never forgot the lesson. 

Avoid Starting with Underscore 

Technically, you can start a variable name with an underscore. But in practice, you shouldn’t. 

Why? 

Because names that begin with an underscore are reserved in many systems for internal or compiler generated variables. If you use them, you might end up colliding with system code or library internals. That’s a headache you don’t want. 

Case Sensitivity: A Mistake That Cost One Student 5 Marks 

C is case sensitive. Which means: 

c 

CopyEdit 

int score, Score, sCore; 
 

These are three different variables. This can be a real trap. 

In one of my internal exams, a student wrote a function that calculated marks using a variable called marks. But inside the loop, he accidentally wrote Marks = Marks + 5;. 

Guess what? That capital ‘M’ meant it was a different variable altogether. His original marks never got updated. He failed the test case. 

I pulled him aside later and told him: “The compiler doesn’t care that they sound the same to your brain. It only cares about what you wrote. Be careful.” 

Reserved Keywords: The Forbidden Names 

Want to name your variable int, for, while, float, or return? 

Good luck. 

These are reserved keywords in C. They’re baked into the grammar of the language. You can’t repurpose them for variables. 

int int = 5;     // illegal 
int for = 10;    // also illegal 
 

Sometimes, to play smart, students write: 

int For = 10; 
int INT = 5; 
 

Technically, these compile but you’re just asking for confusion. Anyone reading your code will do a double take. Don’t be clever at the cost of clarity. 

Special Characters: Keep It Simple 

Apart from the underscore (_), most special characters are off limits in C variable names. 

I’ve seen students experiment with $, @, %, and #. Some compilers (especially GCC) may accept $ but it’s non standard. Don’t count on portability. 

Rule of thumb: stick to alphabets, digits, and the occasional underscore. 

Real World Analogy: Naming Variables is Like Labeling Jars in a Kitchen 

Here’s how I explain this in workshops: 

Imagine your kitchen. You’ve got a dozen identical jars. No labels. Inside them, you’ve stored sugar, coffee, turmeric, salt, tea leaves, rice, etc. 

Now imagine you’re blindfolded and someone says, “Find sugar.” 

That’s what debugging code feels like when all your variables are named x1, y, or a. 

But if your jars are labeled “sugar”, “coffee”, “salt” you find what you need in seconds. 

Label your variables the same way. Future you, your teammates, and even your IDE’s auto complete will thank you. 

A Note on Variable Length: Short, But Not Cryptic 

Don’t go overboard with verbose names like: 

int total_marks_scored_by_student_in_semester_one = 90; 
 

Yes, it’s readable. But it’s also hard to reuse. Aim for something like: 

int sem1TotalMarks; 
 

It’s short, readable, and descriptive. Strike the balance. 

Common Mistakes I Still See Students Make 

Here’s a quick list of mistakes my students make in almost every new batch: 

1. Using spaces in variable names 
   int my age; // invalid
   Use my_age instead. 

2. Case confusion 
   Writing Total instead of total then wondering why it doesn’t work. 

3. Reusing variable names in nested scopes 
   We’ll talk about scope in a later blog, but defining int x; in the outer block and again in a nested block leads to subtle bugs. 

4. Using reserved keywords 
   Naming variables for, int, float, main, etc. 

5. Being too clever with acronyms 
   Naming everything as tp, mp, qp, assuming you’ll remember what those mean later. You won’t. 

Student Reactions: The Eye Opening Exercise 

I now do a fun drill in every beginner C class. I hand them two identical programs. Same logic. One written with good variable names, one with random ones like x1, a, b3. 

I time how long it takes them to identify where the final value is computed. 

On average: 

• With meaningful names: under 30 seconds. 

• With gibberish names: over 3 minutes. 

That’s a 6x drop in speed just because of poor naming. 

I let the numbers speak for themselves. 

Final Thought: Code is Read More Than It’s Written 

I end every session on naming with a mantra I ask my students to repeat out loud: 

“Code is read more than it’s written.” 

Your code is a story. Someone will read it maybe even years from now. Good variable names are like good narration: they make the story flow. 

So take that extra second to write totalMarks instead of tm. It adds hours of clarity. 

Homework (Yes, Even Here) 

Write a small program in C that: 

• Takes your name, age, and score in 3 subjects as input 

• Calculates the total and average 

• Prints everything in a readable format 

Here’s the twist: 
Write two versions. 
One with meaningful variable names, and one with short cryptic ones. 

Then hand both to a friend and ask them to understand it. 
Watch their face. 

That reaction? 
That’s why variable naming matters. 

See you in the next blog. Until then, write like someone else has to read it tomorrow. Because someone will.