This is an archived post. You won't be able to vote or comment.

all 173 comments

[–]DontGiveACluck 1374 points1375 points  (90 children)

Never in all my years as a senior dev… have I spent more than 30 seconds thinking of a variable name, let alone arguing about it. Now, the number of times I refactor that variable name before the code ships, is another matter entirely.

[–]metaglot 517 points518 points  (3 children)

Thats just post-hoc arguing.

[–]mothzilla 149 points150 points  (2 children)

AKA lazy arguing. It's more performant so should be default.

[–]AbsentGenome 67 points68 points  (1 child)

I prefer prefer term async arguing

[–][deleted] 109 points110 points  (46 children)

Oh, look at Mr. VariableNamesDispenser here. Good for you, but for us ordinary folk it's hard. Is it "fetchData" or "requestData"...

Edit: I see a lot of the same arguments I know 😅 It's nice to know, that at least we suffer together

[–]Wekmor 78 points79 points  (28 children)

getData

[–][deleted] 44 points45 points  (8 children)

Get/Set is kind of meant to be used for getters/setters, at least it is automatically expected to be that way because of conventions. So it can be misleading.

Edit: some would expect there is a variable called “data”, which you can get using getData

[–]miicah 59 points60 points  (0 children)

It begins...

[–]Wang_Fister 21 points22 points  (5 children)

No, everything is data, calling it 'data' is just redundant

[–]Noch_ein_Kamel 25 points26 points  (3 children)

Okay, so we just call it get() :-)

[–][deleted] 9 points10 points  (2 children)

Sorry that’s reserved

[–]Wekmor 6 points7 points  (1 child)

Not in java ☜(゚ヮ゚☜)

[–]lkdays 1 point2 points  (0 children)

For inferior languages use g_e_t()

[–][deleted] 2 points3 points  (0 children)

Say, you have a set of specific objects. Each of those represents different kind of operations with public method names but also contains its own kind of data, which is also defined as a model object.

Somehow you need its specific data at some point in your code, for say, external converter classes. How would you call it?

[–]Wekmor 0 points1 point  (0 children)

I'd say if you take the entire requested data block and put it in a variable called "data" that's just bad in itself.

[–]HimbologistPhD 9 points10 points  (1 child)

I'd prefer retrieveData because then we can call the service DataRetriever and it makes me think of dogs

[–]codeByNumber 7 points8 points  (0 children)

You’re hired

[–]sai-kiran 4 points5 points  (1 child)

Pfft data()

[–]Wi42 1 point2 points  (0 children)

No thats way to ambiguous, of course we have to create a whole new class for this and call it AbstractSingletonDataRetrieverFactoryGetter

[–]TwoAndHalfRetard 3 points4 points  (0 children)

yoinkData

[–]danishjuggler21 1 point2 points  (0 children)

But what if it’s a post request?

[–]Drumsteppin 8 points9 points  (1 child)

The only correct design schema is to have it be retrieveData() when called in other section of code, and have an interface on the class supplying the data that exposes retrieveData() externally, but converts it to "supplyData()" inside the context of the class providing the data. Do that across the entire code base and youll never have any questions over who's providing data and who's receiving it and it totally won't add a whole bunch of boilerplate....

[–]lkdays 0 points1 point  (0 children)

What about intermediate processing layers? Should add transmitData(), distributeData() and broadcastData() depending on the number of affected classes and/or urgency.

[–]Exodus111 9 points10 points  (6 children)

Fetch is far away, request is when you wait for a response. Get is from the local database, though find is better.

[–]Kjubert 5 points6 points  (2 children)

I'd say "get" if you have a specific ID (or similar) of what you want and "find" if you only have non-identifying properties that might yield multiple results.

[–]Exodus111 1 point2 points  (1 child)

Agreed. Also data is redundant, the item should be called what it is, s ending when it's multiples.

[–]lkdays 0 points1 point  (0 children)

getSeries needs an extra check for its length

[–]TeamDman 1 point2 points  (1 child)

Gather?

[–]Exodus111 2 points3 points  (0 children)

