Almost Without a Hitch…

I was able to get through one big upgrade of Windows Vista 64bit to Windows 7 (also 64bit) today in about 2.5 hours.  That included transferring over 1 million user files, programs and settings.  No hang-ups, no problems, except for this one:

Setup has detected that the .NET Framework version 4 needs to be repaired. Do not restart your computer until Setup is complete.

So, it got pretty close, but there were some casualties along the way.  Now, that said, I’m using Beta 2 bits for Visual Studio 2010, and on a big plus – after waiting about 20 minutes a little worried about a freeze – I got the ever-rewarding message telling me I was ready to go:

Other than that, my development machine and all of it’s endless list of software seem to be running a treat in the land of Windows 7…

…and Vista Vanishes

The last computer in my life not running Windows 7 is my primary development machine.  Today, in approximately 49 minutes, that’s all about to change:

I’m actually only going to be running this for a while…this machine is SO old school…at least six months old! 

The order for my new beast of a machine is off to Dell:

• i7 quad core processor – this is rated FOUR TIMES faster than my current processor config.  Nice.
• 8Gb Ram
• 1TB hard drive on Raid 0
• Windows 7…huzzah!
• 1Gb graphics with 2xDVI output plus two USB video adapters, which I need for the…
• Dell 21.5” multi-touch monitor…huzzah!  …along with the other three monitors tied to my system: 24” Wide, and 2x19” 4:3

So, this computer (now a mere 43 minutes away from Win7) will only serve me for a few weeks in a primary capacity.  Then it gets nuked for a clean OS install for the next owner.

We’re also very close to deploying our new NAS solution which will give me 6TB on raid 5 with 100MB/sec (yes, full gigabit transfer rates, woot!) just an IP address away. 

Ah…to be a geek!

Badass Box Selection

Brittany Behrens on Monday re-introduced the much-improved version of Box Selection that came out with the Visual Studio 2010 Beta 2 bits.  I was stoked about this earlier in the year.

I’m continually surprised when I see how many of my friends aren’t aware of so many of the time-saving tools that exist inside Visual Studio.  It feels more and more like you can “run” when you code and less and less like you have to push through it.

I found a neat little compound trick using a couple of the features that I routinely exploit.  Starting from essentially the same place as Brittany, I copied and pasted a list of variables into some multiline Console.WriteLine statements.  That was pretty cool.  Like Brittany, I was left with a series of semi-colons that I wanted to remove. 

To get rid of the punctuation, I simply redo the box selection and then invoke the Find and Replace dialog with Ctrl-H:

From there, I can employ a simple matching technique and scrub the semi-colons.  Just make sure you have Look in: Selection selected and hit Replace All.

If it were a more complex scenario, I could have also used regular expressions in Find and Replace (located in “Find Options”) to be more discerning on the text I was replacing. 

I Like Pushing Arrows

There is something else in here of a hidden gem that wasn’t fully revealed in the video but that I picked up on (I heard Brittany tapping on the keyboard and had to try it out): using the cursor keys while holding down Shift allows you to “walk the box” and change the shape of the selection.

After using Alt+Mouse or Shift+Alt+Arrows to box-select, use Shift+Arrows to alter the target of the selection. 

Let me Choose!

One thing that I liked in the video was that the white space was copied as well.  This left the pasted text block-aligned and ready to go.  The video obviously pre-dates the version of box selection in Beta 2, however, because as you can see from my above image, there is no whitespace after my variable names (watch the video to see the difference).

I think it would be good to have some optional, intermediary dialog box that you could call up (perhaps a la Office-Ctrl tapping) that would allow you to preserve or remove whitespace, punctuation, etc. 

I suspect that the visibility of the selection is made available to any plug-ins, but I also hope there is something by way of box selection events so that context menus can leverage this.  Not having worked with the extensibility bits around selection in the editor, I’m not sure if you can distinguish between box selection and stream selection when creating something to extend the IDE.

Visual Studio 2010 – Getting Around a Little Easier

There have been a number of improvements to Visual Studio that aren’t all as visible as some of the styling or new tools have been.  The newly announced Visual Studio Blog has member blogger Josh talking about the Toolbox Search feature.  We're not given Josh’s last name, but judging from previous forum posts related to the toolbox on MSDN forums, I’m going to assume it’s Josh Stevens (even then, not a lot of posts from him since VS2005 on the subject…).

Josh introduced the Toolbox Search which allows you to use the keyboard to quickly navigate to controls in the toolbox.  After a keystroke or two you can find the control you’re looking for and use the tab key to move to the next item. This is a nice touch, but would be even more handy if it did partial matches.  This would allow me to start typing in view and then press tab to move from DocumentViewer to ListView to Scrollviewer and on to Viewbox.

