I wanted to see what could be done with the Fibonacci sequence, but I didn’t have something that played nicely with LINQ. Here is my first cut:

public static class Fibonacci
{
    public static IEnumerable<BigInteger> Generate( int n )
    {
        return Generate( (long) n );
    }

    public static IEnumerable<BigInteger> Generate( long n )
    {
        yield return 1;
        if ( n == 1 )
        {
            yield break;
        }
        yield return 1;
        if ( n == 2 )
        {
            yield break;
        }

        BigInteger n1 = 1, n2 = 1;
        for ( BigInteger i = 3; i <= n; i++ )
        {
            BigInteger n3 = n1 + n2;
            n1 = n2;
            n2 = n3;
            yield return n3;
        }
    }
}

Then you can do all sorts of computations.

// Sum all
Fibonacci.Generate( 144 ).Aggregate( BigInteger.Add ); // 1454489111232772683678306641952
// Average them (via extension method below)
Fibonacci.Generate( 144 ).Average(); // (10100618828005365858877129458, remainder 0, total 144)

But why BigInteger? When using int, the 46th Fibonacci number is the last capable of being represented; making the data type a uint gets us the 47th. When using long, the 92nd is the last with the and with ulong the 93rd. With the BigInteger implementation, I can generate the 250,000th in about four seconds! And I can go much higher. If .NET had shipped with a BigFloat class I would have tried using the closed form solution which we could use to calculate the series in parallel. Having to sort may negate the speedup, but any solutions that don’t require order might benefit well.

There is another problem with using BigInteger; I can’t return a BigFloat from an .Average() calculation and BigInteger doesn’t support any kind of fraction support other than modulo. I wonder how much work it would be to create a BogFloat based on BigInteger.

public static class BigIntegerExtensions
{
    public static Tuple<BigInteger, BigInteger, BigInteger> Average( this IEnumerable<BigInteger> source )
    {
        BigInteger total = BigInteger.Zero;
        BigInteger elements = BigInteger.Zero;
        foreach ( BigInteger item in source )
        {
            total += item;
            elements += BigInteger.One;
        }
        BigInteger remainder;
        BigInteger average = BigInteger.DivRem( total, elements, out remainder );
        return new Tuple<BigInteger, BigInteger, BigInteger>( average, remainder, elements );
    }
}

I had to reset my keyboard and I had forgotten the setup that I need to do in order to get it configured the way I like it. In case anyone else ever wants to set theirs up, here is mine:

• To disable tones used by Caps Lock, Keypad, and others, hold down Progrm and press the hyphen (-) key. Repeat to turn then back on.
• To disable key click audio hold down Progrm and press the Backslash key (“\”) located just below the hyphen key)
• Remapping embedded Insert key to top layer (This is critical for ReSharper):
  If you would like to remap the embedded Insert key to the top layer, follow these instructions:
  1). Turn Keypad On.
  2). Press and hold the Progrm key and tap F12 (LED’s on keyboard will flash rapidly).
  3). Press and release the “Insert” key (LED’s will slow down).
  6). Press and release the Keypad key.
  7). Press and release the Insert key again (LED’s will speed up).
  8). Exit by repeating step 2 (LED’s will stop flashing).
• Hold ‘=’ and press ‘w’ in a text editor. Hold ‘=’ and press ‘s’ and you should see:
  v3.1[SL K H e ] or v3.2[SL K H e ]
  - Thumb key modifier keys are optimized for Windows
  - Keypad = is the same as Number row =
  - Scroll lock performs scroll lock action
  - Keyboard stays awake when computer sleeps setting is active
  - Fast mouse speed is set on

You can use whatever macros you like, but this setup is most conducive to my workflow.

If you are using the TFS Shell Extension and you get an error dialog when choosing Team Foundation Server -> Reconnect

There is a workaround. TFS extension only supports windows credentials at the moment, so if the server is using domain authentication, you can try to open your TFS server url in an IE window, enter your domain\user credentials and password. Now try try reconnect and you should be able to use the shell extension.

If you are using Windows 7, maybe Vista as well, you can use the Credential Manager in the Control Panel to manage the caching of this information without IE.

