mob's dev blog

Allen Toussaint - The Bright Mississippi

mob — Sat, 31 Oct 2009 23:08:51 GMT

If you like Jazz/Blues I’d highly recommend picking up Allen Toussaint’s album The Bright Mississippi. I heard his adaption of Saint James Infirmary on a local blues station and was hooked.

Creating a Catch-all Redirect Page with Countdown

mob — Wed, 21 Oct 2009 00:23:22 GMT

I just changed the domain of my site and I wanted to create a page notifying that the site has moved and then auto redirect them after a few seconds. Here’s how I did it:

1) I’m using IIS 7.5 so I opted to use the IIS7 RewriteModule. I simply ran the installer and the applet appears under the site options.

2) I created a catch all site in IIS and bound it to all the old public domains:

3) Then created a UrlRewrite Rule to rewrite all requests to /Default.aspx (Except ones specifically to /Default.aspx):

4) Next created the redirection page (Stripped down for clarity):

<%@ Page Language="C#" %>
<% string redirectUrl = string.Format("{0}://{1}{2}{3}",
Request.Url.Scheme, Request.Url.Host.Replace("mikeobrien.net", "mikeobrien.net"),
(Request.Url.Port != 80 ? ":" + Request.Url.Port
: string.Empty), Request.Headers["X-Original-URL"]); %> <html>
<head>
<title>We've
Moved</title>
<script language="javascript">
function RedirectPage(url, seconds) { self.setTimeout('self.location.href
= \'' + url + '\';', seconds * 1000); } function CountDown(seconds,
elementId) { if (seconds == 0) return;
document.getElementById(elementId).innerHTML = seconds; self.setTimeout('CountDown(' +
(seconds - 1) + ', \'' + elementId + '\');',
1000); } </script>
</head>
<body onLoad="RedirectPage('<% =
redirectUrl %>',
5);CountDown(5, 'timeLeft');"> <h3>We've
moved!</h3>
<p> The
page you requested can now be found <a href="<% =
redirectUrl %>">here</a>.
You will be redirected in <span id="timeLeft">5</span> seconds. </p>
</body>
</html>

5) And voila!

Goodbye Hyphen!

mob — Tue, 20 Oct 2009 15:23:31 GMT

Thanks to Michael O’Brien of Akron Ohio for letting mikeobrien.net expire! I am now able to drop the stupid hyphen in my domain name. If you are one of the 60 odd people that subscribe to my blog feed (Thanks for subscribing BTW) you should be ok since I use Feed Burner and I’ll update the new url there. If you have my old email address it will be exactly the same just without the hyphen.

Life without the hyphen, it’s much better than I could have ever imagined.

F# October CTP for VS2008 & VS2010 Beta2 is out

mob — Tue, 20 Oct 2009 01:27:32 GMT

F# October CTP for VS2008 announcement & download.

VS2010 Beta2 announcement (Download is available for MSDN subscribers).

Type Tests with Pattern Matching in F#

mob — Sun, 11 Oct 2009 17:39:53 GMT

I’m working on an application where I’m sending output to a console window. If the output is an integer or double I wanted the print function to perform special formatting. For everything else just call .ToString(). Page 115 in Expert F# shows an example of how to do this sort of thing with pattern matching, here is an example (Stripped down for clarity):

let Print (t:obj) = let text
= match t with |
:? int -> (t :?> int).ToString("#,###")
| :? double -> (t :?> double).ToString("#,###.0")
| _ -> t.ToString() ... Console.Write(text)

A few points:

The compiler complained that I didn’t have a type annotation on the parameter. Not sure why this is but book shows that annotating it as an obj does the trick.
The :? <type> construct looks at the type of the value.
The :?> operator casts the value down to a particular type.

Using a TimeSpan to Represent a Frequency in Configuration

mob — Sat, 10 Oct 2009 14:33:27 GMT

We have a number of Windows Services in our infrastructure, all of which have a frequency in their configuration. Originally this frequency was in milliseconds but this is a real pain since when you set or read the configuration you are always doing the math between milliseconds and hours/minutes/seconds. Then is occurred that we could probably use a TimeSpan in the configuration to represent frequency instead of an integer of milliseconds. The .NET configuration API has a built in converter for the TimeSpan class so all you have to do is set the configuration property type to TimeSpan and your good to go!

Here is the configuration class:

public class Section : ConfigurationSection { private
const string FREQUENCY = "frequency";
[ConfigurationProperty(FREQUENCY)] public TimeSpan Frequency
{ get { return (TimeSpan)this[FREQUENCY];
} } }

Here is the configuration, much easier to read/set:

<company>  <services>
<someService frequency="00:00:30"/>
</services>
</company>

And the usage:

private Common.Timers.Timer _processTimer
= new Common.Timers.Timer(
Configuration.Manager.Current.SomeService.Frequency.TotalMilliseconds,
Common.Timers.Timer.TimerElapseStartMode.Immediate,
Common.Timers.Timer.TimerElapseReentranceMode.NonReentrant);

