IntelliTrace Info : Microsoft General

Depends.exe and working with assembly dependencies

ianhu — Tue, 18 Jul 2006 02:52:00 GMT

So in my last blog article I talked about using the fuslogvw.exe tool to figure out .NET assembly binding issues. In this article I’m going to look at another tool that I find myself using daily in the debugging world, depends.exe. In a nutshell, depends looks at your binary files and creates a tree of all their dependencies along with some other useful information. Unlike fuslogvw.exe this works with both .NET and native applications. You can get depends from the official site and it also ships with many different Microsoft development products so you may already have it present on your system. You’ll want to use depends when one of your programs fails to load with some sort of system error or initialization message. I make it a habit to check any program that fails on startup with depends first so that I don’t waste any time trying to debug what is just a missing assembly or a versioning mismatch.

At a basic usage level depends is super simple to operate, just load depends and do a file open on the binary file that you are having issues with. When the file opens up you should see something similar to what I’m showing below.

This example I just did using by using notepad.exe. In the top-left pane you can see the tree structure of all the dependent assemblies of notepad. In the middle pane you can see more detailed information about all of the items in the dependency tree. And in the bottom you can see any errors that popped up during analysis. As you can see, some errors are benign as I currently have a possible error in notepad.exe but it runs just fine. Another benign example is that MSJAVA.dll often shows up as missing in the dependency tree but the application will run just fine without it.

So we’ve seen what depends looks like when a binary with all its binaries is correctly added. So what types of errors and mistakes can depends help you to find? Here is a quick list of the ways that I’ve used depends or seen depends used:

1. As a quick way to check the architecture of a binary

2. CRT side by side issues for msvcr80.dll

3. Discovering that a driver was linking in user mode code (a big no-no)

4. Checking the timestamps of dependent files

5. Checking to see what version of a dependent file is being loaded

So if you are running into initialization or dependency issue with your native or managed applications give depends a try to see what you turn up.

Using the new Connect community feedback system for Visual Studio Team System

ianhu — Wed, 14 Jun 2006 20:45:00 GMT

For my team I’m the point man on tracking all of the customer feedback bugs that we get submitted from external users. This is one of the best parts of my job as I really enjoy interacting with customers and getting to keep my finger on the pulse of what issues are bugging our users the most. Having a deeply involved community of users that will call out any flaws in your software is not just a perk; it’s a necessity to ship high quality software in this day and age.

Previously I’ve blogged about the ladybug system that customers use to submit feedback issues to us. While Ladybug worked ok for us it had some issues with how it interfaced with customers and with our work item database. So for our Orcas release we’ve switched over to a new Connect system to use for reporting customer issues. Connect is a nice system and we hope that it will be easy for customers to use and easy for them to get issues filed against the correct team (this was a big issue with the ladybug system).

Say that you are working with the profiler in Visual Studio Team System for Developers when you think up a suggestion for a new visualization that you’d like to be able to use to view performance data. What are the steps that you would take to get a new suggestion filed in Connect? Note that many of these steps will only need to be done the first time that you open a Connect issue.

1. Navigate to the main Connect site

2. In the left hand navigation menu select Available Connections

3. “Visual Studio and .NET Framework” should be in the available connection list, click on it

4. Agree to the terms of service on the next page

5. Fill out the registration information on the next page

6. After registering, read the introduction on the welcome page and click the “Feedback” link to get to the actual feedback page

Now that you are registered you can just bookmark the feedback page so that you can get to it easily when you have more suggestions to add or issue to report. So how do we go about opening our new suggestion from the feedback page?

1. When submitting a new issue or suggestion the place that you will want to start is the big “Submit Feedback” button at the top of this page.

2. The first step in the submission process will force you to search to see if your issue or suggestion has already been files.

3. Please, before you submit your feedback use the search box with a few different keywords to see if your particular suggestion or issue is already registered with Connect. If it is already registered then please just add a vote for it as opposed to opening up a new feedback issue. That way the developers here at Microsoft can spend less time resolving issues as duplicates and more time actually fixing customer feedback issues ;-)

