Don’t bother with the tinyurl link, unless you’re into yet another blog post/article about the future of twitter.

If you enjoy our post, feel free to subscribes to our rss feeds

IE8 includes a new syntax highlighting View Source tool similar to what is available in other web browsers. However, you may not want to use the built-in, view-only tool. It’s easy to change.

1)

Start Internet Explorer 8 if it isn’t already started. Within IE8, click the Tools menu, then select Developer Tools (or just press [F12]).

2) Then, from the developer tools, select File, Customize Internet Explorer View Source, and then Other….

A file open dialog is displayed. Navigate to the application you want to use … for example Visual Studio 2008:

That’s it!

Note (how to completely reset Internet Explorer 8 View Source option):

When I first installed IE8, after having installed earlier builds of IE8 (beta and RC), I wasn’t able to reset the view source option back to the Default Viewer. (I’ve later noticed that even after selecting Default Viewer, it never actually leaves the Default Viewer option selected, even if that is the current option). After some registry hunting, you may need to clear out a registry setting that is incorrectly set.

HKEY_CURRENT_USER\Software\Classes\VirtualStore\MACHINE\SOFTWARE\Microsoft\Internet Explorer\View Source Editor\Editor Name

The Key’s (Default) value was set to Notepad on my machine, which would cause IE8 to always use Notepad to view source, even though I wanted to use the built-in view source option. I cleared the value (but did not remove the key) and everything began working as normal again. Using the menu option within the developer tool’s in IE8 does not appear to set this value correctly, even though it is used as a potential supplying key/value.

Hope this helps someone!

If you enjoy our post, feel free to subscribes to our rss feeds

Via Scott Kelby, “Top Ten Annoying Things That Photographers Say to Each Other.”

Although most weren’t really that funny, #8, “Dude! Dude! You’re in my shot!” brought back a memory of a recent trip to Oregon.

My wife and I were visiting Oregon and were hitting a bunch of hiking and view spots near the Columbia River Gorge area and stopped at Multnomah Falls. The falls, from the ground view that is most accessible to tourists, is actually partially blocked by a wonderful stone bridge that connects two plateaus. 

There are often people in these popular tourist locations that want to be in control — such is the nature of some people (unfortunately, probably more often than not U.S.A. citizens). There were several people standing at ground level, YELLING up at the people on the bridge, “GET OFF THE BRIDGE! CLEAR THE BRIDGE!” Over and over and over. They wanted to take a picture without the people obscuring nature.

My personality – I said to my wife, “I’m running up to the bridge to wave down at these morons.” She decided for me that I wouldn’t do that. Needless to say, the people standing on the bridge didn’t move.

Although I would have liked to have a picture without all of the people – I didn’t mind there were people as it was part of the experience. We weren’t alone there – why should my photos show it any other way?

If you enjoy our post, feel free to subscribes to our rss feeds

Put together by Microsoft’s Internet Explorer team …

Watch

If you enjoy our post, feel free to subscribes to our rss feeds

Do you need a way to switch between the beta version of the tools for Visual Studio 2008 for Silverlight 3 and the released version of Silverlight 2?

Thanks to Amy for posting a solution here.

If you enjoy our post, feel free to subscribes to our rss feeds

Some compelling new announcements:

Expression Web SuperPreview

Expression 3 Blend (download now available here).

Silverlight 3 – lots of new things, but it’s a developer only release, no go-live license. Finally an Out-of the browser experience (download, and run-offline!)

If you enjoy our post, feel free to subscribes to our rss feeds

Sometimes using the same display template in web applications can lead to amusing/gross errors:

Not sure that used Shells & White Cheddar would be as tasty.

(Amazon is running a good deal thru the end of March 2009 on these and other Annie’s products right now if you’re interested, here. We really like their Shells and Cheese – better than that blue box you might be familiar with.)

If you enjoy our post, feel free to subscribes to our rss feeds

Although my Mix09 entry didn’t place/win, as promised I’m posting the source code, as-is. It’s not the final completely condensed version that I actually submitted (as that version had carriage returns/line feeds, tabs, etc. all removed).

Download Source

As a consolation prize, I did receive a limited edition T-shirt just for entering (which admittedly, didn’t make the effort worth while – but, I had fun putting it all together nonetheless).

I’ve programmed in many nasty, strict environments over the years, but it felt really dirty to do this in c#:

DateTime _t, _aL, _tS;
B[] _b, _e;
Random _r = new Random();
double TW = 12, TH = 12, SY = 50, MW, MH, SA, G = .03, CSA, SSA;
Point A;
int CW = 20, CH = 40, TB = 21, _s, GM = 0, _c, BR;
Brush _o;
IsolatedStorageSettings _a;
delegate void PAD(Canvas c);

Yeah. Seriously, those were the variable names that I used to keep the file smaller.

