The bracketless if statement is frowned upon, but is it still bad style if your IDE is equipped for it?

Question

This type of conditional statement is generally frowned upon

if(condition)
  statement;

because if you add another statement, like this

if(condition)
  statement;
  statement;

it gives the impression that the second statement is part of the if block when it isn't.

That said, my IDE does automatic indentation, which I think makes this problem moot. Furthermore, when I want to add another statement, it automatically does the bracket completion--which makes the issue about having to manually add brackets when you want to add another statement moot.

Is there any reason why this would still be bad style?

Answer 1

Yes, because not everyone on your team may be using that particular IDE. In general, it's still pretty dangerous since most IDEs/editors don't have this functionality so it can still let bugs creep in.

Also, many people prefer the brackets for readability purposes, since it makes it more clear that certain code is associated with an if statement.

Answer 2

Alright, I'll be the one to state the unspoken. If omitting the brackets was such a serious offense, it would show up with -Wall, and none of the newer languages would let you do it at all. It is nowhere near a universal preference, and a lot of people even remove the brackets from existing code because it removes clutter and clarifies you only intended to include one statement. It's a rookie mistake because the code won't pass even basic testing, and in my experience the following mistake is more common among rookies:

if (condition);
{
    statement;
}

Probably because autoindent won't catch this bug, but will catch the one cited as the reason for including the superfluous brackets. Autoindent has been a feature of every single programmer's editor for decades, and if you don't use it, you deserve to get stymied by stupid syntax errors.

Answer 3

Readability and maintainability are, in most circumstances, the two most important attributes of any piece of code. Using conditional logic without braces reduces readability, which is why it's considered bad style. Having a fancy IDE doesn't turn bad style into good style. Don't do it.

Answer 4

Whether or not to use the brace is a personal (and/or team) preference. There are pros to cons about each. The reason for picking sides is to be consistent, and to produce code that is easiest for you to understand and maintain (and by "you" I mean "your team" if you're working in a team environment).

Your question seems to be not whether one is better than the other, but whether you should let your IDE tell you what is best. And to that question I say a resounding NO. Choose your coding conventions based on what you think is best, or your team if you're working on a team.

Answer 5

One of the nice things about using block delimiters (I.e.: Braces in C-Styled languages, or begin/end in Pascal-like languages) is that when used singly and on a separate line, they introduce additional white-space in your code. Now, without getting into a battle over hanging-brace vs inline-brace style choices, the point is simply that insofar as the compiler doesn't care either way, adding a little extra space helps to improve readability (particularly for those of us with eyes that aren't quite as young as they used to be!!). It's the same trick that you use when you create a resume. More white space makes things stand out better by themselves.

The other reasons to use block delimiters is to make it absolutely clear where something begins and ends. Sure, you can do the following:

DoTheFirstThing();
if (condition)
DoSomething();
DoSomethingElse();

Yet, when reading the code, the eyes can easily skip through the code, and you end up making assumptions about what has occurred as a part of the if statement. Whereas if you were to add a couple of braces:

DoTheFirstThing();
if (condition)
{
DoSomething();
}
DoSomethingElse();

you are making it clearer where the if block actually begins and ends. Of course, if you are pedantic about your indentation, you might argue that a simple indent is enough. Sure if you are used to using a language like Python, you may be used to paying particular attention to your indentation, but does it really make things much clearer? Let's look at a couple more examples. Decide which if statement stands out as the clearest when you take a really quick glance at the following:

DoTheFirstThing();
if (condition)
    DoSomething();
DoSomethingElse();
DoTheSecondThing();
if (condition)
{
    DoSomething();
}
DoSomethingElse();

Now do the same as the previous example, with this:

DoTheFirstThing();
if (condition)
    DoSomething();
DoSomethingElse();
DoTheFirstThing();

if (condition)
{
    DoSomething();
}

DoSomethingElse();

Out of the two examples, the very last if statement with the greater amount of whitespace stands out, and the code appears clearer, even though it is exactly the same.

So to really answer the OP's question, is it Bad to bunch things up and avoid brackets? My answer is no, and that I think calling it bad or poor or some other negative is laying it on a bit strongly. The compiler doesn't really care, and the code will work exactly the same. However, it is certainly more readable if you add the braces, and is shows the purpose of the If statement more clearly. More importantly perhaps, is that it shows that you are taking a little care to ensure the quality of your work stands out. It's like the difference between quickly painting a wall with a wide paint-brush once, or using a roller and carefully applying two coats of paint. Just as it is important to look at the finish of a paint job, so to the extra care taken in your code shows that you are willing to take the time to ensure others will not find it difficult to read through your work. This pays itself back when you need to revisit the code months or even years later, or when someone else needs to support you code after you're done.

Carefully written, clean, readable code inspires confidence in the code, while messy looking code will usually inspire an it's awful and too hard to work with attitude towards the code. Attention to detail shows a difference between the careful professional, and the less careful programmer. It inspires trust in your work, and is a pleasure to work with.

Answer 6

Code quality is independent of the IDE used to generate it (past tense!). The IDE that will be used to change it might alleviate some code problems. But this is in the future. You should strive for quality now.

As you can see from the other answers, some people do not consider this to be bad style. But I suppose most would agree that mixing two styles is much worth than < whatever coding style you despise goes here >. So if you are on a team or work with an existing consistent code base, stick to the rules. IMHO that's the professional thing to do.