Developers solve problems. Good developers solve problems efficiently. The reward for that efficiency is [insert your preferred reward here]. Let’s assume you’re simply motivated by the satisfaction of a job well done (or maybe a promotion, a raise, longer lunch breaks, or just some extra time with your family). Whatever the motivation, the secret to solving problems efficiently is not inventing everything from scratch. Certainly the secret is not spinning your mental wheels hoping for inspiration. And most definitely the secret is not using Intellisense to arbitrarily try classes, methods, and properties until something works.

The secret to solving development problems efficiently is having the right information and the means to find the information you don’t have.

If you have been developing software for more than a week, you know that a working knowledge of language syntax and program construction (that is, "programming") is only a small part of the necessary skill set for solving problems with software. As a developer, you need to understand the technologies, processes, and methods available to you. You also need to have a set of reliable resources you can turn to when you encounter problems.

Below you will find some resource recommendations to help you find the information you need to help solve development problems more efficiently so you can get on with living the rest of your life.

Finding Answers to Specific Problems

Search Engines

I have heard colleagues muse about the changing role of "software developer," postulating that development has become a job mostly concerned with research and discovery. While that is no doubt an overstatement, the ability to find information quickly is an important skill. The place many of us turn to first is our search engine of choice whether it’s Live Search, Google, or a meta search site like Dogpile.

The appeal of most search engines is the beautiful simplicity of a single search box, but the needs of a developer are not simple when you factor in multiple versions of frameworks, programming languages with similar constructs, and behavior differences between competing products (I’m looking at you, Structured Query Language and Cascading Style Sheets). With just a short time investment, you can learn some advanced search operators and tricks to help narrow search results to exactly the information you need. For example, search for "live advanced search keywords" or "google advanced operators" and you’ll find a bunch of operators to help you become a search ninja.