If you ever need to run a child process in an elevated state, you can easily set the Verbs property on the ProcessStartInformation to “runas” and the child process will ask for permission when started. You need to watch out the the user denying access however as a Win32Exception will be thrown with its NativeErrorCode = 1223. Here is a simple example launching the admin command prompt.

internal class Program
{
	private const int UserCanceled = 1223;

	private static void Main( string[] args )
	{
		var psInfo = new ProcessStartInfo
					 {
						 FileName = Environment.GetEnvironmentVariable ("ComSpec"),
						 UseShellExecute = true,
						 Verb = ( Environment.OSVersion.Version.Major >= 6 ) ? "runas" : string.Empty
					 };

		try
		{
			Process process = Process.Start( psInfo );
			Console.WriteLine( "Process has Id: {0}", process.Id );
			Console.WriteLine( "Waiting for app to exit." );
			process.WaitForExit();
		}
		catch ( Win32Exception ex )
		{
			if ( ex.NativeErrorCode != UserCanceled )
			{
				throw;
			}
			// permission was denied.
			Console.WriteLine( "The operation was canceled by the user." );
		}

		Console.WriteLine( "App exited, press enter to exit." );
		Console.ReadLine();
	}
}

You can build off of the previous article and make dealing with the dual libraries much easier using an IoC container. Instead of building an interface that constantly has to check which code path to execute based on the current platform, you can load the services into an IoC container. Once you know what platform you are on, you can reference the type forcing its assembly to be loaded into your current AppDomain (as shown previously). Once done, you can get the assembly through a few different ways and build up services with an IoC container.

You can use the assembly scanner in StructureMap, or other mechanisms in another container, to go through the assembly and build up services that you can run. If your platform specific assemblies reference a third contract definition assembly then you are in great shape. If not, you might use string resolution (container.Get(“MyService”)) to obtain the object and either duck type or reflection invoke its members.

I had to figure out how to make an application run as its native type while loading only the proper dlls for that platform – when the application runs on x64, load only x64 assemblies so that the application will run fully as x64 and the same for x86. The answer is counterintuitive and not straightforward.

Below is an example application that exhibits this behavior. The Amd64Library.Foo is defined in an assembly compiled for x64; the Win32Library.Foo is similarly defined in an x86 assemly. The Loader application is compiled as ‘Any CPU’ so it will load natively on either platform as long as we load the correct dependency assemblies. Remember that the using statement, is just a compiler hint and doesn’t effect the created MSIL application.

#region Using Directives

using System;
using Win32Library;

#endregion

namespace LoaderApplication
{
    internal class Program
    {
        private static void Main( string[] args )
        {
            //RunLoadingBothAssemblies(); // will crash.
            RunLoadingOneAssembly();
            Console.ReadLine();
        }

        private static void RunLoadingBothAssemblies()
        {
            if ( IntPtr.Size == 4 )
            {
                var foo = new Foo();
                foo.Bar();
            }
            else
            {
                var foo = new Amd64Library.Foo();
                foo.Bar();
            }
        }

        private static void RunLoadingOneAssembly()
        {
            if ( IntPtr.Size == 4 )
            {
                LoadWin32Foo();
            }
            else
            {
                LoadAmd64Foo();
            }
        }

        private static void LoadAmd64Foo()
        {
            var foo = new Amd64Library.Foo();
            foo.Bar();
        }

        private static void LoadWin32Foo()
        {
            var foo = new Foo();
            foo.Bar();
        }
    }
}

The LoaderApplication references both x64 and x86 assemblies – yes, at the same time. The key is that the assemblies aren’t loaded into the process until the last possible moment. If you look at the RunLoadingBothAssemblies method, the moment you enter the method, the .NET runtime will load the assemblies for the types in that method. This means it will try to load the x64 library into a 32bit process and vise versa resulting in errors. The RunLoadingOneAssembly determines which platform is being used and then makes another call so that only the library needed is loaded.

There is a caveat to this method. The assemblies need to use separate namespaces or different type names. If both assemblies use the same namespace, you will run into type resolution issues as the compiler won’t know which class you are trying to load while referencing both assemblies. If you have source access to the assembly that has to be compiled for each platform, #if statements will allow you to easily adjust the namespaces or type names.

You can watch this application run on x64 and the process name will not have *32 as it will be running natively. So, if you want to have a single build of your application, but run on x64 and x86, this is one way to go.

You can download the full source here.

