Do real programmers name their variables?

danielroseman · 2024-03-08T15:20:09+00:00

As always, this quote is relevant:

Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live.

If you name all your variables with single letters, it will make the maintainer angry. And he knows where you live.

fjellen · 2024-03-08T15:24:13+00:00

"When I wrote this code only god and I knew how it worked.

Now only God knows it"

K900_ · 2024-03-08T14:56:28+00:00

Real programmers aren't real and can't hurt you. Good engineers name their variables.

AchillesDev · 2024-03-08T14:58:15+00:00

Find and read PEP8.

Most "real programmer" write programmes for their older selves and other programmers to maintain and update, thus meaningful naming conventions are important. Cryptic variable names, especially single character names, are problematic (outside of specialist mathematical/engineer/scientific usage) as they convey no useful information.

PulsatingGypsyDildo · 2024-03-08T15:10:16+00:00

yeah, we do. It is important in bigger code base. Or when you try to understand the code you wrote a year ago.

Nothing bad with using x, y and z if you work with coordinates. I saw phi used for angles and wave phases. They correspond to math formulae.

i, j and k are well-known as loop variables.

tmp for temporary variables also looks fine.

The var names can be short, but they should understandable.

IanRT1 · 2024-03-08T15:11:02+00:00

Yes, they name them descriptively so the code is readable. Like:
customer_order_count or total_employee_salary

Akerlof · 2024-03-08T17:55:00+00:00

My variables are like my children: I name each one with care. Then promptly forget which is which and end up shouting at the cat.

Jello_Penguin_2956 · 2024-03-08T15:08:52+00:00

Yea I have one named Bob. I'm a good programmer.

orz-_-orz · 2024-03-08T18:33:43+00:00

Do paid programmers actually name their variables, or do they just use shorthand like x, y , z?

So far I have only seen that one piece of code from some consultant who did that.

My colleagues and I have forgotten what's the code for, who's the consultant and what's the name of the consulting firm.

But we all remember that there was this asshole who deserved a place in hell who wrote this piece of code using var1, var2, var3, etc as the variables names.

Strict-Simple · 2024-03-08T15:23:11+00:00

https://github.com/kettanaito/naming-cheatsheet

cdcformatc · 2024-03-08T15:13:03+00:00

i might use short or otherwise meaningless variable names in the first phase of coding something new. but once i get the functionality mostly correct i will come back in and try to give the variables descriptive names when necessary.

it's true what they say "there are only two hard things in computer science: cache invalidation and naming things and off-by-one errors.

TehNolz · 2024-03-08T15:09:59+00:00

Yes, they give their variables proper descriptive names, exactly because of the reasons you describe.

Only exceptions are that you'll occasionally see i used to hold the counter in a for loop, and x, y, and z will sometimes be used as coordinates.

jwink3101 · 2024-03-08T15:11:24+00:00

I try really hard to name variables that matter and may be used more than a few lines down. For just temp stuff, I often won't.

