When you want to directly use a macro with an @ in its name (at-macro, from now on), then you have to make sure that @ is considered a letter, that is the call must be after a \makeatletter declaration.
However normal macros that are defined in terms of at-macros don't need to be used in such a regime. Let's look at an example.
The LaTeX kernel defines \item as follows:
\def\item{%
\@inmatherr\item
\@ifnextchar [ {\@item}{\@noitemargtrue \@item[\@itemlabel]}%
}
and it does so where \makeatletter is in force. When the \def is executed, TeX stores \item and its replacement text in memory, but in a form that is independent of the actual characters that form the names of the used control sequences. Thus, when \item appears in your document (where \makeatother is usually in force), the fact that its expansion contains at-macros is irrelevant as far as the expansion process is concerned: TeX retrieves from its memory the meaning of \item in the internal form and the same happens when the first control sequence, \@inmatherr, must be expanded.
To the contrary, if you need to modify the definition of \item in order to add something at the beginning, this has to be made properly:
\makeatletter
\def\item{%
\typeout{Doh! An item!}%
\@inmatherr\item
\@ifnextchar [ {\@item}{\@noitemargtrue \@item[\@itemlabel]}%
}
\makeatother
since you are referring to at-macros in the body of the definition. Without \makeatletter, the line \@inmatherr\item would be parsed (I use • to separate one token from another)
\@•i•n•m•a•t•h•e•r•r•\item
that is, eleven tokens and not two! This is because in normal regime @ is not a letter: when TeX is looking for a command name because it has found a backslash, any non-letter immediately stops the scanning and the command name will be formed by that non-letter.
What's a letter? Any character with category code 11 at the moment the scanning takes place. But, I repeat, once the scanning has been performed, the control sequence enters TeX in an internal format that's independent of category codes.
Looking at your example with \somemacro@, it's "easy" to distinguish the two cases:
\makeatletter
\somemacro@ % <- ONE token
\makeatother
\somemacro@ % <- TWO tokens
So, if you have defined both \somemacro@ (as an at-macro) and \somemacro, in a normal place of the document the combination \somemacro@ will expand \somemacro and not the at-macro. In fact, the scanning for a control sequence name will be stopped by @, which is not a letter in the document (if you haven't done \makeatletter, of course).
A doubt can arise for the following:
\makeatletter
\def\somemacro@#1{Do something smart with #1}
\def\somemacro#1{\somemacro@{(#1)}}
\makeatother
and the input (under normal conditions, that is, \makeatother)
\somemacro@
Now these are two tokens: \somemacro•@, so @ will be the argument to \somemacro and the final result would be printing
Do something smart with (@)
It takes a while to digest these tricks; but once one realizes that TeX works with the tokens it forms by reading the input file and works on them after translating into an internal format (which is irrelevant for the user to know), things begin to go more smoothly.
\makeatletter. But I'd love to hear what really experienced TeX users/programmers have to say. – mbork Sep 24 '12 at 08:07