To better coincide with my company, my blog has moved to https://blogs.counterpunchsoftware.com; I hope to see you at that new location!

Thanks,

Eric.

Sorry, in my Hemi tool, I’m using a 3rd party control from Component One.  I have a license for their tools and they allow redistribution.  The file you need is located here: C1.Win.C1FlexGrid.2.zip.

Thanks to Grant for spotting this so quickly.

Eric.

I’ve posted the tool to: https://www.counterpunchsoftware.com/downloads/hemi.release.zip.  You’ll also need: C1.Win.C1FlexGrid.2.zip.

I included the Team Foundation Server binaries that it depends on, but the best way to run the tool is just to run Hemi.exe from the Visual Studio Tools Command Prompt.

Hemi starts up and looks as follows:

I’m thinking about using a MDI type of interface in the future; that would enable you to save and re-run moves that you might do on a regular basis. 

To start moving work items, the first thing to do is use the File menu…

This starts the various stages involved in moving work items from one team project to another. 

The first thing to do is pick the Team Foundation Server that you want to access.

Depending on the authentication that you are using, you may get prompted for credentials.  Once you’ve chosen a Team Foundation Server, the next step is to select the work items that you want to move.  This is done by selecting a Team Foundation Server Query.

Pressing this button will bring up the same work item query control that is used in the Excel integration. 

Once you select a query, press the Find button on this dialog to bring up the actual work items.  Press OK and you’ve established the work items that you are going to move.  Now select the Team Project to move these work items to.

Once you’ve done that, press Next to move on to the next stage.

Any query that you might use might encompass a few different work item types, so in this stage, you’ll decide how to map those work item types to the Team Project you are moving the work items to.  In most cases, you’ll probably move the work items to the same type in the other Team Project. 

But, sometimes work item types are defined differently.  For example, in a CMMI project, a bug is defined with two required fields – Symptoms and Steps to Reproduce.  These fields aren’t required in an Agile project.  So, this stage also gives you the chance to fill these missing values in.  Press the Check for Missing Values to see what these missing values are.

If there are any, enter values into the table.

Press Next to move on to the next stage and actually move your work items.

This stage shows you what work items will be moved, as well give you a couple of options for your original work items.  Team Foundation Server doesn’t support deleting work items, so your original work items will still exist.  By default, Hemi will create a Moved state for these work items and assign them to that state.  Also, it will create links between the original work items and their new copies, and vice versa.

Once you move to the next stage, your move will be committed! 

If you look at your original work items, what you should see is that it is in a Moved state:

And also, your original work item will be linked to the new one, and vice versa.

Anyways, I hope you find Hemi useful – if you run into any bugs or have suggestions, please let me know.  Either through this blog or email me at eric@counterpunchsoftware.com.

Thanks!

Eric.

Well, the time has come.

After 8 years at Microsoft, I've decided to pursue a long-time dream of running my own business.  My new venture will be in a Seattle-based consulting company, CounterPunch Software (www.counterpunchsoftware.com).  Not surprisingly we (or more accurately I) will be focusing on Microsoft technologies and solutions.  My last day at Microsoft will be towards the end of November.

Not too much will change blog-wise – I believe that I am still allowed to have my blog on MSDN so I’ll keep it here.  MSDN has been pretty good to me, and I’m loathe to change my blogjet settings

I will always look back on the past 8 years with fond memories.  I'll apologize for not thanking everyone individually, but I've enjoyed the tremendous privilege of working with, and learning from, some of the smartest and most passionate people imaginable.  For that, I'll always be grateful.

It's a cliché of course, but it really does seem like yesterday when I walked into building 44 to start my first day at Microsoft.  At the time, I thought I was joining what was then known as the Visual Interdev team, little did I know that I had already experienced my first re-org and had been transferred to the Visual J++ team :)  In any case, it all worked out very well

I’ve always been very passionate about Microsoft products – particularly, but not limited to, developer tools – and the folks who use them.  I think, and hope that my new venture will allow me to get closer to that.

My new email address is eric@counterpunchsoftware.com.   

Anyways, just a personal update

Thanks!

Eric.

As you can probably tell, the bright shiny lights of the soon-to-be-released products like Windows Vista and Office 2007 have caught my eye lately.  I promise I’ll be back to Team Foundation Server blogging soon.

I’ve been playing with a feature in Windows Vista that I thought might be useful for development teams who are practicing Extreme Programming.  The feature is called Windows Meeting Space and is one of the out-of-the-box applications that takes advantage of Windows Vista Peer-to-Peer networking and more specifically, People Near Me.

Both Peer-to-Peer networking and People Near Me are vast areas that I don’t fully understand; Justin Smith does a nice job of talking about the technology in his recent MSDN article.

In terms of leveraging what is already there, Windows Meeting Space struck me as an easier to use netmeeting/netsharing/livemeeting technology.  It seems perfectly suited for a quick code review, or paired programming session.

I found Windows Meeting Space from the handy search dialog in the start menu:

Starting a meeting is pretty easy – easier than most of the Microsoft collaboration tools I’ve used.  Basically pick a name and a password.  I like how Windows Meeting Space puts the time into your name automatically.  You could also search for existing meetings.  Let’s say that we’ll create a code review meeting.

Once created, you can invite people from the menu.  This is where People Near Me (PNM) comes into play.  PNM is supposed to search your subnet for peopled who have chosen to broadcast their identity.  From this list, you can invite people to join your meeting.  It might have been because of mismatching versions of Vista, a weird network connection, or something else, but I was never able to get a list populated with people near me. 

In any case, you can use the “Invite others…” button to create an invitation file that you email around.  Or, people in your network can use Windows Meeting Space to find this meeting, and invite themselves.  For example, on my other Windows Vista machine, I’m running Windows Meeting Space and I can see this meeting we’ve just created:

Suppose that we were given the password out of band, we’re able to join this meeting.

Now we can start some sharing and do our code review.  If you press the sharing icon in the meeting, you get a choice of what kinds of applications you want to share.  The PNM API supports a way to determine whether the attendees of your meeting have the same application or not.  In our case, since we are doing a code review, we’ll share Visual Studio.

As the person you initiated the sharing, you see a subtle tool bar in your desktop that says you are doing the sharing.  You have the option of stopping your sharing, pausing it and even sending it to a projector.

On the other side, for the folks who are attending the meeting, they see Visual Studio embedded into their meeting space window.

The image of VS that I have there is really squeezed, it is because I only have 1 monitor, so I have to show both my host VS instance as well as my shared one on the same real estate.

Anyone in the meeting can request control of the application and make code changes, comments etc.

None of this is necessarily anything new – you could always share with LiveMeeting and Remote Assistance and what not, but somehow Windows Meeting Spaces feels easier to use than all of those technologies.  I like that you don’t have to explicitly send out invitations if you don’t want to; you can just search on your network for a meeting to join.  Also, I like that there is an API underneath the covers; in theory you could build this type of sharing into right your application.  For example, for Visual Studio, maybe you could setup sharing for individual document windows or something?

In any case, I thought this might be an interestig feature in Windows Vista, so I thought I would share.

Thanks!

Eric

Thanks!

Eric

Thanks,

Eric

Exchange is a Microsoft technology that I’ve used everyday for email, but never really delved into as a developer.  I’ve been working on some Office 2007 stuff, so I figured I would give it a try.

I was absolutely knocked out by how much you can do as a developer with Exchange Server 2007.  There are a number of things, but what really caught my eye was the Web Service API.

I’ve experimented with CDO and MAPI a little bit in the past, but I’ve always struggled with it.  It was always a struggle to download the version of CDO/MAPI that matched my server; and even the most trivial task like sending an email seemed really difficult.

But, with Exchange Server 2007, you can access a wide range of its functionality through its web service API.  I didn’t find a lot of documentation about the API – a lot of it seems to be a work in progress – but I managed to get some of it working, so I wanted to share what I’ve learned.

First, I downloaded Exchange Server 2007 from https://www.microsoft.com/technet/prodtechnol/exchange/2007/downloads/beta.mspx.  The installation was relatively painless.  The setup is quite good, there were a few prerequisites that I didn’t have, so I was notified and had a chance to restart the setup.

The exchange web service is located at https://<yourserver>/EWS/Exchange.asmx, so you can literally just add a web reference to that URL and get a proxy class generated for you.

The main proxy class is ExchangeServiceBinding, you can instantiate it just like any other web proxy class.

The exercise I took myself through was fairly straightforward – what I wanted to do was to expand a distribution list to see who belonged to that list.  For each person on that list, I want to check their availability.  In other words, I want to see if they are available for a 1–hour meeting today.

The first thing to do is to expand out the distribution alias – Exchange Server 2007 has a web method to do exactly this, so it is just a matter of making the call.

You’ll notice something about the Exchange Server 2007 API that you may love, or you may hate.  Notice that the ExpandDL takes a single parameter – an instance of ExpandDLType.  That type contains members for all of the information that ExpandDL might need as input. 

In my experience, there are essentially two main schools of thought about how to define a Web Service API. 

One school of thought is to develop web service methods just like they are ‘regular’ methods.  For example, if a web service method needs 4 parameters for input, that web service method signature would have 4 parameters.  It is pretty intuitive for developers to use a Web Service API like that.

Another school of thought is to develop web service methods as though they were endpoints to which documents were submitted.  I was introduced to this approach when I was a developer on the UDDI feature in Windows Server 2003.  That is how we defined our web service API.  There are pros and cons to this approach.  When you take this approach, you typically start designing the web service method from the XSD schema onwards.  When you have to worry about interoperability, this isn’t a bad approach at all.  When I worked in UDDI, we worked with other companies to be sure that our UDDI implementatio would work with theirs.  Whenever we met, we would work on defining just the XML schema.  That helped because some companies used Java, some script and we used .NET to implement our version of UDDI.  It would have been difficult to talk about programming interfaces since there were so many in play.  What is also helpful about this approach is that you can use XSD schema validation to do some basic parameter checking.  For example, consider the following XSD type:

Exchange Server 2007 uses this type as a return value of sorts when you make a request to see a user’s oof (out of office) settings.  It’s funny to see a relatively colloquial term like OOF make it into the API of a enterprise messaging solution   Anyways, the author of this API is using XSD and its ‘minOccurs’ and ‘maxOccurs’ operators to define what is essentially the post-condition the operation to retrieve a user’s oof.

This can be good for both the producer and consumer of the API.  For someone who is looking to use this API, the XSD gives them an idea of what to expect as a return value.  When you have detailed documentation, this isn’t a big deal, but when you have a new API like with Exchange Server 2007, reading the XSD is critical.  For someone who is developing this API, there is validation that is usually done on the outgoing end of the web service.  Each outgoing message (i.e. GetUserOofSettingsResponse) is validated against its schema.  If it violates something, it is returning something the user is not expecting, so it fails.  Essentially, you are checking against the contract you agreed upon with your intended caller.

This approach was really helpful for us in UDDI because our shared UDDI specification was always changing.  What we did was put XSD schema validation on the incoming and outgoing ends of our web service.  Whenever we got a UDDI message, we validated it against schema before we passed it on to the appropriate method (ASP.NET allows you a hook to do this before it delegates to the appropriate web method).  If the incoming message didn’t pass validation, that meant it would give our actual method trouble of some sort.  Either the signature didn’t match, or the expected parameters changed.  In any case, if the message failed validation, we threw an exception right away.  On the outgoing end, we validated each response message we sent against its schema.  If something failed validation, that meant whatever we were returning was not what was expected by our caller.  Again, we threw an exception in this case.  Whenever our UDDI specification changed, we just uploaded the new XSD schemas in our system.  Whenever the UDDI design committee decided that a given parameter must occur at least once, but not more than 5 times for example, they put it into the XSD.  And through XSD validation, our code automatically checked for that condition.  That saved us from spending a lot time writing and changing our input and output validation code.

All that said, there are drawbacks to this approach as well.  Mainly, it feels weird if you’re coming from a pure programming perspective, and instantiating a bunch of composite classes can be a pain   Once you get used to it though, it’s not so bad.