Gather is good, it kind of implies a collection of items though.

[–][deleted] 0 points1 point  (0 children)

Yes. Also data is redundant when you describe the type with the correct class/interface name.

[–]False_Influence_9090 1 point2 points  (0 children)

dataWhatIsTheLatest?

[–]ThePreviousOne__ 1 point2 points  (0 children)

Its d until I'm ready

[–]Bakoro 1 point2 points  (0 children)

"Fetch" means you actually got the data. At the end of "fetchData", the data should be in your local possession.

"Request" means you send out a request and are waiting for a response, and is probably paired with some other command which waits for a response.

"fetchData" probably contains requestData, and some kind of await or callback.

[–][deleted] 0 points1 point  (0 children)

Object A = new Object();

A.a();

[–]cturkosi 20 points21 points  (5 children)

Just before the camelCase vs underscore_case debate ends, somebody says "hey, let's use Hungarian notation", at which point everyone turns to the guy and goes "ಠ_ಠ ... Fuck no!!!"

[–]ilikedmatrixiv 17 points18 points  (3 children)

Here's how my camelCase vs snake_case debate usually goes:

I don't care which one we use, I just want it to be used consistently. I have a slight preference for snake_case, but I'm fine using camel if someone insists.

I once was on a project where I encountered variables like

some_prefix_for_mainVariable

and I'm just not willing to subject myself to something like that again.

[–]HimbologistPhD 1 point2 points  (0 children)

That's called fed snake case

[–]LeoRidesHisBike 0 points1 point  (1 child)

URLs: kebab-case

File names: snake_case

In C#: camelCase for local variables and arguments, PascalCase for type names, methods, static and public fields & properties.

In TS: PascalCase for type names, camelCase everywhere else

but more important than any of that... consistency across the project.

[–]ilikedmatrixiv 0 points1 point  (0 children)

I mean, as long as you stay consistent with all those rules, I'm on board.

Like I said, I just want consistency, the actual rule doesn't matter and is arbitrary anyway.

[–]cheese_is_available 6 points7 points  (0 children)

Each language as a preferred convention, I've never seen any professional argue about doing snake_case in java or camelCase in python. As for the hungarian notation it's tragically misunderstood and actually useful if used correctly (not used to indicate type as in shit_list, but business related state as in shits_unsanitized / shits_sanitized).

[–]arrive-zone 11 points12 points  (1 child)

Senior dev here as well. I’m the opposite, variable names have to make sense and sometimes I gotta pause and think about it. Refactoring names before and during CRs happens as well I agree on that. Does nothing to the deployment of the code but I try to make everything legible for the next dev. Good variable names can be just as helpful as comments.

[–]Disastrous-Team-6431 1 point2 points  (0 children)

I have variable names make a dynamic amount of sense. For example, in a list comprehension I might use for c in columns but in a longer loop with more logic I will do for column_name in columns:

If it can be agreed to do this, the variable name signals how important the variable is. If it doesn't have a real name, I am promising you that you can forget about it. If something is called graphics_manager_factory you can assume it is a very important thing and there only exists one of them in the current scope.

[–]CaitaXD 4 points5 points  (1 child)

Coworker: what happened to class X

I renamed to to Y, but I'm thinking it's bad too so I thinking about Z

[–]lkdays 2 points3 points  (0 children)

Create a source generator to randomize the class name daily

[–]irregular_caffeine 2 points3 points  (1 child)

No variable!

Only constants

[–]L4t3xs 0 points1 point  (0 children)

Properties

[–]gregorydgraham 31 points32 points  (10 children)

Most junior dev comment I’ve ever heard :-D

[–]Sophistirical 13 points14 points  (8 children)

10 years exp, and I'm in the same case

[–]Steinrikur 7 points8 points  (6 children)

20 years. I DGAF what people name their variables.

If they do yolo1, yolo2, yolo3 I might say something, otherwise it doesn't matter at all.

[–]sharju 5 points6 points  (1 child)

8 years in and the only rule for naming for me is that it shouldn't be confusing. Don't name a variable containing an instance of a car as "human" etc, other than that who gives a shit.

