Of course, since I haven't used an optical drive in years, I didn't have a blank DVD and I didn't want to wait until the morning to buy some. But I did have a USB flash drive and so I decided to create a bootable USB flash drive to install Windows 8.

To create a bootable USB flash drive the easy way, you can download the Windows 7 USB/DVD download tool from the Microsoft Store. If you feel adventurous and are comfortable with command line tools, below are the step-by-step instructions for installing Windows 8 Developer Preview from a USB flash drive. But be warned, if you are not comfortable with command line tools, downloading the Windows 7 USB/DVD download tool is a much better option and will save you the effort of reading the remainder of this blog.

Instructions (using the command line)

At a high level, the steps are:

1. Mount the Windows 8 Developer Preview ISO image on your computer
2. Format a USB flash drive
3. Copy the Windows 8 files onto the USB flash drive
4. Make the USB flash drive bootable
5. Install Windows 8 from the bootable flash drive

Step 1: Mount the Windows 8 Developer Preview ISO image on your computer

The first step is to mount the ISO image on your computer. Since Windows 7 doesn’t have the capability to mount an ISO image, you’ll have to use a 3rd party tool.

1. Download the Windows Developer Preview ISO image (choose one of the three available)
2. Using your favorite ISO image software, mount the ISO image on your computer

To check that the ISO image mounted successfully, you should be able to browse the Windows 8 files, as shown below.

Step 2: Format a USB flash drive

In case you’re wondering how big of a USB flash drive you need, an 8GB drive is perfect since it can accommodate any of the three available ISO images. Here are the steps to format a USB flash drive.

1. Insert a USB flash drive into your computer
2. Start a Command Prompt as an Administrator and type diskpart. This starts the Disk Partition tool which you need to use to format the flash drive. Once you see the DISKPART command prompt, type in the following commands
3. DISKPART> list disk                                 /* shows list of active disks */
4. DISKPART> select disk #                         /* # is the number for your USB flash drive */
5. DISKPART> clean                                     /* deletes any existing partitions on the USB flash drive */
6. DISKPART> create partition primary     /* create a primary partition on the USB flash drive */
7. DISKPART> select partition 1                 /* select the newly created partition */
8. DISKPART> active                                    /* make the new partition active */
9. DISKPART> format FS=NTFS                 /* format the USB drive with NTFS file system */
10. DISKPART> assign                                   /* assign a volume and drive letter to the USB drive */
11. DISKPART> exit                                        /* exit Disk Partition */

At this point, your USB flash drive should be showing up in Windows Explorer and have a drive letter assigned to it, e.g. F:\.

Step 3: Make the USB flash drive bootable

We just need to make the USB flash drive bootable before copying the files. To do this, you can use the Boot Sector Registration Tool (bootsect.exe) which is located in the boot folder of the Windows 8 ISO image.

1. Start a Command Prompt as an Administrator and CHDIR into the boot folder of the Windows 8 ISO image, e.g. I:\boot where I:\ is the drive where the ISO image is mounted
2. Type bootsect /nt60 E:                              /* where E: is the drive assigned to the USB flash drive */

You should see the following confirmation after bootsec.exe completes:

Step 4: Copy the Windows 8 files onto the USB flash drive

From a command line, use XCOPY to copy the Windows 8 files to the USB flash drive . In the example below, I:\ is the drive where the ISO image is mounted. F:\ is the USB flash drive.

XCOPY I:\*.* F:\ /E /F /H

Step 5: Install Windows 8 from the bootable flash drive

Finally, follow these instructions to install Windows 8 on your computer.