Timer With Elapse Reentrance and Start Options

mob — Thu, 08 Oct 2009 21:39:44 GMT

I needed a timer that I could set to elapse immediately when it was enabled (Instead of waiting for the first elapse event) and also not be reentrant on the elapsed event. I couldn’t seem to find anything out there so I rolled my own. Unfortunately the System.Timers.Timer doesn't offer a lot in the way of extension so I ended up just using composition over inheritance. Here is a quick test:

static Timer _timer
= new Timer(5000, Timer.TimerElapseStartMode.Immediate, Timer.TimerElapseReentranceMode.NonReentrant); static
void Main(string[] args) { Console.WriteLine( "Started
@ {0}\r\n-----------------------------", DateTime.Now);
_timer.Elapsed += _timer_Elapsed; _timer.Start(); Application.Run();
} static void _timer_Elapsed(object sender, Timer.ElapsedEventArgs e)
{ Console.WriteLine("Elapsed
@ {0}", e.SignalTime); Thread.Sleep(10000);
}

Here is the implementation:

public class Timer { //
────────────────────────── Enumerations ────────────────────────── public
enum TimerElapseStartMode { Immediate,
AfterInterval } public enum TimerElapseReentranceMode {
Reentrant, NonReentrant } // ──────────────────────────
Events ────────────────────────── public delegate
void ElapsedEventHandler(object sender, ElapsedEventArgs e); public
event ElapsedEventHandler Elapsed; //
────────────────────────── Private Fields ────────────────────────── private System.Timers.Timer _timer
= new System.Timers.Timer(); private
int _executing; // ────────────────────────── Constructor
────────────────────────── public Timer(double interval)
: this( interval, TimerElapseStartMode.AfterInterval, TimerElapseReentranceMode.Reentrant)
{ } public Timer( double interval, TimerElapseStartMode startMode, TimerElapseReentranceMode reentranceMode)
{ _timer = new System.Timers.Timer(interval);
_timer.Elapsed += OnElapsed; ElapseStartMode = startMode; ElapseReentranceMode = reentranceMode;
} // ────────────────────────── Public Members ────────────────────────── public
bool AutoReset { get { return _timer.AutoReset;
} set { _timer.AutoReset = value;
} } public bool Enabled { get { return _timer.Enabled;
} set { _timer.Enabled = value;
} } public double Interval { get { return _timer.Interval;
} set { _timer.Interval = value;
} } public TimerElapseStartMode ElapseStartMode
{ get; set; } public TimerElapseReentranceMode ElapseReentranceMode
{ get; set; } public
void Start() { if (ElapseStartMode == TimerElapseStartMode.Immediate) ThreadPool.QueueUserWorkItem(
state => Elapse(new ElapsedEventArgs()));
Enabled = true; } public
void BeginInit() { _timer.BeginInit(); } public void Close()
{ _timer.Close(); } public void EndInit() { _timer.EndInit();
} public void Stop() { Enabled = false;
} // ────────────────────────── Private Members ────────────────────────── private
void OnElapsed(object sender, System.Timers.ElapsedEventArgs e)
{ Elapse(new ElapsedEventArgs(e));
} private void Elapse(ElapsedEventArgs args)
{ if (ElapseReentranceMode == TimerElapseReentranceMode.NonReentrant
&& Interlocked.CompareExchange(ref _executing,
1, 0) == 1) return; if (Elapsed
!= null) Elapsed(this,
args); _executing = 0; } // ──────────────────────────
Nested Types ────────────────────────── public class ElapsedEventArgs : EventArgs { private DateTime _signalTime; public ElapsedEventArgs()
{ _signalTime = DateTime.Now; } public ElapsedEventArgs(System.Timers.ElapsedEventArgs args)
{ _signalTime = args.SignalTime; } public DateTime SignalTime
{ get { return _signalTime;
} } } }

F# Function or Value?

mob — Wed, 07 Oct 2009 22:50:43 GMT

I didn't really understand this until today when I asked the following on hubFS:

“I'm wondering if the F# compiler has an optimization that will make it so that the sqrt5 and Phi functions only execute once, no matter how many times the fibn function is called, since the results of those functions are always constant.

let sqrt5 = sqrt 5.0

let Phi = (1.0 + sqrt5)
/ 2.0

let fibn n = Phi ** float
n / sqrt5 |> round |> int

let fib2 = Seq.unfold (fun index -> Some
(fibn index,index + 1)) 1

I'm trying to figure out if the compiler automagically makes this happen or if I have to make it happen.”

Keith kindly broke it down (Thanks Keith!):

“In the code that you've written, sqrt5 and Phi are not functions but values (they don't take any arguments). As such, their definitions will never be re-evaluated… For top level definitions, something is a value if it doesn't take parameters. For instance, given the two definitions:

let now = System.DateTime.Now
let add x y = x + y

"now" is a value, and will never change. add is a function taking two arguments, and each time both arguments are supplied, the definition on the right will be evaluated to give the return value.

However, when defining .NET classes, things become more complicated, because classes can contain fields, methods, events, properties, etc. Properties are re-evaluated whenever they are gotten, and DateTime.Now is a property, which is why the value appears to change over time.

Things can also be a bit confusing when using functions in a first-class way. For instance:

let myFun =
let time = System.DateTime.Now
fun () -> System.DateTime.Now - time

Here, myFun is a value (which happens to be a function!), and its definition is only evaluated once (so, in particular, "time" is only ever set once, when myFun is first defined). However, calling the myFun function then results in the evaluation of the function's body (that is, the right hand side of the last line of myFun's definition, which calls System.DateTime.Now and subtracts the original time).”