I decided to try out Ruby today. I have wanted to try it out for quite a while. Some of my impressions may be inaccurate, but I have done what I can. I have Zero interest in DB and web ‘programming’ so I am going to skip rails and related material.

Edit
I intially tried to use JetBrains’ RubyMine and had a few issues. Since then I tried it again and everything worked great. It is very comparable to Ruby In Steel (IMHO) and another great product from JetBrains.

I installed Ruby In Steel Personal Edition and that was a great way to get started. I ran the installers and I was up and running in a familiar environment. I created a Ruby project and I started with hello world. After that I started going through the guide at Techtopia and the RDocs. I love the product for a free version, but for someone trying to learn Ruby, the intellisence feature would be handy. I am never going to pay $200 for an IDE that I would use as a hobby; that being said, if I ever were to program Ruby as a job, $200 is a great price.

What I like

• very straightforward language
  • I loved that when I wanted to shift the elements of an array I found it was built-in
• Class library
• being able to have a line of code like this; I wish I knew what to call it
  • return SolveUsingClosedFormExpression( n ) if ( 0..1474 ).include? n
  • return SolveUsingClosedFormExpression( n ) if (0..1474) === n
• I will complain about this as well, but in writing the closed form Fibonacci solution, the data type changes allowing for huge results
  def SolveUsingClosedFormExpression(n)
  left = GOLDENRATIO ** n
  right = (-GOLDENRATIOINV) ** n
  return ( (left – right) / ROOT5 ).to_i
  end

What I didn’t like

• Trying to figure out how to use gems (packages, not the tool) and files in the class library
• Lack of type information
  • Yes, yes, I know, I know, but for a c, c++/cli, c#  programmer, it feels just wrong
  • Declaring a variable feels like I am introducing a magic variable – *poof* it exists. At least in TI-Basic I had to declare my dynamically typed variables. \
  • Lack of method return types
• At least four ways to return a value from a method, see below.
• Inconsistent API
  • I was very frustrated when trying to use .power! only to find that it isn’t defined for Float types – I have to use ** everywhere.
• Ruby is supposed to be super OO, but what object contains puts/print?

What I really didn’t like

def multiplyWithReturn(val1, val2 )
    result = val1 * val2
    return result
end

def multiplyLocalVariable(val1, val2 )
    result = val1 * val2
end

def multiplyNoVariables(val1, val2 )
    val1 * val2
end

def multiplyAssignToMethodName(val1, val2 )
    multiplyAssignToMethodName = val1 * val2
end

puts multiplyWithReturn(5,6)
puts multiplyLocalVariable(5,6)
puts multiplyNoVariables(5,6)
puts multiplyAssignToMethodName(5,6)

Running this code prints 30303030

I don’t know if I am missing a key ‘feature’ of the language, but at least four ways to return a value from a method just really irks me. Given that there is no return type of a method, reading code to determine what is returning a value and what methods are void seems ridiculous.

I have never programmed in a dynamic language, so it has been a bit of a ride. There a so many nuances to the language, it will take a while to get them down, but they allow for very concise code.

I have gone through so many tools trying to create the right build environment that it is a bit disheartening. I have set up multiple continuous integration systems and it keeps getting easier, but there is still a bit too much friction.

I tried to look into using Team Foundation Server and Team Build, but the cost is very high for a startup (even with the top msdn subscription). This is compounded when you have external developers that must also hook into the system.

I have fallen for TeamCity but with one deal breaker for me: no FinalBuilder support. I submitted some feedback and I received a detailed response from JetBrains; I have always received great customer support from JetBrains:

There are several ways to support FinalBuilder:
1. You may start using CommandLine runner to start the process.
2. To Add custom FinalBuilder reporting you may use TeamCity service messages.
   Please refer to
http://www.jetbrains.net/confluence/display/TCD4/Build+Script+Interaction+with+TeamCity
   documentation article on service messages for details
3. You may start FinalBuilder from any other build scripts,
   for example NAnt, MSBuild, Ant, Maven.
   If  you  need  custom  logging,  you  may  consider using TeamCity
   Service messages as well
4. Write a build runner plugin for TeamCity. There are two
   public available examples on the build runners at:
http://www.jetbrains.net/confluence/display/TW/Rake+Runner
   and
