fully-qualified-naming

I have just learnt how to upgrade a module in Erlang and I know that only the function calls that use the fully qualified names (eg. module:function() ) gets "relinked" to the current version loaded into the VM, but the function calls that do not specify the module's name do not get "relinked" to the current version, but keep using the older one. Is there a rule of thumb on when to use a fully qualified function call and when it's OK to call a function just by its name? Is it a bad idea to call all functions using their full name (like module:function() )? Erlang applications normally make use

Not quite sure of the best title but I will explain what I am asking as best I can. Assume I have the following file: MyCustomClass.php <?php namespace MyNamespace; use FooNamespace\FooClass; use BarNamespace\BarClass as Bar; use BazNamespace\BazClass as BazSpecial; class MyCustomClass { protected $someDependencies = []; public function __construct(FooClass $foo, Bar $bar) { $someDependencies[] = $foo; $someDependencies[] = $bar; } } Now if I were to use reflection, I could get the fully qualified class names from the type hints in the construct. However, I would recieve FooNamespace\FooClass

(It is possible to directly jump to the question, further down, and to skip the introduction.) There is a common difficulty with pickling Python objects from user-defined classes: # This is program dumper.py import pickle class C(object): pass with open('obj.pickle', 'wb') as f: pickle.dump(C(), f) In fact, trying to get the object back from another program loader.py with # This is program loader.py with open('obj.pickle', 'rb') as f: obj = pickle.load(f) results in AttributeError: 'module' object has no attribute 'C' In fact, the class is pickled by name ("C"), and the loader.py program does

In my example below, why do I have to fully qualify the name of the free function in the cpp to avoid linker errors and why does it work for the class function without? Can you explain the difference? ctest.h: namespace Test { int FreeFunction(); class CTest { public: CTest(); ~CTest(); }; } ctest.cpp: #include "ctest.h" using namespace Test; // int FreeFunction() -> undefined reference error int Test::FreeFunction() -> works just fine { return 0; } CTest::CTest() -> no need to fully qualify name, i.e. Test::CTest {} CTest::~CTest() {} Thanks for your time & help. int FreeFunction(void); is

Like the title says, is there a way to deal with this? I have imported two separate third party libraries and they have a fully qualified class name conflict. Right now both libraries are being imported in jar form, and it appears that in some environments (command line invocation, Eclipse) the correct class is found and in others (Maven) the wrong class is found and I get a missing method exception. If no solution can be found, I can fall back to re-factoring one of these libraries and rebuilding the jar, but I would rather not have to repeat that work every time the library has an update.