Every day, every minute and every second, as programmers, we make implementation decisions. These could be anything from whether to use a for loop or a while loop to where to place a class in a layered architecture.
Many of these decisions are made unconsciously or semi-consciously, letting our learned instincts take control. This is a good thing when our instincts are right. But only when they are right. We make some of the decisions consciously, making what we think is the right choice based on our experience. This is also a good thing, but only when we have enough experience to make a good decision.
This book will offer you a pair programming session with an experienced developer, working on an application starting with the very first line of code. And while developing the application we will focus on many of the decisions and make them consciously after discussing alternatives. The book presents programming principles and practices that are commonly accepted in the industry, and presents them in a context and with a motivation that makes them easy to understand.
By reading this book, my hope is that you, the reader, will start thinking. My hope is that this book will inspire you to pause once in a while to reflect about these decisions, and make them more consciously than before. Because that is the only way you can improve your coding skills, and therefore that is the only way you can improve the quality of your conscious and unconscious decisions.
And prepare to be surprised, because all the roads we walk down might not be what you expect.
Background
The book is based on a true story. A few years ago, Stefan Alfbo and I were assigned the task to develop an application. In our pairing sessions we had really good discussions, so good that I feel I want to share them with the world. This book is an attempt to do just that, retelling a somehow modified version of the story of our development work, including our most interesting discussions while also adding discussions about some other interesting topics.
While working on the book, I got the honor of working together with Daniel Brolund on a web application. I learned from him that the pattern Stefan and I were using for our tests is called Page Object Pattern in the web world. Together we also developed a more fluent way of expressing the intent of the tests.
Work in progress
This is an online book and will probably stay that way, for many reasons. First, it allows me to let the book grow in length. New features and new discussions can be added in a way that is not possible in a published book. Also, it enables the book to grow and change in breadth. I have, just like everyone else, a learning curve, and when I learn something new I will try to squeeze it in or change the story.
For this purpose, I have also chosen a format where you, the reader, can comment on my work. Hopefully you will teach me as much as this book will teach you. Hopefully we can make the book better together.
Who is this book for?
This is a technical book targeted for a software developer. I expect you to have good understanding of C#, java or a similar language, but you don't need to be an expert C# programmer. Whenever I use non-mainstream language features, things you won't find in e.g. java, I will explain it first.
The application is developed using TDD (Test-Driven Development), but it does not attempt to describe the technique for the absolute beginner. It assumes that you have at least used some xUnit testing framework and that you know the basic TDD principles and practices.
Technology
Stefan and I had the restriction of using WinForms as GUI framework. My first plan for this book was to modernize things and use Windows Presentation Foundation (WPF). However, when trying that, some interesting points got lost or were not as clear, and therefore I decided to stick with WinForms. I don't think that is a big disadvantage for the book though, since it is a book about principles, practices and design, not about frameworks.
This book should, as I have mentioned, make you start thinking, meaning that all discussions should be possible to apply to WPF, Swing, web, SOA, or whatever kind of application you might be writing.
The language we used was C# and for the same reason the code in this book uses C#.
How to read the book
This is a story meant to be read from page one. There are a few appendices that you can read at any time, but they might make more sense when you have read parts of the book.