In the episode 65 Uncle Bob reviews SOLID and Component principles, and discusses how they affect the architecture. In the book it corresponds to parts III and IV. I’ve decided to split my review in two parts as well, since there’s a lot to cover. This post will cover SOLID principles, that guide software design on a module level. Continue →

In Episode 64 of the video lesson series, Uncle Bob introduces us to three foundational programming paradigms: structured, object-oriented, and functional programming. That episode maps to Part II of Clean Architecture book. Continue →

I read Robert Martin’s (aka Uncle Bob’s) latest book Clean Architecture a couple years ago. I found the ideas in this book quite valuable, even eye-opening at times. Recently, Uncle Bob started a series of video lessons on the same subject. I decided to take this opportunity to revisit his book along with watching the videos. This post is my notes on Episode 63: Architecture Begins, which corresponds to Part 1 in the book. In this episode, Uncle Bob introduces us to what software architecture is and why it’s important. Continue →

In 2015, I attended a ScanAgile conference in Helsinki. The opening talk at that conference was given by Gojko Adzic. During the talk he presented his vision on what was going to be a next big change in the software industry. In this blog post, I’d like to recap some ideas Gojko presented and lay the ground for future posts. The full video recording of the presentation can be found on YouTube. Continue →

After a previous post a friend of mine asked for some practical examples of ATDD. Well, that’s a challenging task. Mostly, ATDD operates in the scope of entire application, so you can’t get away with simple ‘stack class’-like examples. You need an idea of an application to build, and it should be an interesting one to highlight the challenges and the way you approach them. Continue →

The idea of automated acceptance tests has been there since the very inception of agile methods. Even the earliest book I can refer to, Extreme Programming Explained, mentions automated ‘functional’ tests. Since then, the same idea re-appeared on the horizon under different names: acceptance tests, executable specifications, system tests, integration tests, etc. The main idea remained the same: develop a set of automated scenarios that examine the system as a whole, and are expressed in terms of the problem domain. When following the practice of test-driven development (which I regard as the way of writing automated tests), these scenarios naturally come before the production code is written. Continue →

The project I’m currently working on produces deliverables for Windows and Linux. Although the core of the application is a platform-independent Java code, there’s still a number of native compiled libraries. Also, the output of the build differs: executable setup for Windows, and a bunch of DEB and RPM packages for Linux. The build procedure is fully automated with Maven, however building for different platforms requires different toolkits to be installed. Continue →

I’ve had a ‘water cooler chat’ with my teammates recently, and occasionally one of us mentioned the concept of Inversion of Control. We all started to give our own explanations but, to my surprise, nobody could give anything better than hand-waving and a mumble ‘The flow of control is inverted, and so…’. Oh, and one thing everyone remembered was that Dependency Injection is a good illustration of the IoC, thanks to the great article by Martin Fowler on the subject. Continue →