Avoid these six common development mistakes

Both rookie and veteran developers often have misconceptions about aspects of their work that can wind up hampering the progress of an entire project. Tony Patton explains why you should be on the lookout for these common mistakes, which include not commenting code or verifying data.

I've been working with junior and entry-level developers lately, and I've noticed some common misconceptions that all developers (even veterans) can fall victim to if they aren't careful. These range from ideas about what tool to use to the appropriate use of Web services. Below I address six overarching development misconceptions.

1. Thinking Visual Studio .NET is required to develop .NET apps

Those new to Microsoft .NET development often suffer from the misunderstanding that Visual Studio .NET is required to develop applications utilizing the .NET Framework. This just isn't true. You will need to install the .NET Framework that is freely available from the Microsoft Web site.

With the .NET Framework installed, you may utilize your favorite text editor in conjunction with the command-line .NET tools. Also, you can use a third-party development tool like SharpDevelop.

Weekly .NET tips in your inbox
TechRepublic's free .NET newsletter, delivered each Wednesday, contains useful tips and coding examples on topics such as Web services, ASP.NET, ADO.NET, and Visual Studio .NET.
Automatically sign up today!

You can refer to a previous column for a more thorough discussion of Visual Studio .NET alternatives. Choosing a development tool is a personal choice, but many development teams standardize to simplify working together.

2. Keeping information to one's self

One of the more peculiar traits of developers is the tendency to hoard information. The ability to know something that others do not often leads to a mistaken sense of importance. On the contrary, sharing such information can help the team by expanding the group's knowledge. In addition, the concept shared may be improved upon with input from other team members. This is one of the key aspects of the open source movement. Finally, when you explain a concept or idea to another developer or group of developers, it usually expands your knowledge.

Teamwork is a driving force in such movements as Agile Software Development. In addition, many groups utilize peer code reviews, where the developers review and comment on other developers' code. This promotes learning and understanding on both sides.

3. Omitting comments in code

Adding comments to your code is a simple and straightforward process, so why is it often overlooked and ignored? Some developers wrongly think a lack of documentation—in any form—can improve job security. This is closely related to the previously covered fallacy of not sharing information.

A few well-placed comments can greatly improve a code's readability and manageability. Now, there is a tipping point where comments are overused. Basically, these should be a short description of the purpose of the code, variables, methods, and so forth. Many groups like to insert comments when changes are made to code. This makes it easy to see what has changed when/if problems occur.

4. Failing to see the value in a version control system

Most developers are all-too-familiar with this scenario: You roll out a new version of a critical Web application, and your cell phone rings constantly the next morning with cries of site problems.

As long as you're willing to admit that you may have made a mistake or two, a version control system can be your best friend in this situation. By using version control systems, such as CVS, IBM Rational ClearCase, or Microsoft Visual SourceSafe, you can easily revert to the previous version of the application and move it to production. This gives you time to locate the problems within the development environment while the production site is readily available. This beats frantically searching through production code to locate the problem.

In addition, a source control system allows concurrent development so different team members may work with the same code. When the developers check their changes into the system, the changes are merged together.

One reason why some developers don't like version control systems is because it adds a layer to the development process, which means the submission and retrieval of code to and from the source control system can be slow. This extra waiting time can tax the patience of some developers.

5. Assuming Web services is necessary for all projects

With all the hype about Web services, many developers enter a project thinking that they must use Web services in some form. While a Web service may be necessary or appropriate, it is not a given. You need to analyze the situation to see if implementing Web services is appropriate. For example, another technology like remoting may be more suitable.

6. Overlooking the importance of data verification

Data is processed and manipulated in various ways in application code. For this reason, developers should verify data integrity and validity along the way. That is, data may be read from a backend database that may return null characters. The data should be checked before resuming execution, since null values often throw exceptions with most operations.

Knowing is half the battle

Whether you're a new developer or a veteran, you still need to be aware of the tendency for developers to have these six misconceptions. Even if you don't find yourself succumbing to these bad habits, be aware that other developers on your team may be falling into these traps. By keeping yourself attuned to these potential mistakes, it will help you prevent these ideas from hampering your team's project.


Tony Patton has worn many hats over his 15+ years in the IT industry while witnessing many technologies come and go. He currently focuses on .NET and Web Development while trying to grasp the many facets of supporting such technologies in a productio...

Editor's Picks