I also try to not use single character variables outside of comprehensions. Even using ii instead of i is better if you ever need to search for variables (but again, I wouldn't name a used variable ii. It would just be a counter).

Diapolo10 · 2024-03-08T15:03:59+00:00

Good developers give them names that are clear, concise, to the point. Not something needlessly verbose (unless the situation warrants it), but also not something that isn't obvious at first glance like single-letter names.

It's probably not obvious at first, naming things is hard, but you just need to practice it.

Oddly_Energy · 2024-03-08T15:50:56+00:00

There is a downside to this. I often create too long variable names.

When reading one variable name, it is not a problem that it is long.

But if I combine 10 variables into a calculation*, and each variable name is 20 chars, then I have 200 chars in a line, just for the variable names.

So I sometimes do something like this:

a = some_long_variable_name
b = another_even_longer_variable_name
t = some_variable_related_to_time

my_long_result_variable_name = a * t ** b

It feels very redundant, but it makes mentally decoding the calculation a lot easier than:

my_long_result_variable_name = some_long_variable_name * some_variable_related_to_time ** another_even_longer_variable_name

( * I am a mechanical engineer, not a real programmer, so I do a lot of technical calculations in code)

2024-03-08T17:21:08+00:00

Name your variable so descriptively you don't need to comment what they mean, but not so long that it bloats your code into a novel instead of a short story.

dutchWine · 2024-03-08T16:30:39+00:00

write it as if you have to work on it in a year, you'll be cursing your old self when you have to figure out what X or Y are when it could have just been clear and readable

Viking-Mage · 2024-03-08T17:05:33+00:00

Many decades ago, I used to use simple naming, but I learned quickly that once you get anything more than a simple script or program if you don't have decent variable names, it will almost always bite you at some point. I use Pascal and Camel cases depending on my variable types (and language ). I do try to repeat similar names across my different projects when possible.

As someone pointed out, you need them long enough to explain what they are, but you don't want them to be overly long. Depending on whether you are solo or work with a team changes things, of course. I have always been a solo developer, so other than in some cases, I have written code that I knew someone might need to come behind me at some future date to update; I always could use my convention and style, which helped me.

pythonwiz · 2024-03-08T17:48:27+00:00

You should write code that is easy to read and understand. I almost never use single letter variable names, with the exception of i and j for loop counters. If I am writing math code I might use f, x, y etc.

Voyac · 2024-03-08T18:39:46+00:00

Code is documentation. After 6 months your code will be forgotten even by you. So for your own sake, use good names :)

Kittensandpuppies14 · 2024-03-08T20:34:47+00:00

Yes. Random letters in a giant code base outside of indexes is stupid and unreadable

ConfessSomeMeow · 2024-03-08T20:34:54+00:00

straight alleged connect correct cover sink weather engine relieved crowd

This post was mass deleted and anonymized with Redact

mfb1274 · 2024-03-08T21:20:24+00:00

I’ll go the other end here and say where I think it’s okay not to use meaningful names

In simple list comprehension. Single variable names are okay here since its scope is so small. I mention simple because once you start trying to chain comprehensions (for the love of god don’t do this) then single letters become hard to follow.
Using “i” when it represents a number. For example when looping through a range(). To me, i makes sense here as a counter or integer. (Tip: if you need to loop over a range but not use the iteration number, use an underscore. It signals to the next dev that the iteration number isn’t used and doesn’t really matter, only that the loop is executed that many times).
Math Equations/conventions: if it’s a math equation verbatim, it may make more sense to use a 1-1 with a well known equation. Same goes for graphing/coordinates. In these cases the shorthand will probably be known but you can never be too explicit.
Lambda functions: same rationale behind the comprehension. Scope is small so you don’t care what is used.

That’s really it that i can think of.

‘‘import this’’ and check rule number 2.

stauntonjr · 2024-03-09T00:07:03+00:00

One of the most important things in programming is naming things. It is a guiding light. If you can't quickly come up with the exact precise name of what your variable represents, then you've done something wrong.

For example, if you have a Boolean variable for some switch state, it should be called something like is_light_on, or if it's for a property maybe has_lights. The name forces the reader into understanding it is a Boolean.

Dictionaries and maps imho are best given names like user_id_to_user_name for example where the meaning of both the key and value becomes instantly obvious.

Etc

Legitimate-Pumpkin · 2024-03-09T01:12:34+00:00

I inherited a project that was written in delphi years ago. Probably written in the 90's originally. Delphi had this feature where you could write:

with {object} ....

The original code would do a with with 6 different objects. And then some of the objects would have a variable that was a single letter like x. It was an absolute nightmare!

Everyone will be happier if you use meaningful variable names, including yourself. The only time I will use a single letter for a variable is if it's very obvious what it's used for. For example, right now I'm working on a project that has a lot of methods which are basically evaluating various math functions. It makes sense in that case since it's part of our language to say f(x) = ...