4. So you’ve done a few searches and you don’t see anything like the issue or suggestion that you want to raise. To proceed just click the “Submit Feedback” button located at the bottom of the search results.

5. Next, pick if you are submitting a bug or a suggestion

6. Now we are finally ready to submit our bug or suggestion. On the submission page please try to fill out as much information as you possibly can (attaching files or screenshots is nice as well). We try hard to work on all the issues that come in, but the better that you explain your suggestion or scenario the easier it is for us to figure out what you want, repro the issue and get back to you with a fix or a workaround. Putting non-specific statements like “Actual Results: It doesn’t work” and “Expected Results: It should work” don’t really help us at all. Try to be specific about exactly what you are seeing, about what is wrong about what you are seeing and about what would be the ideal fix for the issue. Remember that the more specific detailed information you can give us the better the chance of us being able to understand your issue and get it fixed.

7. Also, put some thought into what Category and Subcategory you will place your issue into. Like with giving us more detailed information placing the bug in the right spot will help us to not have to bounce the bug around in our work item tracking software (go TFS!) and we will be able to get back to you quicker.

8. After submitting your bug you will be able to track it from the “My Participation” tab on the main connect website. Not only will Microsoft employees be able to give you feedback and ask you questions but other Connect customers will be able to vote on the issue or suggestion and help you with possible solutions.

So that’s my brief little introduction to using the Connect system. Remember that the more you participate with Connect the better future releases of Visual Studio will be. So if you use Visual Studio you should also be using the Connect system to help get the features and fixes that you want.

VSTS Team Suite Edition boxed up and ready to roll

ianhu — Fri, 23 Dec 2005 01:34:00 GMT

Just yesterday I moseyed down to our team admin’s office and picked up my boxed copy of Visual Studio 2005 Team Suite edition. While we did officially ship some time before this it was still a pretty fun occasion for me to pick up the first “box” of software that I helped to create. As I came to Microsoft directly after graduating from college (to the same team that I had interned with before) this is the first software that I have shipped in any fashion and I was pretty jazzed. Software is a little bizarre in that, unlike something like the Xbox 360, the cost to produce and package is quite small after it is developed. So the company is able to pretty easily print out extra copies of Visual Studio Team Suite for all the team even though to actually purchase Team System you have to spend in the thousands of dollars. Still, I like that they took the time to print out official copies for us all, it’s defiantly something that I’m going to hold onto.

Plus the packaging is very nice! Inside of the main case it has a little CD case that has a fake metal finish that looks a bit like the metallic briefcases that it has become so trendy to package things in. Below the CD case is all the usual manuals and posters that you would expect with a Visual Studio project. After I’m back from my Christmas break I’ll see if I can post up some digital pictures of the Team Suite box contents.

Impressed by Static Analysis

ianhu — Fri, 30 Sep 2005 23:09:00 GMT

For the last two days we had a chance as a team to pick up a pre-release version of Team System and give it a through user scenario test to see if we could sign off on it being a quality product. I actually quite enjoyed this as it gave me a change to try out some of the features that I haven’t had the time to look at before now. For me this mainly meant taking a look at static code analysis and web and load tests. In this blog entry I’ll look a little deeper at the static code analysis tool.

For my example I was using a small ASP.net front-end that pushed and pulled some simple data out of a local SQLEXPRESS database. I chose this because I don’t have a great deal of experience with working with databases or ASP.net, so please excuse any sloppy code as I was trying to pull this together by the seat of my pants in an hour or two. After writing some of the basic functionality, pushing and pulling news posts from the database to the ASP.net form controls, I ran the code analysis tool on the website. For websites, the code analysis tool can be run by clicking on the menu shown below (for non-website projects you access this from the code analysis tab of the project’s property page).

When you run the code analysis tool you will get a parcel of warnings in the error list tool window (pictured below).

To help you sort through these warnings they are all grouped into namespaces such as Microsoft.Design or Microsoft.Security. To get more information about a warning, just right-click it and select error help (example help screen shown below). These help screens are great as they explain what the warning is, detail about the violated rule, instructions on how to fix it, examples of when to exclude (ignore) the warning and a very nice code example. The code example is a favorite of mine as it shows and example of the rule being broken and of how to fix it.