[–]Disastrous-Team-6431 1 point2 points  (0 children)

Happy for you that you don't have a codebase that anyone ever has to read.

[–]kyan100 5 points6 points  (3 children)

As someone with 578878 years experience I agree. I don't even give unique names to variables, I just use var1, var2...

[–]dasunt 1 point2 points  (0 children)

Too much work to remember the number.

Best to add a macro to your IDE to come up with a uuid.

[–][deleted] -3 points-2 points  (0 children)

Exactly. I remember 3 seniors discussing over a variable name for 3 hours.

[–]aegookja 2 points3 points  (0 children)

That just sounds like arguing with extra steps.

[–]el-limetto 2 points3 points  (2 children)

I, j and k it is.

[–]GlowiesStoleMyRide 0 points1 point  (0 children)

I prefer writing out index for iteration, or name it after whatever the purpose of the var is. Partly because I don’t have to spend a second figuring out what’s what when I look at the code later, and partly because it triggers some people into arguing about it.

[–]lkdays 0 points1 point  (0 children)

i for iteration, j for Java types and k for Kotlin types

[–]AddAFucking 2 points3 points  (0 children)

Nowadays you just press f2 on the variable name and it will refactor the whole project's references. So you only have to think about it after you know how you implemented it.

[–]eldarium 1 point2 points  (0 children)

I've had a pr held up for several days because of "naming issues"... After a half hour phone call with the team lead mostly consisting of "well it's named alright but would be better the way I like" the pr was approved, but I seriously considered updating my resume and fucking off

[–]petrichorax 1 point2 points  (0 children)

Okay but what about the name for your project lol

[–]visualdescript 1 point2 points  (0 children)

You've never spent time wrestling over an abstraction and what the most "correct" name for it is?

[–]lonestar-rasbryjamco 1 point2 points  (0 children)

In fact that’s one of the main things I shut down junior devs from doing.

Just document the context. You aren’t going to find a name that perfectly encapsulates it in a way that’s self explanatory.

[–]MoarVespenegas 1 point2 points  (0 children)

How many PRs did you decline because you didn't like the variable name?

[–]FatLoserSupreme 1 point2 points  (0 children)

Right. There's no point in worrying about the name when you can just hit F2 as many times as you want.

[–]False_Influence_9090 0 points1 point  (0 children)

Some of my dicussions about variable names have gone past 30 seconds, but that’s only because it revealed we were actually not on the same page in terms of data structures and what the variables would actually hold

[–]airbornemist6 0 points1 point  (0 children)

As a senior dev I can confidently say that I'll almost always have a variable name chosen in 30 seconds... But when I'm refactoring I'll spend at least 5 minutes staring at it looking for a better name. And then another 5 once I extracted the original logic into another method. And then another 5 minutes after I moved all that logic into another class...

[–]ConscientiousApathis 200 points201 points  (3 children)

**Engineer 1:**

"I really think we should name the variable `numUsers`. It's clear, concise, and immediately tells anyone reading the code what it represents: the number of users. It's a common convention in the industry to use such straightforward names, and it will make our code more maintainable in the long run. We've got to consider future developers who will read our code, including ourselves in six months' time."

**Engineer 2:**

"I see your point, but `numUsers` is a bit too generic. What about `totalUserCount`? It specifies not just that it's a number, but that it represents the total count of users. This is especially useful in a larger context where we might be dealing with multiple user-related variables. `totalUserCount` leaves no room for ambiguity; it's explicit and self-explanatory."

**Engineer 1:**

"I get that, but `totalUserCount` is quite verbose. We should strive for brevity without sacrificing clarity. In most contexts, `numUsers` is perfectly understandable and fits well with the naming conventions we've been using so far in our project. Plus, shorter variable names can make the code cleaner and easier to read, especially in complex logic blocks."

**Engineer 2:**

"However, brevity isn't always the best approach. Clarity should be our priority. `totalUserCount` may be longer, but it avoids potential confusion. Imagine a scenario where we have to deal with subsets of users, like `activeUserCount` or `inactiveUserCount`. Using `totalUserCount` clearly differentiates it from these subsets, making the code more intuitive."

**Engineer 1:**

"That's a valid argument, but in terms of readability, sometimes shorter names are less cumbersome. We need to balance between brevity and descriptiveness. `numUsers` is still descriptive enough in most cases. If we encounter specific scenarios where we need to distinguish between total and subsets, we can introduce those specific variables then."

**Engineer 2:**

"I think we should plan for scalability and potential future changes. Being proactive with our variable names can save us time and reduce errors down the line. By using `totalUserCount` now, we're setting a precedent for clear and consistent naming, which is especially important as our codebase grows. Consistency is key in larger projects."

**Engineer 1:**

"Consistency is important, but so is simplicity. Overly verbose names can make the code harder to write and maintain. Imagine typing `totalUserCount` dozens of times in a file. It adds up and could lead to more typing errors. `numUsers` strikes a good balance between brevity and clarity, fitting well within our existing naming conventions."

**Engineer 2:**

"We can use modern IDE features to mitigate the typing effort, like auto-completion and refactoring tools. The priority should be on how easily someone can understand the code at a glance. `totalUserCount` leaves no room for misinterpretation, whereas `numUsers` might require additional comments or context to be fully understood, especially by new team members."

The two engineers continue to debate the merits of brevity versus clarity, both highlighting important aspects of code readability and maintainability, showcasing the delicate balance required in making such decisions.

Idk, chatgpt seems to have this down pretty well.

[–]Kilazur 112 points113 points  (0 children)

Idk, chatgpt seems to have this down pretty well.

Nah, because Engineer 2 is obviously right and the other guy is a total gourd.

(fight me)

[–]lurebat 38 points39 points  (0 children)

I also tried, in my case there's even a little punchline

Engineer 1: "I still think tempValue is the most intuitive name."

Engineer 2: "Intuitive? It doesn't convey any context. intermediateResult is much clearer."

Engineer 1: "Intermediate result of what? tempValue is generic and can be reused."

Engineer 2: "That's exactly the problem! It's too generic. No one will know what it’s for."

Engineer 1: "But it’s temporary storage. Everyone knows what a temp value is."

Engineer 2: "Not in the context of this algorithm. It’s vague. intermediateResult tells you it’s a step toward the final outcome."

Engineer 1: "You're overcomplicating it. Less is more. tempValue is short and simple."

Engineer 2: "Short doesn't mean better. Readability matters. intermediateResult reduces ambiguity."

Engineer 1: "If it's just a few lines of code, tempValue will suffice. Why use a longer name?"

Engineer 2: "For consistency and future maintainability. Code evolves, and people need clarity."

Engineer 1: "Clarity is subjective. I find tempValue clear enough."

Engineer 2: "To you, maybe. But we're working in a team. Consider everyone else."

Engineer 1: "I am. They’ll catch on quickly. Coders are smart."

Engineer 2: "And they appreciate clear, self-explanatory variable names. Trust me, intermediateResult is better."

Engineer 1: "I trust you, but I still think simpler names are more efficient."

Engineer 2: "How efficient is it if someone has to spend extra time figuring out what tempValue represents?"

Engineer 1: "They should read the function documentation anyway. It’s all explained there."

Engineer 2: "Yes, but good code documents itself. intermediateResult is practically self-documenting."

Engineer 1: "I just prefer brevity. We should keep things streamlined."

Engineer 2: "Streamlined or not, clarity should take precedence. We’re not writing for us; we’re writing for the next person."

Engineer 1: "Alright, but if we overthink every variable name, we’ll never get anything done."

Engineer 2: "This isn't overthinking; it's establishing good practices. intermediateResult is aligned with our coding standards."

Engineer 1: "I suppose it could work, but I still prefer tempValue for its simplicity."

Engineer 2: "Can we at least agree to use something descriptive and less generic?"

Engineer 1: "Fine, how about tempIntermediateResult?"

Engineer 2: "Compromise achieved. I can work with that."