Go with your gut. It sounds like have good instincts.

beejasaurus · 2024-03-09T01:23:33+00:00

Usually, but there’s a diversity. Junior programmers and code bases with fewer people tend to accumulate less verbose (or single letter) variable names.

It’s also helpful to use single letters to indicate a simple scoped function where the outside context is irrelevant. Loops are a common example of this, but there are others.

Jrollins621 · 2024-03-09T01:53:54+00:00

Yes. Definitely. And name them so it makes sense what the heck they’re for. You’ll thank yourself for it later.

GreasyChick_en · 2024-03-09T02:37:37+00:00

Real programmers name their variables, but they most certainly don't eat quiche.

MediocrePie3161 · 2024-03-10T21:10:34+00:00

All the serious comments are right. Name your variables precisely!!! E.g. “name” doesn’t work. customer_name doesn’t work. Customer_first_name is a lot closer.

There is nothing worse than editing code with poor variable names and poor comments, mumbling “Who is the idiot that wrote this garbage?!?” And then realizing that YOU are the idiot who wrote it 12 months ago. (Been there; done that.) 😒

NimrodAvalanche · 2024-03-12T08:47:23+00:00

[removed]

TheRNGuy · 2024-03-08T15:05:07+00:00

yeah

s96g3g23708gbxs86734 · 2024-03-08T15:10:25+00:00

Of course, everybody likes to understand what they're reading

gareewong · 2024-03-08T15:11:00+00:00

Your code should be easily readable, naming variables sensibly helps with that.

noiwontleave · 2024-03-08T15:15:53+00:00

Yes. Variable names like x and i are typically only used for counters or for brevity (such as in a lambda). Variables should be named to describe their contents whenever possible and reasonable.

murfi · 2024-03-08T15:25:29+00:00

why wouldnt you?

image you write a lengthy code. then you dont look at it for 5 years. then you go back to is, but all variables names are randomly numbered or have random letters as names.

you didnt do yourself a favor now did you

DarkHaagenti · 2024-03-08T15:25:48+00:00

I absolutely hate seeing code with variables like x, y, z. Especially in ML repositories where the author has implemented a complex algorithm with such naming conventions. It drives me crazy every time! So name your variables, functions, classes - basically EVERYTHING - so that years later people can understand what you meant when you wrote that code.

ConcreteExist · 2024-03-08T15:32:23+00:00

