I was in an interesting discussion last night: what software development practices do you consider essential?
While opinions varied, I think there was some consensus on a few items. In my list I also include some tools. Some of these were mentioned by the group, but consider them my own additions. Also, I am making this list specific to .NET, but the list applies to just about every language.
Universally agreed Practices
- Source Control (1)
- Subversion
- VSTS ($)
- Vault ($)
- Local Development -- Every developer should have everything on their computer to run the system. This includes all of the software and all of the source code.
- Bug Tracking - nuf said. There are to many tools available to list here.
- TDD - Test Driven Development. There was a little bit of back and forth, but the general consensus was that this should be done.
- NUnit
- MBUnit
- Rhino Mocks (2)
- TypeMock ($) (2)
- NMock (2)
- ORM - Object-Relational Mapping
- NHibernate
- SubSonic - My person favorite
- LINQ to SQL - not yet, but I feel this should be on the list.
- LLBLGen ($) - Not free, but I've heard many good things about it.
- More
- Continuous Integration - Simple process that sits on a server and waits for things to get checked into your source control system. When it sees something new, it gets all of the latest source code, compiles it, and runs all of the unit tests. If there are any problems anywhere in that process it alerts the users (email, desktop icon, wave red flag, etc). (3)
- One Step Build - it is unbelievably cool to be able to click one button and have your entire project compile, run all tests, and possibly create an install in one step. Personally, I do like it, but with the current set of tools this is one of the hardest parts to setup.
- MSBuild
- Nant
- BooBS/Bake (Ayende please, please, please change the name to Bake. As cool as a project named BooBs could be -- I don't want to start an HR nightmare)
- FinalBuilder ($)
- Visual Build Pro ($)
Highly thought of but non-essential practices
- IOC - Inversion of Control - Everyone seemed to agree it was a good idea...but not actually essential.
- Castle Windsor - DotNetSlackers has a nice series on using this.
- Spring.Net
- StructureMap
- ReSharper ($) - Not a best practice per say, but it sure does make life easier. (4)
I'm sure I have missed some tools in the list, but it is the practices that are more important anyway. But if you put a comment about any tool that I missed I will add it to the list.
(1) Source Safe was notably not in the list. While I don't like it either, it is better than nothing. But if your team is greater than 5 people or you have multiple people working on the same project you really should look at one of the other products on the list.
(2) Not a unit testing library, but a Mock Object library. Pick a unit testing libarary (NUnit, MBUnit, XUnit), then pick a mock object library (Rhino Mocks, TypeMock, NMock) to use with it.
(3) I really need to talk about continuous integration more. But it is one of those things that leads you down a path. First you add source control, then you start adhering to separation of concerns, then you start unit testing and mocking more, then you add continuous integration, and then one step builds are all part of the mix. One best practice leads to another, but they don't make a bit of sense without some of the prior pieces.
(4) If you are a Code Rush person instead of a ReSharper person -- carry on, you are in good company.
($) The cost money - not just beer, but may have free version versions as well.
