Luckily there are some awesome (720p quality) videos from FOSDEM 2010 of some Mono centric presentations.

Lluis Sanchez Gual on MonoDevelop – I knew MonoDevelop 2.2 had some awesome in it, but I didn’t know about some of the code generation things in it. Think R# mixed with CodeRush. It is very sweet.  Lluis’s Blog is always a good read too.

Ivan Porto Carrero on IronRuby – Poor Ivan had some demo troubles, but overall the presentation was excellent. It is VERY cool to see a Banshee add-in written in Ruby. I don’t think I was reading Ivan’s Blog before, but I am now.

Miguel on Mono – I think this is kind of Miguel’s “State of the Monkey” of the day. Its a status overview with a few deep dives into things. I especially thought it was cool that he went deep (well, deeper than most) into Expression<>.

The videos seem to be coming out slowly. I’m posting these brief summaries of the videos as I watch them, so expect me to link to more as I watch them.

I looked for this thing for what felt like hours over the past year. Eventually I sucked it up and downloaded mp3tag, but its still nice to know that this is there for the next time.

Normally when browsing my mp3 files I see a window that looks like this:

See that summary pane at the bottom? Select a file with editable metadata, like an mp3 and resize that pane. Then click one of the metadata values.

Wow, I wish that had been more discoverable. –1 point for Windows 7 for making that far from intuitive, but 1 point for Windows 7 for having the feature.

I want to do this:

dynamic x;
var h = from y in x where y == 1 select y.something;

But I get error messages on both where and select that says

Query expressions over source type ‘dynamic’ or with a join sequence of ‘dynamic’ are not allowed

Major bummer.

But surely there is something I can do.

*the title of this post starts with LINQ abuse… please don’t comment about how stupid and evil this is. I know it. Instead, consider this an exercise in getting to know C# a little better.

The dynamic type is just sugar for the object type and some attributes to which the compiler pays attention.

Lets use object…

object things = new[] { 0,1,2,3,4,5,6,7, };
var whatIwant = from thing in things
                            where thing % 2 == 0
                            select thing;
// or if you like longhand:
var wiw = things.Where(thing => thing%2 == 0).Select(thing => thing);

How does this compile? Well, by making Where and Select resolve to extension methods on object instead of extension methods on IEnumerable<T> (which is what people USUALLY think of when they think LINQ).

public static IEnumerable<dynamic> Select(this object source, Func<dynamic, dynamic> map)
{
    foreach (dynamic item in source as dynamic)
    {
        yield return map(item);
    }
}
public static IEnumerable<dynamic> Where(this object source, Func<dynamic, dynamic> predicate)
{
    foreach (dynamic item in source as dynamic)
    {
        if (predicate(item))
            yield return item;
    }
}

Extension methods on object, then cast to dynamic (extension methods aren’t allowed on dynamic).

It should be short work to fill out whatever LINQ methods are necessary to make whatever LINQ expressions you wish work against dynamic (object) and now you can use LINQ with a source that is typed dynamic.

http://martinfowler.com/bliki/VersionControlTools.html

Martin does say that Mercurial and git get most of the attention and that the choice between the two come down to “…the shadow of github.”

He is dead right, but I’d argue that this is where the recommendability starts. github is awesome. Ask anyone who has used it and I’ve rarely heard anything negative said. But for anything but the tiniest organization outsourcing your VCS to github is not a practical option. There could be IP requirements or legal requirements about keeping source private and just the over cautious nature of people is to want to run VCS in house. github is not open source. gitorious is.

http://gitorious.org/about

You can go checkout the source code to gitorious and run your own in your own internal organization. AWESOME!

I’d never heard of the Mercurial hosting project http://bitbucket.org/ until i read Martin’s post. That is great to know that it exists. But…

The most mature solution is something which is also open source, has the best project management implementation, has the best bug tracking implementation and integration and is just all around awesome. Its called Launchpad.

http://launchpad.net/

Yes, the same software that drives launchpad is open source and you can install and run it for your own team, company, organization or however you are structured.

Launchpad is written by open source volunteers as well as employees of Canonical. You can buy support for Launchpad from Canonical. Launchpad uses the lesser known bazaar DVCS. Martin kindly left out the DVCS which is used by the most prominent Linux distribution, ubuntu, and the most prominent open source database software, MySQL.

Just like GIT is not going away, because linux uses it, and Mercurial isn’t going away because python and google use it, bazaar is not going away, because ubuntu and mysql use it.

My point is that the web hub to your code and the tools surrounding how you get to your code is just as important as the base DVCS tool itself. SVN has always been good, but ViewVC makes it great. GIT is good. github makes it great. Launchpad makes bazaar great. It makes bazaar at least as good of a choice as either git or mercurial.

So there are no good comprehensive media library managers.

Its sad but true. I think tomorrow I’ll be going back to using foobar2000 for my audio listening. WMP12 was so so so close for me, but this issue is a show stopper.

I feel a little better (and a great deal worse after thinking about it) when I see that the largest software company in the world deals with some of the same problems.

I found this gem in the WPFToolkit (it is MSPL) source.

