Ok. So I have some traffic. But the other night, I got three comments saying "Hi" and posting a link to thieir pop-up infested P.O.S. site. I immediately deleted them, but the bigger question is why they targeted my site.

I get referral spam all the time, which doesn't serve any purpose. The only people accessing my referral stats page are me and them. I don't link to that page on the site, nor do I display referrer information on my homepage. So what's the point?

Back to the comments - let's say I left them in. Do they really believe that either of my readers would click on the link? I can just see it now. "Wow, they said hi. That's an awesome comment! Let me check out their site for some more indepth analysis." Can't they find a better blog to spam? I haven't been scoble-anched yet. Maybe after I get the famed Scoble link I'd have enough traffic to be spammable.

Until then, let me give the spammer's some advice. From Waynes World, "We're not worthy!"

I got an email last night from a reader (well, a reader now!) asking this:

"Any chance you know of a web service that posts the weekly NFL lines & possibly scores as well?"

My answer? No. I don't. But I'd like to! So that's why I'm opening it up. Does anyone know of a web service that offers up NFL scores and/or odds?

I can think of one possibility, but it's a hack. Screen scrapes. There are a few sites that have a standard page for displaying that info, so scraping would be a pretty straightforward process. But a true service that served up the info would be better.

I'v always thought about using a service like that to get NFL stats, and "roll my own" fantasy football software, but never was able to find a reliable (and free) one. I could say the same thing about odds too.

Go get the latest version of Skype. It looks a potentially serious flaw was fixed.

From the release notes: bugfix: buffer overflow fix.

Don't mess around with buffer overflows!

I was listening to the podcasting session at BloggerCon, and there was a comment about how someone listened to thier podcasts, and I thought it was a very cool idea. he copied his podcasts onto his XBox, and listened to them while he was playing games. Actually, he copied ones his wife would be interested in, and that justified his XBox playing time.

I don't know. Could I listen to the Daily Source Code while flying through the streets in NFS: Underground? Who knows, but it would be interesting to try! Maybe that's what I'll race to when the new one comes out Wednesday.

One more note. My comment about Bob and Tom releasing thier show as a podcast? I'm not the only one who thinks about it - a search to get to my site? "bob and tom show" podcast.

Oh yeah. Google still doesn't know what podcasting is. No, I didn't mean "bob and tom show" broadcast!

Brian Goldfarb has a good explanation of a couple of the changes to ASP.NET 2.0, namely, "magic directory" name changes, and the compilation model. It looks like the bin directory survives! The cool thing is that both of these changes are directly related to feedback from the community. It really is a treat to know that our input is affecting the products we use. For a company as large as Microsoft to listen to us is awesome.

Next, Eric Lippert has some more details about bouncing zero bugs. Best quote? "if you reward developers for fixing bugs, they'll write a lot of bugs."

Scott Guthrie has another post on the progress of ASP.NET 2.0 and Visual Web Developer, and this one is exciting. No insights into their processes this time, but instead, he announced that the team hit ZBB - Zero Bug Bounce.

Here's the highlight: 1142 fixed bugs in three weeks! Congrats, Scott. I can't wait to see it!

How about putting a web server on it? Cool idea, but can you cluster them?

We use Cassini for our desktop version of the Tourney Pool Manager, and it works great. Maybe it's time to build a portable Tourney Pool Manager that you can host on your phone!

Cyrus, from the C# team, is asking about how to handle the release of new C# features in between official release cycles. He wants to know if people would be willing to install unsupported software in order to get features they either wouldn't normally get, or would have to wait until the next full version is released.

I would. If there's something that makes my life as a developer easier, then I'm all for it. And if I can turn them off if things stop working, then even better. I tend to repave my box every six months or so, so even if I had to reformat, I would still probably take the risk.

He's looking for feedback, so head over there and give him some. So far, most of the feedback has been positive.

One other note from the post: "What's worse is that the C# team just hit ZBB." I hate it when my code is bug free too! I think that explains a lot about my code...

I ran across this post earlier in the week, and it gave me the last peice I needed to complete my sorter class I wrote earlier this spring. Mine was missing the ability to sort on any type but strings. At the time, that was fine - all properties were treated as strings. But as I moved this to another project, we needed to sort on other types, like dates, numbers, etc. Using reflection, you can dynamically find the property, and then compare the values based on the type of the property.

So how is mine different than the one linked above? Mine supports subsorting. So I could sort orders by the date they were sold (descending), then by the sales person who sold them (ascending), and then by the total amount of the order (descending). Pretty powerful.

