In short: libraries are the vehicle for delivering the power of any programming language into the hands of its everyday users.
In today’s professional software development world, it can be hard to make the case for long-term investment in reusable code. Programmers are (often rightly) expected to do the simplest thing that could possibly work, under the assumption that generalization won’t be needed. As the problems we need to solve become more complex, however, we need reusable library components that can help us keep our solutions simple.
Most software projects integrate diverse infrastructure technologies addressing domains such as concurrency, graphics, communication, databases, etc., to solve problems in some more-specialized domain (such as financial analysis, animation, or circuit simulation).
The most effective programming teams get their infrastructure in the form of libraries with high-level abstractions and expressive interfaces, allowing them to focus on their own problem domains with power and confidence.
Great application programmers quickly absorb their organization’s ideas and proprietary knowledge, develop experience and deep insight into the application domain, and bring that experience and insight to bear on the project.
The best way to capitalize on those talents is to keep developers focused on programming that directly expresses those skills.
Library authors gain deep expertise in their problem domain, too, but because they serve many users and applications, their view is broad as well as deep. That breadth is crucial: it yields flexible designs that better accommodate your evolving application requirements. As a result, your application’s infrastructure is more stable over time, avoiding the high cost of redesigning fundamental interfaces when the application’s requirements evolve.
Finally, the best libraries actually change the way we program. In the same way that C++ abstractions like classes make better code possible, powerful library abstractions dramatically improve the cleanliness, expressiveness, and maintainability of code that uses them. Any developer who discovered the C++ Standard Template Library (STL) after working with hand-rolled collection and algorithm libraries has experienced the effect firsthand.