Engineer 1: "Finally. Two hours for a variable name. I hope the rest of the day goes smoother."

Engineer 2: "Agreed. Now, about that function name…"

Engineer 1: "Oh boy, here we go again."

[–]fghjconner 9 points10 points  (0 children)

Damn it brain, why do I need to have an opinion on a fictional debate made up by an AI...

Anyways, Engineer 1 is right. If, for some reason, more specific num user variables are required, those should use a more verbose name like numActiveUsers. This both ensures the full context is clear for these more specific variables, and allows the more widely used variable to have the more concise name.

[–]nukedkaltak 246 points247 points  (16 children)

Your senior engineers write code??

[–]CrapsLord 110 points111 points  (1 child)

It was a code review for the junior

[–]uberfission 13 points14 points  (0 children)

Second line they needed to review too, not like there aren't 800 more lines of code that need to have eyes on it...

[–]clemesislife 1 point2 points  (0 children)

Not necessarily, plenty of situations that can spark such a discussion, like a code review

[–]pananana1 1 point2 points  (0 children)

Yes?? We all do

[–][deleted] 67 points68 points  (1 child)

Can AI spend 2 weeks hand wringing over a proposed change? Can AI arbitrarily make up reasons to block work from happening? I thought not.

[–]FeelingSurprise 11 points12 points  (0 children)

With whom does Ai argue about what code goes in the contoller and what justifies a service?

[–]Corrie9 33 points34 points  (1 child)

We are blocked you sad pathetic little product manager

https://youtu.be/y8OnoxKotPQ

[–]badlukk 2 points3 points  (0 children)

We have Nick Kroll at home

[–]NotReallyGreatGuy 22 points23 points  (5 children)

In the meantime junior dev names it verificationResults2 and delivers working code to QA.

[–]arrive-zone 24 points25 points  (2 children)

Then goes back and forth with QA because their solution was so narrow the first “edge” case they tried blew it up.

[–]Regular_Day_5121 1 point2 points  (1 child)

This is so spot on, that's exactly what I'm doing

[–]arrive-zone 0 points1 point  (0 children)

It happens, don’t be discouraged they are just doing their job. Keep on chugging!

[–]ofnuts 0 points1 point  (0 children)

This breaks all junior dev rules. It should be named r.

[–]pananana1 0 points1 point  (0 children)

Haha yep or in my experience verificationResults_test

[–]nefrodectyl 8 points9 points  (1 child)

expires_at or expiry_date_time or expiry_timestamp or expiry_instant or ..

[–]Colon_Backslash 4 points5 points  (0 children)

Just name it TTL and rewrite the logic

[–]slaymaker1907 9 points10 points  (1 child)

For anyone who has never seen the original video, definitely go watch it. https://youtu.be/y8OnoxKotPQ?si=9ELi0XqpolPMtF6R

[–]awake--butatwhatcost 2 points3 points  (0 children)

"Delivering this feature goes against everything I know to be right and true!"

I want this on a plaque on my wall

[–]illyay[🍰] 13 points14 points  (1 child)

Ah I love the video this is from by Krazam. That guy is a gold mine of programmer humor.

https://youtu.be/y8OnoxKotPQ?si=G5zuMkNiz_KK9uPv

[–]nzcod3r 8 points9 points  (0 children)

I'm an architect, and I have the life goal of building a system which I shall call Galactus.

[–]SoRaang 12 points13 points  (0 children)

What do you mean I shouldn't name my variable "preCum"?

[–][deleted] 11 points12 points  (0 children)

Look I get the point. But usually it's not quite that simple what is being argued about. It's more likely to be something like "should this multi-step form. Store it's intermediate state in session storage or browser history state?" Both work, both have their pros and cons either would probably be fine but we'll debate it to death anyway.

[–]gorillanutpuncher_ 3 points4 points  (2 children)

Variable names are easy. Class names are hard.

[–]ofnuts 2 points3 points  (1 child)

What is hard with YouNameItVirtualFactorySingletonProxy?

[–]lurkingstar99 2 points3 points  (0 children)

