Frameworks versus libraries

You have two choices to aid your development efforts—either choose a framework like Rails or AngularJS or choose smaller libraries. The Clojure community (in general) dislikes frameworks, so there wasn't a full-fledged web framework such as Rails in the Clojure landscape for long. Let's look at the pros and cons of choosing one over the other:

Frameworks	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.