Frameworks can help jump-start productivity on projects. But be careful. Relying too much on frameworks could also limit yourself in the long run.
Whenever the opportunity presents itself, programmers should carefully consider whether using a framework is beneficial. It may provide immediate benefits, but there should be no magic happening that isn’t understood by the programmer.
Years ago, I learned how to make websites with C#. I had help from many books, tutorials, and co-workers. With those resources I used the ASP.NET MVC 1 framework to build websites in a new way. However, while building my sample MVC sites, the code I wrote was there just because that’s how it was written in a tutorial somewhere. At the time, I had very little understanding of how the internals worked. I didn’t understand how routing worked, or how reflection worked, or how factories fit in, or anything about what a view engine did, or model binding. It was all just magic that I accepted and had faith in.
I was able to build a working website with C# and ASP.NET MVC, and I did it fairly quickly. It was certainly done faster than it would have been without the framework. This fact can’t be ignored. Learning a technology while achieving results is important for any beginner. The experience of finishing something is valuable for the sense of accomplishment and for the motivation to keep going. But, it’s important to understand that once a project is finished, the learning should not stop. Understanding the building blocks of any framework is the foundation for every solid programmer.
In my case, it was very important that I continued to build up my foundation of understanding. That’s because projects in the real world don’t just end like side projects could. They live on and they evolve. Real projects keep receiving feature requests. New requirements will appear. Technology will change. Eventually, the chosen framework might lose support, or might not keep up with requirements. When that happens, knowledge of how the framework functions is imperative. Without that knowledge, programmers are at the mercy of tutorial writers and the framework creators. But with a knowledgeable foundation, programmers are equipped to continue building and shipping their projects.
The bottom line is this: frameworks can be wielded much more effectively after the programmer understands enough of the language and design concepts so that the framework’s behavior isn’t magic anymore. Programmers equipped with such understanding will know where to look for seams in the execution pipeline, and they will be able to add customizations where appropriate.