I shrunk the standard Application class down to it’s bare minimum and used Lamda expressions everywhere:

public partial class App : Application
{
    public App()
    {
        Startup += ((s, e) => RootVisual = new Page());
        UnhandledException += ((s, e) =>
        {
            if(!System.Diagnostics.Debugger.IsAttached)
            {
                e.Handled = true;
            }
        });
        InitializeComponent();
    }
}

and …

Loaded += ((s, e) =>
{
    _a = IsolatedStorageSettings.ApplicationSettings;
    btnP.Click += ((o, a) =>
    {
        cMs.Visibility = Visibility.Collapsed;
        RG();
        GO();
    });

Last but not least, this was probably the silliest thing I did to stop needing to use the Canvas class everywhere directly (it was still necessary in some places):

class C : Canvas
{
}

You’ve got it. I derived from Canvas so I could just refer to the Canvas class as the letter “C”! Thankfully, it wasn’t sealed.

The code does the necessary math to compute an Isometric view of the game table so that the balls on the table are properly placed.

Fully condensed down, I think I ended up with 240 bytes to spare.

(Are you going to Mix09? Sounds like some great stuff will be announced!)

If you enjoy our post, feel free to subscribes to our rss feeds

Dear web site owner,

My distrust of your web site and product increases ten-fold when you add dozens or hundreds of search words or phrases to your web pages in order to potentially lure unsuspecting Internet searchers.

In the example above, Word reports that there are

487 extra words on your page (none of which are standard copyright text) and 3,472 characters total.

If you have a good web site or product, they will come. I promise. Get rid of the slimy techniques to draw traffic. You may have drawn me there, but I almost always move on as soon as I see that type of nonsense. You must have something to hide, or your product is inferior. You’ve just lost a repeat visitor and/or customer.

Signed,

Concerned about your giant footer.

If you enjoy our post, feel free to subscribes to our rss feeds

I needed a simple method for doing some timings in Silverlight. Silverlight lacks the high performance query counter that is available natively in Windows (and available in .NET 3.5 for example), but it does have a TickCount. My code (mostly) mirrors the existing .NET Stopwatch class using the TickCount property of the Environment class.

Just create an instance of the class and call Start to start the timer, and then get the value of one of the  ElapsedNNN properties to get a live reading without stopping the timer or the Stop function to stop the timer completely.

using System;

namespace WiredPrairie.Silverlight
{
    /// <summary>
    /// Stopwatch is used to measure the general performance of Silverlight functionality. Silverlight
    /// does not provide a high resolution timer as is available in many operating systems,
    /// so the resolution of this timer is limited to "ticks." This class is best used to measure
    /// the relative performance of functions over many iterations.
    /// </summary>
    public sealed class Stopwatch
    {
        private int _startTick;
        private long _elapsed;
        private bool _isRunning;

        /// <summary>
        /// Creates a new instance of the class and starts the watch immediately.
        /// </summary>
        /// <returns>An instance of Stopwatch, running.</returns>
        public static Stopwatch StartNew()
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();
            return sw;
        }

        /// <summary>
        /// Creates an instance of the Stopwatch class.
        /// </summary>
        public Stopwatch()
        {
        }

        /// <summary>
        /// Completely resets and deactivates the timer.
        /// </summary>
        public void Reset()
        {
            _elapsed = 0;
            _isRunning = false;
            _startTick = 0;
        }

        /// <summary>
        /// Begins the timer.
        /// </summary>
        public void Start()
        {
            if(!_isRunning)
            {
                _startTick = Environment.TickCount;
                _isRunning = true;
            }
        }

        /// <summary>
        /// Stops the current timer.
        /// </summary>
        public void Stop()
        {
            if(_isRunning)
            {
                _elapsed += Environment.TickCount - _startTick;
                _isRunning = false;
            }
        }

        /// <summary>
        /// Gets a value indicating whether the instance is currently recording.
        /// </summary>
        public bool IsRunning
        {
            get { return _isRunning; }
        }

        /// <summary>
        /// Gets the Ellapsed time as a Timespan.
        /// </summary>
        public TimeSpan Ellapsed
        {
            get { return new TimeSpan(GetCurrentElapsed()); }
        }

        /// <summary>
        /// Gets the Ellapsed time as the total number of milliseconds.
        /// </summary>
        public long EllapsedMilliseconds
        {
            get { return GetCurrentElapsed() / TimeSpan.TicksPerMillisecond; }
        }

        /// <summary>
        /// Gets the Ellapsed time as the total number of ticks
        /// </summary>
        public long EllapsedTicks
        {
            get { return GetCurrentElapsed(); }
        }

        private long GetCurrentElapsed()
        {
            return this._elapsed + (IsRunning ? (Environment.TickCount - _startTick) : 0);
        }
    }
}

If you enjoy our post, feel free to subscribes to our rss feeds