Bxdty

What would you make of this; do you think my language was
unprofessional?

Yes.

Your comment crossed the line from correcting (which typically relies on specific and concrete comments) to insulting ("this is terrible and if we keep it up we're doomed").

It doesn't matter how much experience you have. It doesn't matter if the code is complete garbage. Honesty isn't an excuse for being rude. That is one of the quickest ways to halt a team's progress and momentum. No matter how experienced or productive you are individually, you are going to be hurting your company overall if the attitude you project at the work place hinders your coworkers.

The reason this is particularly troublesome (and why your management likely responded so sternly) is because it actually hurts your team in the long run. You should know that if your goal is to improve the real quality of code produced by your team, then this will actively hurt your goals. The reason why is because when you get a reputation for being critical, and not helpful, people will not come to you for help (nor will they generally listen to you when you try to offer help). As a result any amount of experience you have will be wasted over time, because people will stop listening to you.

Be polite. Offer help and corrections, and not criticism. I personally think that in situations like this an apology (both to the person in question and to the team) is very reasonable.

Edit to add it is certainly good that there was a helpful review in there too, but keep in mind that perception is as important as reality. In many cases it can take just one poorly chosen word to undo any real good that the code review itself does. A very informative code review that ends with (and I understand this isn't exactly what happened) "overall, this is garbage" is still going to leave the coder with a very bad impression overall, and it is quite likely that they will stop listening to everything else you say. It's important to keep the whole thing professional, every step of the way.

It is the nadir of unprofessionalism in Information Technology to be derisive of another's code in such a fashion and it goes beyond the derision to the way you made the point.

1. It was done publicly, which is why you were pulled aside (virtually)


2. It disrupts a team.


3. It breeds resentment.


4. Coders, like artists take critique VERY personally.


5. It was a massively demotivating thing to say. Productivity from that coder is going to take hit.


6. It makes others less willing to take risks, lest they get ridiculed.

I must say in the strongest possible terms that this is a BAD THING. There is no excuse for this behavior. Do not repeat it.

I have my own feelings and quite a few of us out here agree. I can manage someone who has written bad code with a good deal less stress than someone with a bad attitude. I can always help you improve your code, but a person's attitude is beyond my control and I won't deal with someone with a bad attitude.

It can be hard for someone offended by language like that to explain their reaction to people who aren't offended by language like that. A rule of thumb that usually works: if the critical statement addresses generalities beyond one specific incident, it's offensive (hence unprofessional).

In other words, the more professional expression would be to stick to your detailed review, which was specific to the particular code under review. You could explain that this bad code is going to improve the code quality score, which means we need to work on the quality metrics too. People are ready to work through and learn from one bad incident. It's all in context.

But when you change to a global context, which is what your one comment did (yep, just one sentence!) now you are criticizing the employees themselves, or the whole company, and that's more threatening. It leads to (as other answers mention) resentment, disconnection, and a loss of collaborative energy.

You can find this difference between global criticism and instance-specific complaint in relationship literature. John Gottman's explanation (see "criticism") is a popular example.

The words you pick do matter, but the context matters more. It's totally okay (in most software shops I know) to say "garbage in, garbage out" because that has a specific meaning and you are using the phrase to describe why a particular design is unsuitable. Go figure.

direct, honest, and straight-forward.

Said otherwise : harsh, abrasive, non-diplomatic.

The tough thing to learn for us programmers is that human beings are not machines. They are not interested in naked truth. Human beings are social animals, and require a good level of diplomacy to be communicated with.

Some even go as far as saying that the real purpose of communication is not to pass information, but to make friendship stronger. I would not go that far, especially in a professional setting, but this is something you should never forget : even in circumstances when nothing is said about you, "direct, honest, and straight-forward" can in fact leave people unhappy with you, which may hinder your work relations later. Ideally, you'd always want to sandwich a layer of criticism between layers of compliment.

What is considered appropriate language for a comment would be entirely dependent on your company culture, but simply calling someone's code "garbage" (and the brackets suggest you actually used a different less polite word) certainly isn't very constructive. It isn't going to help anyone improve.

What was wrong with the code? How could they have improved it? What should the developer do differently? That is the only information you should have included. If it was so bad as to go beyond the scope of a comment you should have pulled the developer aside and discussed it in person.

As team leader, and the one with experience, it is incumbent you to help your team improve. That is your job. Belittling them them in a code review comment doesn't accomplish anything good.

What would you make of this; why you think my language was unprofessional?

So ... here's the deal:

• You are the team lead; that means that you are supposed to build up the team, not beat them down.




• The code is the developer's work; calling it garbage in writing in front of their peers is a heavy blow.

Okay, that's the part which directly addresses the question. Okay to stop reading now. Next part ... what might you have done differently?

• Keep the detailed suggestions, those are good




• In the 'overall' section, say that this file isn't following best practices per detailed notes below




• Have a breakout, either 1-1 with the guy, or a training session with the team to go through best practices. In other words, turn this mistake into an opportunity

Just my two bits, yo.

This is very dependent on company culture. However, there are some general things to consider. There are mainly two reasons why calling code garbage might be considered unprofessional:

1. It does - by itself - not provide insight as to what is bad or how to improve the situation, it just gives that code a (low) value, while typically you want to look at its advantages and disadvantages rather than consider it generally bad or good


2. it may be offensive to a colleague, i.e. the person who wrote that code

As for 1), that can be alleviated by providing concrete details as to what you think is bad and how to fix it. Typically, there are reasons why things are as they are and it's not that someone just wanted to write garbage. The code might have been perfect for the job it was intended for when it was written, but the context changed.

