Have you ever heard a classically-trained musician practice?

For years, I roomed with a classically-trained clarinetist. I quickly learned I wasn't going to hear complete pieces very often. More often than not, our apartment was filled with hours of scales and short bits of a piece he was learning, played at different tempos.

It reminded me of the endless hours I spent drilling basketball fundamentals when I was growing up. Whether it was practicing dribbling or my free throw form, I spent dozens of hours in my driveway developing skills for every hour I spent at a team practice. And even at team practice, we would typically only spend a small fraction of each practice scrimmaging.

Fast forward to today, and I'm still talking about practice and how to do it better.

Only now, I'm talking about how to practice software development skills.

Our team has been discussing the book Practice Perfect: 42 Rules for Getting Better at Getting Better by Doug Lemov, Erica Woolway, and Katie Yezzi. The book offers a helpful framework for understanding how to improve skills through deliberate and structured practice. And the framework mirrors how we structure practice projects for curricular.dev.

This post is part 2 of our series on Practice Perfect. In part 1, we looked at the overall Practice Perfect framework and how it applies to developing software development skills. In this post, we’re looking at how different types of practice — like drilling, scrimmaging, and reflecting — serve distinct purposes in your learning journey. By understanding and applying these practice styles effectively, you can really up your software development game.

Drilling involves deliberate repetition of a specific skill to perfect it.


Drilling is all about repeating a specific skill until it becomes second nature. It's great for focusing intensely on one aspect of your work without the distractions of a full task.

In sports, an example would be practicing dribbling. If you were training to be a chef, you would practice chopping or slicing vegetables.

How to Apply Drilling in Software Development:

Scrimmaging involves applying skills in a brief simulated real world experience.


Scrimmaging simulates real-world conditions and helps integrate various skills in a setting that mimics actual performance environments. It's about putting skills together under conditions similar to what you’ll face in the real world.

In sports, a scrimmage is a short, informal practice game. I mentioned earlier that when I was younger and played basketball, we would typically end an hour-long practice by scrimmaging for a few minutes, putting together what we practiced into a game-like situation.

How to Apply Scrimmaging in Software Development:

Integrating Drilling and Scrimmaging

To maximize learning in software development, it’s beneficial to integrate both drilling and scrimmaging:

  1. Start with Drilling: Begin by isolating and practicing specific skills through drills until you feel confident.
  2. Move to Scrimmaging: Once you're comfortable with individual elements, start putting them together through project work and other scrimmage-like practices where you can apply what you’ve drilled in a more integrated way.
  3. Feedback Loop: Use feedback from scrimmaging to identify areas that need more drilling. This continuous loop helps refine skills and integrate them into your broader capabilities.

By effectively alternating between drilling for skill refinement and scrimmaging for contextual application, you can develop a strong, practical skill set in software development, preparing you well for professional challenges.

Beyond drilling and scrimmaging, another valuable form of practice you should include in your learning is reflective practice. Reflective practice is a more introspective method that involves critically thinking about your own learning and projects, identifying lessons and areas for improvement, and planning how to enhance your skills and work processes. It’s super useful for deepening your understanding of your technical skills and problem-solving approaches in software development.

How to Implement Reflective Practice in Software Development

  1. Code Review and Analysis
    • After finishing a project or a significant piece of code, review your work critically. Look for bugs, but also look for potential improvements in efficiency, readability, and scalability.
    • Ask yourself: Could this code be more efficient? Is there a cleaner way to implement this function? What would I do differently next time?
  2. Maintain a Developer Journal
    • Keep a development journal where you jot down the challenges you face, the solutions you implement, and the outcomes of your projects.
    • Use this journal to reflect on what you’ve learned from each experience and to set goals for what you want to learn or improve next.
    • This is one of the central activities we encourage as part of submitting a project solution on curricular.dev. We ask you to reflect on what you did well, which parts of the process were most challenging, and consider ways you could improve your code with a rewrite.
  3. Peer Feedback
    • Regularly engage with peers or mentors to get feedback on your code and projects. This feedback can provide new perspectives and insights that you might not have considered on your own.
    • Use the feedback to reflect on your approaches and consider alternative methods or strategies.
  4. Post-Mortems
    • After completing a project, especially a larger one, conduct a post-mortem analysis where you and any team members discuss what went well and what didn’t.
    • Focus on extracting actionable insights that can improve future projects.
  5. Study and Reflect on Industry Trends and Case Studies
    • Regularly read about new technologies, tools, and best practices in software development. Reflect on how these could be integrated into your own work.
    • Analyze case studies from other projects or companies to understand different problem-solving approaches and outcomes.

Benefits of Reflective Practice

Reflective practice helps you:

Integrating reflective practice into your learning routine complements drilling and scrimmaging by providing a broader, more holistic approach to your development as a software professional.

This triad of practices—drilling, scrimmaging, and reflecting—ensures that you not only practice and apply your skills but also continuously refine and adapt them based on insightful retrospection.


Looking for practice opportunities? Check out our practice projects, which help you follow these principles by targeting specific skills on real world projects. Most of our projects are available for free, so get started today.

Images courtesy Mira Kireeva https://unsplash.com/@solarfri