// The standard CLR double.IsNaN() function is approximately 100 times slower than our own wrapper,
// so please make sure to use DoubleUtil.IsNaN() in performance sensitive code.
// PS item that tracks the CLR improvement is DevDiv Schedule : 26916.
// IEEE 754 : If the argument is any value in the range 0×7ff0000000000001L through 0×7fffffffffffffffL
// or in the range 0xfff0000000000001L through 0xffffffffffffffffL, the result will be NaN.        
public static bool IsNaN(double value)
{
    NanUnion t = new NanUnion();
    t.DoubleValue = value;

    ulong exp = t.UintValue & 0xfff0000000000000;
    ulong man = t.UintValue & 0×000fffffffffffff;
    return (exp == 0×7ff0000000000000 || exp == 0xfff0000000000000) && (man != 0);
}

 

My jaw was open pretty far for quite a few seconds as I read this.

Ever taken a survey on the streets from someone with a PC style tablet? I’ve taken a few. I’m always surprised by the hardware choice. For some things, it seems like a clipboard and paper would be better.

At work, there is an upcoming project that involves something like the above. Here is why I think the iPad is a better choice. It mostly comes down to boring IT Operations reasons, aka management of the underlying platform.

• With iPad, you never have to defragment your disk.
• With iPad, you never have to run antivirus or update antivirus definitions.
• With iPad, you never have to run anitspyware or update antispyware definitions.
• With iPad, there is no moving and spinning disk which is prone to higher failure.
• With iPad, you don’t have to worry about some slick-kid or script kiddie downloading and installing some crazy software that turns your computer into a bot or even just overwrites important files preventing you from booting the next time.
• With iPad, you don’t have to worry about not having a replacement part available if a piece of hardware fails.
• With iPad, the user will have a more familiar experience. Given the prevalence of iPhone, it is likely that an end user will understand many of the touch and drag gestures.
• With iPad, there is no stylus like the PC Tablets of old.
• With iPad, there is a very clear future. When was the last time apple canceled a product line? Newton? Ok, how about under Jobs? I’ve no idea.

I’m as anti-fud as any person that I know. Yes, the above is definitely anti-windows fud cited by Mac and Linux lovers everywhere and normally I’m the first person to refute it. However, I think under that fud there are tiny grains of truth. For certain applications those bits of truth are highly amplified. It is a different risk vector. These things become very important and translate directly to cost of ownership.

Notice that I’ve listed no pros or cons for iPad as a general purpose device. I don’t care to go there. I’ve also not mentioned if there is much of a market for the above use case (there isn’t enough to sustain the device alone). These are all things to be answered elsewhere. My point in short: here is a use case if you have been wondering for what kind of things iPad can be used.

http://wlanchannelinfo.codeplex.com/

https://code.edge.launchpad.net/~evarlast/+junk/WlanChannelInfo

I wrote this because Wifi in my home is very slow. Its so slow I’m tempted to run a network cable to my couch so that even when I’m couch surfing I can have fast access to my server.

In an effort to diagnose my slow Wifi, I tried to see if my neighbors were causing interference by running Wifi on the same or overlapping channel as me. I downloaded netstumbler; it didn’t work. I downloaded some other tool; neither did it.

So I wondered how hard it would be to write my own. It turns out Windows 7 added to the Wlan* api to expose all of the necessary data. After some digging I found the managedwlan project on codeplex. Now I got to play.

Once I figured out the api, I was able to write the entire application with pretty much one LINQ expression:

var client = new WlanClient();
var retval =
from wlanIface in client.Interfaces
from bssentry in wlanIface.GetNetworkBssList()
from network in wlanIface.GetAvailableNetworkList(Wlan.WlanGetAvailableNetworkFlags.IncludeAllAdhocProfiles)
where InterfaceService.GetStringForSSID(network.dot11Ssid) == InterfaceService.GetStringForSSID(bssentry.dot11Ssid)
select new WifiInfo
{
bssentry = GetStringForSSID(bssentry.dot11Ssid),
channel = Wifi.FrequencyChannelMap[bssentry.chCenterFrequency],
frequency = bssentry.chCenterFrequency,
linqQuality = bssentry.linkQuality,
strength = bssentry.rssi,
signalQuality = network.wlanSignalQuality,
wifitype = network.dot11BssType
};

The result of that expression is directly databound to a WPF DataGrid and I can now view the data that I want to.

I really love the platform (C#+.NET) on which I work.

I wanted something like this today as I was toggling between NUnit and MSTest. Sure, Assert.That( something, Is(0) ) is readable, but its not portable. Its NUnit only, and for this project, I can’t do that. I also like the english reading of IsZero() vs. Is(0)

I think I’ve stated before that any code on this blog (c) by me and licensed under the MIT/X11 License, but for certain bits of code, I see no point in that. So I’m going to start tagging code with CC0, Unlicense and/or WTFPL.

I recently got a new laptop and when adding this into the mix I had to add more storage to my WHS. I did, and after doing so I got this:

What good is a backup system if it loses your backups? Not much good IMO.

Windows 7’s backup is very good now and I think I may benefit from just using it rather than WHS. I’ll duke it out with WHS one last time, but I won’t be recommending it to Mom, Dad or Grandma anytime soon.