How can a large number of developers write software together without a cumbersome process or poor quality software?

Question

I work in a company with hundreds of people writing software for almost the same product. The quality of the software should be high, because so many people depend on it (not least the developers themselves). Because of this, every serious problem led to a new check - either automatic or manual.

As a result, the software delivery process is becoming increasingly burdensome. So it takes more developers who ... well, you can see that this is a vicious cycle.

Now we have a problem releasing software quickly - the lead time even for changing one line of code for a very serious problem is at least one day.

What methods do you use to expedite software delivery to a large organization while maintaining software quality?

Answer 1

I also work in a large and cumbersome organization. I have successfully implemented several methodologies of flexible software development , but there are, in particular, two features that I found particularly valuable.

Iterative and incremental development - Keep your release cycle short and tight. Through a large team, if numerous changes are made between releases, you may find yourself in a nightmare of integration.

Large organizations tend to large projects with long development periods. Struggle with that. Project planning for a whole year does not make sense when your perception may change after the first two weeks of development. Make your stakeholders get used to the idea of ​​creating small incremental releases and adapting to ever-changing requirements.

Automated device tests - This is a great way to ensure that you are releasing quality software. The worst mistakes are caused by seemingly innocent code changes that have unintended consequences elsewhere. Comprehensive unit tests are probably the best way to catch this error. If you can switch to a test development process or development - driven behavior , even better.

Any large organization will have some mediocre developers. This is a fact of life. Automatic unit testing is a great way to keep track of them. Ask one of your best developers to write your unit tests for them. You will be sure that at least their code works (even if it is ugly).

Answer 2

See Continuous Integration

And read the Joel Test: 12 steps to improve the code .

Answer 3

There are many ways to improve the process, but modularity is a key component. By clearly dividing responsibilities (both in code and in the organization) and defining clear and consistent interfaces, one large team can work just like many small teams, all related.

Answer 4

Wise but gloomy sayings:

• Fred Brooks: Adding programmers to a late project makes it later .

• Gerry Sussman: Programmers use resistors in parallel.

• Someone else: The project cost is the number of programmers multiplied by the duration of the schedule.

Something that might work:

Organize the project so that there is a basic application built by one or two people, preferably working in the language. Then let all programmers be efficient kernel users by coding in this language.

I think of language products: SAS , S / R , MATLAB , etc.