Developer Survey Results - Part 4

This is the forth and last post in my series summaries of the develop practices survey I ran  (the other posts are here, here and here).


This one is about practices to ensure code quality. But tool driven things. I'm less interested in the use LINT-style tools, than in the use reviews, pair programming and refactoring. so the last ones were the ones I asked about.


Asking "do you pair programming" survey says:

Yes, all the time			2%
Yes, often			6%
Yes, from time to time			19%
No, almost never			47%
No, never			18%

In other words, next to no respondents practice pairing often, and two thirds almost never or never practice it. , I honestly almost never pair myself.  Can't decide if this is good or bad.
Next question was if respondents use code reviews. The responses were:

Yes, all code is reviewed			6%
Yes, most code is reviewed			16%
Yes, some code is reviewed			27%
No, almost no code is reviewed			34%
No, never			8%

Again usage is pretty low. Now, this I do think is a waste. In my experience reviews really do work, when they are kept at the right balance between the totally informal "just discussing stuff" and the totally formal "you have to sign this before you leave".
Of the 92% that do use code reviews on at least at bit of code now and then, the types of reviews used were:

Formal reviews with formal approvals			4%
Formal reviews without formal approvals			17%
Code walk throughs			48%
Active design reviews			7%
"Hey, come take a look at this code on my screen"			72%

The weight here is one the more informal review types. Not surprising I guess. They are easy and cheap. And they can return a lot of value. Lastly I asked about a personal favorite - something I think is absolutely necessary in order keep code maintainable: "Do you use refactoring?" The responses were:

Yes, I always try to leave the code cleaner than I found it			26%
Yes, from time to time			44%
Yes, as separate tasks			10%
No			11%
Other			10%

Which is a fairly good note to end on :-)

Developer Survey Results - Part 3

This is the third part of my walk through of the results of a survey I recently did (part 1, part 2). This time I focus on practices around continuous integration.

The survey shows that 58% of respondents use CI, which  is fewer than I expected.

Those who use CI have their CI servers do different things. The answers show respondents use their servers to:

Build			94%
Run unit tests			86%
Run integration tests			75%
Run system tests			22%
Run UI tests			14%
Run acceptance tests			14%
Create release or deployment package			58%
Create tag/branch in source control on success			19%
Deploy to non-production environment (like test or staging)			22%
Deploy to production			11%
Other			8%

So - not surprisingly - people build their code on the CI server. Then they seem to run the tests they've written - the numbers for running different kinds of tests align nicely with the numbers for writing different kinds of tests (see part 1). Furthermore over half create releases of deployment packages. That's pretty high, I think - even if it's only just over half of the half of the respondents that use CI at all; i.e. about a quarter of all respondents. Only very few take the next step and actually deploy to production. This is as expected; continuous deployment is still pretty new.

Next question how often CI runs and it shows that by far most people have it running on every commit. 

Turning to how often things brake the distribution is as follows:

Most of the time			11%
Several times a day			3%
Once a day			33%
Once a week			42%
Once a month			6%
Never			3%
Other			3%

So its seems something is broken sort of often. Is that a problem? -Not in my opinion. It just shows that the CI server finds stuff. What could be a problem is if this stuff isn't fixed. Asking about how long from something brakes to work to fix it is started the answer were:

Within 15 minutes			22%
Within an hour			47%
Within half a day			14%
Within a day			11%
Within a week			3%
Within a month			0%
Never			3%
Other			0%

which I thinks shows that the issues found by CI are taken seriously.

All in all, it's a mixed impression on this one: Too few do any CI, but those who do have it build, run the tests they have, and create releases. And they react quickly to issues.