It happened again.

This time my colleague, is abbreviating "cumulative" as "cum" in a variable name, and now I have to control my 6th grade humor...

Code works.

Rename a variable for clarity.
Third-party lib behaves differently, breaks things.

Change the var names back.
Still broken.

Stash changes and checkout previous commit.
Everything works.

Diff with stash.
No notable changes. (some comments, ...)

Checkout branch again, pop stash.
Broken again.

... What?

Stop using anal as a variable or function name wherever I look I see anal_this and anal_that please stop. Use analyze, analyzer or whatever and not anal_insert ( ) or anal_check ()

There was a variable named 'isVisible'

Wanted to make it visible

I typed in 'yeah' as a keyword instead of 'true'

🤦‍♂️

You know that moment you realize you read/write the wrong variable, and that's why u were stuck for 2-4 hours?

That.

God, I love when people name stuff right. Now I'm reading through an open source project, trying to find out how they solved a critical issue I'm facing now. It's not a small one but navigating through it is a breeze. Look through variable/function names and I don't even really need to read the code. Meanwhile, last assignment, there was "yangDataHandler" and "yangDataManager" that, obviously, had nothing to do with each other in either interoperability or functionality - and then half of the variables would get aliased to abbreviations. Uh, yes, sure it's obvious what
𝚋𝚣𝚋𝚠𝚒 variable means. Just let me run it through 𝚒𝚍𝚣𝚍() function.

I've told the same story multiple times but the subject of "painfully incompetent co-worker" just comes up so often.

I have one coworker who never really grew out of the mindset of a college student who just took "Intro to Programming". If a problem couldn't be solved with a textbook solution, then he would waste several weeks struggling with it until eventually someone else would pick up the ticket and finish it in a couple days. And if he found a janky workaround for a problem, he'd consider that problem "solved" and never think about it again.

He lasted less than a year before he quit and went off to get a job somewhere else, leaving the rest of our team to comb through his messy code and fix it. Unfortunately, our team is mostly split across multiple projects and our processes were kind of a mess until recently, so his work was a black box of code that had never been reviewed.

I opened the box and found only despair and regret. He was using deprecated features from older versions of the language to work around language bugs that no longer existed. He overused constants to a ridiculous degree (hundreds of constants, all of which are used exactly once in the entire codebase, stored in a single mutable map variable named "values" because why not). He didn't really seem to understand DRY at all. His code threw warnings in the IDE and had weird errors that were difficult to reproduce because there was just a whole pile of race conditions.

I ended up having to take a figurative hacksaw to it, ripping out huge sections of unnecessary crap and modernizing it to use recent language features to get rid of the deprecation warnings and intermittent errors. And then I went through the same process again for every other project he'd touched.

Good riddance.

At my first big boy job at a start up with only 50 users, we noticed we had cloud cost spikes about 20x larger than we were expecting. I remember spending all night debugging it, checking the requests as they go through.

The culprit? Someone left an async on a UseEffect with a variable that was regularly updated as a parameter.

In other words: every time a request was fired, the variable would change… so the function would sense the variable changed and fire it again, and so on.

Felt like a total hero.

it finally happened, PM/PO/SM is now also dev シ

each standup he now also gives update about his work in progress, with his diligently designed subtasks, perfectly sticking to the daily script, like a good well-behaved employee boi. it's weirdly cute

devs can't await to review his first PR. feeling the strong urge to spank his ass for each minor coding style issue or poorly-named variable...

Because DevOps in a lot of organizations is really “help desk for clueless developers”, conversations like this happen a lot:

Dev “hey the thing seems to be not working right”

Me “what does that even mean? I need you to be a good deal more specific. What thing. What isn’t working?”

Dev “I dunno”

Me “Are there error messages?”

Dev “yes”

Me “….would you like to share them with me?”

Dev *sends error*

Me “ok did you actually read this error message?”

Dev “yes”

Me “…so you’re good then? It says you’re trying to use a variable that hasn’t been declared yet. You should fix that. “

Dev “…”

Me “good luck”

So about two months ago in my consulting firm I was asked to replace a colleague on a project (node and Angular). The project is only a few months old but it’s already a total clusterfuck. DB is very poorly designed. It’s supposed to be a relational database but there’s not a trace of a foreign key or any key for that matter and I’ve seen joins like tableA.name = tableB.description (seriously, that’s your relation??). The code is a mess with entire blocks of code copied from another project and many parts of the code aren’t even used. He didn’t even bother renaming variables so they would make sense in the context they were shamelessly thrown into. The code is at best poorly typed if not typed at all.