As for 2), if the code you refer to is a recent commit from a particular person, that person might feel offended. Especially if he had reasons to write something objectively bad, like time constraints, that you don't take into account. And often what is garbage to you is perfect for someone else, calling it garbage just brings emotions into what otherwise could have been a well founded objective discussion. On the other end of the spectrum - if you take over an old large codebase that no one in the current team already considers "his code", it's pretty impersonal to call that big pile of probably convoluted code garbage (still doesn't address 1. though and you better back it up).
Another issue is how you deliver any line containing expletives. The more emotionally loaded (and accusing) the worse, the more light-hearted, perhaps ironically aimed at yourself the more acceptable.

So, if you are unsure, never call something garbage. If you want to test the waters, start using such valuing language for code that no one feels attached to (or your own code) and back yourself up with some details as to what you don't like.

Whether people react offended and consider you (un)professional solely based on the words you use depends on the company culture. However, universally people will judge you based on how you use your words. If you just call stuff garbage without arguing your point of view, without accepting another developers argument as to why the code is fine as it is, people will think you are unreasonable and judgemental. And thus unprofessional. Especially if you explicitly or implicitly blame your co-workers for what you consider bad code.
This is true no matter whether you use expletives or not, i.e. saying "this code is just bad", without any further comments, is unprofessional as well, but the more emotionally loaded words you use (and the more emotionally loaded you present them), the worse this gets.

That being said, if you use expletive words in a reasonable fashion without directing them at your co-workers but rather as a means to give weight to your impressions or vent off some frustration, it can be totally fine. I've worked in an environment where the tone was very direct, playful and the sentences often full of expletives. But typically any such expletive was directed at some technical problems, the way some frameworks behaved unpredictably or even at one's own code ("Look at the garbage I did there, it's incredible that I wrote that stuff!"). On the other hand, I've rarely seen a team working so professionally - respecting each other, always looking how to fix the problem and not how to distribute the blame.

TLDR: using expletives to describe code isn't necessarily unprofessional in itself. In some cultural contexts, however, any use of expletives is considered unprofessional/offensive. It is your job to figure out whether this is the case in your environment before using them, not doing this first is unprofessional.
If (another person's) code is absolutely valued, using expletives or not, without a) giving details and b) without separating that criticism from the person and c) without knowing that the other person can separate criticism of their code and criticism of themselves, this is unprofessional as well.
In your current company, people are obviously not accustomed to any swearing / expletives and consider it bad behaviour - so don't do it.

The truth is that most software is garbage. The lie is pretending otherwise, like the posts above.