When You Create Software to Learn Programming, Your Most Important User Is You

Learning to code is a challenging but rewarding endeavor. As a beginner, it‘s easy to get overwhelmed by the sheer amount of information to absorb – syntax, data structures, algorithms, design patterns, best practices, and more. Amidst all the tutorials, textbooks, and toy problems, one of the most effective ways to cement your programming knowledge is to build real software for yourself.

The Power of Personal Projects

According to a 2019 Stack Overflow survey, over 80% of developers said they code as a hobby. Of those, 91% work on personal projects, with the majority (63%) spending between 1-10 hours per week on their hobby projects. Interestingly, developers who work on personal projects reported higher levels of job satisfaction compared to those who don‘t (78% vs. 72%).

What is it about personal projects that makes them so compelling and beneficial for programmers? For one, they provide an intrinsic motivation boost. When you‘re working on something of your own choosing, tailored to your specific interests and needs, the drive to see it through to completion is much stronger. You‘re not just learning abstract concepts, but applying them to solve a concrete problem or create a tool you‘ll actually use.

As legendary programmer Abelson Sussman put it in the preface to "Structure and Interpretation of Computer Programs":

Our design of this introductory computer-science subject reflects two major concerns. First, we want to establish the idea that a computer language is not just a way of getting a computer to perform operations but rather that it is a novel formal medium for expressing ideas about methodology. Thus, programs must be written for people to read, and only incidentally for machines to execute. Second, we believe that the essential material to be addressed by a subject at this level is not the syntax of particular programming-language constructs, nor clever algorithms for computing particular functions efficiently, nor even the mathematical analysis of algorithms and the foundations of computing, but rather the techniques used to control the intellectual complexity of large software systems.

Building personal projects is the perfect way to engage with both of these concerns. You‘re not just learning to code, but learning to think computationally and express your ideas in a new medium. At the same time, you‘re grappling with the inherent complexity of software development, even on a small scale. Every decision you make – how to structure your data, what libraries to use, how to organize your code – is an opportunity to learn and grow as a programmer.

Full-Stack Skills, Full-Cycle Motivation

As a full-stack developer, I‘ve found that personal projects are an ideal way to sharpen skills across the entire web development spectrum. Building a web app from scratch forces you to think through the entire stack, from the user interface to the server-side logic to the database schema. You get hands-on experience with:

• Frontend development: Creating the user interface, laying out components, handling user interactions and events, and connecting to backend APIs. Technologies like HTML, CSS, JavaScript, and frontend frameworks like React come into play here.

• Backend development: Designing the server-side architecture, creating routes and controllers, integrating with databases, and exposing data through APIs. Backend languages like Python, Ruby, or JavaScript (Node.js) are commonly used, along with frameworks like Django, Rails, or Express.

• Databases: Choosing a database system (relational vs. non-relational), designing schemas and data models, optimizing queries, and ensuring data integrity. Relational databases like PostgreSQL or MySQL and NoSQL databases like MongoDB are popular choices.

• APIs: Designing RESTful interfaces, handling authentication and authorization, versioning, documentation, and best practices for building and consuming APIs.

• Deployment and DevOps: Deploying applications to production environments, managing servers and infrastructure, scaling and performance optimization, and build/deployment automation. Tools like Heroku, AWS, Docker, and CI/CD pipelines come into play.

By wearing all these hats and seeing a project through from ideation to deployment, you gain a holistic understanding of the web development process. The experience of building something from nothing is incredibly empowering and gives you a newfound appreciation for the craft of software engineering.

Peter Norvig, co-author of the influential "Artificial Intelligence: A Modern Approach", emphasizes the importance of this kind of holistic, project-based learning:

I think the best way to become a good programmer is to write a lot of code, read a lot of code, and learn from your mistakes. Work on projects that interest you, with people that you like and respect. Contribute to open source projects. Build something cool that other people can use.

The Virtuous Cycle of Coding for Fun

Another key benefit of personal projects is that they create a virtuous cycle of learning and creating. The more you build, the more you learn. The more you learn, the more inspired you are to build. It‘s a positive feedback loop that fuels continuous growth and improvement.

In contrast, learning to code without a creative outlet can quickly become tedious and demotivating. You may be able to memorize syntax and algorithms, but without applying that knowledge in a meaningful way, it‘s easy to lose steam. Personal projects provide a sandbox for experimentation and play, where you can try new things, take risks, and learn from your failures in a low-stakes environment.

