Frameworks versus libraries

Pros

Less R&D is needed: A framework will solve a lot of problems, and you won't need as many libraries to get the work done.

Smaller learning curve: A library is typically easier to learn than a framework.

Better code quality: Since the framework has a prescribed way of doing things, you can follow the prescribed best practices and your code will attain a much better quality (than if you were to do things yourself).

Easier to fix library bugs: It might be easier to fix a bug in the library itself (because of the smaller codebase).

Uniformity in code: Different codebases written using the same framework are easier to understand. This is because they all will be following the same structure, patterns, and so on.

More flexible: Since you're choosing libraries, it might be easier to adapt those individual libraries to your needs.

Cons

Bigger learning curve: Depending on what a framework does, it can be big or small and the learning curve will be proportionately large or small.

More R&D is needed: Since you'll have to use many libraries to complete your task, you'll have to spend time and resources to research many different libraries.

Code complexity: The code will be more complex for anyone who hasn't learned the ways of the framework.

Code quality: Since you are using many different libraries, you might have to come up with ways to organize code. Consequently, the code quality might suffer (this is less of a problem for experienced developers).

Less flexible: Any task for which there is a prescribed way of doing things is easy to implement. However, it may prove to be difficult to implement tasks outside the purview of the framework.

Missing uniformity in code: Two developers using the same library might structure code in totally different ways. Alternatively, two codebases that use the same set of libraries might be structured in a totally different way. So, there are less chances of code uniformity between two different codebases.

Difficult to fix framework bugs: It might be difficult to fix bugs in the framework itself.

Learning curve: It might be easier to learn a library. However, if you are trying to replace a framework, chances are that you'll have to learn about various libraries. So, the learning curve might be higher than learning a single framework.