Another great idea for this one: share the idea with the folks who work on the Class Explorer!

Project Pinning

Also very cool on the list of features is the ability to ‘pin’ your usual suspects to the start page in Visual Studio.  This is a feature that I will make use of extensively.  My normal workflow gets me into at least three or four IDEs at a time – and I do a lot of my work in spike solutions – so my recent items list is not very useful most of the time. 

IntelliTrace

Very welcome in Visual Studio 2010 is the addition of IntelliTrace.  This feature adds incredible access to key debugging areas and information to an already incredible debug story in Visual Studio.

I can’t wait to really put this feature through the paces.  One of the biggest complaints I’ve had about the debugging experience in Visual Studio had to do with threads and async operations that end up exceptioning out.  IntelliTrace looks as though it may help me out with finding all the broken parts of my app. 

Without taking anything away from the existing debugger, IntelliTrace gives me the ability to walk through events that have been fired since application start up, making it way easier to find and fix those non-repros in your bug list.

You also have the ability to save IntelliTrace data off of test machines, giving you the ability to stuff the log files into a work item to be shared with anyone on your team…there is a host of ability buried in the product and once you have Team Foundation Server set up (I don’t have the lastest build installed yet) things are going to get very interesting!

Fast Split View Re-Orientation

This is actually something that was around in the WPF designer in Visual Studio 2008, and it’s back again in Visual Studio 2010.  This feature is activated while working on WPF projects and allows you to either stack your split view horizontally or vertically on the screen.

I have a big enough monitor that I can work comfortably side-by-side with most of my code, but it’s still super handy to be able to throw the designer up top (or below) when working with longer or more intensely with the XAML.

Unfortunately, this feature was not extended to the Asp.Net designer for Aspx pages as I had hoped it would be.  Oh well, I guess there’s always Visual Studio 2012 to look forward to!

I’m Just Sayin’…

More and more features are revealing themselves and processes are better streamlined everywhere I look (even dialogues for things like adding a project to an existing solution).  If you’re a geek like me, this is gearing up to be a pretty exciting tool.  While I don’t get to hit PDC this year, I hope they post the session after the fact for Paul Harrington’s talk on ‘porting’ Visual Studio 2008 to WPF and hear of the challenges and wins that they got to experience ahead of the rest of us.

Word 2010 – Background Removal is Awesome

 

I’m really enjoying Office more and more as I use it.  I just came across this great little feature called Background Removal that is fun to play with and really neat to watch it work.

The idea is pretty simple: you have a picture that has some background element to it that you want to take out.  You highlight the area containing the subject you would like to keep, then the magic algorithm kicks in and subtracts out the ugly parts.  Nice.

My guess would be that they are sussing out the selected portion of the image for a number of cues: sharpness, color variation, separation of back/foreground through focus, etc.  Though this sounds easy, I once worked on a graphics library that figured out if there was “direction” visually present in an image (like prominent vertical, horizontal or diagonal lines) and know that this kind of work is tough…especially with the speed that this tool works at.

For power users, the tool is located on the Picture Tools menu for selected images.  Skip to the end of this post to see the end result.  Otherwise, here’s a step-by-step":

First, find a picture that you want to work with:

Next, view and copy the image to your clipboard:

Paste the image into Word (or any Office application) and select the image by clicking on it.  You’ll know that the image is properly selected when there are handles on it and Word’s Ribbon interface has the “Picture Tools” option added to it.  By the way, who picked hot pink for a UI color?

Select Format under the Picture Tools ribbon and click on Background Removal.

Next, play around with the bounding box to help instruct the Background Removal tool on how to better figure out what is foreground and what is background.

You can also use the “Mark to Include” tool to further tune the selection. 

Lastly, press ENTER to see your final result.

Dang.  It’s literally 4-5 seconds to do this.  Do you know how many man-years I’ve spent in Photoshop doing this?  Hehehe…it’s not perfect by any means, but for 95% of what you do this will likely work. 

My best guess would be that anyone doing presentations and trying to incorporate product or people shots while dropping the backgrounds will now look a lot more pro.  This is a significant improvement over the previous hit-and-miss method of “Choose Transparent Color”.

Nice work, Office folks!

Visual Studio 2010 Intellisense Wish List

The folks on the IDE team for Visual Studio 2010 have made some great improvements to the editor’s intellisense experience for developers.  Most notably, the following features have been implemented:

• Keyword-based searching on type members
• Type based searching
• Pascal Case inference (instead of ActionLink you can find the member with AL)

For the complete story see Scott Guthrie’s take on the features.

One thing that I would have really liked to have seen would be a feature that filters based on local scope and type.  For instance, if I am looking for a string in Visual Studio 2010, here is my experience:

Now, it doesn’t really make sense to say bar = float (or any enumeration, or any type without static fields, etc).  Arguably, one might suggest that there are cases where you would want this, most likely in cases where you’re working with reflection or code generation, so they need to find a way to work out both stories, rather than anyone’s “best” story…which we all know won’t be the best for everyone.

What about taking a cue from the Office folks and the story they’ve written around paste?  I think it would be great if when intellisense was invoked, you could tap on CTRL and intellisense would immediately filter the list to in-scope strings.

Strings are only a simple example here.  There’s nothing quite like declaring an instance of a custom type then trying to assign it’s value to finally.  What? :oP

Take this to the next level as well: if I’m assigning a value to a string, and I’m looking for a property on a class instance, when I invoke intellisense, I could tap CTRL and filter the list of type members down to just strings (much like they’re already doing with keywords).

I suppose no matter how smart the people are that you put in a room, no matter the engineering feat accomplished to put off something so complex and render it simple to the end-user, there will always be some twit like me with a blog saying, “Yeah, but…”

So, I will state this: We are in a weird loop when toolsets and SDKs are competing with the IDE for completedness and maturity, so Visual Studio 2010 promises to be a real refreshing release.  There are a just a ton of things right with the direction of the IDE and this last build (Beta 2) is a performant, welcome foreshadow of the next generation of Visual Studio.

Go-Live License With .Net 4.0

Woot!  I can officially move our apps developed to target the 4.0 framework for .Net from the test/development environment to our production server.  I just caught this from Scott Guthrie’s blog:

.NET 4 and VS 2010 Beta 2 include a “go-live” license which means you can start using the products for production projects.

Also, and I’m loving this as being part of the Web Spark program, the Visual Studio 2010 Ultimate:

also includes 250 hours/month of Azure cloud computing.

Yum.  I’ve been playing with Azure and have worked through the samples while keeping in mind a project I’ve had on the backburner for 2 years now.  With this feature at this kit level, I will have access to the cloud for over 8 hours a day.

Time to get my code on.

Visual Studio 2010 Beta 2

It’s out and it’s rockin’.  I’ve been running it on a VM and, after Beta 1, it’s considerably faster (and truth be told, I wasn’t really complaining about performance on Beta 1).

Per Phil Haack’s post on ASP.Net MVC 2 Preview 2, I was expecting some tooling for MVC in this build, but alas, it did not make it into the release.  I’m really digging the idea of built-in tool support for areas, something that MVC is already paining me to require (and I suppose I’ll have to get the bits for 2008 to use the feature).

There seems to be less chrome, as well, per this dual-purposed screen capture:

One feature I am glad to see in the mix is the ability to close a child window in the IDE that does not have focus.  When you hover over a tab, a small X is displayed in the highlight area allowing you to close a document without having to switch to it first.  This is something I actually recommended to the IDE folks. So, yeah, I’ll take credit for that one.  ;o)  …and I’m sure no one else asked hehehe…

Contravariant Indices

I always find myself summing over related indices when working with co-ordinate frames, so the metric tensor trick employed by Einstein’s summation convention seemed very natural to me when thinking of enumerable collections and watching this video.

Yeah right! ;o)

This is a great video and really provides some amazing insight into the workings of the upcoming Rx framework, Microsoft’s addition to .Net which addresses observable collections and multithreading concerns that many of us didn’t have vocabulary to previously describe. 

We are standing on the edge of a fundamental shift in the way we approach programming – with new processors, functional programming blending with procedural, faster, multi-core systems on everyone’s desk – and this is one of those libraries that further evidences the change. You can be certain of it because of this screencap:

Let me be clear: any library introduced with an example of a fruit array accepting a new Banana must be genius.

I wish I would’ve seen this earlier in the summer to get a crack at some of the early bits, but you can be darn sure I’m givin’er a whack over the next couple of days!

The framework is also being called the .Net Reactive Framework, though I’m not sure if the name will stick as some Microsofters are out in the forums and have not promised the name.

The above image is Erik Meijer explaining the symmetry of IEnumerable and IObservable, one of the new interfaces in Rx.

The basic idea is that Rx is the “mathematical dual of LINQ to Objects.”  There are two primary components: a couple of interfaces to help work with observable collections in a push-model, and the LINQ extensions and helpers written to code against those interfaces.

I have really enjoyed working in the asynchronous space and sometimes have struggled leaving threading out of my apps.  I think there is something beautiful in turning over control to the machine. It is cool when you get to a point in the app where the metrics you’ve implemented give you the confidence you need to “unleash” your code on your processor in a way that you can’t really monitor, and even more rewarding when you see the results.

Full link to the video:

http://channel9.msdn.com/shows/Going+Deep/Expert-to-Expert-Brian-Beckman-and-Erik-Meijer-Inside-the-NET-Reactive-Framework-Rx/

Or you can watch it here: