Introduction
This marks my 100th blog post and the final one for 2024. To commemorate the occasion, I’ve decided to reflect on my two-year journey of maintaining a programming blog and writing nearly one post every week. In this post, I’ll share why I started blogging, how the journey has unfolded, the surprises along the way, both expected and unexpected, how blogging has benefited me, where it hasn’t, and what you can anticipate if you’re considering starting your own programming blog.
I realize this post is a bit different from my usual content. However, like every other post I’ve written, it’s aimed at helping you become a better programmer. This time, instead of focusing on technical details, I hope to inspire you to discover the rewards of starting a programming blog.
In The Beginning
About two years ago, I decided to start a blog focused on programming in C# and Unity. There were three main reasons that motivated me to take this step:
Answering Frequently Asked Questions
I often found myself answering the same questions repeatedly, whether for colleagues, forum members, or users on Discord. While quick answers could address the immediate problem, programming is all about context. To provide comprehensive answers, I would need to write lengthy explanations filled with additional information that might not be relevant in the moment but could be useful in other contexts. Without a blog, this would mean rewriting the same detailed response over and over again. With a blog, I could write a thorough post once and simply share the link whenever needed.
Sharing Discoveries and Creations
Occasionally, I would discover or create something I wanted to share with the world. These could range from small insights, like how
trueandfalsein C# are not just values but also operators that can be overloaded (see my Schrodinger’s cat box implementation), to larger projects like my Stat System. Blogging allowed me to share these findings not only with people I know or interact with online but also with anyone searching for such topics on the Internet.Expressing Opinions and Frustrations
There were times when I just needed to vent. Often, I encountered bad practices or misinformation and felt compelled to write about them. Social media posts were too short to express my thoughts fully, so I wanted to use my blog to craft detailed articles presenting my arguments, explaining why something was wrong in my opinion, and proposing better solutions. Posts like What Are The Implied If Statements In Code and The Single Responsibility Principle came from these moments. For example, I grew tired of repeatedly seeing claims that the SRP states every class should “do just one thing,” accompanied by examples that contradicted the principle’s actual meaning. A quick read of the first paragraph of Clean Architecture or watching Bob Martin’s videos makes it clear that this interpretation is incorrect.
Through these motivations, my blogging journey began and has continued to be a rewarding experience.
Keeping Schedule And Forming A Habit
There’s a Greek proverb that says, “Every beginning is difficult,” and a Japanese proverb that goes, “Beginning is easy, continuing is hard.” I agree with both.
Starting a blog is challenging, especially when balancing work, hobbies, family, and social life. Writing programming blog posts is even more demanding than writing about purely subjective topics. While programming involves some subjective elements, two significant differences set it apart:
Context Matters
Writing code is highly contextual. The same piece of code can be considered good or bad depending on the context in which it’s used. To ensure readers understand the reasoning behind your code, you must explain the requirements that led to its creation. This often takes more time than writing the code itself.
Code Must Work
Your code needs to function correctly. Readers may copy and paste your code or clone a GitHub repository, which means there’s no room for silly syntax errors or glaring bugs that prevent the code from working as intended.
These factors make starting a programming blog seem tedious, but continuing to write posts consistently is even harder. Forming a habit and maintaining a steady schedule is challenging not only because of the effort required to write high-quality posts but also because finding topics to write about can become difficult over time.
Don’t get me wrong—there are plenty of programming topics to explore. However, since blogging is often a hobby, there will be times when you want to write about something that doesn’t consume too much time. On one hand, you want to maintain your streak of posting regularly. On the other hand, you need to find a topic that can be researched, coded, and written about in just a few hours.
The common advice, “Keep a list of quick-to-write topics”, isn’t a perfect solution. Eventually, you’ll exhaust those easy topics, and your motivation may dip because you’d rather tackle more complex subjects but can’t seem to find the time.
The solution I’ve found is to shift my approach. Instead of setting aside one day a week to write a blog post, I make it a habit to work on my blog throughout the week. The key is not to focus on writing a blog post each week but to make a daily habit of contributing something to your weekly blog post.
This habit doesn’t mean writing part of the post every day. One day, you might research your topic. Another day, you might write the code. On yet another day, you might draft sections of your post. By dedicating even 30 minutes daily to your blog, you’ll find it much easier to maintain a consistent schedule and keep your blogging momentum alive.
What I Expected And What I Didn’t
After two years and 100 blog posts, there are some things I expected to happen and others that came as surprises when I decided to start a blog.
Learning Unexpectedly
Although I write about topics I’m knowledgeable about and avoid writing about subjects I’m still learning, I frequently discover new insights while researching. For instance, during my research, I learned that in C#, true and false are not only boolean values but also operators that can be overloaded and that they don’t necessarily have to complement each other. These unexpected details about familiar topics make the process of writing posts incredibly rewarding.
A Self-Referencing Resource
One of my expectations, and one of the reasons I started the blog, was to create a reference for topics I often need to revisit. This has proven to be highly useful. For example, my posts on equality and comparisons in C# have become resources I frequently revisit to refresh my memory about the different types of equality and comparisons.
Embracing Public Repositories
Before starting my blog, I rarely used public repositories on GitHub. Even when I began writing blog posts, I didn’t initially plan to make my code publicly available. Perhaps it wasn’t something I was accustomed to. Over time, however, I found the need to use public repositories. Sometimes it was because including all the code in a blog post would make it too lengthy or include unrelated elements. Other times, it was simply more convenient to improve or expand code in a repository rather than in a blog post. Blogging has led me to create open-source code, which has been rewarding as more people use and provide feedback on it. This, in turn, motivates me to improve or add features to those projects.
The Rise of “Imaginary Code”
Another unexpected experience has been encountering people who critique my code by comparing it to what I call “imaginary code”. It’s common for programmers to look at a piece of code they disagree with, rewrite it, and then analyze the pros and cons of the original versus their version. Often, the act of rewriting reveals why certain decisions were made, especially to handle edge cases. However, I didn’t anticipate people comparing my real, tested code to hypothetical, non-existent code that exists only in their imagination. Since imaginary code doesn’t consider edge cases, it often appears better, but that’s the nature of imagination: it’s unconstrained by reality. These experiences have taught me the importance of writing and testing any alternative code I propose before discussing it, ensuring I’m comparing real, functional solutions.
An Overflow of “SEO Experts”
When I launched my blog, I included contact information for readers who wanted to reach out with questions or feedback about my posts. What I didn’t expect was the flood of unsolicited emails from people claiming to “fix” my site. With subject lines like “SEO Specialist” or “Executive SEO Professional,” these cold emails offer free site analyses and urge me to improve my site’s SEO to increase revenue—even though I don’t run ads on my site. The sheer volume of these emails, especially for a small personal site, has left me wondering how many such emails larger sites receive and likely ignore. While I understand most of these are sent by bots, I didn’t anticipate receiving so many for a site without any ads.
Benefits Of Having And Writing A Programming Blog
Having a programming blog offers several benefits, some obvious and others less apparent.
Inspiration and Creativity
One of the first benefits is that searching for topics to write about can inspire you to try new approaches to familiar tasks. Things you’ve been doing routinely for years may feel mundane, but a programming blog can motivate you to revisit them with fresh perspectives. It can also spark ideas for fun or unique projects and provide reasons to explore new technologies or concepts.
Staying Current
A blog encourages you to stay up to date with the latest updates and trends in your field. Knowledge about certain frameworks, APIs, or libraries can become outdated if you haven’t used them recently. Writing a blog post often requires research, which can reveal new updates or changes that you might otherwise overlook. Without the motivation to write, these updates might go unnoticed or feel overwhelming when you eventually need to use them.
Personal Archive
As mentioned earlier, I expected my blog to serve as a reference for specific topics, but it has also become a personal archive of reusable code snippets. These snippets might otherwise be buried in my GitHub account as gists or lost in the shuffle of daily work. Having them documented in blog posts makes them more accessible and organized.
Improved Documentation Skills
Writing technical blog posts has also improved my ability to write better documentation for my code. While I still find documentation tedious, maintaining a blog has helped me approach it more effectively. The practice of explaining technical concepts in blog posts translates directly to writing clearer and more helpful documentation.
Non-Technical Benefits
Beyond the technical advantages, maintaining a programming blog has improved several non-technical skills as well:
Consistency and Time Management
Writing a blog post every week tests your ability to stay consistent. It pushes you to organize your time, finding small opportunities during the day to write. It also serves as an anchor in the chaos of daily life. With so many tasks to juggle and long-term projects that take months or years to complete, having a weekly blog post provides a sense of accomplishment. Each week, you complete something tangible, offering a refreshing contrast to the drawn-out nature of larger commitments.
Writing Skills
The blog has significantly improved my writing, particularly in English, which is not my native language. It has helped me become more expressive and better at describing and explaining complex concepts. I was never particularly skilled at writing non-technical content and didn’t enjoy it much. However, the blog has ‘forced’ me to improve when I needed to write posts that involve less code and more detailed explanations of architectural principles and patterns. While I still have room for growth, this practice of articulating ideas I care about has been invaluable.
Conclusion: Should You Start Blogging?
If you’re considering starting your own programming blog, my answer is a resounding yes, with a caveat.
Starting a programming blog offers numerous benefits. It provides you with an excuse to learn new things, explore alternative approaches to systems you already know, and dive deeper into subjects you write about. Beyond the technical advantages, blogging helps improve your writing skills, encourages you to document your code more thoroughly since it’s public and accessible to a diverse audience, and offers a sense of accomplishment. Blog posts typically take less time to complete than many programming tasks, providing satisfying milestones along the way. Just try to remember two things:
The Importance Of Consistency
The key to success is consistency. Whether you choose to write weekly, bi-weekly, or monthly, maintaining a regular schedule is crucial. If you only write when inspiration strikes, chances are you’ll eventually stop altogether. Blogging requires a commitment of your free time, and without a schedule, you’ll often opt for other activities instead of working on your blog. This can lead to a negative cycle where your blog becomes a source of stress rather than a tool for growth, leaving you feeling guilty about neglecting it without actually making progress.
Start Small And Build Gradually
The best approach is to begin with a manageable schedule, perhaps writing a post every two months, and gradually increase your frequency if you find it sustainable. Avoid the temptation to start with overly ambitious goals, like writing multiple posts per week. While it might seem feasible at first, the demands of maintaining such a pace can quickly become overwhelming, leading to frustration and, ultimately, abandonment.
Remember, writing consistently doesn’t mean finishing an entire post in one sitting. Instead, make it a habit to work on your blog in small increments throughout the week. Finding “pockets” of time each day for research, coding, or drafting sections of your post makes the process more manageable and ensures steady progress.
In short, a programming blog can be a rewarding endeavor, but it requires thoughtful planning and commitment. Start small, stay consistent, and enjoy the journey of learning, sharing, and growing as a programmer.
As always, thank you for reading, and if you have any questions or comments you can use the comments section, or contact me directly via the contact form or by email. Also, if you don’t want to miss any of the new blog posts, you can subscribe to my newsletter or the RSS feed.