http://svn.jetbrains.org/teamcity/plugins/fxcop/
   Please feel free asking any questions on the integration.
5. Post an issue to our tracker at
   http://www.jetbrains.net/tracker

I checked out the code for the build runner plugins, but it is too much work. It is hard not to sound lazy in saying that, but I haven’t used java since my sophomore  year in college, and it doesn’t sit high on my list to spend hours getting a build runner going (I am looking for less friction, not more). I chose the 5th option and submitted a feature request TW-6442. With FinalBuilder support I don’t need any other build runners/tools as FinalBuilder most likely wraps them up in its UI.

One other feature that I would like to have, but am hesitant to request right now, is to be able to selected a successful build, and run a publish script (through the web interface (see Cruise)) that can tag the build and use the build  artifacts to deploy that build to Dev/Stage/Production environment.

It has been a long time (10 months) since I worked with the Ninject MessageBroker and a couple things have changed since my last post. In the old version you had to connect the MessageBroker as a kernel component by hand. Since then the extension environment has been flushed out a lot more. Now you can register the MessageBrokerModule when constructing your kernel object.

using System;
using System.Diagnostics;
using System.Net;
using System.Text.RegularExpressions;
using Ninject;
using Ninject.Extensions.MessageBroker;

namespace NinjectMessageBroker
{
    internal class Program
    {
        private static void Main()
        {
            // Intialize our injection kernel adding message broker functionality.
            using (var kernel = new StandardKernel(new MessageBrokerModule()))
            {
                // Get the event publisher. It reads the current time and fires an event
                var pub = kernel.Get<TimeReader>();
                Debug.Assert(pub != null);

                // Get the subscriber, it waits to get the current time and writes it to stdout
                var sub = kernel.Get<TimeWriter>();
                Debug.Assert(sub != null);

                // Verify that they were wired together
                Debug.Assert(pub.HasListeners);
                Debug.Assert(sub.LastMessage == null);

                // Get the current time. It should automatically let the TimeWriter know
                // without either of them ever knowing of one another.
                pub.GetCurrentTime();

                // Wait to exit.
                Console.ReadLine();
            }
        }
    }

    internal class TimeWriter
    {
        public string LastMessage { get; set; }

        [Subscribe("message://Time/MessageReceived")]
        public void OnMessageReceived(object sender, EventArgs<string> args)
        {
            LastMessage = args.EventData;
            Console.WriteLine(LastMessage);
        }
    }

    internal class TimeReader
    {
        public bool HasListeners
        {
            get { return (MessageReceived != null); }
        }

        [Publish("message://Time/MessageReceived")]
        public event EventHandler<EventArgs<string>> MessageReceived;

        /// <summary>
        /// Gets the current time and updates all subscribers.
        /// </summary>
        public virtual void GetCurrentTime()
        {
            string text = GetWebPage();
            var regex = new Regex(@"\d\d:\d\d:\d\d");
            MatchCollection matches = regex.Matches(text);
            string time = ((matches.Count == 2) ? matches[1] : matches[0]).Value;
            SendMessage(time);
        }

        /// <summary>
        /// Gets the contents of a web page as a string.
        /// </summary>
        /// <returns></returns>
        private static string GetWebPage()
        {
            const string url = "http://www.time.gov/timezone.cgi?Eastern/d/-5";
            var webClient = new WebClient();
            return webClient.DownloadString(url);
        }

        /// <summary>
        /// Sends the message to all subscribers in a threadsafe manner.
        /// </summary>
        /// <param name="message">The message.</param>
        public void SendMessage(string message)
        {
            EventHandler<EventArgs<string>> messageReceived = MessageReceived;

            if (messageReceived != null)
            {
                messageReceived(this, new EventArgs<string>(message));
            }
        }
    }

    public class EventArgs<TData> : EventArgs
    {
        public new static readonly EventArgs<TData> Empty;

        static EventArgs()
        {
            Empty = new EventArgs<TData>();
        }

        private EventArgs()
        {
        }

        public EventArgs(TData eventData)
        {
            EventData = eventData;
        }

        public TData EventData { get; private set; }
    }
}

I found that you can do work such as assigning a variable and executing a method outside of the main expression of an if statement. For example:

if(hRes = GetApplicationState(), NT_SUCCESS(hRes))
{
// Do something
}