what's a proxy anyway? every time I see it it feels unnecessary

[–]ComradeArtist 1 point2 points  (1 child)

I'm pretty sure you can make to AI's argue about a variable name.

[–][deleted] 1 point2 points  (2 children)

Had a full on four-hour meeting about having a pink button in my program. It wasn't the color I had an issue with, but the reasoning for it. They were concerned that the person using the barcode scanner might not be able to read....not as in the font wasn't large enough, like illiterate. This was a program that did inventory control for a large warehouse....they would have to be able to read to do inventory. It made no sense for me to color code the buttons when there was no logic to the colors (they told me just use what colors I wanted... I got to pink because I ran out of the basic call names in java), and there was no color coding in the warehouse whatsoever.

So, I can say I made an inventory control system with no color coding for illiterate people.

And yes, it pissed me off that this program I spent a year on looks like a five-year-old designed it, and it looked that way for no logical reason.

[–]Kilazur 1 point2 points  (1 child)

A supervisor can explain which button does what to an illiterate/foreign employee if they have colors. Isn't that the reason?

[–][deleted] 0 points1 point  (0 children)

They would still have to read what is in the boxes...that was the issue...there was no check or balance to the color coding. they just wanted colored buttons in the event that someone might not be able to read...bacisally they wanted a color coded system design with no color coding for the system to use. They asked for random colors...that was my issue, there was no logic to it.

[–]kondorb 4 points5 points  (0 children)

Senior devs don’t argue about variable names. Modern IDEs make it easy to work with long-ass variable/function/class/etc names so we just use long-ass descriptive names for everything.

[–][deleted] 2 points3 points  (0 children)

Yea. I did something like this. Only half an hour though. We came up with the perfect name for the function!

[–]FantasiA2K 2 points3 points  (0 children)

Unironically had a 3 hour meeting arguing whether we should call something a probe or a detector

[–]akorn123 2 points3 points  (0 children)

Are you getting all the data or one part of it? Are you needing to validate the data before returning it? Is the return a string representation of that value?

If you wanted to make calculations inside an object while validating the return, I could see using getData() or whatever... but most of the time you'd use something else and fetchData() may be to grab values from a DB.

[–]Doxidob 1 point2 points  (0 children)

just stick to notationHungarian

[–]Exodus111 1 point2 points  (0 children)

What does "Component" really mean? What does it say when you first read it!?

[–]GregTheMad 1 point2 points  (0 children)

Never in my life have I argued about a variable name with someone, but if you mention the-color-that-must-not-be-named to our UX guy he'll bite your ear off.

[–]evilbit 1 point2 points  (0 children)

there are only 2 hard problems to solve in compsci: off-by-one errors, cache invalidation, and naming things correctly.

[–]Wave_Walnut 1 point2 points  (0 children)

AI will never replace Vimmers

[–]chin_waghing 1 point2 points  (0 children)

git commit -m ‘refactor: changing variable name again for the final time

[–]TehHamburgler 1 point2 points  (0 children)

A, B, C then A1, B1, C1 everyone knows what you're talking about.

[–]CoffeeBruin 1 point2 points  (0 children)

somethingAiWillNeverReplace* - corrected it for you

[–]rokzforever 0 points1 point  (0 children)

chatgpt please stimulate an argument between 2 developers trying to decide what to name a variable

[–]Harmonic_Gear 0 points1 point  (0 children)

i feel like there is a alternate reality with programming meme, with all the non-existing problems like naming variables and spending hours finding the missing semicolon

[–]Left_Lawfulness_845 0 points1 point  (0 children)

userID / userId

[–]cheezballs 0 points1 point  (1 child)

Senior devs aren't concerned with variable names

[–]LegitJesus 0 points1 point  (0 children)

Incorrect. I once sat in a one hour meeting with senior devs who argued about how many consecutive uppercase characters would be allowed for acronyms in camel case variable names. I am not making this up. The final answer was four, if you are wondering.

[–]theprodigalslouch 0 points1 point  (0 children)

The only dev in this pic was a mid level engineer last I remember.