Anyway, here's the class:

     1: using System;

     2: using System.Collections;

     3: using System.Reflection;

     4:  

     5:  

     6: namespace Ross.Utilities {

     7:     /// <summary>

     8:     /// Class used to sort objects

     9:     /// </summary>

    10:     public class Comparer : IComparer {

    11:         private ArrayList _sortClasses;

    12:  

    13:         /// <summary>

    14:         /// The collection of sorting classes

    15:         /// </summary>

    16:         public ArrayList SortClasses {

    17:             get { return _sortClasses; }

    18:         }

    19:  

    20:         /// <summary>

    21:         /// Default Constructor

    22:         /// </summary>

    23:         public Comparer() {

    24:             _sortClasses = new ArrayList();

    25:         }

    26:  

    27:         /// <summary>

    28:         /// Constructor that takes a collection of sorting classes

    29:         /// </summary>

    30:         /// <param name="SortClasses">The prebuilt collection of sort information</param>

    31:         public Comparer(ArrayList SortClasses) {

    32:             _sortClasses = SortClasses;

    33:         }

    34:  

    35:         /// <summary>

    36:         /// Constructor that takes the information about one sort

    37:         /// </summary>

    38:         /// <param name="SortColumn">The column to sort on</param>

    39:         /// <param name="SortDirection">The direction to sort</param>

    40:         public Comparer(string SortColumn, SortDirection SortDirection) {

    41:             _sortClasses = new ArrayList();

    42:             _sortClasses.Add(new SortClass(SortColumn, SortDirection));

    43:         }

    44:         

    45:         /// <summary>

    46:         /// IComparer interface implementation to compare two objects

    47:         /// </summary>

    48:         /// <param name="x">Object 1</param>

    49:         /// <param name="y">Object 2</param>

    50:         /// <returns></returns>

    51:         public int Compare(object x, object y) {

    52:             if(SortClasses.Count == 0) {

    53:                 return 0;

    54:             }

    55:             return CheckSort(0, x, y);

    56:         }

    57:  

    58:         /// <summary>

    59:         /// Recursive function to do sorting

    60:         /// </summary>

    61:         /// <param name="SortLevel">The current level we are sorting at</param>

    62:         /// <param name="MyObject1">Object 1</param>

    63:         /// <param name="MyObject2">Object 2</param>

    64:         /// <returns></returns>

    65:         private int CheckSort(int SortLevel, object MyObject1, object MyObject2) {

    66:             int returnVal = 0;

    67:             

    68:             if(SortClasses.Count - 1 >= SortLevel) {

    69:                 object valueOf1 = MyObject1.GetType().GetProperty(((SortClass) SortClasses[SortLevel]).SortColumn).GetValue(MyObject1, null);

    70:                 object valueOf2 = MyObject2.GetType().GetProperty(((SortClass) SortClasses[SortLevel]).SortColumn).GetValue(MyObject2, null);

    71:  

    72:                 if(((SortClass) SortClasses[SortLevel]).SortDirection == SortDirection.Ascending) {

    73:                     returnVal = ((IComparable) valueOf1).CompareTo(valueOf2);

    74:                 } 

    75:                 else {

    76:                     returnVal = ((IComparable) valueOf2).CompareTo(valueOf1);

    77:                 }

    78:  

    79:                 if(returnVal == 0){

    80:                     returnVal = CheckSort(SortLevel + 1, MyObject1, MyObject2);

    81:                 }

    82:             }

    83:             return returnVal;

    84:         }

    85:     }

    86:  

    87:     /// <summary>

    88:     /// Enumeration to determine sorting direction

    89:     /// </summary>

    90:     public enum SortDirection {

    91:         /// <summary>Sort Ascending</summary>

    92:         Ascending = 1,

    93:  

    94:         /// <summary>Sort Descending</summary>

    95:         Descending = 2

    96:     }

    97:  

    98:     /// <summary>

    99:     /// Class used to hold sort information

   100:     /// </summary>

   101:     public class SortClass {

   102:         /// <summary>

   103:         /// Default constructor taking a column and a direction

   104:         /// </summary>

   105:         /// <param name="SortColumn">The column to sort on</param>

   106:         /// <param name="SortDirection">The direction to sort.</param>

   107:         public SortClass(string SortColumn, SortDirection SortDirection) {

   108:             this.SortColumn = SortColumn;

   109:             this.SortDirection = SortDirection;

   110:         }

   111:  

   112:         private string    _sortColumn;

   113:         

   114:         /// <summary>

   115:         /// The column to sort on

   116:         /// </summary>

   117:         public string SortColumn {

   118:             get { return _sortColumn; }

   119:             set { _sortColumn = value; }

   120:         }

   121:         

   122:         private SortDirection _sortDirection;

   123:  

   124:         /// <summary>

   125:         /// The direction to sort

   126:         /// </summary>

   127:         public SortDirection SortDirection {

   128:             get { return _sortDirection; }

   129:             set { _sortDirection = value; }

   130:         }

   131:     }

   132: }

To use it, you add a SortClass to the Comparer. You can add as many as you want. A SortClass is made up of the property name and a direction. So, for example:

     1:     public MyCollectionClass SortMyClass(MyCollectionClass myClass){

     2:         Comparer comparer = new Comparer();

     3:         comparer.SortClasses.Add(new SortClass("MyProperty1", SortDirection.Ascending);

     4:         comparer.SortClasses.Add(new SortClass("MyProperty2", SortDirection.Descending);

     5:         myClass.Sort(comparer);

     6:         return myClass;

     7:     }

So after the sort, myClass would be sorted by MyProperty1 (ascending), then by MyProperty2 (descending).

It looks like Rojo.com is actually starting to invite people to try out thier service. After I found out about it, I signed up for an invite. A couple of days ago, I got my invite.

To be honest, I couldn't find much about it at the time, so I had no idea what to expect. The sign up was simple, and it even gives you a default set of subscriptions, so you can get right to it. And when I did, I found out what it was: an online aggregator. They pull in over 1,000,000 feeds, and most of the default ones are from major publications, not blogs. Sites like the Washington Post, CBS Market Watch, etc.

But it's not just that - it's also a social network. So if you want to try out Rojo.com, let me know, and I will get an invite off to you.

With the combo of those two services, they allow you to flag stories as Shared. Once shared, anyone in your network can view these shared stories. They also have a recommended stories feature, which I'm guessing is the top shared stories, but I'm not positive on that.

They also have a tagging feature, where you can tag articles with any tag you want, and the more you use a certain tag, the bigger that tag gets, so you can visually see where the most articles are stored. Basically, a way to mark stories with a keyword.

Overall, the service seems pretty good. It still won't overtake Newsgator for me, but it's fun to play with.