Getting the Progress of a DBCC SHRINKFILE

mob — Mon, 05 Oct 2009 15:50:15 GMT

I’m running a DBCC SHRINKFILE on a HUGE database (315Gb) after a major prune (Around 60%) and it’s taking forever. Anyways, found a helpful nugget on the internets for determining it’s progress.

SELECT percent_complete,
* FROM sys.dm_exec_requests

And you get something like this:

I’ve noticed that even though it says “suspended” it’s still progressing. I think it must be that this task is constantly firing off child tasks (Like #194 above) and waiting for them to complete (And thus the status of “suspended” most of the time).

Solving Project Euler Problem #2 in F#

mob — Sun, 04 Oct 2009 01:31:26 GMT

Project Euler rocks! I think it’s an especially good way to learn another programming language. I’m planning to try to solve the problems in 2 ways. First, if possible, the brute force method (Which I think helps you to learn the language better) and second, if possible, the formula method (Which I think helps you learn the mathematical concepts better).

Problem #2 states:

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

Find the sum of all the even-valued terms in the sequence which do not exceed four million.

Solution 1

So the first approach is using the brute force method where we iterate through all the numbers and determine the next Fibonacci number by adding the last two. I used the Seq.unfold method to do this (Which I discuss further here). Short and sweet:

let max = 4000000 let fib
= Seq.unfold (fun (last, current) -> Some
(last, (current, current + last))) (1, 1) let Run1
_ = fib |> Seq.takeWhile (fun i -> i
<= max) |> Seq.filter (fun i -> i
% 2 = 0) |> Seq.fold(fun state item -> state
+ item) 0 |> Display.PrintInteger

Solution 2

The second approach actually calculates each Fibonacci number using the Binet formula. Now this is still pretty much brute force in that we still have to iterate from 0 to the max and include only the positive values, but at least we’re using a formula that doesn't require knowledge of the previous values in the sequence. Ron Knott has a nice page on calculating Fibonacci numbers and a “reduced” Binet for calculating positive integers. The reduced Binet formula is round(φⁿ / √5). The rounding is required because of the irrational numbers in the equation. Theoretically the result would be an integer but because of limits on the number of digits we can calculate, the result will be slightly off and the rounding fixes this. I discuss calculating φ (Or the Golden Ratio) in my last post. Check that out to get a better understanding of how we calculate it.

let max = 4000000 let sqrt5
= sqrt 5.0 let Phi = (1.0 + sqrt5) / 2.0 let fibn
n = Phi ** float n / sqrt5 |> round |> int let fib2
= Seq.unfold (fun index -> Some
(fibn index,index + 1)) 1 let Run2 _ = fib2 |>
Seq.takeWhile (fun i -> i
<= max) |> Seq.filter (fun i -> i
% 2 = 0) |> Seq.fold(fun state item -> state
+ item) 0 |> Display.PrintInteger

Results

EDIT: After the fact I realized that my original results were skewed by the JIT compiler. Anyways, made some modifications to take this out of the equation and got more accurate results. As you can see in this case that the heavier calculations in solution 2 don’t buy us any performance since we have to iterate through and find the positive numbers starting from 0 anyways. So solution 1 was the best solution in this case. However if we needed to target a specific range of Fibonacci numbers (Especially a high range) the second solution would most definitely win out.

Determining the Golden Ratio

mob — Sat, 03 Oct 2009 15:42:35 GMT

Patrick McKeague has an excellent video explaining the math behind the golden rectangle. It also explains how to derive the formula for the golden ratio.

First we start with a square like so:

Mark halfway between one of the sides and draw a line from this point to one of the opposite corners. This forms a right triangle.

Now if you were to swing the hypotenuse of this right triangle down to zero degrees of the side of the origin (maintaining the same point of origin) and extend the square to the termination of this line you would get a golden rectangle.

The golden ratio would be the length of this rectangle divided it’s width . We know the width is 2. The length is made up of half of the side of the original square which is 1, plus the hypotenuse of the triangle that was formed above. Using the Pythagorean Theorem (a² + b² = c²) we see that the hypotenuse is:

1² + 2² = c² 
1 + 4 = c² 
c² = 5 
√c² = √5 
c = √5

So the length is 1 + √5. We can then see that the formula for the golden ration is:

1 + √5 
——————  =  φ
   2

Now the cool thing is if you create a square of any size and follow the above procedure, you will always be able to reduce the equation down to the one above.