The kitchen sink comes from the conflict between the C ideology C++ inherited, and the requirement for OO language features. RTTI and exceptions are fine when you can rely on them, but C++ users don't always want to pay for those features, so you end up with some libraries that require them, others that forbid them, and some in between which reinvented their own exceptions and RTTI mechanisms. Trying to glue all these disparate things together where there's so little accepted as being in common is a pain.
Languages built around platforms, like Java and C#, on the other hand, can assume that java.lang.Object / System.Object is the root of the inheritance hierarchy, that exceptions are used throughout for error handling, that reflection is available throughout (modulo security concerns), etc. The fact that you can rely on the base library, and that you can communicate between modules using containers / common interfaces in the box makes the job of integrating modules far easier.
C++ included some of these features, but didn't make them mandatory. So you end up with a strange mix across the board.
The other issue is that C++'s features aren't well thought out in an orthogonal sense. One example: the idea of exception safety doesn't mesh well with C++'s copy constructors, to the degree that you can't write a generic stack type whose pop method returns the value popped, because you can't get exception safety right on the mutation to the stack if the copy constructor on the returned value threw an exception.
Languages built around platforms, like Java and C#, on the other hand, can assume that java.lang.Object / System.Object is the root of the inheritance hierarchy, that exceptions are used throughout for error handling, that reflection is available throughout (modulo security concerns), etc. The fact that you can rely on the base library, and that you can communicate between modules using containers / common interfaces in the box makes the job of integrating modules far easier.
C++ included some of these features, but didn't make them mandatory. So you end up with a strange mix across the board.
The other issue is that C++'s features aren't well thought out in an orthogonal sense. One example: the idea of exception safety doesn't mesh well with C++'s copy constructors, to the degree that you can't write a generic stack type whose pop method returns the value popped, because you can't get exception safety right on the mutation to the stack if the copy constructor on the returned value threw an exception.