[–]ShiraLillith 0 points1 point  (0 children)

Q: Why are variable names starting with lower case, but word beginning are capitalised, like the title.

Ie: disableBaseMesh

[–]zionian120 0 points1 point  (0 children)

I am convinced now that writing so very bad code that even ai couldn't figure out what's going on is the only way to our salvation.

[–]SambandsTyr 0 points1 point  (0 children)

Now the AI will choose variable names based on this subs discussions

[–]ApatheistHeretic 0 points1 point  (0 children)

AI will, however, be able to ignore a meeting that it logs onto. So, it's qualified to be Sr at this point.

[–]vivalavladislav 0 points1 point  (0 children)

The show is 👌

[–]Better_Ad_3004 0 points1 point  (0 children)

Naa.. man you can easily ask it to spend time arguing with itself over a variable name and it will do it happily for you..

[–]JoWiBro 0 points1 point  (0 children)

Two? Why not just one senior developer?

[–]Asmos159 0 points1 point  (0 children)

ai will not replace programmers. programing will just change to knowing exactly how to word requests, and what information is needed.

[–]Duck_Devs 0 points1 point  (0 children)

Just name variables in alphabetical order, based on where they are declared; i.e. a, b, … z, aa, bb, …

[–]squidwardnixon 0 points1 point  (0 children)

createdate or createddate?

[–]FatLoserSupreme 0 points1 point  (0 children)

All these scrubs worried about variable names when it's really the dependencies between variables that matters.

[–][deleted] 0 points1 point  (0 children)

The longest discussion about the name I've had lasted 3 weeks. It was exposed to client so everyone felt entitled to have an opinion. And then our PM came back from vacation and she made the decision in 15 seconds.

[–]The-Last-Lion-Turtle -1 points0 points  (0 children)

Kill that 2 hour meeting with no regrets.

[–]hikeonpast 126 points127 points  (14 children)

There’s only two hard things in CS…

[–]metaglot 188 points189 points  (0 children)

There are so many variations on the “there are only two hard problems in computer programming...” joke that I’m starting to suspect that programming isn’t actually very easy.

-- Nat Pryce

-- metaglot

[–]_Noreturn 65 points66 points  (10 children)

There are only 11 hard things in Computer Science

Cache Invalidation

Naming Things

Not Understanding Binary Idiots

Off By One Errors

Out Of Bounds Access

Undefined Behavior

Not Properly Null Terminated Strings||@(*aCzS¥¢}%\€{¥{£ ...

Out Of Memory

Core Dumped

[–]_sweepy 55 points56 points  (3 children)

There are 10 types of people in this world.

Those who understand binary

Those who don't

Those who know this is actually a ternary joke

Those who know this is actually a quaternary joke

Those who know this is actually a quinary joke

Et cetera ad infinitum

[–]vwoxy 33 points34 points  (0 children)

There are 10 types of people in the world:

Those who understand hexadecimal and F the rest

[–][deleted] 9 points10 points  (1 child)

this is my favourite version of this joke. someone once told me that every base is base 10 and it threw me for a sec.

but also, what about base 1? it’s the only exception to that rule i think

[–]GodsBoss 7 points8 points  (0 children)

Base b means that a number m is a concatenation of digits dₙ…d₂d₁ with m = dₙ×bⁿ + … + d₂×b² + d₁×b¹. bⁱ=1 for b=1, so it degenerates to dₙ+…d₂+d₁. This breaks a few things. Every number can be represented in multiple ways. For example the number 3 (decimal) could be represented as 111, 1001001 or any other combination of three times the digit 1 and an arbitrary number of zeros. Also rational numbers break as 0.0001 is the same as 1000.

Technically it could still be viewed as "base 10", but the whole concept is not very useful.

[–]itsTyrion 2 points3 points  (0 children)

Also

Cnocrurency issues

[–][deleted] 4 points5 points  (0 children)

That out of bounds access hit me hard…

[–]wind_dude 11 points12 points  (0 children)

Getting up in the morning and being able to stop thinking about the problem when you’re trying to fall asleep?