So not every static analysis warning is something that you *need* to fix. For example, for my mini-app I didn’t want to deal with all the Globalization warnings, since my one hour hack is intended only for the US market ;). So there are two different ways to exclude warnings from code analysis. The first way is to right click on one of the warnings in the error list window and choose “Suppress Message”; this will add an attribute into one of your code files to suppress that specific instance of that warning. But what if you want to suppress a message for all instances or suppress an entire class of messages? For an ASP.net website go to the Website menu and select “Code Analysis Configuration.” This will bring up the dialog shown below that will let you choose warnings and classes of warnings to exclude from static analysis. Also by clicking on the warning section you can change a message to show up as an error instead of a warning when running static analysis. Again for non-website projects you access this screen through the code analysis tab of a project’s property pages.

In summary, I was impressed by Static Analysis’ ability to ferret out issues in code, and for big programming shops to enforce specific coding guidelines for their employees. Since I was unfamiliar with ASP.net and database programming Static Analysis was able to point out several mistakes that I had made, and through the help files I was not only able to fix the issue, but to understand “why” I was fixing the issue.

Extensions for MSN desktop search

ianhu — Thu, 30 Jun 2005 18:35:00 GMT

One of my favorite new tools to come out of Microsoft is the new desktop search tool. I keep this tool running over basically all of my computers directories and it can be a real lifesaver at times. When I need to find what source file an interface that another team uses is in, I can just type the interface name in the search box and almost instantly get all of the source files that that interface appears in. If you haven’t given this nifty tool a try, I suggest you download it right here and give it a look. I personally think that it’s the best desktop search tool out there, but if you think I’m just a shill (which I am ;) ) ask Ars Technica what they think. I’ll give you a hint, they like it much better then the desktop search offered by that G<mumble> company. Here is a selected quote from their review; “MSN Desktop has by far the most elegant and transparent interface of the set.” Good times.

Now MSN desktop search has been out for some time now, the reason that I’m highlighting it currently is to get the word out about the API that has been released for it. Window desktop search is made to be highly expandable, and it has already had some interesting hacks and search filters released for it. If you want an easy way to create some cool desktop search hacks, just click here for development info on extensions for MSN desktop search.

I’m a little sad to have seen (what I consider) a pretty small amount of hype around MSN desktop search. It’s a great technology with an easy way to create some cool new extensions. So I’m going to do what little I can to get the word out (perhaps the Scoble can be of better service). Plus, if I tell enough people, I can stop hearing that Windows won’t have desktop search until Longhorn; desktop search is here now and it’s dang cool.

Getting version and company information in an interop DLL created with tlbimp

ianhu — Fri, 17 Jun 2005 00:57:00 GMT

Recently at work I was called on to fix a bug regarding primary interop assemblies created with tlbimp. Our issue was in finding out how to get the correct company name and version info into the interop assemblies, since tlbimp does not let you specify those. Since it was an interesting problem and an interesting fix, I figure that it would be a good thing to blog about.

Primary Interop Assemblies:

Primary interop assemblies are created to allow COM components to be consumed by managed components. The primary interop assembly (PIA from now on) contains metadata to describe the functionality of the COM components. The PIA contains no implementation, just type definitions and instructions on marshaling. Actually, the above description also describes a normal interop assembly. A primary interop assembly is all of the above, plus it is the only “official” description of the COM components. The PIA must be created and signed by the company that produces the original COM components to be considered a PIA.

Tlbimp:

Tlbimp.exe is a tool provided by Microsoft as part of the .NET Framework for creating interop assemblies. Tlbimp provides a large number of options, but no option for setting the company name or version info on the created interop DLLs. Let us say that we have a fictional DLL called comstuff.dll that we want to create a primary interop assembly for. We would use the following command line to create it:

C:\>tlbimp comstuff.dll /primary /keyfile:myPublicKey.snk /out:comstuff.interop.dll

But the comstuff.interop.dll created above does not have version and company name information and there is no way to specify them through tlbimp.

Our plan of attack:

Now it’s time to get into the details of how we are going to actually get our company name and version info into this DLL. Our basic plan of attack is as follows:

1. Compile an .RC file into a .RES file containing our version information

2. Ildasm the DLL to disassemble it into intermediate language

3. Ilasm the intermediate language and the new .RES file to compile a new DLL with the correct version information

The resource file:

All that the .RC file needs to do is define a few specific constants. Below is an example some of the entries in just such an .RC file.

#define VER_FILEDESCRIPTION_STR "Interop Library"

#define VER_COMPANYNAME_STR "Microsoft Corporation"

#define VER_PRODUCTVERSION_STR “100.10.100.10”

There are lots of other things that can be set at this point, but I’ll leave that up to the readers to find out what you need to add. Plus it depends on exactly what things you need to set on the file that you are creating. Next, you need to compile this into a .RES file using the rc.exe tool. Verinfo.rc is the .RC file that we created above.

C:\>rc.exe /r /fo versioninfo.res verinfo.rc

Ildasm:

Ildasm.exe is a tool to break down a PE (portable executable) file that contains managed code and exports it into an .IL file which can later be reassembled back into a PE file. Also, although it is not pertinent to this blog topic, just type ildasm followed by a PE filename to get a display of all the metadata for that PE, very handy! Below is the command line that we will use to disassemble our DLL.

C:\>ildasm /nobar comstuff.interop.dll /out=comstuff.interop.il

Ilasm:

Ilasm.exe is the polar opposite from ildasm. It takes .IL files and compiles them back into PE files. Also, it allows us to specify a .RES file for the new PE file, which is what we are going to be doing with it.

C:\>ilasm comstuff.interop.il /OUTPUT=comstuff.interop.dll /RESOURCE=versioninfo.res /DLL

Conclusion:

So now we end up with an interop DLL (comstuff.interop.dll) that contains everything from the original DLL plus the new stuff specified in our .RC file. Quite the process! I like to wrap all this up into a .CMD file which you can call it from a .vcproj file as part of your normal build process.

Ian’s top eight things about working at Microsoft

ianhu — Wed, 08 Jun 2005 18:51:00 GMT

One year ago today, I started my full-time (I was also a former summer intern) employment here at Microsoft. It seems like as good a chance as any to reflect on the things that I enjoy about working here. So since June 8^th is the date, here are the top eight things that I love about working at Microsoft in general and on the Visual Studio Profiler in particular. By the way, I’ve really enjoyed my first year here so, if you are a cynic, you might want to go read Slashdot instead ;).

Number eight: Organization at work

Compared to so many other jobs everything here is so well organized that it’s scary. When you work here you know the “chain of command” from the interns all the way up to Ballmer and Gates. There is never any confusion about who your boss really is, like there is in so many other companies. Plus the review process keeps you informed about how you are performing at your job. Getting good feedback is super important for being able to improve yourself as an employee.

Number seven: Making new contacts outside of my team

I’ve reserved a higher slot for my daily co-workers, but Microsoft is full of excellent and interesting people. You might meet them through working out some technical issue, chatting on a blog or playing ultimate Frisbee. At times it’s like a huge college campus full of very smart geeks who have a lot in common, which makes it pretty easy to meet new people.

Number six: Working for a company that is a newsmaker

Sure, maybe it’s not always good news, but everyday Microsoft news is all over print and TV media. And the amount of internet and blogging traffic regarding the company was just stunning to me when I started working here. One way or another, other companies and the stock market are directly affected by choices made by Microsoft. And that’s the type of company that I want to work for.

Number five: Getting to enjoy products from your company

For me, this involves all the Microsoft products that I don’t work on, but I still get to use and enjoy. I like going home and firing up Windows XP and playing some music in Windows Media Player. There is a definite small, but fun, sense of ownership in using products that were made by the company that I now work for. Plus, I get to be excited about upcoming products like the Xbox360 or possibly a computer with Windows Media Center Edition. Call it being a fanboy if you like, but I’m having a lot of fun with it!

Number four: Lots of cool things are happening elsewhere in the company

Now I’m completely happy with my current job. But it is a sign of a good company (like Microsoft) when there are tons of other interesting jobs available internally. I love working on Visual Studio Team System (see item number one) but if I wasn’t working here I’d love to be working for: the usability team, or maybe Windows Media Center Edition, or one of the Xbox teams or working on the new IE7. The point is, it’s great to work somewhere with lots of interesting projects, not just the one that you’re currently working on.

Number three: Learning something new and applying it on the job

Few things feel better then figuring out something new, and then using it to get the job done. Coming straight out of college, almost everything that I’m asked to do here is new to me. In all the crazy rush of cleaning up bugs for the release date, it’s good to step back and realize that I’m still learning lots of new tools and techniques that will help make be a better programmer. Also there are great trainings here, although I need to get around to actually making the time to attend more of them.

Number two: The co-workers

This one is for my co-workers on the profiler team. It’s hard to get motivated or to really challenge yourself without other smart folks around to push you on. And we happen to have some of the smartest here on our team. In addition to being a bunch of smart guys, they are also pretty dang fun to hang out with, which is a major plus.

Number one: Working with the tools that you have helped to build every day

This is the big one, and along with my co-workers the reason that I’m so happy on my current team. It’s a great feeling the first time you check in some code and then see your changes showing up in the IDE the next time you update. It’s a real sense that you are contributing to something big; and not just anything big, but something that I use to complete my job everyday. You know that I’m going to be thrilled for my first product launch when Visual Studio Team Systems is released November 7th.

A big thanks goes out to everyone who I’ve worked with for helping to make this a great first year.

Analyzing a performance report in Visual Studio Team System 2005 Part 4: Fixing the performance issue and analyzing the results.

ianhu — Fri, 08 Apr 2005 19:34:00 GMT

The last three installments of this walkthrough have helped show you how to use the new profiler in Visual Studio Team System 2005. In this final section, I’ll show how to jump into the code to fix a performance issue, then how to run the profiler again to see if we improved the performance with our code fixes. In these walkthroughs, we’ve been using an example program that I downloaded from Got Dot Net. To better follow along with the analysis that we’ve already done, you should check out the first three walkthroughs here, here and here.

The summary of our initial analysis is that we see two possible performance issues. I’ve placed a picture below from the summary view of our earlier analysis. First off, we see that most of our time is taken up in the Rational.reduce function (check the functions with most individual work section). And secondly, we see that Array.GetUpperBound is being called a very large number of times. In addition, in the caller / callee view we noted that Array.GetUpperBound was always being called from Rational.reduce, so perhaps there was a link between the two issues.

Now we are at the point in the analysis where we know enough to jump into the source code to look around for our issue. From any view, just right click on the Rational.reduce function and select “View Source” to jump straight to the correct point in the source file. Pictured below on the left is where Array.GetUpperBound was being called in Rational.reduce. By being called in for loop it must be called every single time the loop runs! Let’s move the call to GetUpperBound outside of the loop, as pictured below on the right.

After making this change, I rebuild the code and ran another performance session in instrumentation mode. Pictured below is the summary view from the new run with the improved code.

As you can see from comparing this to the original summary view above, we made a *major* performance improvement to Rational.reduce. The time spent in that function dropped from 164 milliseconds to 70 milliseconds. And GetUpperBound is no longer on the top three functions in terms of number of calls or in the terms of most individual work. You’ll notice that the function Forms.Application.Run took a little longer with the new code. That is only due to the fact that I was a little slow in closing the application window on the second run-through of my scenario.

So in summary, I was able to download a random application off of the internet, find a performance issue in it, change the code to fix the issue and then figure out how much we improved the code in just about half an hour of work. Also, the issue that I found was a real issue, not a fake performance blip that I seeded the program with. That’s the great thing about the profiler, it makes it easier to find performance issues in code that you did not write yourself and are not familiar with.

Reviewing Data Display Websites and Programs: ESPN.com’s NCAA Tournament Challenge

ianhu — Tue, 22 Mar 2005 15:46:00 GMT

This is the third entry in my series of reviews of websites and programs that have to display a large amount of data to the user. By examining what sites do right and wrong, I can come up with good idea for how to make the data display better for the profiler that I’m working on. My two previous entries covered the Social Security Administration’s Index of Popular Baby Names and the Football Outsiders web site. In the spirit of March Madness, todays entry will be looking at the pros and cons of ESPN’s NCAA Tournament Challenge website.

During the NCAA tournament, ESPN provides a free bracket service to anyone who signs up on the site. Each year the site hosts millions of user’s brackets for the length of the tournament. As any sports fan (or compulsive gambler) can tell you, the numbers is part of what makes the NCAA tournament such fun. So how good of a job does ESPN do at providing a clean, quality interface and access to deep statistics? To answer this question, I’ll be looking at several important categories for a good data display UI design.

Interesting Information (Data):

There are two main sections that the common user uses to follow along with the NCAA tournament. The first section is the display of their bracket, pictured below. The applet is what you use to keep tabs on all your picks throughout the tournament. It uses a simple scheme of crossing out incorrect picks, while highlighting correct picks in bold green. Also, picks that cannot be correct (due to earlier losses) are in light gray. So you can see from my bracket quickly and easily just how much UConn not making it into the Sweet Sixteen hurts. In the top right of the bracket, you can get the info about the current amount of points you have, as well as some other interesting stats, such as how well you are doing vs. the entire nation, and how many possible point you have remaining to get. The possible points remaining is a very useful stat, you can correctly pick every team but one in the first round, but if that incorrect pick was your pick for national champ, then your possible points remaining will take a big hit. The bracket page provides all the major bracket info you need, as well as some interesting info as to the relative strength of your bracket.

The second main section is the scoreboard section. This section shows the scores of all the games being played on a specific date. For the games in progress it updates the scores in close to real-time, and lists how the most recent points were scored. While the visual design of this page can use some major work, it does provide the very basics that you need to follow the tournament. It would be very nice if they could put the game flow graphs used elsewhere (see picture below) on this page so that you can track the runs that teams make during a game. The game flow charts are smart little graphs that chart the scores of the two teams during the game, so you can see what team is making a run or continuing to fall behind. Also, providing some mechanism to access more info without leaving the page (perhaps mousing over a specific game) would be a nice addition.

Accessing Information (Functionality):

Here is where the NCAA tournament challenge website starts to run into some major issues. First off, the bracket page and the scores page need to get some better degree of interaction with each other. Why not have continually updating scores on the bracket page itself? In fact, the bracket page is often not updated until the end of a full day of play, greatly reducing its value to the user. Also, to actually get to your bracket, you have to dig through too many layers of menus from the ESPN.com homepage. ESPN should recognize what the fans want and give them a link straight to their bracket from the home page.

In regards to the scores page (shown below), it needs more information on the current events in the game. Instead of just posing the last score, post the last five major events to happen in each game. With a little better layout there would be more then enough room to add the five latest events. There are game by game update pages, but I see no reason why the main scoreboard page can’t be improved so that you can monitor several games from one window. As mentioned above, it would be nice to have some richer statistics available without having to open a new window for just one particular game.

Look and Feel (Sex Appeal):

The bracket page is a quality example of design for a web-based bracket. It is well proportioned, with almost all the space in it dedicated to user data. The color coding system works well and lets you sum up an entire tournament in a glance. My only major concern with this page is the useless text in the middle top of the page. The options surfaced here (such as the link to the bulletin board) would be better placed in a menu or a sidebar of some sort.

The scoreboard page, on the other hand, could use a large amount of graphical revamping. The overly cute “hardwood” graphics on the right side of the screen eat up tons of valuable real estate. Also, there is far too much clutter at the top of the page, which you must glance over before you get to the actual scores. I understand that advertising is needed in a site like this, but it should be placed in sidebars or at the bottom of the page. Perhaps a good redesign would replace the “hardwood” graphic on the right side with an ad bar, and move the scores up to the top of the page. This would also free more room for the individual game boxes to provide more data on current game events.

Summary (The Lowdown):

In summary, the NCAA bracket tools provided by ESPN are decent examples of data displaying websites. However, some layout blunders and lack of functionality keep them from being really laudable examples to use. Also, they need to provide access to deeper information, without making you open any new pages.

Later this week I’ll be back with the next walkthrough on analyzing a performance report in the IDE.

Improving .NET Application Performance and Scalability

ianhu — Wed, 16 Mar 2005 16:43:00 GMT

Hidden in one of the many nooks and crannies on MSDN is this massive (1120 Printed pages) guide to improving the performance and scalability of .NET applications. It’s been available for a while, but I just discovered it, and wanted to pass the goodness on to you. I’m just starting to work my way through it, and I can tell you that it is a very exhaustive guide to performance issues. Given the depth of the guide there may be many sections that are not of interest to you, so a good way to read it is to jump to the chapter that interests you the most and start from there. Even if you are an experienced developer, it can be good to brush up on performance issues. Remember that managed code (what with its garbage collection and JITing) brings a different set of performance issues to the table then native code does. Thankfully, the guide is also available as a PDF, so you can browse it offline as well.

Rico Mariani has a perf wiki up on Channel 9

ianhu — Thu, 10 Mar 2005 00:26:00 GMT

Interested in writing application that perform well? If you’re not just messing around in your parent’s basement, then you should be. It can be too tempting at times to not optimize your code for performance and just continue to up the minimum system requirements. But PC are reaching market saturation and users are growing less and less accommodating to having to buy a new PC every three or four years; especially if they aren’t working with CPU or RAM intensive applications like games or graphics. So now that you know that you need to write better performing code, how exactly do you do that?

The new profiler in Visual Studio 2005 Team System can help you find performance problems in already existing code. But the fastest way to better performing code is to be aware of performance issues from day one of development. In that vein, I’m providing a link to Rico Mariani's new Perf Wiki hosted on Microsoft’s Channel 9 community web site. Check there for some great articles about how to write performance code for both large scale and small scale applications.

Channel 9 Demo is live!

ianhu — Mon, 07 Mar 2005 21:23:00 GMT

The video demo of our profiler that I blogged about earlier has been posted to Microsoft’s Channel 9 community web site.

Check it out on the Channel 9 front page or link to the specific video post. There should also be an interview portion coming up soon, I’ll post here when it goes live.

Performance Tools demo filmed for Channel 9

ianhu — Fri, 25 Feb 2005 00:32:00 GMT

On Tuesday of this week I got a chance to demo our performance tools for Microsoft’s Channel Nine community web site. One of the community team members liked my blog postings (Part one, Part two and Part three are all up now), and contacted me about doing the demo. I was glad to say yes, as I generally enjoy the community work, and I don’t have any problems with interviews. So on the day of the demo, I was chilling in my office working on some bugs and looking around for a demo application to test out our tools on, and I was feeling pretty good about the amount of time I had to get my demo together (the demo was at 4 in the afternoon). Then my boss came in and was, shall we say, *surprised* that I didn’t have the demo application and script ready yet. I guess that low-stress attitude that I have isn’t always the best thing…although it does help keep the blood pressure low.

But regardless of the doubts, I was able to find a good application to use and I had plenty of time to prepare and practice my script. However, I totally agree with my boss that I should have gotten the demo application earlier; I was fairly lucky that the second app that I tried turned into a good sample. I was also happy that I was able to quickly use our tools to find a performance issue in the sample application. I didn’t even have to “seed” it with a fake performance issue to find. That is one of the best things about using our profiler; it makes it much easier to find performance issue in code bases that you are not familiar with.

Doing the actual demo seemed to go pretty well, as I usually don’t get too nervous in front of cameras. My only real issue is if my WPM gets too high, as cameras seem to make me talk faster then normal. After the demo, there was a small interview portion, where I got a chance to talk a bit about my team and about my work experience. Soon I’ll get to take a look at the demo, and if my team (and MS legal) gives it the ok, then it will be posted on Channel Nine in a week or so. I’ll be sure to post a link to it when it goes up.

