I already did this thing last year, so I thought I would do it again. Below is an overview of the articles I posted this year and a little bit of reflection on them.
It’s interesting to look at the progression of blogging topics throughout the whole year. They mostly followed the Pluralsight courses I was working on at the time. While writing a course, I remember finding lots of ideas that were worth extracting into a separate self-contained blog post. It worked the other way around too. Some of the earlier articles combined with a few newer ones eventually ended up forming Pluralsight courses. These two activities – blogging and creating courses for Pluralsight – played out together really well.
Also, thanks to everyone who asked me questions either here or in the comment section on Pluralsight. Many of them gave me fuel for new blogging topics. Quite a few are still in my queue, and I will take care of them next year.
Alright, here are some top lists.
Most viewed articles posted this year:
- Having the domain model separated from the persistence model
- Specification pattern: C# implementation
- Entity vs Value Object: the ultimate list of differences
- Law of Demeter and immutability
- Growing Object-Oriented Software, Guided by Tests Without Mocks
Most of them are now top results on Google for corresponding queries, so no surprise they turned out to be most viewed posts.
Most valuable posts. These are the articles I personally consider the most valuable in terms of the benefits you get should you incorporate advice from them into your day-to-day work. If you haven’t read them, I encourage you to do so:
- Growing Object-Oriented Software, Guided by Tests Without Mocks, and the whole article series that preceded it. In it, I tried to describe why the mockist approach often entails poor code and test quality. The most interesting part is the sample project from the GOOS book itself and its refactored alternative.
- Having the domain model separated from the persistence model. In this one, I tried to debunk the common approach to building enterprise applications using ORMs. In short: don’t introduce a separate persistence model, it just isn’t worth the effort. Use your ORM as a mapper between the domain model and the database, don’t do the mapping yourself.
- Domain model isolation followed by How to know if your Domain model is properly isolated? If you work in enterprise software development, it’s really important to protect your domain model from external influence. In these two posts, I wrote about what it really means to keep your domain model isolated and how to actually determine if you achieved a good degree of isolation. It’s interesting that the notion of domain model isolation highly correlates with the concept of purity and side effect avoidance from Functional Programming.
Most insightful posts. These articles I consider the ones which help you to “dot the I’s and cross the T’s”. Meaning that they help lift understanding of some topic to a new level. Writing them definitely did that to me.
- Law of Demeter and immutability. This post is about why it’s generally OK to violate the Law of Demeter when you work with immutable data structures.
- OCP vs YAGNI. This one is about when to actually apply the Robert Martin’s OCP principle and when to stick to YAGNI.
- Unit tests value proposition. Here, I wrote about 3 components that comprise a valuable test. The important thing here is that it’s impossible to achieve a perfect record for all of them, and you always need to sacrifice one of them in order to advance the others, there’s no way around it. However, knowing these components help you make a deliberate choice. BTW, this topic is covered in my Pragmatic Unit Testing Pluralsight course in depth, with lots of visuals and examples, so check it out if you want to dive deeper into this subject.
Most philosophical posts. I wish I could keep this section larger 🙂 I like contemplating various topics, both technical and non-technical. Will try to do that more next year.
- Trying to impress people with your code. Many programmers like to brag about their craft. We all do that, of course, and there’s nothing wrong with that. However, a lot of people choose a wrong subject for their brag. Instead of showing off how many language or framework features you use to implement some functionality, boast about how many of them you don’t use.
And of course, I can’t leave this post without mentioning my Pluralsight courses. I’ve put a lot of work in them (now that I think about it, it’s actually quite insane how much time each of them took me to accomplish), so I would recommend you watch all of them 🙂
However, if I have to pick one or two, I would point out my DDD in practice and Functional C# ones. With them, I tried to convey the most important parts of my personal experience in a condensed, refined manner. The density of the material might be quite high there (and I hate when other authors put out densely packed courses because that means I can’t watch them at 1.5x speed) but I would recommend them regardless.
Alright, that’s it for this year. Happy holidays and I’ll see you in January!