OK, enough about XSD and web service API design methodologies and back to Exchange Server 2007.  Once you make the call to expand the DL, you basically get back a set of email addresses (sort of).

What you get back at first is a collection of response messages.  I’m not sure when there will be more than one response to your request, maybe if there are clustered/linked Exchange servers.  In any case, in any given response, there is a collection of email addresses.  The double loop to go through this looks like:

I should mention, I don’t work at a fashion design firm – the context of the code being shown is for a demonstration that I’m working on

What our inner loop, as illustrated above, is working through is each member of our distribution list.  Each member may be a person or another distribution list itself.  I didn’t write this code, but what we should do is check for the type of member that we got back.  There is an enumerated type on EmailAddressType that we can check for:

If this is another DL, I suppose you might want to go through and recursively expand each one.  We won’t do that in this simple example, so let’s assume that each member we get back is just a person and not another DL.

If that’s the case, the only thing we need to do is define what our meeting time looks like:

And make the call to check the user’s availability.

I skipped some of the plumbing code – mostly setting up some of the parameter types.  I’m having some trouble with my FTP server, but I’ll post the rest of my code tomorrow.

That’s about it – the next thing I’d like to look at is actually creating some lists and folders in Exchange 2007.

Thanks!

Eric

When I first started at Microsoft 8 years ago, I was an awful presenter.  I hardly made any eye contact and I spoke really, really, really fast.  Over the years, I’ve had some training by some really good instructors and gotten a lot of practice.  Now I like to think of speaking as one of my strong points.

Mentally, I’ve been keeping a little list of tips and tricks – many of which have come from fellow speakers – that have helped me.  I thought I would share some of them in this post.  A lot has to do with doing technical demos since I feel like that is one of my strong points in any presentation I do.

Make sure the audience can see what you’re doing

It can be really hard for an audience to see things on the screen when you’re doing a demo; particularly in a complicated user interface like Visual Studio.  There are some things you can do, and utilities that you can use to help them out. 

• ZoomIt is a great tool for zooming in on specific parts of Visual Studio (thanks for the tip Martin Woodward!)

Try the following from Tools -> Options in Visual Studio

• In the Environment->Fonts and Colors setting, make the text editor font use at least size 16 and change the font to Lucida Console (I find this font shows the larger text better).  Try to make this change before you speak because the first time you access the Fonts and Colors settings it takes a long, long time.
• Turn your system font up to Large from the properties of your Windows desktop.  The Visual Studio tool windows will pick up this larger font.  Make sure to test all the windows that you are going to show since some VS windows don’t handle the large system font that well.  You might have to restart Visual Studio as well.
• Try hiding as many tool bars as possible to keep Visual Studio from looking cluttered.

Keep things snappy

Performance is always important for any demo that you might do.  It goes without saying to get a machine with as much RAM and CPU horsepower as possible; here are some of my other favorite tips.

