To kick things off: what are these exec*() functions? Well, they allow us to execute Python code dynamically at runtime a feature that can be both incredibly useful and incredibly dangerous. Let’s dig into this at each one:

1) `exec(string [, globals[, locals]])`
This function executes the given string as if it were in a new script file.

It’s like running Python code from within your program but with all the risks that come along with it!

2) `eval(expression[, globals[, locals]])`
Similar to `exec()`, but instead of executing an entire string, this function evaluates a single expression. It’s like using Python as a calculator except you can also use variables and functions in your expressions!

3) `compile(source, filename, ‘eval’)`
This function compiles the given source code into bytecode that can be executed with `exec()`. The main benefit of this approach is that it allows us to compile our Python code once and then execute it multiple times without having to re-parse or re-compile each time. Now, why you should avoid using these functions whenever possible:

1) Security risks by allowing arbitrary Python code to be executed at runtime, we open ourselves up to all sorts of security vulnerabilities.

If someone can inject malicious code into our program via `exec()` or `eval()`, they could potentially steal sensitive data, modify our system settings, or even take control of our entire computer!

2) Performance issues dynamic execution is generally slower than static compilation, since the interpreter has to parse and execute each line of code at runtime. This can lead to significant performance degradation in large programs that rely heavily on `exec()` or `eval()`.

3) Debugging challenges when we use these functions, it becomes much harder to debug our code. Since Python is interpreting the code dynamically, we don’t have access to all of the same tools and techniques that we would with static compilation (such as line numbers, syntax highlighting, or debugger support). So, what should you do instead? Well, if possible, try to avoid using `exec()` or `eval()` altogether.

Instead, consider writing your code in a more modular way breaking it down into smaller functions and modules that can be imported and executed separately. This will not only improve the security and performance of your program, but also make it much easier to debug and maintain over time! But if you absolutely must use `exec()` or `eval()`, here are a few tips for doing so safely:

1) Use them sparingly limit your usage of these functions to specific cases where they’re truly necessary. For example, you might use `eval()` to evaluate user input in a simple calculator program, but avoid using it in more complex applications that involve sensitive data or system settings.

2) Sanitize your inputs make sure any code that is executed dynamically has been properly sanitized and validated beforehand.

This can help prevent security vulnerabilities by ensuring that only trusted input is allowed to execute.

3) Use a whitelist approach instead of allowing arbitrary Python code to be executed, consider creating a list of approved functions or expressions that are safe to use in your program. This will give you more control over what gets executed and help prevent security vulnerabilities from being introduced accidentally.