Boost Your Coding Interview Skills With an Effective Study Plan
- What You’ll Learn:
- Step One: Build a Process, Not a Portfolio
- Step Two: Use Spaced Repetition to Engage Your Long-Term Memory
- How to Use Spaced Repetition in Your Coding Interview Study Plan
- Step Three: Practice Getting Stuck
- Step Four: Apply the Concept to a Project
- Following up With Concrete Applications After Your Interview
- Key Takeaways
- About the Author
Are you preparing for a coding interview — and feeling overwhelmed by the prospect of showcasing your programming skills under pressure? Don’t worry, you aren’t alone. Most candidates find technical interviews uncomfortable. After all, coding under pressure is nothing like working on your personal projects.
But the good news is that with a well-designed study plan, you can prepare yourself to demonstrate your unique value to a company, even with standardized coding challenges. In this article, you’ll learn how to create a study plan that maximizes your chances of acing your technical interview and landing your dream job.
Don’t just study; study effectively. Image by Bing Image Creator
What You’ll Learn:
- Your real goal when preparing for a coding interview.
- How to use spaced repetition to internalize the skills you’ll need for the technical interview.
- Tips to effectively prepare for things to go wrong — or too right!
In the following sections, you’ll explore how to create a study plan that helps you remember all of those design systems and algorithms you’re studying and prepares you to shine in your coding interview.
Step One: Build a Process, Not a Portfolio
Performing well in a coding interview isn’t about collecting the biggest list of LeetCode challenges; nobody cares about the 327 challenges you completed while you practiced. They only care how you perform during the 328h challenge — at the interview.
When you’re working on the endless series of data structures and algorithms listed for the hot tech companies you’re applying for, your focus should be on developing a repeatable, sustainable process for approaching the problems you’ll tackle for that company.
Everyone has their own way of doing things, but most successful processes include these key elements:
- Defining the constraints of the problem: “What can I assume about my inputs?”
- Clarifying how you’ll handle edge cases: “What should I return as the maximum element if I’m given an empty array?”
- Using pseudo-code to define the logical steps of the problem.
- Identifying possible helper functions to break the process down into more concrete steps.
- Testing your code after writing X number of lines.
Companies don’t want to know that you can reverse a binary tree; they want to present you with challenges that force you to reach into your mental toolkit and pull out all your finest problem-solving techniques. And that’s why binary trees are on the list: They are simple to explain and have difficult-to-implement methods readily available.
Your goal for each code challenge isn’t to get to the right answer as quickly as possible. It’s to demonstrate that you have a process for defining and solving code challenges, as well as how you think about optimizing performance once you have a working solution.
Remember, while practicing for code challenge interviews, always remember your goal is perfecting your problem-solving process until it becomes second nature.
Step Two: Use Spaced Repetition to Engage Your Long-Term Memory
Have you ever sat down to take a test feeling pretty confident… and then blanked as soon as you saw the first problem? It’s a common and confusing experience caused by failing to transfer the information you learned from short-term to long-term memory. And sadly, many learning strategies do nothing to prevent this from happening.
Spaced repetition helps you remember what you learn long-term. Image by Bing Image Creator
It’s natural to organize your study plan according to the most common data structures and algorithms, then tackle them one at a time. You devote one week to sorts, the next to graphs, and so on. After all, that’s how most learning experiences are organized.
However, learning science could not be clearer that this is the wrong way to go.
Say you’re working with binary trees, for example. It’s typical to write the basics of the structure one time. You might copy and paste what you’ve already written between challenges, or just keep writing each new challenge in the same file. Once you’ve gotten through the binary trees section of your study plan, you move on to more interesting and engaging challenges.
What you end up with is a castle made of sand. You’ve only done each part once; as time goes by, the memory fades. You move on to other structures and other algorithms, and eventually, you’ll lose most of what you learned through disuse.
When you’re actually working on the challenges, it’s easy to remember what you need to do because it’s all in short-term memory.
But if you’ve never needed to recall the answers after briefly forgetting them for a while, then the first time you’ll search your brain for them will be during the interview itself: the highest-stress environment possible!
Instead, you need to practice your skills by giving yourself time between challenges to forget, then reconstruct the knowledge. That’s called spaced repetition.
Spaced repetition might feel harder and more frustrating, but it’s the most scientifically effective way to add new skills and knowledge to your long-term memory.
How to Use Spaced Repetition in Your Coding Interview Study Plan
To use spaced repetition, avoid going deep into one topic and then moving on. Instead, move from topic to topic in a semi-programmed sequence to give yourself time away from each subject before revisiting it.
Spaced repetition is a delicate balancing act of waiting long enough between iterations for your knowledge of each subject to slip from your short-term memory, but not so long that your memory of the topic is completely gone.
Each time you recall the subject matter successfully, you can increase the amount of time until your next repetition. Your first repetition of a concept should be relatively soon after you’ve just learned it. You then reschedule your next repetition sooner or later, depending on how well you did. If you nail a problem three times in a row, then you won’t need a fourth repetition for a while.
If this sounds complicated, don’t worry; there are plenty of apps to help, though most of them take the form of flashcards and specific questions rather than families of questions like “binary tree problems” or “searching algorithms.”
Alternatively, you could develop your own system with sticky notes and columns for how frequently you want to review a given problem type, along with room to note your last encounter with the challenge.
For example, set up on a whiteboard columns for “daily,” “every three days,” “weekly,” and “bi-weekly” review sessions. Each topic gets its own sticky note. If you get the problem right, move the sticky note from the “daily” column to the “every three days” column. If you get it wrong, slide it back into a more frequent column or keep it where it is.