Running SpecFlow Acceptance Tests in parallel on BrowserStack

Automated acceptance tests play a vital role in continuous delivery. Contrary to unit tests though, they’re quite hard to get right. This is not only because end-to-end testing is harder than testing single units, but also because of the way they need to be executed. You need the a fully working version of the application […] Read More...

Simple code: a sample app

In my last few posts I have hammered a lot on simplicity in software. In my first post (Simplicity in software) I explained what the difference is between easy and simple code (or hard and complex code). On the basis that introducing frameworks and libraries increases complexity, the following posts then touched on a few […] Read More...

Using partial application for dependency injection

In my post on how to simplify code by using composition instead of an AOP-framework I showed a way of substituting attribute based programming with a more composable paradigm. The result of that transformation will be my starting point for today’s post. For reference, I’m including that code here again: public class TaskCommandHandlers : ICommandHandler<CreateTask>, […] Read More...

How to use Pure DI

In my previous posts I talked about how you can decrease dependency on external libraries and frameworks while making your code simpler (not easier, simpler). In this post I want to continue on the same thread and show some of the benefits of Pure DI (as opposed to DI with a container). DI-containers are beneficial […] Read More...

How to ditch your ORM

In my previous post on how to simplify code by using composition I talked about how we can reduce complexity by removing an AOP-framework (or annotations-based programming). In this post I want to continue on the same line and talk about how we can reduce complexity by removing an ORM and replacing it by a […] Read More...

Simplify code by using composition

In my post about software simplicity I talked about how we introduce complexity in software without realizing it. In this post I want to discuss a pattern that allows you to get rid of the complexity introduced by using annotations or aspect oriented concepts. Let’s take a look at a basic example: public class TaskService […] Read More...

Simplicity in software: what you see is not what you get

As software developers we put a lot of focus on simplicity. And rightly so, because making code readable and understandable keeps it from becoming a maintenance nightmare. Simplicity is often confused though with how many lines of code there are. When you use lines of code to measure complexity, you’re likely just hiding complexity behind […] Read More...

Deploying cloud services to Azure with Powershell

Recently I was asked to create an automated deployment from TeamCity for an Azure web role. I had done this before with Azure websites so I figured the process was going to be similar. For websites you can use msdeploy  which is relatively easy to configure. This is another reason why, if possible, you should […] Read More...

Introduction to Domain Driven Design, CQRS and Event Sourcing

I recently started learning about domain driven design, CQRS and event sourcing. Up until now, I have been mostly involved in projects that use a ‘classic’ N tier/layer architecture with a relational database. As projects become more complex, I noticed that this model doesn’t always work well.  A while ago, I wrote an article about […] Read More...

Improve your command-line experience with ConEmu

Over the last decade, almost all software has made huge leaps in usability. Browsers have gotten tabs, you can do everything off-line and interfaces are slicker than ever. And then there’s the windows command-prompt. Nothing has changed over the last decade or longer. It still has the same issues it had years ago: copy-pasting is […] Read More...