email article printer friendly more resources

Enforce Standards With .NET Inheritance
Take advantage of the new inheritance features in .NET to create standards that speed applications from inception to implementation.
by Donald King

For this solution: .NET Framework, Object-oriented analysis and design methodology

ADVERTISEMENT

Your developers are at lunch and the quality-assurance analyst is saying she won't sign the code into production form unless the user interfaces start resembling the ones defined in the software-development standards. If this sounds familiar, you're not alone. Enforcing development standards across your enterprise might be the toughest job you have as an IT manager. However, by gaining an understanding of the difficulties associated with maintaining standards and learning how you can use the inheritance capabilities of .NET to make it easier, you can lessen your burden.

Standards in software development can make or break an application (see the sidebar, "Avoid Disaster: The Consequences of Standard-Free Applications"). However, too often standards are treated as trivial, unimportant pieces of the process that might or might not get addressed during the software-development life cycle. This is unfortunate, because well-defined, strictly enforced standards can be the key to reducing the costs and time associated with new development and maintenance. For example, many companies enforce strict standards for the user interface or look and feel of the application. Uniform and familiar UIs have a reduced learning curve and quicker user-acceptance period, and they also facilitate a faster time to production.

However, there are always problems associated with maintaining standards, including lack of time, laziness, protective developers who don't want anyone telling them how to implement software, and managers who fear confrontation concerning any of these issues. Sometimes the staff has an inadequate level of training to understand what standards are and how to maintain them, or the standards are poorly written or unclear, in particular UI standards where the users are involved heavily. In this situation, part of your job as the manager is to take charge and educate your development staff about why standards are important and must be maintained.

Manage Standards Effectively
You can use several techniques to manage standards within your organization. For example, you could use an object-oriented methodology of software design, which consists of methods and tools, such as the Unified Modeling Language (UML). Using a standard such as UML is advantageous because it's generally accepted throughout the industry as the standard for Object Oriented Analysis and Design (OOA&D). As other developers join the project, as either full-time regular employees or consultants, the established industry standard should be familiar. Your organization should adopt a methodology suited to the type of software you develop.

You can also publish the standards for use by development staff. This might include standards for requirements gathering, design and architecture, coding, and so on. If you involve your development staff in creating the standards, everyone involved will feel a sense of ownership and be more likely to promote standards enforcement among the rest of the staff.

However, you don't necessarily have to develop these standards on your own. You can take advantage of proven industry standards, such as those published by vendors. For example, many shops adopt Microsoft's suggested coding conventions, or another vendor or industry standard, for their own use and modify it to suit their needs.

There's no doubt that documentation is the most effective tool for managing standards. Written policies or guidelines offer the quickest and most effective answers when questions or conflicts arise as to what the standards should be. Your organization should provide a developer's handbook to new and existing staff so there's no question about expectations.

Now that you've established standards, you need to enforce them. Code reviews, when several developers get together and walk through source code literally line by line, are one option. This exercise can help to find potential design problems as well as deviations from the agreed-upon standards. Although you might encounter developers who are protective of their code and don't take criticism (constructive or otherwise) well, you shouldn't let that deter you from this option. One effective approach is to ensure all developers, whatever their skill level, are allowed to participate in the reviewer role. This ensures everyone understands it's a quality-assurance process, not micromanagement.