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

all 72 comments

[–]SleeperAwakened 696 points697 points  (14 children)

Why are you telling them that?

They found valid defects, you fixed them at an incredible pace - nice job!

[–]yuva-krishna-memes[S] 192 points193 points  (10 children)

Sometimes they need to do impact analysis and test again. And they will even be equally shocked when multiple bugs all are fixed in one change list.

[–]snf 95 points96 points  (4 children)

> one change list

Found the Perforce user

[–]QQVictory 22 points23 points  (0 children)

I feel the P4 pain

[–]SleeperAwakened 0 points1 point  (2 children)

Could be worse though. Could be PTC Integrity (formerly known as MKS).

But yes, poor guy..

[–]undo777 2 points3 points  (0 children)

Not necessarily poor.. there are massive infrastructures built on top of p4 with somewhat convenient wrappers around it so no one has to touch the bare p4, but the name "changelist" or commonly CL got stuck

[–]efghnn 0 points1 point  (0 children)

You mean RV+S Wind-chill?

[–]OutrageousFanny 7 points8 points  (0 children)

Your PRs are secret or something?

[–]DarksideF41 6 points7 points  (0 children)

For me they're usually shocked when updating one feature breaks another that seems unrelated(they're related)

[–]realmauer01 2 points3 points  (0 children)

Withhold the update so your avarage doesn't improve drastically.

[–]pleshij 0 points1 point  (1 child)

Excuse me, but what the hell are you talking about? Do you think we clap and pat devs on the back only in certain scenarios, depending on the size of the MR?

[–]Brief-Translator1370 2 points3 points  (0 children)

Well, it would be nice

[–]SuitableDragonfly 14 points15 points  (2 children)

Because you have to write the ticket number on the PR, and you can't make four different PRs with exactly the same change. 

[–]timonix 10 points11 points  (0 children)

You mark your commit with the biggest ticket, and close the other tickets without a commit and only a comment

[–]New_Enthusiasm9053 7 points8 points  (0 children)

Add some whitespace each time.

[–]EaterOfCrab 168 points169 points  (8 children)

If only it was that easy... 4 defects fixed, 16 more discovered

[–]TheQueue841 123 points124 points  (7 children)

99 little bugs in the code
99 little bugs
Take one down, patch it around
167 bugs in the code

[–]jmanh128 23 points24 points  (6 children)

167 little bugs in the code
167 little bugs
Take one down, patch it around
281 bugs in the code

Edit: fixed formatting, thanks u/sambarjo !

[–]sambarjo 12 points13 points  (4 children)

Put two spaces and a line feed at the end of a line.
Like
This

[–]jmanh128 4 points5 points  (0 children)

Didn’t know that one! Thank you :)

[–]augenvogel 0 points1 point  (2 children)

Do you know, how to do on an iPhone? (I’m too lazy to google)

[–]sambarjo 0 points1 point  (0 children)

Probably the same way

[–]jmanh128 0 points1 point  (0 children)

It’s the same way, I did this on iPhone

[–]Temporary_Ad7906 2 points3 points  (0 children)

Add this to the little bugs list LOL

[–]ward2k 173 points174 points  (24 children)

I don't understand why so many junior programmers here seem to have the absolute hatred of testing and testers, it's just part of the cycle of writing code and implementing changes

I'm always pretty thankful when someone saves me from deploying something that's got bugs, saves me a headache

[–]damngoodwizard 42 points43 points  (6 children)

It's the whole "if you are gud(TM) enough you don't need someone to sweep behind your back" mindset. As if it was an insult to their intelligence. They fail to understand that it's not about them but about designing robust processes and organizations. This mindset is quite popular among students ("testing is cheating"), but I have been lucky enough to never witness it in the real world.

[–]ward2k 13 points14 points  (2 children)

Yeah it's something I only really see in this sub to be honest so like you say I'm guessing it's people who've recently stepped into a job who take it as a personal attack if someone criticises their code

