Recently, several programming languages have been proposed to improve modularity by using advanced-dispatching mechanisms. These mechanisms allow programmers to express implicit program behaviour: an advanced-dispatching module can alter the runtime behaviour of program modules, which contain no explicit reference to the advanced-dispatching module. The language elements, that enables programmers to express implicit program behaviour, are com- piled away and transformed such that their semantics are expressed in terms of a well-known existing programming language. This transfor- mation creates complex synthetic structures of the language elements, and can even result into the loss of several source abstractions. Con- sequently, existing debugger tools that target these transformations cannot offer tool support in terms of the original source abstractions, and can become unaware of the presence of source abstractions that were compiled away. This limits existing debuggers because they can- not offer proper support regarding said language elements. This thesis proposes the design and implementation of a trace-based debugging approach, which can capture the activity of language elements of the advanced-dispatching concept, and offers several features to debug such elements accordingly. Because of the trace-based fashion of our approach, it becomes particularly useful in situations where the symp- tom of a bug is located relatively far away from its actual cause (which can be related to an advanced-dispatching language element), because the program trace that lead to the bug is captured and can be explored. The novelty about this approach is that it offers multiple navigational techniques to locate the activity of advanced-dispatching language elements, and help programmers to comprehend their interplay with the execution of the program.