Learning, Unlearning and ASP.NET
"The illiterate of the 21st century will not be those who cannot read and
write, but those who cannot learn, unlearn, and relearn."
~ Alvin Toffler
I am sure, you all will agree wholeheartedly with the above quote. Software industry
is one of the most dynamic industries to work with. Everyday something new comes
up and you have no option but to learn it to be in the race. While learning is a
commonly acquired skill by software developers, not many can acquire the
unlearning abilities. My experience of training software developers tells me
that this skill - unlearning - can dramatically affect your experience with a
technology or tool you are learning. Let me tell you how...
As a software developer we always try to apply our knowledge of the
existing skillset to the new skills being learned. In fact, not just software
development we do this in many spheres of life. We use our past
experiences while dealing with the new things. While this may sound quite natural
process, this may not be always the best thing to do. That's because by doing so we are allowing
our past experiences and biases to control our future experiences.
Based on our
past experiences we form a set of expectations that are often rigid and biased.
In the process we might be rejecting or ignoring new approaches to deal with a
situation. It's like this - if a stranger robs us of our valuables we learn to deal with
extreme caution with all the strangers, overlooking the possibility that at least
some of them can be friendly and good.
Exactly the same thing happens
when we learn a new programming framework or tool with a mind full of
expectations born out of our past experiences. In the process we may fail to
enjoy the new learning experience and may even fail to put the new framework to its best possible use. Since our
programming habits are often formed by programming frameworks we used in the
past, the new (and good) approaches provided by the new framework to solve a
remain underutilized or even used wrongly.
That's why learning a new programming
framework with an open mind free of rigid expectations is important. This
requires unlearning - letting go what we learned in the past - and then taking a
look at the new framework with a fresh mind. So, unlearning involves
"forgetting" a piece of knowledge or experiences (at least temporarily). And
unlearning is done for the sake of learning something new in a better way, Or to
simplify your developer's life by discarding knowledge / experiences that are no longer
I often come across developers who know ASP.NET Web Forms and want to learn
MVC. When they are learning MVC, many of them make the same mistake - they learn
MVC with Web Forms sitting at the back of their mind. This actually hinders
their new learning experience because every now and then they keep comparing -
"In Web Forms it is this way, in MVC it is that way...". My experience is that
those who can't "forget" the Web Forms programming model while using MVC often
introduce the following mistakes in their MVC applications:
- Fat views (because just like web forms they try to stuff too much in one
- Too much branching in the view.
- Too much logic and branching in the controllers. While controllers are
analogous to Web Form code-behind they are not the same!
- Passing too much data using ViewData or ViewBag
- Thinking constantly in terms of Views while developing the application
(Web Forms development is often too much UI centric)
So, watch out your MVC applications for these kind of mistakes. Chances are
they are the result of you "porting" your Web Forms knowledge as it is on the
MVC framework and trying to replicate the approach you used in Web Forms.
Web Forms developers wanting to learn MVC should learn it keeping this in
mind - Don't learn MVC with the same set of rigid experiences of Web Forms.
Learn it as a new (and better) tool to program for the web. Try to understand
why some things in MVC are designed in the way they are. And also see why some
features of Web Forms are totally missing from MVC.
Nobody knows for sure how web development world will shape up, say,
5-10 years from now. Even software vendors need to keep a watch on changing
industry trends and then mould their frameworks or develop new ones. At
the same time, as a developers we all need to absorb the new happenings and
trends with an open mind, without influencing the new knowledge and
possibilities with the biases from our past knowledge. While learning new
technologies some developers find the task quite easy whereas many other find it
too daunting. If you cultivate the habit of unlearning while learning
new technologies you can prepare yourself in a better way than before. Once a
new technology is mastered you can then reflect at it using your past learning
(if at all required).
However, this should be done in attempt to enrich your experience with the new
technology and not to fallback on the older way of developing applications.
That's it for now. Keep unlearning :-)