Many years ago I had to try to debug a memory manager written by a really talented software engineer, with an interesting take on naming things…
-
He referred to blocks of memory as “cookies”.
-
He had a temporary variable named “handy” because it was handy to have around.
-
He had a second temporary variable that referenced the first one that he called “son_of_handy”.
-
If corruption was detected in a block of memory then it would set the flag “shit_cookie_corrupt”.
-
If too many cookies were corrupt then the system would halt by calling the function “oh_shit_oh_shit_oh_shit”.
I like him already
To be honest I’d like to see his resume, kinda wanna hire him
That was close to 30 years ago - a DOS memory manager written prior to Windows 3.0. He’s likely retired now…
proposal to rename exit() to oh_shit_oh_shit_oh_shit()
screw_you_guys_im_going_home()
fuck_this_shit_im_outta_here()
In the 90s there was a Redhat distro called Cartman.
Red Hat 6.1, that was my first Linux distro.
screw_you_im_gonna_go_play_minecraft()
I will keep this legacy alive within my code
Okay yeah but I know what all those variables do
Ugh.
Sounds like my type of guy.
-
Naming things is one of the two hardest problems in computer science. The other one is cache coherency and off by one errors.
That’s three… Ohhhh…😅
The number of times I have labeled something as fart, poop, fart_poop, temp_fart_poop, etc, and just forgot about it is not okay.
U nd to rembr tht mny snr devs grw up prgrmng on old hrdwr tht ddn’t hv mch mmry & oftn th lang ony allwd shrt var nms anywy. Also thy wr th gen of txtspk fr smlr rsns.
Yngr snr devs pckd up bd hbts frm tht gen.
And here’s a sentence that’s not squashed to cleanse your palettes / give a sigh of relief because I figure if I need a break from typing like that, you need a break from reading it.
Nmng thngs s hrd.
I’ve been at this for 25 years and a restriction on variable name length hasn’t been a problem since then.
A good senior dev shouldn’t just be older, they should have continued to learn and evolve.
I do remember texting abbreviations because we texted on a number pad with no autocomplete.
Everyone I know was happy to switch to better keyboards and autocomplete as soon as they were available.
Speak for yourself. My company only stopped using Fortran this decade.
And with “this decade” you mean within the last 10 years or since 2020? Either way, I’m scared… Just kidding, if this is a bank we’re talking about, they’re actually ahead of the curve.
I was mostly poking (heh) fun at myself, (also) a member of the generation I spoke about. Very much not a professional, but I do code a little, and know about the non-triviality of naming things.
Also also, for reasons I won’t go into, my phone is still a flip phone.
Fck ff wth yr rbtrr lngth vrbl nms.
oftn th lang ony allwd shrt var nms
I started coding with TurboBasic which allowed variable names of any length but the compiler only looked at the first two letters (and case-insensitive at that), so DOUGHNUT_COUNT and DoobieCounter were actually the same variable. Good times debugging that kind of shit.
Yeah, I was thinking of old 8-bit computers that did the same ignore-after-second-char thing. Most people didn’t bother typing the extra characters though because 1) those characters took up valuable memory and 2) if you accidentally put a keyword in the middle of your longer name, the tokeniser would see it and assume it was a keyword.
e.g. Calling your variable
FORGETseemed like a good idea until you got a syntax error becauseFORandGETare both keywords.FOit is, then. Or justF.COLORwas cursed too;ORis usually a keyword, even ifCOLORitself isn’t. British EnglishCOLOURmight save you here, but you’re still losing those four extra bytes.
Jks on u I invntd my own lphbt onc, whr vwls r a mrk n th nxt lttr nstd of seprt lttrs. I gt vry gd at rdng cnsnnts.
U nd to rembr tht mny snr devs grw up prgrmng on old hrdwr tht ddn’t hv mch mmry & oftn th lang ony allwd shrt var nms anywy.
My generation. Many of us learned and adapted over time, and use perfectly decent variable names now.
Also thy wr th gen of txtspk fr smlr rsns.
Nope. Got my first cell phone 8 years into my professional life, and 18-20 years after I started programming. Txtspkrs r th nxt gnrtn. Whippersnappers!
Now get the hell off my lawn!
Long, descriptive names are great! That’s how APIs like CNLabelContactRelationYoungerCousinMothersSiblingsSonOrFathersSistersSon make your code look so clean!
I’m glad you provided a link, because I would not have believed you otherwise. Take my upvote.
deleted by creator
Yeah, this is actually a non-example, but the concept is still valid. I think the real solution is to make use of OOP and go with a short, descriptive name that’s available in scope.
Hey, sometimes we put a little effort into our acronyms. I published a component named UTI and it was too late to change it by the time management caught on.
That can’t be true, because it’s never to late for management to edict changes to a project, even just on a whim.
“Actually we decided we’re going to take this project in a completely different direction. Go ahead and rework 90% of what you just created over the last six months.”
It was a trivial enough component that upper management couldn’t be bothered to give a shit, and middle management was toothless. I left before HR had to get involved again.
Fuck character limits for names. Looking at you, ABAP.
Character limits and a stupid badly used Hungarian notation to waste limited characters to tell use what the ide already knows.
If you have a table, (that’s an array for sane programmers) name the variable as a plural and we will know it’s a table.
Don’t name two variables the same stupid abbreviation with different Hungarian notation characters stuck to the front
I’ve worked with the Windows API and “things the IDE already knows” isn’t something you should rely on. Everything is an LPVOID if you cast and recast long enough. In Windows various longs returned by the system are actually secretly pointers or handles, and using them as if they’re the type the IDE derives can lead to very annoying bugs.
Using plurals for lists and tables isn’t very clear, unless you have explicit naming guidelines about them. Plenty of people use plurals to indicate counts, and neither are good uses of them in my opinion.
itemCountanditemListsolve everything here.But that is a typing weakness of that language. I just prefer using languages where the compiler actually does know what the types are at all time and thus can inform me instead of me trying to make sure that types align correctly.
That is tedious work that has been proven to be a terrible idea to shift onto humans. Strong type systems make much more robust code.
Abap only has one collection type, and its tables. Contextually it’s not hard to read what a collection of things are and what a single thing is.
If I am looping through comments and do something with comment, it’s contextually clear what ma going on. The exact type can be easily checked for when it’s actually needed.
Naming a count of something the plural seems like a much less intuitive thing. Especially sense generally the count is gotten from the collection.
Are you not blind after staring at ABAP?
Can you bleach my eyes with some really bad ABAP code? I’ve never seen ABAP and I want to feel scared
Let me introduce you to Cobol …
Classic ASP for the win …
No, pleeease grandpa, I don’t wanna sweep the cobwebs off the server rack
I’m not gonna lie, I haven’t seen ABAP in 10 years and was only briefly familiar with it. But I did what one does and asked GPT4 for some tax computation ABAP.
DATA: lv_income TYPE P DECIMALS 2 VALUE '50000', lv_tax_rate TYPE P DECIMALS 2, lv_tax_amount TYPE P DECIMALS 2. * Select the appropriate tax rate from the tax table based on income SELECT SINGLE TAX_RATE INTO lv_tax_rate FROM ZTAX_TABLE WHERE INCOME >= lv_income ORDER BY INCOME ASCENDING. IF sy-subrc = 0. lv_tax_amount = lv_income * lv_tax_rate / 100. WRITE: / 'Income:', lv_income, / 'Tax Rate:', lv_tax_rate, / 'Tax Amount:', lv_tax_amount. ELSE. WRITE: / 'No tax rate found for income', lv_income. ENDIF.Oh that looks awful. Maybe it’s just because I don’t know how to read it, but the fact that it is similar to SQL (definitely pronounced sequel at this time) messed with my head
Oh my, that’s an abomination, I’m literally squinting my eyes to read it. That
ENDIFtho, that’s where I draw the line °~°This isn’t even like the worst of it. It’s an old enough language they still thought the compiler shouldn’t have to do more work.
So you have to declare all variables, types, and methods in the top section of the class, and the method implementation in its own section. That means while working on a method, the method signature is a long way away. And because abap developers are allergic to splitting up code into reasonable classes, that can be a couple thousand lines away.
Oh and all classes are in the global namespace. So all the classes you make must start with the letter z because SAP reserves any and all names that don’t start with z.
Oh and they didn’t feel like making library code to do a lot of basic stuff, oh no, they thought that 3000+ keywords was a much better system. Especially sense hovering over a keyword gives no documentation and discoverable is therefore pretty terrible.
Also they wanted everything to be sentenced like so keyword structures are often many special words in specific orders and hopefully you can write enough of it to get a prompt to fill in the rest.
Ah yes, gotta love /company/product_abc table names.
doSomeAwesomeStuffThatCanBeUsedInVariousEnvironmentsWithoutHavingToCareAboutTheReturnValue()
Hah, I (a Sr developer at the time) once built an entire mapping layer in our ETL system to deal with the fact that our product had long and expressive names for every data point but our scientists used statistical tools that had no autocomplete and choked on variable names longer than 32 chars so they named everything in like 8 chars of disemvoweled nonsense.
May those who build such unergonomic tools choke on a hair ball
I worked with a guy who was a pretty decent programmer, but his background was really heavy in Linux engineering. His variable names were horrible. He named everything as if it was going to be some CLI command. Even that wasn’t the worst. At one point he had var1 - var17. Having to maintain that code has not been fun. If re-write it if I didn’t know it was going to go away.
I tried talking to him about it many times while we were working together, but he just kept on doing what he was doing.
That just sounds to me like he hasn’t worked on large code bases with multiple teams. No way it would be considered acceptable once you’re interesting with enough other people.
Or just worked on codebases long enough to forget them… the biggest bastard I’ve encountered has been past me
Solution: Code Style Guidelines doc that the team agrees on. A checkbox in the PR template that affirms that code is compliant with the guidelines.
This way it’s not personal, it’s a rule that everyone should follow as a shared standard.
I tried going the style guidelines route, but we didn’t have a good code review process to really enforce it. It basically would have ended up being me doing 100% of the reviews. At the time I was just happy to get them to actually use source control properly.
Use cicd tooling to enforce it not human eyes
We’re getting there. Though I’m not sure what kind of rule in a CICD process could check to see if a variable name actually made sense. Using snake or camel case, sure, but how does it know if ‘dc_loc_5’ is good or not from the perspective of someone who needs to maintain the code?
This sadly sounds like one of the projects on my teamat the moment and it’s horrifying.
One guy working on it, I’m really the only reviewer. Code is all stuff like this. Variables named j1 through j20, dozens and dozens of nearly identical functions with tons of brute force, copy-pasted code, etc. Works well enough but it’s just horrifying to try to read and review.
Edit:. Just remembered, he had all these grouped functions passing (and sometimes returning) 60+ identical variables that didn’t need to be local because he refused to use class vars, etc.
He’s gotten a lot better about this stuff in the last year though
You know, as an amateur with massive impostor syndrome who’s probably going to be applying for jobs soon, this comment and those like it give me strength.
I work with a guy who is constantly patting himself on the back about how great he is, nitpicking everyone’s stuff based on his own ignorance, and bragging about his 20 years in the industry. He is primarily a Python dev and has never written a class. He thinks anyone who write anything in a language he doesn’t know is some kind of wizard. He’s constantly trying to answer people’s questions by posting half—ass answers from ChatGPT. And he will spend months battling for an ideal based of a quick search and 2 minutes of reading; it takes a hammer to the head to get him to back down and admit he’s wrong and didn’t have all the information when he started the fight. Most people just let him go, because they don’t have the energy for it.
I’ll take an amateur with imposter syndrome looking to learn every single day of the week, over a self-important, know it all, blow hard.
enforce it
Stop right there. This idea does not exist in a workplace setting
Is he perhaps a decompiler?
I found a variable named “t” Friday. I figured I must be looking at the minified version, but nope! Someone just decided to name something “t”, I have no idea why.
I pity the fool!
Also, can somebody explain this to sysadmins when it comes to naming computers?
I mean programmers can have some weird naming conventions, but I’ve never met an adult professional programmer who named all his variables after planets or Harry Potter characters or just called everything stuff like ADMUTIL6 or PBLAB03T1 or PBPCD1602.
Windows backwards compatibility can’t handle more than 15 characters in a name.
Harry1
Harry2
Harry3
RFC1123 supports 63 chars, but even that gets problematic when you have things like $cluster-$datacenter-$node-additional-seed-service in k8s.
Harry Potter characters is a perfectly reasonable server naming scheme. Server names should be easily recognisable but not tied to any particular service/project/function on that machine (as the server may be used for other things later etc)
See RFC 1178: https://www.rfc-editor.org/rfc/rfc1178
August 1990
So?
Don’t act like the internet isn’t built on RFCs that old
There was a thread about that on c/selfhosted a few weeks ago. Created by a particular wild-cat-inspired sysadmin, I might add.
But on a more serious note, the interactions between a sysadmin and their servers (that they have enough responsibility for to be able to name) are much more intimate than the interactions between a dev and their variables. The server names also exist in a much larger namespace, so they need to be more unique.
Pros use computer names like
Server
newerserver
newnewerserver
latestserver
NewlatestserverMy home lab took that personally, how dare
My SSID’s are still listed as Testnet and Testnet5 after years. Had to test something at one point, it worked and never cared to go back and update things. 🤷♂️
- Totally
- Everlasting
- SSID
- Title
- net
- the 5th
- Totally
- Everlasting
- SSID
- Title
- never
- ever
- transformed
- the 5th
fixed it for you :) acronyms with full words in the middle of them are not acronyms
You are correct, however 5 is actually short for 5725 …
I once worked in a company that named theirs servers
server1,server2,server3, etc.That atleast makes them (hopefully) chronological and easy to refer to.
but easy to mix up
Unfortunately no. The servers were set up when needed for whatever was needed. server2 was the AD, server1 had a business application running, server3 had backup and time tracking … it was a whole mess.
Edit: the the memories come back. Nothing was virtualized.
server2was an old Dell tower computer running Windows 2000 on the bare metal andserver1was manually installed Debian with kernel 2.6.*something*.
Every place I’ve ever worked has had a bobafet.
Documentation is like sex: Even when it’s bad, it’s still pretty good.
You’ve obviously never used Google Cloud documentation.
Does that mean self-documenting code is actually masturbation?
Which makes my incomprehensible notes to my future self an elaborate form of masturbation.
…Because no one else wants to write my documentation.
What kind of shit senior devs are you working with?
Any one who worked on an Oracle DB when they had the 30 character object name limit learned to make names like this. You’d figure out all your domain objects, and abbreviate them all (person could be PRS_, account could be ACCT_, etc). It was a horrible experience.
I mean, sure, but it’s not like that makes you forget the normal English words. Just don’t abbreviate those words and you’ve likely got a semi-decent variable name.
Well, and my expectation for non-shit seniors is to be somewhat good at their job and to lead by example.
Nah, always use as lewd names as possible, like really over the top, preferably r34 compliant. And the comments need to be there to explain the fictional stories behind all the names and all the lewdness - and not really to explain what the code does, that’s just a common misconception.
If someones dares to look into my code they need to be ready to suffer.
(And no, I’m not a dev, no one in my team can code anything, boss won’t give me a an actual dev - and when I write something for other ppl as a favor I make an effort to make the code clean and comments only mildly amusing)
Reminds me when back in the day I was working on a system where one of major component’s acronym was BOOTY. It was hard picking right terms and names for the new parts, but I managed to fit a variable named BOOTY_SLAP in there such that none of the reviewers even questioned it.
Reminds me of a system I worked in that utilized DADDY ports. It was always amusing to overhear conversations about expanding the DADDY ports, things being stuck in DADDY ports, etc. Submitting tickets for them was always a lot of fun.
Help me DADDY! I’m stuck in the port!
Quality work!
Does anyone have any good advice on variable naming? Here’s some of my rules I try to live by:
- camelCase
- use prefixes
- prefixes should be one word followed by an underscore.
- 10 character limit or 3 word limit, not counting the prefix
- functions should be prefixed with the file in which they’re defined, ie
utils_FooBar - file names should be one word
- Start Bools with
is - Don’t use
notin bool names.- This has farther-reaching implications that will keep you from making confusing code most of the time (I’m sure this will be controversial, but it works no matter what they say)
- start output with
_ - Globals should be
g_VARIABLENAME - use the least amount of words possible
- but being too verbose can draw attention - use this to aide in readability
calc_ImportantValueThatWillDecideTheUsersViewis better thancalc_SumYearsif the variable is more important than the others.
- Even the greatest variable names are not replacements for documentation
- Even the most readable code is not replacement for documentation.
- Force yourself to love documentation.
Edit: I realize I was speaking about function-naming with the prefix stuff.
For variables, I still use prefixes, but for variable type. Even if you define the variables as types, it’s still incredibly useful. For instance,
a string is
s_MyName,enumerable is
e_MyType,A number is int or double or whatever
i_MyAgeord_MyWeightThis might be obvious for custom objects, but I’d still do it like this
p_Personorper_Person.Seriously it does make a huge difference
- Don’t code in a language/style that requires you to write code that makes prefixing necessary - divide and conquer instead
- Readable code and well written unit/BDD tests is much better than separate documentation that will go out of sync the minute another Dev does some surgical incision into the code
- Be verbose if you need to in order to convey the relevant semantics, the characters are virtually free
- Use the casing that is mainstream/recommended by its’ developers for the language at hand
I have to disagree on some points, but I def feel like you’re helping me learn, so for that I am grateful.
I feel like you’re speaking from the perspective of a perfect coding environment, which if you have that, that’s great. Maybe all your code is in one place, maybe you have an IDE that does a lot of the work for you, and that’s great. However, for most of us, that’s rarely the case.
Prefixes have been an absolute game changer for me personally, and I will never not use them again.
I have also found that verbosity of variable name and readability are mutually exclusive. A long variable name, most of the time, takes away from the logic. Yes, they are “free” as far as memory, but are very expensive to reliability.
Units tests, again are great, but most places think unit tests are like golden toilets. It sucks, but that’s the way it is. Usually you’re given a task, and if it’s not done next week, maybe you’re not as good as they thought.
Not sure if you’re trolling or serious.
Sorry, I’m serious. These are things I have picked up from 18 years in the industry.
These are things I have picked up from 18 years in the industry.
Let me comment some of it then …
camelCase
use prefixes
prefixes should be one word followed by an underscore.Highly depends on your environment, your naming convention, etc.
functions should be prefixed with the file in which they’re defined
In modern day programming the file names are pretty much irrelevant. All somewhat recent programming languages have modules and namespaces. I don’t care in what file
fooBarwas defined. ALso: what happens if you refactor stuff and rename the file? Do you want to go through everything where the function is mentioned? (This can be automated, though, but still.)Start Bools with is
Or with whatever is the naming convention you or your team follows. I do embedded scripting and one of the projects explicitly wants
can_verb_thingwhen it comes to user permissions (can_change_foobar,can_run_baz, etc.). It is a good advice but heavily depends on your environment.start output with
_Paraphrasing the naming convention I mostly work with: Start everything with
_that will be exported to global namespace. Also use the name of your module. Instead offoobaruse_mymodule_foobar.Globals should be
g_VARIABLENAMEGlobals should be properly namespaced to global context. constants are uppercase.
calc_ImportantValueThatWillDecideTheUsersViewis better thancalc_SumYearsAnd
summarizeYearsis even better. Do not use abbreviations and describe what the function does. If it summarizes the years there is no need to name it something else. Document your code (in-code documentation as well as user-facing documentation if applicable).I appreciate your emacs perspective, thanks for the input.
I get the sense that programmerhumor hates prefixes, but I’m telling you, they have changed my life. Next project-for-fun, just give it a try and see what happens. I think you’ll be surprised.
To many of your points, I say I agree that a lot of naming conventions depend on context. The environment you’re working in, the IDE, the team you’re working on, the language you’re coding in.
However, prefixes I’m firm on. I think it’s unpopular because it’s from a bygone era where IDEs were non-existent. And while yes, ides have replaced many of the uses, they have been the most radical change to my readability and comprehension of the code I’ve written.
Also, I’m mostly a js programmer, so yes, very different from emacs.
Also, for calc_SumYears, I literally meant to add the years together, hense the prefix. So, maybe the prefixes are a little more useful than you give them credit.
Camel case for local variables
Pascal case for global ones
The name should tell me it’s purpose
That’s it
Right?! People out here are writing a bible on how to name variables lmao
Yeah I bet they feel so good about having the perfect recipe for naming variables, a recipe only they know or care about
I might be already exposing myself as an emacs user, but I think Lisp naming convention is pretty reasonable. I use it in other languages as far as their language rules allow me
-
if a variable or function is a predicate (as in if it tests if something is true or not), append
por_p/-p -
variables and functions both have lisp case
variable-name-here. Sub for_in languages that dont allow-in names -
unused or unexposed variables are prefixed
_. -
top level packages get naming rights. So if I’m making
cool-packagethen variables or functions that are specific to it arecool-package-variable(especially if it is exposed to other packages).cool-package/variableis also good if allowed. -
otherwise, separate namespaces with
/. So there’smain-functionandmy/main-function. If/is reserved, then I assume the language has a way of segmenting namespaces already and just default to that since_or-would get ambiguous here.
See the rest here: https://github.com/bbatsov/emacs-lisp-style-guide
-
I have never had any patience with variable names when I realize I have to do a 3-way swap: c=a, a=b, b=c. I’m sure there’s 40 years of goddamit=a and fml=a in the wake I’ve left behind me.
Programmers really like their AJTI (acronyms just to impress)
BTDTGTTSAWIO
Banana bread at work is pretty good though.
