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.