Scott Young has recently been writing about a concept he calls ultralearning, a philosophy and collection of techniques for quickly gaining mastery of a subject. This week, I’m going to explore how we can use ultralearning techniques for competitive programming practice.
What is Ultralearning?
In How is Ultralearning Different?, Scott distinguishes ultralearning from other learning techniques he writes about, such as self-education, rapid learning, active learning, and efficient studying. Although it’s related to these techniques and practices, ultralearning is distinguished by two characteristics:
- The student is in the driver’s seat
The first principle of ultralearning is that the student is responsible for their learning results. They are empowered to choose the resources, techniques, and schedule that allows them to meet their learning goals. With ultralearning, ineffective teaching or poorly-written textbooks are not an excuse for failing to learn a subject, especially given the resources that are now available for free on the Internet.
Although self-education is most compatible with ultralearning because of the flexibility it affords, it’s also possible to ultralearn a standard college class. You just have to be willing to find your own resources and techniques if the class syllabus doesn’t work for you.
- It’s an intense process
The goal of ultralearning is to achieve deep understanding of a subject. The way you accomplish this is by targeting the hardest concepts in the subject as soon as you can. For technical subjects, this means working on problems at the limit of your ability, rather than spending time reviewing those that you’re already good at.
To maintain an intense focus on hard concepts, ultralearning demands more effort and discipline than traditional learning techniques. As a result, it requires a concrete learning plan, not just a vague goal. Because ultralearning is intense, there’s more risk that you’ll get off track and revert back to some other learning process. This makes it essential to use some kind of productivity system.
How to Ultralearn Competitive Programming
To qualify as ultralearning, a competitive programming learning process needs to embrace the two characteristics in the previous section. First, it needs to be mainly self-directed, meaning that each learner is responsible for their own results. This is more common in competitive programming than in a traditional computer science curriculum, since not every student who is interested in competitive programming has access to a team and a coach. But even for those who do, the ultralearning philosophy encourages each person to find the resources and techniques that enable them to do their best.
For competitive programming, the second fundamental principal of ultralearning tells you to study problems at the limit of your ability. Although reinforcing concepts that you already know can be useful, that needs to be combined with a commitment to learning new problem types and harder versions of existing problem types. As you work on solving your first thousand problems, make sure most of them are pushing you forward.
In addition to these fundamentals, an ultralearning project can benefit from learning principles and techniques that are common to other effective learning methodologies. In his articles on ultralearning, Scott covers a number of these. Let’s see how we can apply two of them to competitive programming practice.
Principles First, Details Later
One of the main goals of competitive programming practice is to become familiar with the standard problem types. Since it’s hard to think of completely unique problems, problem setters tend to repeatedly come back to the same themes. If you get familiar with most of these, your job in solving a new problem is reduced to figuring out how it differs from those you have seen before, and how you can adapt a solution you already know.
This description might make it seem like the best approach is to grab a book like CP3, find solutions to the starred problems, and try to memorize them. Ultralearning principles say that this is unlikely to be a successful strategy. Even if you could somehow memorize the solutions (which would be a hard enough task in itself), you’re not going to encounter exact copies of the problems you have learned in that fashion.
Instead, the best approach is to fully understand each problem type. The first step in this process is to try to solve the problem yourself. Once you have solved it, or have spent enough time working on a solution, you can study someone else’s solution using ultralearning techniques. The goal is not just to know the solution to this particular problem type, but to know why it works, how you might have found it yourself, and how it is related to similar solutions.
Since ultralearning is student-driven, it relies on the student having some meta learning skills. One such skill is the ability to recognize when one is lacking prerequisite knowledge. Ultralearning handles missing prerequisites by encouraging recursively learning: if a concept is too difficult, figure out what concept you would need to learn to make it easier. If that concept is also too difficult, find something that would make that one easier. Repeat until you reach a concept that you have already mastered.
Recursive learning is essential in cases where you’re building your own curriculum, since there’s no one other than you to assemble the appropriate prerequisites. But it can be useful in traditional learning as well, since it’s impossible for an instructor to target a class perfectly for every student. The instructor can suggest general prerequisites (such as other classes), but even students who took the same sequence of classes will have different levels of skill based on how well they learned the prerequisites.
For competitive programming, a problem classifier like uHunt takes care of some of the prerequisite research. If you’re working on a problem from the dynamic programming section, you know you’ll have to read up on that technique if you aren’t already familiar with it.
But even a classified problem depends on a collection of prior knowledge besides the main algorithm or technique that it’s designed to test. For example: programming language fluency, mathematical thinking skills, and general problem-solving ability. Every problem is an opportunity to expose weaknesses in these areas, and find the appropriate resources to strengthen them.
Scott’s description of ultralearning (see the Sources section below) emphasizes a few things:
- Well-known learning principles like spaced repetition and the value of problem-solving practice for learning technical subjects.
- Taking control of your own learning plan, and using compressed learning timelines to learn more in less time.
- Case studies of ultralearning in action. For our purposes, the most relevant of these is the MIT Challenge, which covers computer science topics.
There are plenty of books and courses on study skills, and they cover some of the same techniques used in ultralearning. However, I like that the ultralearning system is being actively developed and tested on real learning projects, and that it has proven itself for math and computer science topics.
Here are some resources on ultralearning.
History: Articles from 2012.
- What You Know Matters More Than What You Do: Cal Newport’s “Ultra-Learning Hypothesis”: regularly mastering new problem-solving techniques is the key to making an impact in your field.
- You Know What You Write: The Textbook Method for Ultra-Learning: Writing your own “textbook” on a subject is a way to ensure that you really understand it.
- Mastering Linear Algebra in 10 Days: Astounding Experiments in Ultra-Learning: A comprehensive guest post from Scott Young, with details on how he approached the MIT Challenge. It covers his ideas on ultralearning from a few years ago.
The 2016 ultralearning series: Scott’s recent articles on the topic.
- If You Had 15 Days to Learn Calculus, How Would You Do It?: Even when you’re under a tight deadline, it’s more effective to learn fundamental principles than to try to memorize details.
- Ultralearning Case Study: Learning Cognitive Science: A report on Scott’s current ultralearning project.
- How to Start Your Own Ultralearning Project (Parts One and Two): Details on setting up a project using this model.
- How is Ultralearning Different?: See my “What is Ultralearning?” section above.
A short ebook: Ultralearning Manifesto: 7 Must-Know Strategies to Learn Anything Faster by Scott Young
- To get a copy, visit Scott’s blog and look for the pop-up. If you already cancelled the pop-up, visiting in your browser’s private mode should do the trick. The book contains a few more details on ultralearning.
(Image credit: Steven S.)