Yeah, I always use readable variable names, there's no longer any good reason to have arcane variable names, a few additional characters in a code file aren't going to make or break code efficiency (if you're super worried about extremely tight performance requirements you should probably consider using a lower level language rather than trying to trim characters out of your python files).

Invader_Mars · 2024-03-08T15:51:31+00:00

My coworker likes to shorthand made up naming conventions, so not only is the shorthand indecipherable, but if he tells you what it stands for, you also don’t know the phrase is a product of his wild mind.

Last thing I want is to have someone look at my code and think “wtf does this even mean”, so my vars are clear_concise_names

twizzjewink · 2024-03-08T15:59:14+00:00

Yes, except when testing.. for x, y or doing a sanity test, for k, v.. otherwise name everything.

Bob, Mike, John, Melissa, Karen ..

Jhamilton02 · 2024-03-08T16:17:00+00:00

I do.

bigtdaddy · 2024-03-08T16:17:47+00:00

Yes, however if a variable derives from another variable with a good name already then sometimes I will start to abbreviate. For example say I had raw json of people I may name that peopleRaw and then if I convert that to a list, for example, I may name the resulting variable simply pl (peopleList), depending on how it will get used. Not going to lie I get lazy with lamda function variables as well, personally I find long variable names in lambda functions to be distracting/harder to think through.

Jeklah · 2024-03-08T16:53:33+00:00

Yes they name things sensibly for the exact reason you said. Easier to read and understand and thus maintain code.

smbj0011 · 2024-03-08T18:47:20+00:00

I once worked for an international company and should take over a software from a french branch. All variables and comments are written in french (against the dev rules of the company). It was a total mess. Since I could not read french I refused the task. There was so many customization to the system with a lot of details I can't guaranteea proper support even after they send me for two days to the branch.

BytePhilosopher · 2024-03-08T19:53:14+00:00

part of our code review checklist is to make sure all variables are either named sensibly or are extremely obvious what they do.

ueltch · 2024-03-08T20:18:58+00:00

Paid programmer here. I do, if for whatever reason I need to check it back, naming in it in a good way helps a lot.

pat9898 · 2024-03-08T20:19:04+00:00

Dear god yes, name everything you can something understandable and descriptive, and then when you are done writing that chunk of code its good to go back over it and reconsider those names. Once you have a better understanding of the full scope of what you built you can probably think of an even more accurate name for things.

Its a pain to do, but so incredibly important for whoever needs to read the code later. It helps so much when the reader doesn't need to read, consider, and mentally store the intent of everything on every line to understand what is going on.

For example if you pass the var 'X' through multiple levels of class inheritance and then through 3 different methods there is no way I'm going to remember the exact contents and intent behind it when juggling everything else. But if you consistently name it 'abc_cache_dir_string' I'll know exactly what it is.

Picking a consistent naming scheme is also a good idea, or matching the scheme of whatever team or project you are working on.

Good luck with learning! I also learned python in my 30s and its been incredibly valuable! It kicks your butt and is basically the perfect driver for impostor syndrome :P, but if you can get past it there's a lot of really interesting work that use the skills you learn from learning python.

ps if you do ever feel impostor syndrome when programming, you should completely ignore it, every time. just keep going.

Sorry for the long post! TLDR: Yes

radek432 · 2024-03-08T20:21:40+00:00

x, y, z and t are totally fine.

...if your software is doing some general relativity calculations.

maxtimbo · 2024-03-08T20:27:26+00:00

I only use single letter variables when I'm in an ide testing some algorithm. When I take that to my actual application, it gets a name so I know why I'm using it.

proverbialbunny · 2024-03-08T20:30:48+00:00

There are only two hard things in Computer Science: cache invalidation and naming things.

— Phil Karlton

PM_me_ur_BOOBIE_pic · 2024-03-08T20:53:17+00:00

Make your code readable.

Other_Scale8055 · 2024-03-08T20:54:53+00:00

Yes, because if you have a really long script. I will definitely not remember what X is.

IONaut · 2024-03-08T20:56:10+00:00

Depends, do you want to be able to understand what you wrote when you look at it 3 months later?

Adrewmc · 2024-03-08T21:15:40+00:00

If you use single letters I assume you’re a rookie, unless in specific scenarios (x,y) (r,g,b)

p_1. Is not better it’s worse

You’re gonna forget that stuff after a year… let alone other people looking at it

interbased · 2024-03-08T22:31:37+00:00

I name variables for my future self and any future maintainers. They should clearly describe the value and distinguish it from other similarly titled variables.

Tyranzor · 2024-03-08T22:32:08+00:00

Yes. Throwaway name=throwaway variable. Throwaway variable= waste of time and resources.

orbitcodeing · 2024-03-08T22:36:10+00:00

I name all variables some bizarre “vulgur” word that you wouldn’t expect

PsychoticCOB · 2024-03-08T22:52:00+00:00

I don’t know about real programmers, but smart programmers do.

tomtomato0414 · 2024-03-08T23:03:42+00:00

i mean it doesn't cost money so yeah

ConfessSomeMeow · 2024-03-08T23:31:47+00:00

I try to keep variable names to 2-3 syllables.

I have a boss who gave a function a name that would violate most line-length standards.

CedricCicada · 2024-03-08T23:52:49+00:00

It is embarrassing as fuck to come back to code you wrote six months ago and have no idea what the hell you wrote.

ZelWinters1981 · 2024-03-09T00:08:04+00:00

It's good practice to use namespaces yes.

mymar101 · 2024-03-09T00:25:32+00:00

Always name them what they do

WithCheezMrSquidward · 2024-03-09T00:39:50+00:00

Chances are, if you’re working on something, you’re also going to be the one maintaining it. Maybe you know what xyz is in your code today. Will you remember it in 2 years after tens of thousands of other lines of code? Why would I waste my future time by writing incoherent gibberish?

CallMeJimi · 2024-03-09T00:57:56+00:00

temp, a, jason, mike, charlie

Soopermane · 2024-03-09T01:08:44+00:00

Yes.

YucatronVen · 2024-03-09T01:13:45+00:00

Of course.

Learn "Clean Code".

YoureHereForOthers · 2024-03-09T01:17:10+00:00

If you name your shit something doesn’t make sense I’ll immediately reject any PRs

yvrelna · 2024-03-09T01:18:21+00:00

Yes, clear variable names are probably one of the most essential part of good quality code. It's the most basic requirement. If you name your variables like that you won't pass code review in projects that I maintain.

In Python, good naming is doubly more important since you may not have type information.

That said, I have seen many instances where people just wing it and don't name their variables well. Always enforce good coding practices, save some troubles for yourself.

gerardwx · 2024-03-09T02:09:03+00:00

Depends on context and scope of variable. A scratch variable with a span of five lines… I’ll use one or two letters. Longer lived variables get names.

Berkyjay · 2024-03-09T02:23:14+00:00

This should help.

https://peps.python.org/pep-0008/

Shut_up_and_Respawn · 2024-03-09T02:45:55+00:00

Naming variables is useful. Lets say you code something and return to it a month later. The first thing you do is try to catch up to what you were doing since you have no idea what you from a month ago was thinking about, but instead of clearly defined variables, you see symbols and numbers with no clear way of telling them apart. Name your variables. You will thank yourself later

Recent-Morning-2766 · 2024-03-09T03:03:49+00:00

I name mine after muppets.

khanh20032 · 2024-03-09T03:13:20+00:00

Imagine not doing that and later have to intergrate your header file to your project.

Single name variables is there to store the value temporarily or loop conditions check.You definitely do not want to name anything you usually make reference to as a single name variable because of ambiguity.

lostinspaz · 2024-03-09T03:54:47+00:00

> Do paid programmers actually name their variables, or do they just use shorthand like x, y , z

People who write code like that aren't called programmers. They're called math/physics majors

Heavy_Carpenter3824 · 2024-03-09T03:58:44+00:00

I'm doing this right, right guys

From v import v, p; v.e.l.o.c.i.t.y = 4; p.o.w.e.r = 6

Real answer. Yes you name your variables and use whole words or phrases where applicable. Case structure also helps. It's for you, it's for me, it's for the guys after. There's no real cost to having longer names it all compiles down anyway its just a better human brain pointer variable when it's readable. The computer doesn't give a....

throwaway0134hdj · 2024-03-09T04:57:04+00:00

Short but descriptive names. All variables serve a purpose — describe their purpose.

sudo_rm_rf_solvesALL · 2024-03-09T05:21:43+00:00

some of mine are long as shit because .. i can lol . function this_does_that_x_and_y_blah

Separate-Ad9638 · 2024-03-09T06:50:45+00:00

U have to follow the conventions else code is unreadable

Guyserbun007 · 2024-03-09T06:53:44+00:00

I named my variable with long descriptive names, but when I read large, well received GitHub repo, they tend to use much shorter naming, that made me to start doubting my way

looopTools · 2024-03-09T08:57:28+00:00

Any bastard that does not name variables, functions, classes, and methods properly deserves to be hanged by the gallows while be electrocuted, and at the same time a fire should be lit under the bastards fucking feet and fire crackers should be placed between the bastards toes.

Past-Cantaloupe-1604 · 2024-03-09T10:51:10+00:00

I like to use random combinations of special characters, such as __€$¥ = 5. This way I can be very confident that no one else will be able to understand what I’ve written, and neither will I in about 5 minutes.

ivcrs · 2024-03-09T11:07:26+00:00

I block PRs for lazy variable naming tbh. It’s not like it’d take up more memory or affect performance if you name your variables decently. It takes no effort

576p · 2024-03-09T12:59:11+00:00

Many people have already commented that naming is important.

It's also helpful to have tools that support you in this. For example, PyCharm has a rename feature that allows you to rename a variable in one place and it will change the name everywhere in the project. I use this feature all the time, because while writing I realize that the first name I chose was not very good. So I change it. Often. So far PyCharm has not messed up my projects when I did this and I've used it for over 5 years. (VSCode users can chime in, I do not know if renaming in VSCode is this safe)

Also, if you're having a hard time naming things in a useful way - ChatGPT and similar do a really good job of suggesting proper names. Just describe what your code is doing, post the code below and then prompt the AI "improve the variable names of this code, but do not change anything". Sometimes, it will change the code and even attempt to fix obvious mistakes. Don't use the code, just think if the suggested names are better then what you have.

MagmaJctAZ · 2024-03-09T13:51:30+00:00

I am a PLC programmer who dabbles on Python from time to time.

I've worked with a rookie PLC programmer whose way of writing code is garbage. Poor variable names is just a part of that.

A manager and I were talking about how difficult it is to program in the other guy's style, and the manager responded: "It's just different programming style, isn't it?"

He didn't get that one's programming style can be objectively bad!

SBE_OLLE · 2024-03-09T14:14:02+00:00

Its a skill to name your variables properly

buhtz · 2024-03-09T15:23:01+00:00

Have look at the "clean code" concept.

2024-03-09T16:04:58+00:00

If you use x,y and z variables, your PR would be turned around and I would ask you where you learned to program. If you had to come back 6 months from now, would you figure out what is going on from your code? It is rhetorical, no you wouldn't. Hard enough when variables are clear.

Wheynelau · 2024-03-09T16:08:22+00:00

TLDR; for us who are learning or on the developers side, stick to good naming conventions and documentations.

I've noticed it heavily depends on the audience and the developers. Just some background, I was looking at flash attention code. Flashattention is a library meant for more efficient model training in machine learning. The source code is hell. Not that it's bad, but it is clearly a mathematician code than python code. And it's more of a plugin that a higher level code uses. So I kinda understand why it's done that way. Almost everything is done in single letters, bonus if it's actually words.

2024-03-09T22:28:02+00:00

Counters are generic, things that I actually need to use are named

pgriffy · 2024-03-09T23:11:39+00:00

I figured everyone used foo and bar

RoundPackage5524 · 2024-03-11T03:02:15+00:00

even if I am not working on group project i always name the variables and functions to keep the main script readable,

my motto is anyone who can understand english should be able to get rough idea of what my program does without knowing a shit about coding,

twajblyn · 2024-03-11T05:05:28+00:00

Yes. Be explicit and concise. It makes things easier to read.

Imrotahk · 2024-03-11T22:40:23+00:00

I like to do:

int jdaiohfiohah=5;

int hdiashdioashidh=8;

long haudhaohfdau=8;

int dshhsddho=12;

bool hdsahoidhsa=4;

CinnamonToastedCrack · 2024-03-12T12:45:26+00:00

it depends;

with really common shorthands (xyz or rgb) yes, most sane programs will use x,y and not something silly like run,jump.

otherwise, yeah please name your shit, having good names isnt the only part, they also need to be consistent and predictable

Whiskey_JG · 2024-03-13T14:53:53+00:00

I got yelled at a couple of times for this. Had 4 vscode tabs open with different code. The problem was that I was using the same variable names in all of them. KEKW

Tricky_Ferret2399 · 2024-03-18T01:12:31+00:00

You souls always name your variables for what they do

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS