There are many articles out there that tell you how to become a good .NET developer and most of them contain some valuable tips on how you can improve. But did you ever read an article that tells you how to become a great .NET developer?

From our experience at Next Generation we have collected 7 of the most common traits an efficient and effective .NET developer should have. Regardless whether you are already an experienced developer or not, this article will break down all the things that are valuable for you to know. Let’s get started.

1.    DON’T REWRITE SHAKESPEARE, GOOGLE IT!

Seems a bit weird that I’m trying to push you to use Google so you can find your answers, but more often than not, I’ve seen many trying to reinvent the wheel, whereas online information to resolve your issues is in abundance! This could save you a lot of time and will create other benefits that you might have overlooked.

Nobody expects you to do what’s already been done and to help you out, I will list a few good resources that you could use to find a resolution for your issues.

r/DotNet for example, is a subreddit dedicated to .NET developers all around the world. The moment you post a question there with details, you can expect to get an answer very quickly.

StackOverflow, albeit an obvious one, is arguably one of the best places where you can discuss any issues that you face. Like r/DotNet, StackOverflow is a place where you can expect to receive answers the same days. It’s also a great place to have discussions regarding the advancements in the industry if you engage with other people that have opened a thread.

DotNetKicks is also a community-driven platform where eager developers like yourself can fence ideas and learn from one another. Other honourable mentions where you can find resources can be found in my other article here.

Whatever platform you decide on, the key takeaway from this tip is to never stop learning. Stay connect, stay updated, and engage in discussions to leverage what you know and learn things you didn’t know before so that you don’t have to tackle your developer issue by starting from zero. This is one of the many things that you should do to stand out from other .NET developers. Which leads me to the second tip.

2.  USE APPROPRIATE DEBUGGING

As per usual, debugging is unavoidable. But it’s up to you to decide on the most effective and efficient method for your situation. My tip for effective bug bash sessions is to do the following

  • Describing

Write a thorough description of the bug and so you can capture evidence regarding the symptoms as to when they appear and when they don’t.

  • Stabilising

Find out what causes the bug to appear. This means replicating the issue to ensure you can identify what causes the bug to appear in the first place. Once you’ve done     that, make sure that under no other conditions the bug appears. After doing so, move on to the next step.

  • Localising

Now you’ve found the bug, it is of the utmost important that you can describe where exactly the bug is located. It should also be documented properly which I will explain in my other tip regarding automated documentation.

  • Developing Solutions

I hear it quite often that a developer tries to tackle a bug, dive straight into the “develop a solution” phase and in turn introduce more bugs, but if you followed the previous steps properly you indemnify the risk of things going wrong. If you’re an experienced .NET developer you are probably already familiar with all these steps, but it’s nonetheless important to follow these processes so that unnecessary mistakes and additional bugs can be avoided.

  • Testing

Test the solution. Replicate the steps from stabilising the bug in order to determine that the symptoms do not longer appear.

  • Regression test

Ensure that no new bugs are added after the solution is tested. Plain and simple.

  • Implementation

Implement the planned changes and move it to production.

3. SAVE YOUR VALUABLE TIME, VIEW THINGS FROM 2 ANGLES

This might seem obvious, but I still want to share you this tip which can be a huge timesaver. Split your screen and make sure that you have a proper overview of the source code and the output. For this you can use dual monitors, but you might want to consider using vertical and horizontal split settings as well. A new world will open for you if you didn’t do this before.

4. THE NITTY GRITTY DETAILS – AUTOMATE YOUR DOCUMENTATION

Simple XML comments to show your remarks on each of the functions is not enough anymore. The best kind of documentation you can apply is one that doesn’t require the reader to sift through all the lines of codes. Make sure that your documentation is easy to digest for the reader. I get the frustration though, not many of you like to document all the things they do, so let me help you out. Documentation needs to be updated as often as the code itself and you can save yourself a large amount of time by using some plugins and tools that automate this process for you. Some recommendations that I heard quite often from the developers I speak to are Ghost Doc and Doc-O-Matic. MonoDoc is another tool I heard of a few times and it’s worth considering.

6. UTILISE COMPARISON TOOLS

Sounds familiar? You’re planning to implement to push out a change, you followed all the steps from my second tip, and suddenly it hit you. You don’t have the latest version of the environment in which you want to implement the changes.  You can avoid this disaster by utilising comparison tools such as Sql Backup and FTP and Kaleidoscope.

7. STAY INFORMED AND PUT YOUR KNOWLEDGE INTO PRACTICE

I cannot urge enough that you need to stay updated with what is going in this industry. There are plenty of sources out there that give you the opportunity to read and stay tuned with all the .NET tips and tricks. A few recommendations that I would like to give are

Use these sources in tandem with the sources mentioned in my first tip and engage in discussions. However, just reading won’t cut it. By implementing fundamental processes while programming enables you to build a strong foundation for the .NET framework.