Codebases grow, they never shrink.
New functionality chunks appear, old ones very rarely get decomissioned.
More code means more complexity, more dependencies, more space for regression & even more troublesome testing - that's sad reality & you can fool yourself with dreaming about full decoupling, atomic services & independent modules, but in majority of cases - this is not going to happen.
When I was working about my last blog post, the one about outsourcing the pain, I've come up with an idea of one, interesting type of pain software developers tend to forget about. Wait, they don't forget about it, they usually intentionally pretend it does not exist: the pain of massive data inertia.
As close to production ..., right?
One of the main reasons why
Straight to business - I've participated in a very interesting discussion about development architecture recently: which scenario works better & brings more benefit to the organization:
- each team is responsible for all their deployment / maintenance mechanisms separately (let's call it Scenario A)
- there's a dedicated DevOps ('Development Architecture') team that is responsible for deployment / maintenance mechanisms (they provide them for other teams) - for
Dealing with technical configuration of your apps may be tricky. In a simple case you just slap a text file or two and there's no harm done, but once your solution gets more & more complex, all those pesky files get really cumbersone:
- keeping the content of them all in sync
- modifying the large number of them (usually remotely) in virtually the very same
Shortening delivery cycle and improving the overall delivery pipeline gets more & more love nowadays. Delivering value more frequently, in a more predictable manner, while remaining truly transparent - who could resist that? That's why 'DevOps' & 'Continuous Delivery' are trending that high in 2014.
Quite recently I've had a discussion with a more senior colleague of mine - we were discussing a particular
I had quite an interesting discussion about frequent delivery of value via changes in software. The topics itself is not new and everyone who knows the basics of Agile / Lean approach (or just Theory of Constraints) knows that stashing the inventory should be reduced to minimum - one should deliver as frequently as possible (while making sure that delivered chunks actually bring some value)
It seems that my recent post about the sanctity of test environments was appreciated more than I expected, so I’ve decided to address another topic that too frequently gets misunderstood or which importance is usually neglected:
Basically, there are to two categories of configuration:
- business (functional) configuration
- technical (non-functional) configuration
The easiest way to distinguish between those two is by