Learn to code (or do anything): top down, bottom up and other approaches
Learning to code is hard. Software engineering, the field we most commonly refer to when talking about ‘learning to code’, is based upon a foundation of computer science and applied mathematics. And while it is true that you don’t need to be a mathematician or a computer scientist in order to be a software engineer, the another truth is that learning even basic programming concepts is hard for most people. In this article we will explore a little bit of learning theory, and how we can apply it to those just getting started with learning how to code. I’ll lay out some of the advantages and disadvantages of concepts like the bottom up versus top down approaches to learning, as well as some alternatives that are worth considering. This content is aimed at newer programmers, but these concepts are applicable to anyone who is interested in learning more effectively, even if the topic isn’t programming.
I’ve been a professional programmer for over 7 years, and I started messing around with code way earlier. If there’s one thing that I can say confidently about this profession, it’s that the learning never stops, and it never gets any easier. Every time you master a difficult concept, you can be sure that another one is right around the corner. I spent a lot of my time early on reading obsessively about programming topics, mostly in the form of what shiny new framework was better than the old solution to the problem. I read about topics like whether or not I should use jQuery or MooTools for my next website project. Frequently felt way out of my depth, like there was no way I could possibly understand any significant part of the web development ecosystem (and this was before the explosion of front-end solutions). Thankfully for you, people like me exist, with just enough perspective to help you steer clear of pitfalls and time sinks that won’t help you effectively level up as a programmer.
So let’s dive right into it.
During my years as an undergrad, I skipped many night-outs to pick up Java hoping it would one day help me get ahead in…go.datadriveninvestor.com
The concepts of top down and bottom up processing have been applied to a number of disciplines, but the one we’re most interested in is how top down and bottom up can be applied to learning. The general definition of top down learning is a process that immerses the learner in the full context of the subject matter. Put another way: if you were someone who was interested in learning how to swim, and I was someone interested in employing the top down method, I’d throw you in to the pool. Conversely, the bottom up approach involves a process that is much more granular and theoretical. A bottom up approach to learning involves exposing the learner to the fundamental concepts of a subject matter in isolation. A bottom up approach to learning to swim would involve learning about fluid dynamics, anatomy and physics, but would not involve a pool.
The bottom up process of learning/teaching involves exposure to only the component parts of a particular subject matter, and slowly builds upon those components towards the whole. Learners using this approach only move on to the next component once the previous, prerequisite components have been mastered. For the most part, traditional public education (at least in the US) employs this approach.
The most obvious disadvantage to the bottom up approach is that a learner employing this method will lack any sort of useful context about the concepts they are learning about. This isolation leads to an inability to apply the learned concepts in any kind of meaningful way. If we return to the swimming example for a moment, it seems like common sense that no matter how much you learn about fluid dynamics, anatomy, and physics, if you never actually try to swim, then it follows that you won’t ever really be a good swimmer. This is also why you’ll almost never see any type of (good) modern programming resource that doesn’t include at least some type of practical portion.
A top down approach to learning embraces a macro-oriented, practical process that has the learner immersed in the subject matter. The priority for a top down approach is to provide a wider perspective of a problem or subject area, without necessarily going into detail about how specific components work together. A great example of top down learning applied to programming would be a situation where a new developer was given a project they needed to complete using an unfamiliar language or toolset. Instead of relying on a progression of mastery of isolated components, a top down approach instead lets the learner understand the individual parts by exploring and experimenting.
Advantages of top down
A top down approach to learning is particularly advantageous for some programming students because getting a chance to see how everything is working together is exciting. Personally, my interest in programming was sparked and maintained by resources that let me implement my own complete, (mostly) working projects. Initially this was messing around with making command line quizzes and adding functionality to games via scripts, but the common denominator here is that I probably wouldn’t have even bothered if the only way to learn was one step at a time. Besides providing an incentive to learn, a top down approach is practical. For many learners, the goal is to learn only what’s necessary to understand or implement a very specific concept. In this situation, a bottom up process would be overkill, and possibly even a waste of time.
Disadvantages of top down
Top down learning also comes with disadvantages. Generally, top down learning leaves the details to the student, which many times can result in a patchy understanding of a concept. Learners may grasp enough to just “get it to work”, with no motivation or clear path to understanding how the foundational components are working together. When I was writing my first command line quizzes, I had no understanding of the differences between primitive values like Strings and Numbers, so I was quite perplexed when statements like
1 + "1" resulted in
Although both the top down and bottom up approaches have their own merits, I believe that like many things, a simple dichotomy doesn’t represent all of the viable options. It’s a little cliché to say, but I really do think the best approach lies somewhere in the middle.
In my experience, there are two types of situations that almost never work out when trying to learn a new programming concept:
Some of you have probably already been here. You get excited to learn about the latest and greatest in Single Page Apps/Machine Learning/Augmented Reality/Blockchain Game Development, so you dive right in to a 32-part YouTube series on how to build your own. By video 4, you’ve entered territory you didn’t even know existed, and convinced yourself you must be the worst developer ever. This is not a productive way to learn, and it showcases some of the nasty downsides of a top down process. Put another way, sometimes total immersion and full context can be overwhelming.
In my experience, ‘the lengthy tutorial’ almost always leads to the other of the two bad learning situations: the comprehensive resource. After you’ve convinced yourself that you don’t know enough to make your great new idea, the only feasible solution is to find the most comprehensive resource available on the subject, and try and slog through it in order to better understand the subject and ultimately build your Single Page App/Machine Learning Algorithm/Augmented Reality Thing/Blockchain Game. However, the comprehensive resource isn’t exciting, and so after the first few chapters you put it down and then never again revisit the subject. This is a great example of how bottom up learning can let you down. Simply put, sometimes the regimented, step-by-step process can be a boring way to learn things.
Build small things every day
I think the solution comes in two parts. First, learning a new programming concept should involve coming up with the smallest possible practical application of that concept. For a developer trying to learn a new language, this might be a command line ‘choose your own adventure’, or an implementation of a simple game in the browser. Once you have a small, achievable goal in mind, learn the bare minimum of what you need to in order to implement that application, but work to master those concepts. If I’m building a ‘choose your own adventure’, then I’ll probably really need to dig in to standard inputs, standard outputs, and simple control flow in the language I’m learning. Ideally, these types of small projects will be something you can complete in a day. That way, you never struggle for too long on a concept, and you continually will incentivize yourself to come up with new projects by the small successes you make on a shorter timeline.
In this article, we explored the concepts of the top down and bottom up approaches to learning/teaching. We also touched on the idea of building small things frequently, in order to navigate around the pitfalls of high complexity and boredom to keep you excited about learning new things.
If you found this article helpful, please consider sharing it with others. If you didn’t, I’d love to know why, and maybe hear your thoughts on what other processes should be considered when learning on your own.
Feel free to follow or tweet at me @tindleaj
Thanks for reading.
Originally published at tndl.io on December 13, 2018.