All right so let's try to summarize what we've learned about the facade design pattern So essentially
you build a facade to provide a simplified API over a set of classes or indeed if you want to take a
bigger a set of subsystems.
It doesn't matter how you scale it because the idea is still the same.
You just provide a nice API for people to use.
You may wish at some point to optionally expose the internals of your subsystem through the interface
of the facade.
And this is typically done for the power uses.
So for example you have some people which are happy with a superficial interface but some people say
well you know this isn't really that hard to figure out.
Why don't you give me more control so I can do a lot more I can do very kind of micro optimizations
inside the system and in this case yeah you can expose more in-depth API so you can give a chunk of
API which are High-Level like console right line for example and you can give the API which are low
level like for example you can expose the console buffer and let people manipulate that.
Yeah it can lead to unpredictable results but this is where you kind of issue a warning that you got
to be careful with what you're doing and with great power comes great responsibility and all that.
So we may allow users to actually escalate to use the more complex API if indeed that is what they need
to do.