• If you’re running a Virtual PC or Virtual Server, a secondary hard drive is an absolute must.  Virtual PC and Virtual Server are really IO intensive, so if you run a virtual image on the same hard drive as your native operating system, you will get a lot of contention on that drive.  Another hard drive, either native in your computer or USB does wonders.
• Buy as much RAM as you can afford/fit into your machine – at least 2 GB is ideal
• Try to use fast hard drives, at least 7200 RPM.
• I’m addicted to defragging my VPC drive – I do this after almost every time I run a virtual PC image.  The built-in defrag utility in Windows is pretty good.  The commercial product from Diskeeper seems to defrag faster and can be put on a schedule.  I’m not sure if it does a better job or not.  I’ve also used a free tool from https://www.flexomizer.com/PermaLink,guid,ce99367e-158c-487a-879d-b32145cc1957.aspx.  That tool probably takes the longest, but does the best job I’ve seen.  Thanks to David Whitney for writing this tool! 
• There are tons of ways to optimize your VPC images themselves.  A good document can be found at: https://blogs.msdn.com/nolansax/attachment/700992.ashx.  These tips really do make a big, big difference in performance.
• Before you finalize your VPC image, try running CCleaner.  This handy tool cleans up IE history, old setup files and a bunch of other bits of data cluttering up your system.
• If you can, don’t use differencing drives – they are really handy, but they eat up your performance.
• If you can, don’t enable undo drives – again, undo drives are super handy, but they do eat up performance.  Despite this, I tend to run with undo drives enabled.
• If you turn off themes in the VPC OS, or set the UI to maximize performance, your image will run faster.  I don’t usually do this because I don’t like the way the display looks.
• For Visual Studio Team System demos, my colleague, Ajay Sudan has a nice technique where he runs a Team Foundation Server in a VPC, but uses a natively installed Visual Studio to access it.  That’s a nice combination because you can’t beat running the client bits natively when it comes to performance.
• This can be time consuming, but I think it’s worth it.  If you’re showing Visual Studio, open up each file type (i.e. C# files, resource files, etc) and note what tool bars they enable in Visual Studio.  To maximize the perceived performance, close every tool bar that every document you are doing to show enables.  This way, when you switch from document to document in Visual Studio, there are no delays from drawing the tool bars.

Slow Down!

This is something that I use to really, really struggle with - trying to slow down my speaking pace.  What I’ve found is that I can’t just tell myself to slow down.  What I try to do is concentrate on maintaining my volume from end-to-end when I’m presenting.  One thing I’ll notice when I’m speaking quickly is that my voice tends to trail off at the end of a sentence.  This is usually because I’ve used one breath for the entire sentence and by the time I get to the end of that sentence, I’ve run out.  Using one breath for a sentence like that is usually a sign for me that I’m going too fast.  So, I concentrate on making sure I take a breath somewhere in the middle so that I can finish strong.  To get that breath in, I’ll need to pause somewhere between my words.  With some practice, I’ve been able to take a quick breath and still sound like I’m speaking naturally.  That has really helped me slow down.  I’m still a fast speaker, and I probably always will be, but what I’ve found with trying to breath better is that I can make myself easier to understand.

A funny thing to keep in mind is that I think that no matter how experienced of a speaker you are, there is some inaccuracy in how you perceive yourself and how your audience perceives you.  This is particularly true for pace.  What tends to happen is that when you’re trying to slow down your pace a bit on stage, your brain will tell you that you’re speaking way too slowly and that you sound like an idiot.  In reality, you sound perfectly normal to your audience.  This is where video tape comes in handy.  What I’ve done in the past is record myself speaking at various speeds.  I’ll go really, really slow; so slow that I can barely take it  and then go watch myself on tape.  What I’ve noticed is that you can go really, really really slow and feel awkward doing it, but it looks and sound perfectly normal.  I didn’t have to do this too many times before I got a better at gauging my actual pace versus my perceived pace.

All that said, the last thing you want to do is stretch out every single word and put your audience to sleep.  Varying your pace is always good and makes you sound (and be) much more a genuine speaker.  If you’re excited about something, let yourself speak a bit faster, a bit louder.  Just be sure to slow down now and again when you wanto make a point or do a re-sync with the audience.

Enjoy Yourself

We’re lucky to be in an industry that is driven by so much passion.  If you’ve taken the time to put together a presentation, take the time to enjoy delivering it.  No matter how badly you think you did, chances are it wasn’t that bad.  Chances are, you did a good job.  In almost all cases, your audience wants you to succeed – so if you meet them 1/2 way, you’ll have done a nice job more times than not.

Anyways, just some thoughts I wanted to share.

Eric.

One of my projects at work right now is to work on the keynote demo that will be delivered at Tech Ed Barcelona later this fall.  Not to give too much away, but one of the things we might try to cover is the developer angle for Windows Live.  So, I thought I would give this alerts thing a try.

I went over to https://signup.alerts.live.com/brochure/index.jsp and registered the RSS feed for my blog as a provider of alerts.  The sign-up experience was a pleasant surprise.  The form was pretty short and a few minutes after submitting it, I received an email with a confirmation link.  After clicking on the confirmation link, I received another email a few minutes later with the following image/link:

If you click on that link, you’ll have the option of signing up for alerts from my blog

Oh one thing – you’ll notice that my alert is called ‘Fabrikam Design’ – I named it that to match the fictious company name we are using for the demo.

Thanks,

Eric.