That's a good habit for nontrivial expressions. Not only does it keep you from having to remember the precedence order for whichever language you are using, but it helps someone reading your program too.

You've reminded me of a very old

thread about a precedence case I tripped over.

The APL programming language (which stands for "A Programming Language") has an extremely simple but at the same time unusual precedence rule. It's sensible given that there are way too many operators (note: actually called "functions" in the language's terminology) to assign an order to. It can be a source of confusion for beginners but after a while becomes quite natural to use. Expressions of the form

*value operator value operator value operator value operator value ...*
are treated as follows (unless parentheses override):

*value operator (value operator (value operator (value operator value ...))*
The operations are performed left-to-right but grouping is right-to-left. Therefore, when you start an expression with

*2 x ...*
the result is guaranteed to be twice whatever the rest of the expression is, no matter what operators it uses. For example, if you know that the perimeter of a rectangle is twice something about the sides, you can write

*2 x*
and then figure out the formula required

*2 x width + height*
without having to add parentheses. If you are used to APL, it reads naturally. If you aren't, it can be misleading.