2015 retrospective

It’s a small post with an overview of the articles I wrote during this year.


It was an interesting year. When I started blogging I thought I would just write about the topics I know and the biggest challenge would be to express them in a more or less grammatically correct English. I was wrong. Even when I write about stuff I’ve been using in my projects for many years, the sole act of trying to articulate it poses unexpected difficulties. I often find edge cases and connections which I didn’t think of previously and which made me dive into the subject deeper than ever before. Blogging turned out to be a two-way street which helps me educate myself.

It’s interesting how my coding habits are translated into writing. In my day-to-day work, I try to employ the KISS principle as much as I can. I try to extract the essential parts and remove all accidental fluff, leaving only the things the code base can’t live without. It seems that I unconsciously apply the same principles to blogging: I noticed that I tend to simplify and distil every post as if it was some piece of code.

While I think it’s a good habit to have, it hinders expressing some non-technical topics, like this one. Probably because it goes under the "accidental fluff" category to my internal critic.

Top posts

Here’s some lists of articles I wrote during this year.

Most viewed posts:

Most of them got to the top of Hacker News at some point, so no surprise they turned out to be the most viewed posts.

Most controversial posts. These are the articles that have received the most controversial feedback: some of the viewers liked the idea, others expressed deep disagreement.

Most valuable posts. These are the ones I consider the most valuable for programmers in a sense that ideas depicted in them can boost your productivity the most:

  • Most valuable software development principles. A series of posts about the most valuable principles in (enterprise) software development. Incorporate them in your day-to-day work and get +20 points of productivity in both the short and the long run.

  • No mocks series. Another series, but at this time specifically about unit testing. It’s interesting this series didn’t get into the most controversial articles. I remember the "to mock or not to mock" discussion was much tenser several years ago. These days, it seems that the "no mocks" approach wins the people’s minds and the whole topic appears to be not as debatable as before.

  • Functional C#. Another series ideas in which I think will benefit you greatly should you incorporate them into your code. Especially Primitive obsession and Non-nullable reference types.

Most insightful posts. These are the articles I consider the "Aha!" ones. They gave me some valuable insights which, in turn, lifted my understanding of the topic to a new level:

  • Cohesion and Coupling: the difference. With this post, I finally vocalized the concept that bothered me for a long time: destructive decoupling. It was a big deal for me personally because it gave me a solid base to finally express my gut feeling about that style of programming.

  • The most important TDD rule. This is another one that helped me to finally answer the question why mocks are evil. In it, I introduced another catchy concept: low-level unit tests (not sure I’m the first one with it, though).

Most underestimated posts. These are the posts which didn’t get a lot of traction, although I personally think the concepts they describe are especially useful and/or interesting:

  • Exceptions for flow control in C#. Here, I wrote about how to work with exceptions and why they shouldn’t be used for validations and other control operations.

  • C# Read-Only Collections and LSP. This one is about the collection interface hierarchy in .NET and how I think it could be rewritten in a way that doesn’t violate LSP. This was one of my first posts, so I guess that’s the reason why it didn’t get much attention. I recommend you to read it if you haven’t already.

Most entertaining posts, the topics I got the most fun writing about:

And finally, the biggest failures. The articles which had a flawed argument or were based on a false premise:

  • CQS with Database-Generated Ids. This article was intended as a reply to a Mark Seemann’s post in which I wanted to show a better way to deal with database-generated identifiers. Not only did I fail to express my point succinctly, I also based some of my arguments on an outdated information I had about SQL Server.

  • Why following software design best practices decreases code complexity. I had a nice (and wrong) idea to express code complexity using the number of possible states a data structure can take. Nice try, nevertheless.


Alright, that’s it for this year. I have a couple of big ideas regarding what to write about next. One of them is a series in which I’ll show an end-to-end process of creating a software project using the best practices I write about in this blog.

Also, I’m currently in the process of writing a "DDD in Practice" course for Pluralsight which I hope will go live in mid-January. Make sure you subscribe to my email list or RSS so that you don’t miss those updates.

Happy holidays and I’ll see you in January!


I don't post everything on my blog. Don't miss smaller tips and updates. Sign up to my mailing list below.


comments powered by Disqus