Los Techies is a blog maintained by a number of contributors who share and discuss various technical ideas. I happen to have met a few of the folks who contribute there and they seem like pretty okay people.
At any rate, I was perusing some blog posts there this morning when I came across a couple of e-books they have. One talks about the SOLID principles and the other discusses refactoring. Both are important skills to be familiar with as a programmer. I personally like to read various sources on both of these topics when I get a chance since I like to continuously improve those skill sets. I encourage you to do the same.
I love long breaks from work! Don’t get me wrong, I also love being a software developer and I am very passionate about creating software. However, long breaks give me an opportunity to spend more time exploring technologies which I don’t use day-to-day at my current job. Long breaks also offer a chance to read a little more than usual. This Thanksgiving break was no different. When I wasn’t preoccupied with the family and other holiday activities, I sat down and read Uncle Bob’sThe Clean Coder: A Code of Conduct for Professional Programmers.
It really was refreshing reading another person’s thoughts on what makes a software programmer a professional. In many ways, this topic is tough as it is very subjective. Several published books tackle the topic of software craftsmanship, but not many really dive into professionalism. Throughout the chapters, there is discussion about responsible communication, estimation, and making commitments. Important topics such as practicing, learning, and personal commitments for self-improvement are also covered. Overall, the book is pleasing and easy to read as the author shares plenty of his life experience to illustrate his points.
I think there are some areas where the book falls short. For example, the chapter of estimation discusses our responsibility to communicate honest estimates and suggests including confidence factors to allow the product folk and project managers to do their duties. However, you won’t find detailed discourse on estimation techniques. In the books defense, it is not a book about estimation techniques and perhaps detailed discourse on such techniques is out of scope. In my opinion, the author would have overcome this by including more references to material where the reader can acquire or develop those skills.
On the other hand, other chapters (like the one on practicing) did give enough reference material to satisfy my wish for more information. I also found the Appendix filled with lots of goodies to help expand your exposure to reading material and tools.
Bottom line – I recommend this book to any software programmer who is passionate about self-improvement in the professional sense.
At work, an initiative to implement some CQRS style architecture for some of our projects subsystems has begun. We were looking at ways to horizontally scale our system and a colleague suggested that we look at CQRS and Event Sourcing. Over the last month, we have researched the topic, spiked out the implementation, and started migrating some parts of our bounded contexts to make use of the architecture.
Below is a list of links to white papers, blog posts, sample applications, and other information on CQRS and Event Sourcing. There are not listed in any particular order:
I just finished reading Domain-Driven Design by Eric Evans. Overall, it is a great book. The complex topic of domain-driven design is tackled and explained exceptionally well. In addition, the companion web site supplements the text very well by allowing quick access to definitions and provides a community for discussion regarding the text and topic. The only draw back I encountered in the text was feeling that some fundamental topic discussions were a bit long winded. This may have been just because of my experience in the software engineering and architecture arena. However, that drawback is minimal as the discussions restated important concepts clearly and reinforced them.
There are several notable characteristics in this book. The very first thing that comes to mind when I am asked why I found this book helpful is the way the author covered the topic from both an academic point of view and then distilled the key concepts using practical tried and true design patterns which have been documented in various notable texts by accomplished technologists. The domain-driven design approach marries itself well to agile development processes that emphasize iterative development practices. Evans made the association between the approach and the processes although there appeared to be a bias towards extreme programming.
In the end, I would definitely recommend the book to anyone who is working on projects where domain driven design principles or is interested in learning both the academic and pragmatic techniques and concepts in this area of software development.