I recently finished reading Peopleware by Tom DeMarco. Though the book is dated, and I wouldn't recommend the book except as a glimpse into the past, it does provide some great insights that have since been repeated elsewhere.

The main gist of Peopleware is that the people who make software and the environment they work in, is more important than the technology used or the architecture decisions which are made. This is because as the famous quote goes, every software problem is really a people problem.

But why isn't this often said about other industries? In other technical industries, the technological problems really are technological problems.

I believe one strong hint is in the old name "Information Technology". When we work in software, we are fundamentally working with information.

What is information? It's nothing more than a label for things which get communicated. And what do we know about communication? We know that communication is highly dependent on the relationship between the communicators. This means that information itself is heavily dependant on the relationship between those that communicate.

In the world of Domain Driven Design, we have a special term for contextually sensitive information. The bounded context.

In the context of development tests, we have seperate what we call unit or isolated tests with social or integration tests.

The development of software and technology is not just a people problem because people are building software. It's a people problem because software itself is inherently about information. And information is inherently about the interplay between the sender, receiver,what is being sent, and how it gets translated.

If you can better understand the people involved, from the end user to the support staff which makes the development possible, you can create better software.

I believe now that Continuous Coding isn't only about how to write code so that it's easy to break up into smaller pieces and be deployed continuously. Continuous Coding is also about the communication which happens between the developers and people who need to trust the coded messages (i.e. software) that is being delivered.