1. Remove your USB flash drive from your "source" computer and insert it into the "target" computer where you want to install Windows 8
2. On the computer where you are installing Windows 8, press the power button to turn on the computer
3. During boot up, select the USB flash drive to boot from (if you don't see the USB flash drive as an option, you may have to adjust your BIOS settings)
4. Follow the instructions to install Windows 8 Developer Preview

Here is a screen shot from the boot manager on my computer showing the USB flash drive as an option.

I installed Windows 8 Developer Preview on a vanilla Dell Inspiron 15R laptop which unfortunately doesn't have touch (or any other sensors for that matter).

The personalization steps in Windows 8 Developer Preview are really quick.

And here is the final screenshot of my shiny new Windows 8 installation!

Habib Heydarian.

In the workflow above, when Developer 1 hands the bug over to Developer 2, there is a lot of context and information that is left out and what usually happens is that Developer 2 restarts debugging the same issue to figure out the root cause. Basically, Developer 2 ends up doing a lot of redundant work that Developer 1 has already done. Ideally, Developer 2 should be able to leverage the investigation work that was done by Developer 1 and just continue the debugging session.

In Visual Studio 2010, using two new features , i.e. Breakpoint Import/Export and DataTips Import/Export allows Developer 1 to hand off the debugging session to Developer 2 so that Developer 2 can just pick up where Developer 1 left off.

Let's go through an example to see how this collaboration works. In this example, Developer 1 is investigating a bug in the Tailspin Toys e-commerce sample application. He is trying to figure out why the Shopping Cart isn't updated when the user adds the same toy to the cart. After debugging the problem in Visual Studio, Developer 1 discovers that the bug is in a method (AdjustQuantity) that is in a component (Tailspin.Model) owned by Developer 2. The screenshot below shows where Developer 1 thinks the bug is.

At this point, Developer 1 wants to give this bug to Developer 2. However, rather than have Developer 2 do all the work to reproduce the bug, Developer 1 captures a couple of crucial pieces of information and sends them along with the bug to Developer 2. In a sense, Developer shares his debugging environment with Developer 2. First, Developer 1 exports his current breakpoint by right-clicking on the breakpoint in the editor and selecting the "Export…" command, as shown below. By exporting the breakpoint, Developer 2 can now easily figure out where to start investigating the bug.

The exported breakpoint file is shown below.

The next piece of information that Developer 1 wants to share with Developer 2 is what information Developer 2 should look at when debugging the problem. In order to do that, Developer 1 first "pins" the variable that he thinks is causing the bug to the editor, as shown below.

After pinning the variable to the editor, Developer 1 exports the pinned variable, by selecting the Debug –> Export DataTips… command. The exported DataTips file is shown below.

Now, instead of Developer 2 restarting the investigation, he can continue where Developer 1 left off by importing the debugging environment. The new workflow is shown below.

To import the debugging environment, Developer 2 can import the DataTips file from Debug –> Import DataTips. The exported breakpoints can be imported from the Breakpoints window, as shown below.

After importing both the breakpoint and the DataTips, Developer 2 can simply continue his investigation by pressing F5. The debugger will now stop at the breakpoint that Developer 1 exported and will show the variable as well. It will even show the comment that Developer 1 wanted to pass onto Developer 2. This is shown below.

If you have any feedback or suggestions on this feature or have any ideas on how to better collaborate when debugging, feel free to leave me a comment.

Habib Heydarian.

1. Search For This Line In IntelliTrace
2. Search For This Method In IntelliTrace

Both of these features are available from the editor context menu (shown below). In this blog post, I'm going to cover the first feature, i.e. Search For This Line In IntelliTrace. In a future blog, I'm going to cover the second feature, i.e. Search For This Method In IntelliTrace.

So what does the "Search For This Line In IntelliTrace" command do exactly and how is it used? Let's walkthrough a simple example to see how this feature works. In the following code snippet, I am interested in finding out how many times the the statement ShoppingCartItem item = FindItem(product); (line 7 below) was executed and also, I want to figure out what happened before this line was called.

   1: /// <summary>

   2: /// Adds a product to the cart

   3: /// </summary>

   4: public void AddItem(Product product, int quantity, DateTime dateAdded) {

   5:  

   6:     //see if this item is in the cart already

   7:     ShoppingCartItem item = FindItem(product);

   8:  

   9:     if (quantity != 0) {

  10:         if (item != null) {

  11:             //if the passed in amount is 0, do nothing

  12:             //as we're assuming "add 0 of this item" means

  13:             //do nothing

  14:             if (quantity != 0)

  15:                 AdjustQuantity(product, quantity);

  16:         } else {

  17:             if (quantity > 0) {

  18:                 item = new ShoppingCartItem(product, quantity, dateAdded);

  19:  

  20:                 //add to list

  21:                 Items.Add(item);

  22:             }

  23:         }

  24:  

  25:     }

  26: }

In order to do that, I can right-click on line 7 above and select "Search For This Line in IntelliTrace".

After selecting the command, the IntelliTrace Search Bar is shown at the top of the editor window. The screenshot below highlights the IntelliTrace Search Bar.

Think of the Search Bar as the controls on your DVR where you can go backwards and forwards through your IntelliTrace recording. One of the key features that the IntelliTrace Search Bar provides is displaying the number of times that a line of code was executed. In the example below, you can see that the highlighted line was executed 4 times.

Using the Search Bar, you can debug backwards from the time when the line of code was executed. In the screenshot below, after clicking the left arrow once, I can now use IntelliTrace to step back through the code.

Habib Heydarian.

In the figure below, the blue section labeled (1) shows one of the most common ways that developers debug their applications today which is by writing code , e.g. Debug. WriteLine("Calling Web Service") to figure out what the application does.

This is often called "explicit instrumentation" because the developer explicitly adds code to the application to instrument its behavior. After the application runs, a log file is generated which is often just a plain text file that developers view using Notepad. This type of debugging is tedious and it can take a long time to investigate a bug.

In comparison, IntelliTrace alleviates the need to write trace statements just to figure out what the application is doing. In the green section above labeled (2), the IntelliTrace Recorder automatically records what the application does and allows the developer to replay the recording at a later time. Specifically, IntelliTrace provides three capabilities:

• Record
• Playback
• Rewind

What's important to note is that IntelliTrace also provides a rich UI to analyze the application recording. No more wading through volumes of text in Notepad just to figure what the application was doing.

Habib Heydarian.

There is a tool called Code Metrics in Visual Studio 2008 and 2010 that among other things, counts the lines of code in a project. Using Code Metrics is very simple. In Solution Explorer, select the project that you want to know the LOC for, right-click and select "Calculate Code Metrics".

The screenshot below shows the Code Metrics window. One of the nice things about the Code Metrics window is that it shows you the lines of code per project, namespace, class or method.

Habib Heydarian.

Since IntelliTrace is a brand new feature, we are eager to hear from developers about what they think about it. So, here is my offer: If you have any questions or feedback (both positive and negative) about IntelliTrace, send me your feedback via this blog and I will reply with an answer within 24 hours. Regardless of weather you've used IntelliTrace extensively and have an "advanced" questions, or you've never used it before and just want to learn about it, I'll be happy to answer any questions related to IntelliTrace.

Thanks in advance.

Habib Heydarian.

Being able to see the return value of a method comes in particularly handy when you have methods that take other methods as their parameters, e.g. F(A(x), B(y)), where A() and B() are methods themselves. For example, in the code example below, how can you see the value that is returned by c.CalculateArea(radius)?

IntelliTrace in Visual Studio 2010 makes it easy to view the return value of a method.

The first step is to change the default IntelliTrace options to record "events and call information", as shown below.

After enabling the above option, IntelliTrace will record the return value and parameters of all methods in the running application. Now, whenever you stop in the debugger, the IntelliTrace NavBar is displayed in the editor margin. To see the return value of a method, click the "Go to Previous Event" button (Ctrl+Shift+F11) to step back to the method that you want to see the value for, shown below.

After clicking the button, the debugger will display the method that you stepped back to in the Autos window, as shown in the following screenshot.

Expanding the method in the Autos window will display the return value. The debugger displays the name of the return value as [Return Value].

Habib Heydarian.

IntelliTrace is not available. See the Debugger Output window or the Windows Application Events Log.

Below is a list of reasons why you might see the above error message when trying to use IntelliTrace.

1) In Visual Studio 2010, IntelliTrace does not support debugging a 64-bit process inside Visual Studio. You can workaround this limitation by changing the project configuration for your project to 32-bit. See this article for more details.