This idea of "learning by doing" is a core tenet of constructionism, a learning theory pioneered by mathematician and computer scientist Seymour Papert. Papert argued that the most effective learning happens when learners are actively engaged in constructing mental models and public entities:

Constructionism—the N word as opposed to the V word— shares constructivism‘s connotation of learning as "building knowledge structures" irrespective of the circumstances of the learning. It then adds the idea that this happens especially felicitously in a context where the learner is consciously engaged in constructing a public entity, whether it‘s a sand castle on the beach or a theory of the universe.

In the context of learning to code, your "public entities" are the software projects you create and share with the world. Every app, script, or website you build is a tangible manifestation of your growing knowledge and skills. The more you create, the more you internalize the concepts and techniques you‘re learning.

Collaborating with Your Future Self

One potential downside of focusing too heavily on personal projects is that you may miss out on the benefits of collaboration and teamwork. After all, most professional software development happens in teams, with multiple developers working together on a shared codebase.

However, I would argue that even solo projects involve collaboration – with your future self! As you revisit and refactor code you wrote days, weeks, or months ago, you‘re essentially collaborating with a past version of yourself. You may look back on certain design decisions and wonder "what was I thinking?", prompting you to rewrite or refactor.

This process of self-review and iteration is a valuable skill in itself. It trains you to write code with maintainability and scalability in mind, as if you were writing it for someone else (or your future self) to read and understand. It also gives you practice in reading and navigating unfamiliar codebases, since even your own code can seem foreign after enough time has passed.

In the wise words of Hal Abelson:

Programs must be written for people to read, and only incidentally for machines to execute.

By writing code for your future self to read and collaborate with, you‘re developing habits and practices that will serve you well in a professional context.

Building in Public and Contributing to Open Source

Personal projects can also be a stepping stone to contributing to open source software and building a public portfolio of work. Many successful open source projects started as personal projects that the creator decided to share with the world.

By open sourcing your personal projects, you create opportunities for collaboration and feedback from the wider developer community. You may find that others are interested in your work and willing to contribute bug fixes, new features, or documentation. This can be a great way to learn from more experienced developers and give back to the community at the same time.

Contributing to open source projects, whether your own or others‘, is also a fantastic way to build a public portfolio of work. Potential employers can see the code you‘ve written, the issues you‘ve tackled, and the contributions you‘ve made. This can be a major asset when applying for jobs or freelance gigs, as it demonstrates your skills and experience in a concrete way.

As GitHub co-founder Tom Preston-Werner put it:

If you‘re a developer, the best way to learn is by contributing to open source projects. Not only will you get real-world experience, but you‘ll also build a public portfolio that you can show to potential employers. It‘s a win-win.

The Mental Health Benefits of Coding for Fun

Finally, it‘s worth noting the mental health benefits of having a creative outlet like programming. Building software for yourself, without the pressure of deadlines or external stakeholders, can be a deeply fulfilling and rewarding experience. It‘s a chance to enter a state of flow, where you‘re fully immersed in the challenge at hand and time seems to fade away.

This kind of focused, creative work has been shown to have numerous benefits for mental health and well-being. It can reduce stress, increase feelings of accomplishment and self-efficacy, and provide a sense of meaning and purpose. In a world where so much of our time is spent consuming information and media, the act of creating something new can be a powerful antidote to burnout and apathy.

As programmer and author Ellen Ullman puts it:

I think that many of us find programming appealing because it is a creative activity that engages both sides of our brain: the logical, algorithmic left brain and the expressive, artistic right brain. When you‘re in the flow of writing code, you feel a sense of mastery and control over the machine, combined with a sense of playfulness and discovery. It‘s a joyful combination.

So next time you‘re feeling overwhelmed or burnt out by the demands of learning to code, remember the joy and creative fulfillment that comes from building something for yourself. Your personal projects are more than just a means to an end – they‘re an essential part of your growth and development as a programmer.

Conclusion

In the end, the most important user of the software you create as a learner is you. Building projects for yourself, no matter how small or silly, is a powerful way to cement your programming knowledge, develop practical skills, and find joy in the craft of coding.

Whether you‘re building a tool to solve a personal problem, exploring a new language or framework, or creating something just for fun, the process of taking an idea from concept to working code is an incredible learning experience. You‘ll make mistakes, encounter bugs and roadblocks, and grapple with the complexities of software development. But you‘ll also experience the thrill of bringing something new into the world, and the satisfaction of knowing that you made it happen.

So embrace the personal project, and code for the audience of one. Your future self will thank you.