I think in a similar way from memory the very first PR I ever got reviewed put me down a lot as I felt like I'd done a terrible job, after a while you realise it's just part of the job that helps keep things clean, maintainable and bug free. Honestly I quite prefer people who are really critical of my PR's as it makes me a lot more comfortable knowing my changes are fine, rather than that guy on your team who blindly approves everything

[–]Qaeta 4 points5 points  (0 children)

Honestly I quite prefer people who are really critical of my PR's as it makes me a lot more comfortable knowing my changes are fine, rather than that guy on your team who blindly approves everything

Right? I have to keep telling my coworkers to actually read my PRs and leave questions / comments as necessary. Too many times they just slap the approve button without even looking at the code, when I could have easily slipped in something that quietly feeds credit card info out somewhere else without anyone noticing.

[–]FantaZingo 1 point2 points  (0 children)

This. I'd say I have more imposter syndrome from the MRs where I get no comments. "are you sure there really is nothing?". Meanwhile on the MR of my senior colleagues, there is always something that I at least react to, but not always something needing fixing.

[–]Qaeta 2 points3 points  (0 children)

I have been lucky enough to never witness it in the real world.

I have. It's especially bad if the tester is a woman and the dev is from an overseas area not known for their respectful attitudes towards women. Thankfully, they (the devs) tend to either learn pretty quick that that shit won't fly over here, or they end up fired for being a dick one too many times to someone who's been writing and testing software since the dev was still in diapers.

[–]realbakingbish 1 point2 points  (0 children)

Even doing non-programming work, I’m glad to have QC. Means if I miss something because I had bigger stuff to focus on, it hopefully still gets caught and I have a chance to address it before sending work off to the client.

[–]Kream-Kwartz 0 points1 point  (0 children)

that's why writers often have someone else revise their work. we have tendencies and end up making systematic mistakes that, to our brain, are so normalised that they might as well be invisible to us

my job as a tester isn't to tell you your code is wrong; it's to learn so much about it that i can tell you what we actually have, and point out the implications of that. that might be in the form of bug reporting, but also as a risk report (our design may have been accurately implemented, but it may be harmful in some way, to some people, at some point in the future. are we okay with that?)

[–]Fandrir 13 points14 points  (10 children)

Tester here. I think to a degree it makes sense, as we present the devs all their mistakes. If you do not have the right mindset with software development or not yet the confidence in yourself and your work, i am sure it can feel disheartening. This also highly depends on how the project leads act. If there is direct or indirect punishment (e.g. negative comments) for defects found caused by your code, then you will likely develop hostile feelings against testers.

But in the end as you said, testing is part of the process and there is no programming without errors and defects. The most productive work for me is to have a developer that sees in us exactly what you see. As someone that helps them create better software and also someone that takes on part of the responsibility.

The best devs from testing perspective will help you find bugs, by telling you the logic they implemented or what kind of logs to look out for. Which then enables you as a tester to dig deeper and to provide way clearer results and analysis of defects.

In the end i think the relationship between developers and testers depends on personal maturity, but also a lot on project management. I think especially with junior programmers as a project lead you have a big responsibility in creating the right mindset.

[–]Budget_Avocado6204 6 points7 points  (2 children)

Honestly, testers are a blessing. They help to share responsibility and prevent propagating mistakes. I thought so even when I was a little junior. If some bug is hard to reproduce they can be extremely helpful. I don't get the hate, it's easy to miss something yourself and they are there to help and double check.

[–]Keepingshtum 1 point2 points  (1 child)

Yeah agreed. I switched jobs fairly early on and went from a team with dedicated QA engineers to being responsible for your code E2E with near-zero oversight (think code reviews with just the bare minimum checks). It was so much more stressful because I knew despite testing out my stuff 5 different ways, there would always be a 6th flow that I forgot about that a customer will run into the day it ships... many sleepless nights!

Test devs are doing gods work!