During our dailies I sometimes express my frustration with my other colleagues as I very politely allude to my predecessor’s code as being hard to work with. (They are all “good friends" with him). I always get the same response from my colleagues: "yeah but you’ve gotta understand Billybob was under a lot of pressure. The user stories were not well defined. He didn’t have time to do a proper job". That type of response just makes me boil inside.

Because you think I have time to deal with this shit? You don’t think I’m working with the same client and his user stories that are barely intelligible? How long does it take to write type definitions for parameters going into a function? That’s right, 30 seconds at most? Maybe a minute if it’s a more elaborate object? How much time do you think you’ll save yourself with a properly typed function or better yet an interface? Hard to tell but certainly A LOT MORE than those 30 seconds you lost (no, the 30 seconds you INVESTED) in writing that interface!!!

FUCK people with their excuses! Never tell me you don’t have time to do a proper job! You’ve wasted HOURS of my time just because you were too fucking lazy to type your functions, too lazy to put just a little more thought into designing your tables, too lazy to rename a variable so that it’s name actually makes sense where it’s being used. It’s not because you were short on time. You’re just lazy!
FUCK!!!!!!

Co-Worker: How can I see what's linked to x variable in the database for this website? [we can't see the actual back end]
Me: Do a var dump...
Co-Worker: but what var do I dump?

Pythons tkinter library has a module called "N". Just N. That's it.
So whenever you type "N" and want to autocomplete some local variable or class name, the IDE will instead import that module!
Who the fuck thought N would be a good name??? Some people have some serious issues...

Of course, the variable for fields should be called "flds", those 2 bytes saved will help us so much! For a small price of this shit being not really readable anymore. Is it "floods"? "fleeds"?

Programmer writer's block (or trying to name a variable):

i have grown to HATE short variable names

nevermind all the generic names like thing/item/object/component

int i;

cute, good enough...oh wait it's referenced here 50 times in a sea of some loop? well fuk...how do... nope highlighting wont work - int, idkwtftonamethisvar, it's a common vowel. can't sed/regex a stand alone 'i' just...gg. gl finding or recognizing a single letter

about to start using iii or i_cnt

Notion: Working with variable arguments in C is weird.

Hypothesis: It might be weird because I am used to it with more....err...dynamic languages.

Solution: hit the docs and stop bitching about shit

Situation that put me in here: Trying to do a game engine is hard....

If not understanding code, read the documentation or debug the code. When trying to modify...
1. Follow proper indentation.
2. Don't make spelling mistakes and follow naming convention.
3. Don't try to write all the code in one line (based on line length set)
4. Simplify if else statements if possible.
5. If value of method call need to be used once, don't store it in a variable. Directly use where ever it is needed.
6. If there is duplicated code, put it in separate method and re-use it if possible.

It all started with this question 😆

Nothing like having to work on a codebase which has most of the class and variable names in a language you don't speak :/

can we agree that T is a dumb variable name?

I mean I totally know what it means in that instance, but why do people keep writing math stuff like they'd skribble it on paper?

get a high priority bug , look at code changes, a variable name getting refactored apparently created a class cast exception

something about this hypothesis doesn't seem right

i hate my job, welcome back from vacation

I thought I found a way to compute PI, but I actually just found a super shitty way to print a variable..

const precision = 1000000

// convert degree to radians
function rad(degree){
return degree * (Math.PI/180);
}
function calculatePI(){
// [x, y]
// take first point on start of unic circle
const point1 = [Math.cos(0) , Math.sin(0)];
// take second point at 0.001 degree
const point2 = [Math.cos(rad(1/precision)), Math.sin(rad(1/precision))];

// Estimate 0.001 degree of circle
const dist = Math.sqrt((point2[0] - point1[0] ) ** 2 + (point2[1] - point1[1]) ** 2);
// Calculate full circle
const perimeter = dist * precision * 180;
return perimeter;
}
console.log(calculatePI());

*deep breaths*

im seeing code where they use keywords as variable names, and then, sure enough, right there next to it, another piece of code that uses a logical name

it's ok. i'm ok. i can deal with this

"Most memorable bug you fixed?"

A recent instance happened in one of my Scratch projects, and the bug involved "Infinities."

I had an opportunity to teach kids programming, and it involved Scratch. So, to have something to show those kids at least, I decided to make a small game.
In that game, I had an object that takes some time before appearing after being cloned (i.e., instantiated.) The duration was calculated by dividing a constant with a variable:
[Wait for ((3) / (variable)) seconds]
The bug is that I forgot about the case where 'variable' can be 0, which is classic and insignificant.