By the start of next week I intend to have another post in my series of reviews of data-displaying web sites. My first review in that series covered the Social Security Administration’s index of popular baby names. Interestingly, you can also find that review by googling “large amount of useless data,” and by looking at result number three on that list. Hopefully that reflects on the topic of that article and not on my blog in general!

Reviewing Data Display Websites and Programs: Social Security Administration's Index of Popular Baby Names

ianhu — Wed, 16 Feb 2005 15:53:00 GMT

At a very general level, the main issue of my job is how to take a large amount of profiling data and present it to the user in a way that is useful, quick, intuitive and pleasant. While it may seem funny that pleasant was included in that list, look and feel is very important in the computer science world. Too many programmers design a product with great internals, but with an unsightly (but functional) UI and then wonder why their product bombed. The iPod is a classic example of this, why do so many buy iPods over less expensive but just as capable competitors? The simple answer is that the iPod’s classy looks (and advertising) made it a big hit, not anything revolutionary going on inside the little white box. Although in my eyes, Apple’s new iPod shuffle may be taking Thoreau’s mantra of “simplify, simplify, simplify” a bit too far. Anyways, that is enough digressing on iPods. The actual focus of this column is that I wanted to take a look at some laudable examples of programs and websites that display a large amount of data to users. I also want to give some negative examples of programs and websites that get it all wrong when trying to communicate data. By better understanding the connections between data and the people that use it, I can learn to do my job better and bring better profiling information to the users of Visual Studio.

The first website that I want to recognize is the social security administration’s index of popular baby names. This site is fairly clean and user friendly, as well as surfacing some very interesting information of interest to almost anyone. To better analyze the site I’m breaking up the review into several categories. I’ve provided a screen shot of the index page of the website below.

Interesting Information (Data):

If you want people to look at your data, you sure as heck better start out with some data that is of interest to the target user. The popular baby names website contains info on the names of babies born in the US from about 1880 up to the present day. This information is of interest to about anyone; the usual thing that most people would do first on this site is to input their own first name to find its popularity. Then they might move on to looking at what names are popular in different states, or what interesting names were popular in 1910. This is just the kind of meaty data that makes people want to poke around in it to find interesting factoids. The screenshot below is a picture of the results for entering my own name “Ian.”

Accessing Information (Functionality):

The front page of this website contains simple forms to access most queries that anyone would need to try. You can check on the popularity of a name over a given time period, overall top lists by years or decades, and popularity of names grouped by state. Sure it doesn’t have anything like full database access, but it covers all the major searches. Especially considering that it caters to the casual browser rather then to a researcher. The forms are all simple and self-explanatory. A good UI shouldn’t require willy-nilly labeling to explain what the function of every specific combo box is.

Look and Feel (Sex Appeal):

This site could be improved in this aspect, but it is still much better the most of the dross out there on the web. The site presents the access forms on the front page, an important feature for any data display website. An example of not placing your best access forms on the front page is the video game review site Game Rankings. The highlight of this website is the large index of averaged review scores for every modern video game (Being in the top 50 in this list is akin to being in the IMDB top 250). Yet the “The Rankings” form isn’t even on the main page, in the front and center spotlight as it so richly deserves!

If I was in change of a redesign of the baby names site, I would surface some more interesting options on the top menu bar, and put the contact info and Q&A links at the bottom where they belong. Also, the data access forms should be placed above the background info, which takes up far too much of the initial page view. The flow of the main page could use some work, as the gray boxes on the left side surface no useful information and break the reading flow of the page. If you are committed to putting non-functional graphical elements on a data display web page, at least make them something more interesting then gray boxes with useless text!

Summary (The Lowdown):

The Social Security Administration has put together a quality website on popular baby names. It overcomes some layout flaws by having a clean, easy-to-use interface to some very interesting data. Perhaps the SSA should pull some people off of website design duty and put them to work figuring out how to stop taking my paycheck to pay for a federal pyramid scheme!

Look for the next installment of my walkthrough of using the new Visual Studio Team System profiler by the end of this week.