Can you provide more context around Maeder's comments? Those statements sound like they are dependent on some previous discussion. For example, "Auxiliary functions or private variables that are used inside the package would be accessible to the user" doesn't sound like something that is always true, but instead depends on how you structure your package (specifically when you expose your variables for the first time).

As it stands right now, neither of your functions are "published". That is, to use f1, you'd need to do this:

MyPackage`Private`f1[5]

I'm not really sure if this has anything to do with your question, but continuing...

To make f1 useable without using the fully-qualified name (i.e. the name with the full context), you need to make sure it's in the MyPackage context. This would be as easy as just inserting the expression f1 between BeginPackage and Begin (I mean literally just f1, not the definition, just the symbol). Typically, however, people put usage messages in that space, which, as a side effect, puts the symbol into the right context. I'm assuming that the function n has no direct utility to package users, so no need to expose it in the main package context.

Side note, there's no benefit to using With to define n, at least not with this simplistic example. Along the same lines, I see no benefit to using Module for f1 (again, for this simplistic example, at least).

Eric Rimbey, thank you very much. I didn't understand why I needed to go all the way into writing MyPackagePrivatef1[5] in order to make use of my new function. Thanks for that piece of knowledge.

Maeder wrote at the former section a function that is built of a module a with, similar to that structure:

f1[arg1_,arg2_]:=
  Module[{arg3,arg4},
    arg3=f2[arg5];
    arg4=f2[arg6,arg5]
  ]
f2[arg3_]:=
  With[{arg3=const},
    BuiltInFunction[arg3]
  ]

And then explained that maybe it works, but you should actually put into a package with contexts and so forth.