Well, the thing is that I learned two things the hard way:
1: Scratch is very flexible about integers and floats (e.g., at one second, it looks like an integer, but one operation later, it's a float.)
2: Scratch does not provide any 'runtime errors' that can crash the project.

In other languages, similar "wait" methods take "milliseconds" in an integer, so it would have barfed out a "DivideByZeroException" or something. But Scratch was so robust against project-crashing behavior that it literally waited for f*<king "infinity seconds," effectively hanging that clone without warning or runtime errors. This masked my bug. It took way too long to debug that s#!+.

Don't blanket-mask any errors.

So, just to recap if you missed the last few episodes. I've been a web developer for years. But I decided to get a degree and go to uni.

Also I am firmly on the fewer comments side of the debate about self-documenting code. Even though I usually rephrase it and say method and variable names are comments. Basic idea: something is unclear, you should leave a comment. But, before you leave a comment, take a good look at your method. Can you rename a variable? Maybe the method name? Maybe extract a method into smaller methods so it doesn't need a comment? And only if you fail to do so, leave a comment.

Alright, now that we rehashed that, uni coding makes no bloody sense.

There is code that is abbreviated to the max (or min).

And then, they need everything commented. I mean, why do that? Why call the parameters a and b instead of base and exponent. And then say:
"But write a whole article about it above the method". Like:

a is the base for a power operation.
b is the exponent for a power operation.
return int representing a to the power of b

How about just do this:

public static int power(int base, int exponent).

How is this not the same documentation?

Is it because we're at a uni, a place for smart people and smart people shouldn't have an issue keeping a mental map between the variables and their meaning?

Or is it because they are all mathematicians. All respect to applied mathematics. I mean, the function about exponent calculation, I was not aware that it could be that effective. But on the other hand, keep mathematicians away from programming. I get it, writing maths per hand doesn't have intellisense and therefore you don't want to write long variable names. It's and old tradition. Yada yada, yah.

But programming is not maths. And maths shouldn't be maths like that. Right naming makes it simpler. It might still be a while until we all LaTeX rather than handwrite and be able to give maths right naming schemes, but programming is beyond the point. Calling the array you handing in a function A and the one that you're returning D makes no fucking sense.

do you guys make a temp copy of every single object and/or variable you ever use? ive gone thru a few projects in this company and our code has so much of this. I cant remember now if there is even a good reason to do it like that. you can end up with a lot of copies! haha!

Is there anything like React Context or Unix envvars in any functional language?

Not global mutable state, but variables with a global identity that I can set to a value for the duration of a function call to influence the behavior of all deeply nested functions that reference the same variable without having to acknowledge them.

You deliver a new feature. After the functionality, how do you prioritize?

- having clear variable- and function names
- having meaningful and orthographically and grammatically spelled commit messages
- having a clean commit history
- having perfect linted syntax
- having it covered with unit-tests
- having a wonderful documentation

!rant One of the better refactoring insights I've heard today: "With great power comes great responsibility".

Just because a language may not care about certain constructs, doesn't mean you should be relaxed about them (e.g. weak/dynamic typing/not caring about (variable name) consistency).

Imagine that I have written 1000 lines of code and imported many libraries. Sometimes I get confused when trying to use a name I defined earlier. In my mind is this name a class or a method, is it a local or global variable, is this a constant. So I came up with a way and it totally works, although my ide complains, but who cares, I use it anyway.
I use PascalCase for class.
camelCase for methods.
snake_case or lowercase for global variables.
kebab-case I don't use this
UPPER_CASE for constants
snake_caseL or lowercaseL with a capital letter L at the ending for local variable.
I hope this is helpful 😊🤔

Javascript autocomplete in chrome is so strange. I'll be trying to access my image variable and it autocompletes to ImageFrameWindowContainer or something I've never heard of

My understand of null

0,empty = values explicitly set
Null = variable exists but it's still virgin.
Undefined = variable doesnot exists

senior: it should only take 30 seconds to replace multiple display strings across our code base

well it would be nice if they'd do it then, and somehow i don't think that 30 seconds included checking your work and making sure you don't fuck up other instances of those strings (e.g. in variable names, etc)

maybe you got a clever enough regex to only hit exactly what you want :shrug:

TIL RVM and I are on different assumptions. I'm talking about RVM allowing unbound variables in its scripts.
I don't because I literally have run "rm -rf /" on my Mac because of an unbound variable in the past. So, when I write a shell script, the second line is always "set -eu."
And because RVM allows unbound variables, this line crashes RVM.
Then for some stupidity on my part, I looked into GitHub for its codebase first to get even more clueless about the issue before finally googling to see if anyone had experienced the same problem 🤦