2) IntelliTrace is not available if you have attached to the application that you are debugging. The only workaround is to start the application under the debugger.

3) IntelliTrace is not supported for native C++ applications. We hope to fix this limitation in the future.

4) IntelliTrace does not support SQL CLR projects

If you have any feedback or are seeing the above error messages in other scenarios, feel free to send me feedback.

Habib Heydarian.

After selecting the option, you can now use the debugger step back through the code. In the following screenshot, you can see a before and after screenshot. On the left hand side (screen 1), the Step Back button is highlighted. The right hand side (screen 2) shows what happens after I've clicked the Step Back button, i.e. the debugger has stepped back into the calling function, Main().

We are very excited about IntelliTrace and we think it's going to change developers' lives. If you have any questions or feedback about IntelliTrace, feel free to drop me a line.

Habib Heydarian.

In this blog post, I'll do a "Hello World!" version of IntelliTrace to help you get started with this feature. We'll start with a vanilla Windows Form project and use it to explore various capabilities of IntelliTrace.

To start with, create a brand new Windows Forms project using either VB or C#. Then, drag and drop a button on the form, as shown below.

Double-click on the button and add the following line to the click event handler.

Debug.WriteLine("Hello IntelliTrace!")

Press F5 to run the application and then click on the "Hello IntelliTrace!" button. On the right-hand of the screen, you should see a new window called the IntelliTrace window, as shown below. Click on the "Break All" link in the IntelliTrace window.

After clicking the "Break All" button, the IntelliTrace window displays a number of very useful "events", as shown below. IntelliTrace records what happened in your application in chronological order. So, reading down the IntelliTrace window, you can see that the following things happened:

1. The application started under the debugger
2. The user clicked on a button with the label "Hello IntelliTrace!"
3. The application output some trace information using Debug.WriteLine()
4. The application paused in the debugger

What IntelliTrace is doing is keeping a diary or journal of the application as it was executing so that you can read through what happened. But what really makes the experience that much more compelling is that you can click on an event in the IntelliTrace window and navigate to the source code that caused that event, shown here.

In the next blog, I'll describe how you can customize IntelliTrace to collect additional events such as opening a file or reading from Windows registry keys.

Habib Heydarian.