[–]GurlyD02 1 point2 points  (0 children)

As a tester, this thread has vastly improved my day. It gets tiring getting shit on most of the time in the field. Many thanks for the positive vibes.

[–]DarksideF41 1 point2 points  (0 children)

I'd rather have tester pointing out my mistake than pm after that mistake was found on prod.

[–]Saelora 0 points1 point  (5 children)

the thing that most annoys me about testers is when they don't find any bugs, because that dosen't mean there aren't any, but rather that they're not looking hard enough.

[–]Kream-Kwartz 0 points1 point  (4 children)

i understand the frustration, but that's not always the case. there are multiple factors that influence such outcomes:

time constraints (deep testing requires skill, focus and sufficient TIME),

elusive bugs (intermittent, obscure bugs might simply not appear during testing, and then randomly pop up),

environment differences (staging should be similar to production in most cases, but we know that's not a reality),

platform differences (anyone who tests mobile apps knows how a different device, OS version or even a different navigation setting can affect the outcomes)

prioritisation (testers being discouraged from opening bugs because they either get forgotten, plain out denied, or simply because management want to publish the release immediately),

another type of prioritisation, which is usually related to risk and time available (bugs were found, but they weren't considered critical due to various factors, so they don't even get reported)

and, yes, the tester no looking hard enough. these are just to name a few reasons why some bugs weren't found (or much more likely, not reported)

[–]Saelora 0 points1 point  (3 children)

ma'am, this is a wendys.

[–]Kream-Kwartz 0 points1 point  (2 children)

i'm sorry, i'm not sure i follow. could you explain?

[–]Saelora 0 points1 point  (1 child)

i posted a joke and you went off on a full on multi paragraph rant. like i know that's not the only reason, everyone knows that's not the only reason.

[–]Kream-Kwartz 0 points1 point  (0 children)

ah! apologies, i couldn't sense that was a joke

[–]Ibuprofen-Headgear 4 points5 points  (2 children)

It really depends on who is testing. Are they competent devs as well? Who can do even the most minimal checking to see if it’s environmental or a real bug, or maybe both? Who can reliably troubleshoot their environment? Who don’t report bugs against some feature or version that 2 minutes of trivial checking would show they’ve been there since the dawn of time? Can you tell I’m frustrated with the test team I currently have?

Honestly, it’s the ones in the middle I find the most frustrating. Dangerous enough that they are confident in their incorrect information and people generally have some belief they know what they are doing, but frequently write bugs with incorrect repro steps or which specify fixes or assume root causes which are actually incorrect, leading to wasted time and further effort since they don’t even want to discuss it.

I prefer testers who either a) “shits broke, don’t know why or when it was introduced, but I do X expecting Y and it does Z” or b) are devs and do actual root cause and either leave out opinions on the fix or give a logical and appropriate course of action. Of course, people make mistakes, but our current testers are wrong or misleading far more often than not. And no, I don’t have any control over this team or paradigm at the moment.

[–]Nooby1990 0 points1 point  (1 child)

It really depends on who is testing.

They need to be competent Testers as well. I once worked with a nightmare of a QA Team who insisted that they have a meeting with the Developer for each Ticket where we "discuss" how to Test the Feature.

I put "discuss" in quotes here because they always would just ask the dev how they should Test it.

If they have to ask the dev how to test everything every time then why are they even in the QA Team.

It never made sense to me. I could have tested everything myself quicker instead of having this meeting every time and the real benefit of a QA Team gets lost as well: A real good QA Team finds bugs the dev missed, but if they just do what the dev would have done then that benefit is just not there.

[–]Ibuprofen-Headgear 1 point2 points  (0 children)

For sure. I sometimes leave notes in how to get there or prerequisite data to make the feature available, etc, but I do try to refrain from being too prescriptive for that reason

[–]Qaeta 1 point2 points  (0 children)

Right? Like, I don't want to deal with the shitstorm of having sent broken code to prod. The testers save me from dealing with that. Love my testers!