In addition to your search engine of choice, Wikipedia can be an invaluable problem solving tool. I have found Wikipedia to be especially useful when searching for general topics such as common computer science algorithms and concepts. Although I often end up at Wikipedia through search engine results, Wikipedia has its own search box right on the home page (http://wikipedia.org/).

Of course not all problems will have solutions waiting to be discovered via a search engine. Some problems have already been solved in another part of your organization and you simply have no idea about the pre-existing solution. There are many tools designed to help companies deal with code asset management and search behind the firewall. One interesting product is Krugle, a specialty search engine built for indexing and searching code.

Stack Overflow

Searching is great when you know exactly what to search for and somebody else has previously solved a similar problem. When you are dealing with a more difficult issue, you may want to pose your specific problem to other developers for advice. There are plenty of discussion boards and forums for developers on the Internet to ask and answer questions.

One intriguing and useful site is Stack Overflow, a "collaboratively edited question and answer site for programmers." This innovative developer Q&A site allows users to post responses to questions and vote answers up or down based on usefulness, accuracy, etc. In addition to posting questions, you can search Stack Overflow or browse posted questions by tag. When you are posting a question on Stack Overflow, the application automatically searches existing questions and shows you matches that might already contain the answer you seek.

For obscure topics and scenarios such as bizarre error codes, Stack Overflow can be a job saver.

Twitter

Microblogging seems to be all the rage these days and some developers find services like Twitter to be an extremely effective way to share tips and send out requests for help. Twitter and similar services can be a two-edged sword, though, as they can be as much a distraction as a tool for information exchange.

If you are not familiar with Twitter, it lets you follow posts or "tweets" from other Twitter users. Tweets can be no more than 140 characters. You choose who you want to follow.

There are plenty of ways to use Twitter that will surely reduce your efficiency, but with a bit of intentionality in your approach, you can build a reasonable size network of trusted colleagues with whom you can swap questions, answers, tips, and tricks. (When your friends hear you are "on Twitter," they may demand to know your Twitter username. You might need to maintain separate Twitter accounts for work and personal use.)

Officemates, Coworkers, and IM Contacts

If you are anything like me, you find it tempting to just ask an officemate or IM contact for an answer. Of course this means solving my problem at the expense of my colleague who is distracted from doing his/her own work. With your recently acquired ninja search engine skills, take a look at some of the research on the impact of interruptions on productivity and ponder how a work culture that accepts interruptions as common practice could ultimately make you a less effective developer. Just something to think about before you start picking the brains of your cubicle mates.

Other Options

What sources do you rely on for finding answers to specific problems? Leave a comment below.

Keeping Up with New Technologies

With the rapid and continuous rate of change in the software development space, keeping up with the latest and greatest technologies could be a full-time job – in fact it is in many organizations! It really has become impossible to keep up with everything, but you should not let the fear of information overload prevent you from staying informed about significant changes directly related to your area of expertise. Being informed about new technologies helps you make informed choices about the tools, platforms, and libraries you will use to get from problem to solution.

Blogs

One easy way to stay informed about topics that might affect you is to subscribe to at least a few blogs in your area. Scott Guthrie’s blog is a good choice if you only want to get the big headline news like a new release of the .NET Framework (http://weblogs.asp.net/scottgu/). If you’re a Silverlight developer, Tim Heuer’s blog would be a good choice (http://timheuer.com/blog/). If you’re an ASP.NET developer, perhaps try the Visual Web Developer Team Blog (http://blogs.msdn.com/webdevtools/).

If checking blogs via a blog reader is not your thing, you might want to use a service that will deliver new blog posts to you via email.  FeedBlitz (http://www.feedblitz.com/) is a service I use for several blogs that I want to track even when I’m too busy to spend time reading my larger blog subscription list. Or you might want to add a few feeds to a customized browser home page through a service like Pageflakes or Netvibes.

Podcasts

Another way to stay current on technology is by listening to audio podcasts like .NET Rocks (http://dotnetrocks.com/) and Hanselminutes (http://hanselminutes.com/). Internet audio shows like these are generally packed with great technical content that helps keep you up to date. Podcasts can be an easy way to transform a tedious commute into a serious professional development opportunity. Personally I use the Zune desktop software (http://zune.net/) to automatically download new podcast episodes and sync them to my Zune device. If you don’t have a Zune, you can still grab the MP3 files from the Zune download folder and copy them to any portable media player.

User Groups

User groups are another great way to stay current on new technologies. User groups are community-run technical groups that hold events (both in-person and virtual) for members to learn about technologies related to the focus area(s) of the groups. User group events often happen outside of normal work hours, which can admittedly make it difficult for some people to attend. In addition to learning opportunities, user group events can be a great place to discuss technical issues you are tackling and increase the size of your network of colleagues that you can turn to for help.

Go to http://www.ineta.org/ to find details (including meeting times and places) for .NET-focused user groups in your neck of the woods.

Challenging Your Thinking

When building software, your existing methods for thinking about problems are used to design a solution based on the tools and information you have available. Too many times I have seen developers stuck in a mental rut and developing solutions inefficiently because of outdated or misguided thinking about the problem at hand. Case in point: I used to spend far too much time building and deploying simple tools and utilities as compiled executables until I learned to embrace scripting as a fully legitimate form of programming (after having turned my back on my past as a UNIX scripting hack). In part my thinking was influenced by the experiences of other developers who were sharing their experiences online.

If you do not have people challenging your think, I believe you will stagnate as a developer. That means talking to or reading the musings of other developers. Ideally you will find yourself disagreeing with or questioning their thoughts on a regular basis. You aren’t being challenged if you only read what likeminded people write.

Below are some sources that I find useful in challenging my thinking and assumptions. They might not work for you, which is fine, but I encourage you to find your own trusted sources that will regularly challenge your thinking.

CodingHorror.com is written by the brilliant and prolific Jeff Atwood. It has been a constant trove of insight and reasoned perspective, ranging from discussions of technical details to choosing a programming chair. (Jeff is one of the founders of the abovementioned Stack Overflow.)

JoelOnSoftware.com is written by the equally brilliant Joel Spolsky. He is the source of such gems as "The Joel Test: 12 Steps to Better Code" and "Things You Should Never Do." In addition to development topics, Joel writes about management and business issues. (Joel is the other founder of Stack Overflow.  Hmmm… perhaps I have a bias.)

Ted Neward writes a technical blog (http://blogs.tedneward.com/) that I regularly enjoy. Although I don’t read every post, I always find his pontifications worth digesting.

Daniel Crenna (http://dimebrain.com/blog) is another technical blogger whose musings I enjoy reading. Daniel is a great community champion and the founder of several open source projects. His blogging pace has slowed down in 2009 as he’s been working on some useful projects, but I keep hoping he’ll starting writing again soon. He’s a web / RIA guy, an area I’m interested in, so he stays in the ol’ blog list.

Join the Conversation

What do you do to be more efficient as a developer? What are your favorite resources for challenging your thinking? How do you keep up on technology changes in your area of expertise? How do you find solutions to specific problems? Leave a comment to share YOUR tips with us.

—–

Derek Hatchard is the content editor for http://microsoft.com/youshapeit/msdn and http://devshaped.com. He is also the founder of Crowd Space. You can find him online at http://derekh.com, http://ardentdev.com, and http://twitter.com/derekhat.

One of the most underutilized productivity features in Visual Studio 2005 and Visual Studio 2008 is Code Snippets. Even though most developers have heard about them, I find when working with consulting customers that there are few developers who use them on a regular basis. Even if they do use them, they vastly underutilize them by only using a couple of them and never create their own. In this article, I give you a quick intro into what code snippets are, how they work, what is available out of the box, and how to go beyond that by quickly creating your own code snippets.

Code Snippets Overview

Code snippets were introduced in Visual Studio 2005 and allow you to emit a chunk of code into your editor by typing a few keystrokes (a shortcut mnemonic). I’m going to use C# for the examples in this article, but just realize that code snippets work in Visual Basic and other .NET languages as well. That chunk of code can just be a static chunk of code, but what really makes code snippets powerful is that they can have placeholders that you can quickly overtype when you invoke the code snippet.

To try them out, the best one to start with is one you can probably use the most often: the prop snippet. Code snippets have both a title and a shortcut, although these will often both just be set to the shortcut value. The prop snippet emits a property with a backing member variable in Visual Studio 2005, or an auto-implemented property in Visual Studio 2008. Code snippets show up in the IntelliSense list as well, so if a snippet has a longer shortcut than a few letters, often you can just invoke it by typing a few of the letters and select it out of IntelliSense.

For example, if I go inside a class declaration and type prop and hit Tab twice (once to dismiss the IntelliSense list, the second time to invoke the code snippet), I get the following in the editor:

public int MyProperty { get; set; }

The type and property name will be highlighted in green, indicating that they are the placeholders defined in the snippet. For this snippet, the type is the first placeholder and will be selected so that if you start typing, you will overtype what is there. So for example, say I want a string property. I type string and hit Tab. Tab moves between the placeholders, and when the focus is placed on the next placeholder, it selects it as well so you can overtype with the value you want. So if I type Name and hit Enter, I leave the placeholder mode and my changes are accepted. If I keep hitting Tab, it revisits the placeholders in order in case you accidently tabbed past one or changed your mind as you were filling things in.

This one may not be stunning in its time savings, but when you add up the keystrokes (4 + 1 + 6 + 1 + 4 + 1) you have 17 versus the 30 for typing out the whole property yourself. Wham! You just became almost twice as fast at writing code! OK, don’t tell your manager just yet, you need to actually get used to doing this all the time first…

Now consider setting a switch case statement for an enumeration with a number of values. For example, say you needed to set up a switch/case on the states for System.Windows.Input.MouseAction. If you had a local variable of that type with something like the following method:

public void HandleMouseInput(MouseAction action)
{

}

If I go inside that method and type switch Tab Tab, I get the following snippet with a placeholder on the variable switch_on.

public void HandleMouseInput(MouseAction action)
{
  switch (switch_on)
  {
    default:
  }
}

If I type in action for the placeholder (the local variable of enum type MouseAction) and hit Enter, the snippet fills in all the enum values as case statements:

public void HandleMouseInput(MouseAction action)
{
    switch (action)
    {
        case MouseAction.LeftClick:
            break;
        case MouseAction.LeftDoubleClick:
            break;
        case MouseAction.MiddleClick:
            break;
        case MouseAction.MiddleDoubleClick:
            break;
        case MouseAction.None:
            break;
        case MouseAction.RightClick:
            break;
        case MouseAction.RightDoubleClick:
            break;
        case MouseAction.WheelClick:
            break;
        default:
            break;
    }
}

That is a huge keystroke savings filling all the tedious structure code! You just need to fill in what to do for each case.

Built-in Code Snippets

The list of built-in code snippets for C# is actually fairly short. There is really only a small number included out of the box. You can find the full list here with a short description of each for the core C# language snippets: (http://msdn.microsoft.com/en-us/library/z41h7fat(VS.80).aspx). There are some additional ones in other categories that ship with Visual Studio 2008, but the list is still fairly short for C#.  Visual Basic actually ships with hundreds. But this shouldn’t make you feel shorted as a C# developer. You can actually find a greatly expanded library of C# code snippets that shipped after VS 2005 here: http://msdn.microsoft.com/en-us/vs2005/aa718338.aspx. You can also find libraries of other code snippets out on CodePlex and other places on the net.  do, while, for, foreach, and a number of other common control structures are all in the basic set, along with everything from data access patterns to file IO patterns in the expanded sets. ctor is another one that is handy for declaring a default constructor for a class.

There is a Code Snippet Manager in the Tools menu of Visual Studio that will let you browse all the built in snippets, import new ones, and search online. However, if you understand what is going on under the covers, it is actually easier to just manipulate them as files.

Inside Code Snippets

Code snippets themselves are nothing more than XML files with a particular schema that reside in some directories that Visual Studio is aware of. Specifically, snippet files end with a (not surprising) extension of .snippet. The built-in code snippets that ship with Visual Studio reside under the folder C:\Program Files\Microsoft Visual Studio 9.0 under VC# or VB respectively. Visual Studio is the default editor for that file type, so you can just browse to those folders and double click on the .snippet files and edit the XML in Visual Studio. If you want to create your own snippets, put them in your Documents folder under Visual Studio 2008\Code Snippets\Visual C#\My Code Snippets (or similar path for VB or 2005). Visual Studio watches this file all the time, so changes or additions to snippets take effect immediately without needing to restart Visual Studio.

There are a lot of elements supported in the schema but the key ones to focus on are Shortcut in the Header element, and the Declarations and Code elements under the Snippet element. Say I wanted to emit a code snippet like the following with a placeholder over the Boo! string so I could overwrite it:

System.Console.WriteLine("Boo!");

To do so, I would have a code snippet that looks like this inside:

<?xml version="1.0" encoding="utf-8" ?>
<CodeSnippets  xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <Shortcut>cwboo</Shortcut>
    </Header>
    <Snippet>
      <Declarations>
        <Literal>
          <ID>output</ID>
          <Default>Boo!</Default>
        </Literal>
      </Declarations>
      <Code Language="csharp">
        <![CDATA[System.Console.WriteLine("$output$"$end$);]]>
      </Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

In this case, the IntelliSense shortcut to invoke it is cwboo. The code snippet declares one literal variable named output with a default value of Boo!. The actual code of the snippet has to be declared inside an XML CDATA section because some legal characters in C #and other languages could cause XML parsing errors. The output literal is a named placeholder in the emitted code which will be replaced with the default value and highlighted for overtyping as discussed earlier. You can see that when you use a literal in the snippet, you enclose it within leading and trailing $ delimiters. Everything else in the snippet (except other variables) is emitted as plain text in the editor when the snippet is invoked. You can see I am also using a built-in literal $end$, which specifies where the input cursor is placed when you hit Enter to leave the placeholder mode of snippets.

Creating Your Own Snippets

By now you are probably emitting some form of "Eeewwww!!!" sound at the thought of editing the XML whenever you want to create your own snippets. The good news is that you don’t have to. There are a couple of free tools out there to help you create and edit snippets without ever needing to touch the XML directly. One I have been using for years as a C# guy is Snippy (http://www.codeplex.com/snippy). It puts a very simple dialog interface on top of the XML schema for you to create your snippets (see Figure 1).

Figure 1: Snippy

A great way to start many custom snippets is to start with an existing one and just edit it. Just remember to do a "Save As…" and save it to your Documents code snippets folder mentioned earlier so you don’t overwrite the built-in ones.

Another choice is the Code Snippet Editor for Visual Basic 2008 (http://msdn.microsoft.com/en-us/vbasic/bb973770.aspx). For those language bigots, you will have to get over the title: it actually supports multiple languages (see Figure 2).

Figure 2: Code Snippet Editor for Visual Basic 2008

Either one of these will allow you to quickly create your own snippets and stop typing the same code over and over again.

Code Snippet Functions

I showed you the switch snippet earlier in the article, and that may lead you down the path of thinking you can pull off anything with a snippet. Unfortunately that is one of the most powerful ones you will find. There is a whopping three functions in the C# library for expanded capabilities in your snippets (http://msdn.microsoft.com/en-us/library/ms242312.aspx). The GenerateSwitchCases function is the one that did the magic for the switch code snippet. The ClassName function will emit the class name of the class in which the snippet is invoked. This is used by the ctor snippet I mentioned earlier to declare a default constructor. And lastly there is the SimpleTypeName function, which will take a fully qualified type name, and will emit both a using statement in C# (Imports in VB) and the root class name so that you don’t have fully qualified types in the emitted code. This is used by the built-in snippet cw, which emits a Console.WriteLine statement. Take a look at that built-in snippet if you want to see the way it is used. Unfortunately there is no way to add your own custom functions. If you want more power to do more custom things in your snippets, you might want to take a look at third party tools such as Developer Express CodeRush (http://www.devexpress.com/CodeRush) or JetBrains ReSharper (http://www.jetbrains.com/resharper/). They have things called templates that are like code snippets on steroids and are also extensible.

Wrap Up

Now you should have a good idea what code snippets are, how they work, and how to go beyond what you get out of the box. Let me share with you my approach to code snippets: If I find myself typing some code and I get that "déjà vu" feeling of "I know I’ve written this little chunk of code before", I stop myself, write it as a code snippet, and then I won’t ever have to write it again. Too often developers take the longer path because they think they will be "wasting time" by going and doing something like authoring a code snippet for the code they are writing. Many times, it is not authoring the code snippet that is the real waste of time.

—-

Brian Noyes is chief architect of IDesign (www.idesign.net), a Microsoft Regional Director and MVP, writer and speaker. He is the author of Developing Applications with Windows Workflow Foundation, Smart Client Deployment with ClickOnce, and Data Binding with Windows Forms 2.0. He is also a frequent speaker at conferences worldwide including Microsoft TechEd, DevConnections, VSLive!, DevTeach and others. You can contact him through his blog at http://briannoyes.net.