I did pull 193 (about JController::factory) and 194 (componentHelper)
https://github.com/joomla/joomla-cms/pull/193 and
https://github.com/joomla/joomla-cms/pull/194 if you want to take a look.

The real issue with com_media is from line 43 to 75 of media.php:

$cmd    = JRequest::getCmd('task', null);

if (strpos($cmd, '.') != false) {
[...]

// Set the name for the controller and instantiate it
$controllerClass = 'MediaController'.ucfirst($controllerName);

if (class_exists($controllerClass)) {
    $controller = new $controllerClass();

else {
    JError::raiseError(500, JText::_('JERROR_INVALID_CONTROLLER_CLASS'));

because it does exactly what the new renderComponent would do. It is about
simplifying it rather than recoding it, but before moving forward with all
the libraries I'd like to hear if the pulls I did on GitHub are in the
right direction.

I'm stuck in those two issues:

1) do we want to mantain both com_example/example.php and
com_example/controller.php files? Should we decide to merge it in one
single file? (controller.php? example.php, which would be the standard one?)
2) for the components that do other stuff, where do we want to put it? In
the base file as they are now, they would be loaded so it is not an issue
to "leave them there". But looking forward, let's try to find a better
place.

There are two kinds of stuff that could be done at startup, the general
bootstrapping (such as defining constants) which should be done only once
and maybe called statically, and an init() for (for example) checking if
the user is authorized, which should be more associated with execute than
to __construct().

Four options come to my mind:
       a) create hooks inside JController (onBootstrap, onBeforeFactory and
onAfterFactory, onBeforeExecute and onAfterExecute)
       b) similar to the previous one, leave people free to overload the
factory and __construct methods without creating a hook  (function
factory(..) { /* ... do your stufff */ $instance = parent::factory(); /* do
other stuff */ }
       c) create a init() method to be called right after __construct(); so
that if I want to just set a couple of variable, I can just define this
init() function
       d) create a static bootstrap() method to be called once by factory()
or by construct()

The more we add methods, the less clear the code will be to understand and
to extend/change so we must be careful. Point c can be just done
overloading __construct() and point d by overloading factory and
contructor, but init and bootstrap are quite easy to remember and I don't
see them as big issues.

I have no clue on what could be the best option...