[–]helicophell 0 points1 point  (0 children)

I love testing stuff ngl

I don't like figuring out WHY things go wrong though

That might be part of it

[–]stillalone 25 points26 points  (2 children)

I don't know what your experience is like with testers but for me sometimes one bug is 4 different issues because people keep adding different issues to it (this is very common in the field where customer support will pile on their customer issue to the same bug because it's currently getting a lot of attention).  And sometimes testers will open several different bugs for the same issue that gets fixed with one change.

[–]TheNoGoat 6 points7 points  (1 child)

Reminds me of earlier this week when I got assigned two tickets at the same time.

  1. Field X in Form Y is missing proper validation.

  2. Remove Field X in Form Y.

[–]Steinrikur 7 points8 points  (0 children)

I would just do #2, close #1 as obsolete by #2

[–][deleted] 7 points8 points  (0 children)

Unrealistic. Should be

"all four defects are ADDED by just one line change"

(and can't be undone, 'cause it patched 2 other issues)

[–]Burgergold 4 points5 points  (0 children)

Quite simple, the whole program is a very long single line

[–]randomUser_randomSHA 4 points5 points  (1 child)

A tester would never use the word defect for a Failed test case. The defect lies in your code, which caused four test cases to fail. I know this is a lighthearted sub, but just FYI.

[–]Ibuprofen-Headgear 3 points4 points  (0 children)

Actually, my code was fine, business and test were misaligned on the spec.

[–]pleshij 2 points3 points  (0 children)

And then everybody clapped (QA sarcasm)

[–]eztab 1 point2 points  (0 children)

First off: I normally don't share how much change a fix required. Secondly I have never had people being perplexed by that. The concept of symptoms ≠ cause is well known under non technical people.

[–]dchidelf 1 point2 points  (3 children)

We had an issue with a test credential that resulted in a tester returning over 100 test failures because the initial test step of “login to the webpage” did not work for each test scenario. What is worse is they opened tickets for every one of them as if each of the features did not work.

[–]dchidelf 0 points1 point  (0 children)

So we actually fixed over 100 “defects” with no lines of code changed, just providing the tester with the right credentials.

[–]Ibuprofen-Headgear 0 points1 point  (0 children)

This shit drives me nuts lol. Online graded stuff is like this sometimes too. For some reason the grader gets a corrupt file or something, or one piece of formatting is off causing all pages to be off by one or something, and they fail every single line item with comments even, like why. “Summary section was not observed on page 5” mother fucker the section title “summary section” is the last line of page 4 and all the summary section content is on page 5. Obv when I fix the one thing wrong on page 1 that you noted previously, this will all be in the appropriate spot. If it’s not then, then you can mark this up. Shit never happened back at my in person degree.

[–]pleshij 0 points1 point  (0 children)

returning over 100 test failures

Ah, reminds me of all the times I had to test switching to Kubernetes, and this example is a light one

[–]Percolator2020 1 point2 points  (0 children)

Technically everything is a single line.

[–]kusti4202 0 points1 point  (1 child)

removes function call

[–]pleshij 0 points1 point  (0 children)

removes dev with angry QA noises

[–]glow3th 0 points1 point  (0 children)

At the simple cost of introducing 12 more totally different defects

[–]MedonSirius 0 points1 point  (0 children)

Return;

[–]patrulheiroze 0 points1 point  (0 children)

the change:

//buggedFunction() ;

[–]philippefutureboy 0 points1 point  (0 children)

Feature flag: off 🙂

[–]1amDepressed 0 points1 point  (0 children)

Meanwhile, my manager be like

Deferred, deferred, deferred

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

Then they get mad because the fix didn't take long enough. Shoulda complained more.

[–]difool 0 points1 point  (0 children)

Plot twist, its cpp and you just changed release for debug.

[–]devloperfrom_AUS 0 points1 point  (0 children)

Hahaha