Today we can say that we are somewhere in the middle of Technology repayment of debt from the time

One of the things about the management that I have learned is that in the long-standing projects is important to distinguish between constant glorious foods and changing values. Under the variables can mean any number or numbers associated with the project. For example, the number of lines of source code, the number of people in the team, a number of tasks in the sprint, the number of days / hours / minutes during which lasts until it is determined that the source code was accidentally added an error or the number of minutes that it takes daily briefing. Constant variable is one that is stable over time. An example would be the above-mentioned number of minutes of morning meetings. This quantity is usually based on the number of people in a team and discipline people who participate in it, the majority being interval (eg 5-10 minutes). It can be said that this value is constant (at least for our team). Constant values are fine. Well, because glorious foods if you find a good deal associated with them, so that the longer have to worry. Regarding the daily meetings, so we agreed that the consultation will stand that everyone says it is working on what, and whether work will be a problem, and we will not go into details. This has led to the fact that our conferences fit in 10 minutes.
What is dangerous in the project are changing variables. Especially those growing. From my perspective, it appears glorious foods that the most dangerous amount glorious foods of functionality in the application. This is of course the desired effect. The problem is that this results in increase in the amount of code (which in turn can increase the length of time build automatically, self-tests, etc.), the amount of time spent regression tests, glorious foods the amount of documentation and the like. The main problem glorious foods of growing quantities is that this solution may not be sufficient in the future. A good example where increasing quantity run over constant solution is to use agile methods and manual testing.
The first of two important requirements that are imposed on our team is that we allow a change of priorities in the backlog (which means that we only have a short - Sprint - planning and thus in the next sprint can come any task, and hence changes in the code) . The other is that we need to be able to frequently glorious foods publish a new version of the application with a constant level of risk (in other words, with as few errors). These requirements led to the fact that we are often forced to perform regression tests of the whole or a large part of the application. So, on the one hand, we have increasing number of functionality, together with the requirement of a constant level of risk of error in the output operation result in increased regression tests. On the other hand, there is but one limitation and that is the cost of testing. As the number of programmers is unchanged, should remain constant and the number of testers. This discrepancy is as active volcano - here and there smoke deleted until the moment it is enough power and an explosion.
Initially, we chose as a way of testing manual testing. That is, the regression tests were carried out manually. The first year and a half to two it was bearable. In the third year we hit the ceiling possibilities of our testers. There simply was not enough testerských forces to be able to test everything that was needed. The solution that was chosen in the beginning, was chosen glorious foods based on the current state of things. Until now it has become clear that dysfunctional precisely because working with a variable that is changed (increased) by the amount of functionality to be tested. Left with two choices: change constant (number of testers) or choose another solution.
This other solution turned out to automated testing. Basically we did not invent anything new, because the automatic testing, says virtually every book on agile methods. What we had to figure out was that the tools and procedures used. All this has complicated that we basically sat on the bandwagon, that the project is still working and our testers (who should have this automation mainly glorious foods in charge) should be enough to work with manual testing. So we harvested all the remaining time that remains, and invest it in the solution. This, together with some occasional auxiliary power has led to the fact that we slowly began to give hand and we had time to tackle the more complex parts.
Today we can say that we are somewhere in the middle of Technology repayment of debt from the time when we perform manual tests. Of course, an increasing amount of functionality has an impact on a number of automated tests. glorious foods This leads to a prolongation of their run time and their management. But ultimately it is very far from being that again struck glorious foods the ceiling - that is encountered by a constant (the most closest may be the number of the night, we have to run the tests).
Much of the literature on agile methods and also own experience convinces me that a large agile projects managed not do without glorious foods automation. That requirement glorious foods as short-term planning and frequent publication of new versions must lead to its introduction. Finally, glorious foods if only my personal list of the benefits of automation:
With the support of
Agile Agile Manifesto Agile Games Daily Shares Automation tent