How fucking hard is it to remain consistent with naming, holy shit! Is it register, sign up, create user and is it user, client, customer, account.. then you have the API to contend with, with it's own terminology! This is such crap.

I feel like Hal in Malcom in the Middle, fixing shit. I start by writing functionality only to end up somewhere in the application layer refactoring a bunch of functions for naming consistency, then going to the repository to refactor something but then I gotta change the interfaces to match and then I gotta change the tests also..

Four hours into this work:
"You're supposed to be adding a button to the sidebar"
- "WHAT DOES IT LOOK LIKE I'M DOING?!"

So recently I completed side gig from random freelancing site where I had to shadow troubleshoot performance problems over teams call with random Indian guy on his client's AWS account. Long story short you can autoscale new instances all you want but it's not gonna help if your FIFO sqs has only one message group ID. This architecture is running an online game, which is basically limited to processing ONE event at the same time for ALL players xD
What's even better, basing on naming convention I realized it's a company that I interviewed for like 4 months ago and they told me "we need someone with more experience". Well good luck, thanks for quick cash

The two hardest things in software are naming things, cache invalidation, and avoiding off-by-one errors.

A LPT I read on Reddit which I really found effective, sharing with the community here:

Using following naming convention really helps to keep file system sorted

YYYY - MM - DD - Name

Example:
2022-12-31-Christmas trip to Amsterdam
2022-02-28-Honeymoon to Maldives
2021-09-15-Banged Christina

Your folders, will always be sorted in order making it easier for you to locate them.

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

Petition to ban vague naming, e.g. "Logo.jpg". Whose ****ing logo is that!?

"raise UnknownException" –🌈🦄

Today I could finally spend some time reviewing the merge requests an intern made (and I occasionally helped).

My god, I want to put it this months amount of work an, put it in a trash, burn it and rewrite it before the fire is gone.

5 small and unrelated issues. The intern used branches with the correct naming scheme, but IT'S A FUCKING STRAIGHT LINE BUILDING ON TOP OF EACHOTHER.

Oh ans also they took the liberty to update the dependencies and the language versions used. There was no issue regarding this. It's the first branch in the line and it was called "update_<dependency>" where they just upped the version numbers of everything and then COMMENT OUT all mentions of <dependency> so that it compiles at the very least.

Now today I spend most of my time reviewing the code by fixing that mess. Thanks to updates I had to update the CI and replace some libraries that are now incompatible. Tomorrow I can finally inspect the shit itself.

On a positive side node, I removed node as a dev dependency and the size of the node modules went down from 128mb to 18mb

There has to be a software project bingo somewhere where I could just mark one item at a time of what's wrong and should be fixed, eventually leading to the same loop all over again. Items include, but are not limited to:

- The application is too tightly coupled
- There are too many repos and people can't keep track
- Someone forgot to create a naming convention for everything
- Nobody is reviewing pull requests
- Someone opened a PR for their 1 month of work
- Some team created a service for themselves, that doesn't cover use cases for every other team (who didn't tell anyone they needed it), thus it was a bad thing
- Business owners telling something needs to get done now and go talk directly to a developer
- Nobody thought about network latency in microservice architecture
- There's an invalid translation in this string, let's push the MVP another two months to make sure everything is perfect before launch
- The API gateway has business logic in it
- Business wants to focus on output, development teams in outcome
- "You need to request a virtual machines from the IT department so we know you won't mine bitcoin there!" Takes two months to fulfill that request.
- <add documentation here>
- 675 vulnerabilities in packages
- People complain about not knowing what others are doing, but nobody wants to speak up

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.

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.

I recently built an automated payout functionality for bank-to-bank transfers, and we initially looked at using the pain.001 XML schema to do it. Luckily, we ended up finding a service that has a simple REST API to do this instead. (Thank god we didn't go with the XML method, I know how much of a headache that could become, I can imagine the treasure trove of memes with naming an XML schema with the name PAIN)

Anyway, for one of our big-brained product managers, this will forever be the infamous "XML Task" that he continues to ask about and bring up. I've already clarified a few times that we have long chosen a solution process that has nothing to do with XML, but to no avail, it will forever be his "XML Task". Wonder what name he'll pick next time we need XML in a solution? "Second XML Task?" Let's just keep the mental overhead idiot train going!

Every fucking time I start a new project I always forget the basics of using the same operation names, either CRUD(I) or BREAD.. Then I have functions that start with fetch or get and some are list some are browse.. Then I spend an hour refactoring all those to use a standardized naming convention! FFS! I'm so stupid!

Should I become the CEO of Xerox, I pledge to rename the company to "Jerome Inc.", and naming our highest performance printing machine "Powell".

Also, I'm going to legally change my name to William "Bill" Printer.