There's a little war going on in the podosphere right now, and it's fun to watch.

So where did it stem from? Keith and The Girl. Alegedly, they got their hands on a Podshow contract and read it on their podcast. If it's the actual contract, then people signing up with Podshow are basically turning everything over to Podshow, for not a lot of guaranteed return. I'm not going to rehash the contract, but Scott Fletcher of Podcheck Review has a nice summary, finishing with this little Fletcherism:

Not the worst contract I've ever heard. In retrospect, that contract I signed when the devil gave me my voice was a bad contract.

After this, how did Adam Curry respond? Well, he basically said he's not going to discuss contacts. By his non-response, to me, he's basically saying that Keith got it right, and that is the contract. If it wasn't, wouldn't you come out and say so? Some of the stuff in there would scare away a lot of podcasters from even talking to Podshow, so it would be in their best interest to get the truth out there.

Unless Keith's version is the truth.

Technorati Tags: Podshow | Contracts | Podcasting

RossCode Weekly #041?- 03.30.2006

I've been dabbling with Audacity?a little bit, and I think I was able to filter out a bit of the dungeon ambience this week. Let me know if you hear a difference, and if so, then I'll keep doing it. I may even start dabbling with some other software to record the show too in the next few weeks, as well as actually looking into changing the show up a little bit?- intro music (maybe even an actual intro), maybe no more background music, etc.?We'll see though. Anyway, this week, we have 35 stories in less than 30 minutes. To me anytime i hit better than a story per minute is good SNR!

Intro - 0:00
Download this episode -?29:19 /?14.1 MB
Subscribe to RossCode Weekly

Previously On RCW - 1:30
FeedDemon 2.0 released
Newsgator Inbox released
Newsgator Online gets revamped
Google's new search interface - revealed

News & Views - 4:05
Google added to S&P 500
Google to sell off 5,300,000 more shares
Google does job search
YouTube limits videos to 10 minutes
MSN-TV to launch in-car service
Microsoft delays Virtual Server to 2007
MSN Spaces to go Live
Biztalk RTM is here

The Cold Wars - 8:48
Cablevision rolling out server-based DVR
Time Warner Cable to offer instant replay TV shows
TiVo court case with EchoStar begins
TiVo upgrades series 2 offerings
ABC offering subscriptions for series on iTunes
France and Denmark want iTunes DRM opened up
Universal Pictures to offer downloadable movies
Universal won't downsample HD DVD content
TorrentSpy standing up to RIAA
Skype founders sued for racketeering
Lycos enters VoIP game
Sprint-Nextel offers Mobile search
Obopay set to launch
Adobe won't be rushing it's port of products to Intel Macs

The Grapevine - 20:35
Quad-Core CPUs due in Q1 2007
Google Music?

Odds & Ends - 23:15
Pimp your rims
Customized Cola
Sony stops producing PSOne
Urinal Games

Bonehead of the Week - 25:53
Vonage user on hold while house burns
More than half of Vista to be rewritten?
Google deletes their own blog

Outro?- 28:11

Contact / Feedback
weekly@NOSPAM.rosscode.com
206-424-4729 (4RCW)

Production Notes
Background music provided by Chronos (Introvert 4) and the Podsafe Music Network.
Hosting of RossCode Weekly is provided by OurMedia.org.
Would you like to sponsor RossCode Weekly? Contact me at sponsor @ rosscode.com.

Technorati Tags: RCW | Podcast | Google | Microsoft | Yahoo | Technology | News

This looks interesting:

This package provides the functionality of the Microsoft Enterprise Library Configuration Console as an editor for Microsoft Visual Studio 2005. Once installed, Visual Studio will open .config files in an editor tree view, display node properties in the Properties window, display configuration and validation errors in the Error List window, and so on. The behaviors of the tree view and context menus have changed from Configuration Console to make more sense in a tabbed interface, but all Configuration Console functionality is still available.

If you've ever used Enterprise Libarary, one thing you may have wondered is why you can't use the configuration editor directly from Visaul Studio. Well, now you can!

[found via Greg]

Technorati Tags: Avanade | Enterprise+Library | Visual+Studio

One of my clients just got word that they will be moving where they host their servers, and the new environment is much stricter than the old one. The public website will be in an outer DMZ and only able to communicate with an inner DMZ. The database server will be inside the firewall completely, meaning that the web server?can no longer communicate directly with the database server, and instead has to do so through an application server.

I'm sure this is a common scenario that people have to deal with. We discussed a few different options, and eventually settled on remoting. But, our number one concern when implementing this was to make it seamless - we didn't want to perform major surgery on the code base. Why? First, we didn't want to risk missing a spot and not catching it until later. Second, we only need to use remoting from the public website, and not the internal application that uses the same DLL. If we had to make a bunch of changes to the web code and then have to use two different coding styles for the internal app and the external app.

So I set out to find the least intrusive mechanism to get remoting running. I think we came up with a nice way to do it. Before I go into details, I should back up and point out our architecture. We used basic data entities - dummy objects that basically just hold data. Then we use static managers to manipulate the data.

So, with remoting, we had a few challenges. How do we perform surgery on a large code base without having to go back and touch every line of code? In my opinion, it's much harder to go in and touch every peice of existing code than it is to introduce a new layer that will make the necessary changes transparent to the rest of the application, so that's what we did.

Before we get into the solution, we need to touch on our architecture. We used static managers with "dumb" data classes. A "dumb" data class has no inherent ability to do anything. It holds data and that's pretty much it. They're easily serializable, but have no smarts. The Managers know nothing about state, so you pass in the data that it should act on. With that, here's how our code looks now, both from the website and in the managers. First, the website code (this would typically be in our controller):

   1:  Model.Customer customer = new CustomerManager.GetCustomer(customerId);

   2:  ?

   3:  customer.FirstName = "Joel";

   4:  customer.LastName = "Ross";

   5:  ?

   6:  CustomerManager.SaveCustomer(customer);

Now, the manager:

   1:  public static class CustomerManager

   2:  {

   3:      public static Model.Customer GetCustomer(int customerId) 

   4:      {

   5:          return Data.Customer.GetCustomer(customerId);

   6:      }

   7:  ?

   8:      public static void SaveCustomer(Model.Customer customer)

   9:      {

  10:          Data.Customer.SaveCustomer(customer);

  11:      }

  12:  }

Obviously, there's more. There's a UI on top of the controller, and there's a data layer below the managers, but since this is where our break will occur, this is the interesting part of the code. So how do we get "remoting goo" between these two? Well, first we have to have objects for remoting. Remoting uses singletons to manage passing data between the two systems. So, we have to have some objects that can be instantiated, but still act like static classes. What I mean there is that they shouldn't have internal data structures, since they will be shared across the application.

This is created in the application layer, and sits on top of the manager layer. Here's an example:

   1:  public class CustomerManagerObject : MarshalByRefObject

   2:  {

   3:      public Model.Customer GetCustomer(int customerId) 

   4:      { 

   5:          return CustomerManager.GetCustomer(customerId); 

   6:      }

   7:  ?

   8:      public Model.Customer SaveCustomer(Model.Customer customer) 

   9:      {

  10:          CustomerManager.SaveCustomer(customer);

  11:          return customer;

  12:      }

  13:  }

A couple things to note: First, this object has to inherit from MarshalByRefObject so it can be moved across the wire from the web server to the application server. The second note is that SaveCustomer now returns a Customer object. When a Customer object is passed over the wire, it's serialized, and is disconnected from the original object. Normally, the object would be passed by reference, so any changes to the object made by the manager layer or below will not be pushed back to the client automatically like they were in the past. By returning the object, we can get those changes back to the client easily.

So that's how the code looks from the application server. There's a couple more things?to do to expose the CustomerManagerObject to the world. First, we need a configuration file, which looks like this:

   1:  <?xml version="1.0" encoding="utf-8" ?>

   2:  <configuration>

   3:    <system.runtime.remoting>

   4:      <application>

   5:        <service>        

   6:          <wellknown mode="Singleton"  type="Application.Business.CustomerManagerObject, Application" objectUri="Application.Business.CustomerManagerObject.rem"/>

   7:        </service>

   8:        <channels>

   9:          <channel ref="http" port="8989"/>

  10:        </channels>

  11:      </application>

  12:    </system.runtime.remoting>

  13:  </configuration>

This, when loaded by the application, will tell the remoting server to listen for requests for Application.Business.CustomerManagerObject.rem on port 8989. The server then uses the app configuration file to fire up the remoting engine:

   1:  RemotingConfiguration.Configure("RemotingServer.exe.config");

So now we have?a fully functional server that is listening for requests. How do we make requests? Well, remember our primary goal: minimal changes to the way the the website is written, and not just that, but minimal changes to the way it will be written going forward. But how do we do that? Remember, our code calls the managers directly, but those aren't exposed via the remoting server - objects sitting on top of those managers are.

Combine the above need with the desire to have the same data objects, and what we came up with was a model in our managers that uses compiler directives. This allowed us to use a modified version of the Application DLL in the web project that would provide us with the necessary "remoting goo" to make it work. I'll show the manager without the compiler directives in it for simplicity - you'll see exactly what the website would see. Later, I'll show the two mashed together. So, here's the manager from the website's perspective:

   1:  public static class CustomerManager

   2:  {

   3:      public static Model.Customer GetCustomer(int customerId) 

   4:      {

   5:          CustomerManagerObject customerManager = new CustomerManagerObject();

   6:          return customerManager.GetCustomer(customerId);

   7:      }

   8:  ?

   9:      public static void SaveCustomer(Model.Customer customer)

  10:      {

  11:          CustomerManagerObject customerManager = new CustomerManagerObject();

  12:          customer = customerManager.SaveCustomer(customer);

  13:      }

  14:  }

Now you can see how we avoided changing the website's existing code. Each call to the manager is "intercepted" by our alternate manager, and instead of doing direct calls, it instantiates the CustomerManagerObject and makes the calls that way. The remoting engine intercepts those calls and passes them over the wire to the application server. Of course, you have to configure that, so there's a configuration file on the web side too:

   1:  <?xml version="1.0"?>

   2:  <configuration>

   3:    <system.runtime.remoting>

   4:      <application>

   5:        <client>

   6:          <wellknown type="Application.Business.CustomerManagerObject, Application" url="http://localhost:8989/Application.Business.CustomerManagerObject.rem" />

   7:        </client>

   8:      </application>

   9:    </system.runtime.remoting>

  10:  </configuration>

This is in a seperate file. It doesn't work in the web.config, so we pulled it out of there. To fire up the remoting engine, you make one call in Application_OnStart in the Global.asax file:

   1:  System.Runtime.Remoting.RemotingConfiguration.Configure(HttpContext.Current.Server.MapPath("client.exe.config"), false);

Now, the remoting engine intercepts calls to the CustomerManagerObject and passes them over the wire. There's one other change that we made to ensure that the remoting service is working, and I'll show that in conjunction with the other changes we made to the CustomerManagerObject. Here's the final version of the object:

   1:  internal class CustomerManagerObject : MarshalByRefObject

   2:  {

   3:      public Model.Customer GetCustomer(int customerId) 

   4:      { 

   5:  #if REMOTINGCLIENT

   6:          throw new NotImplementedException(); 

   7:  #else

   8:          return CustomerManager.GetCustomer(customerId); 

   9:  #endif

  10:      }

  11:  ?

  12:      public Model.Customer SaveCustomer(Model.Customer customer) 

  13:      {

  14:  #if REMOTINGCLIENT

  15:          throw new NotImplementedException();

  16:  #else

  17:          CustomerManager.SaveCustomer(customer);

  18:          return customer;

  19:  #endif

  20:      }

  21:  }

We use the REMOTINGCLIENT compiler directive to get the alternate business object for the website, so if the remoting engine isn't started, we'll get a?NotImplementedException() whenever we make calls - which tells us something has gone wrong. The other interesting note is that because the managers are in the Application assembly, and they are the only class that calls the remoting objects, we can make them all internal. This ensures that all of the website interaction goes through the managers, meaning that if we got to a point where we didn't need the application server anymore, it would be easy to switch back to the old way of doing things.

For completeness, here's the actual CustomerManager, with the compiler directives in it, so you can see how it would look when developing:

   1:  public static class CustomerManager

   2:  {

   3:      public static Model.Customer GetCustomer(int customerId) 

   4:      {

   5:  #if REMOTINGCLIENT

   6:          CustomerManagerObject customerManager = new CustomerManagerObject();

   7:          return customerManager.GetCustomer(customerId);

   8:  #else

   9:          return Data.Customer.GetCustomer(customerId);

  10:  #endif

  11:      }

  12:  ?

  13:      public static void SaveCustomer(Model.Customer customer)

  14:      {

  15:  #if REMOTINGCLIENT

  16:          CustomerManagerObject customerManager = new CustomerManagerObject();

  17:          customer = customerManager.SaveCustomer(customer);

  18:  #else

  19:          Data.Customer.SaveCustomer(customer);

  20:  #endif

  21:      }

  22:  }

So, if you're using a Manager design, and have a need for remoting, here's one way to do it.

If so, then this'll be of interest to you. For those not in the know, Web Content Management is the next version of Microsoft Content Management Server, and should bve a solid replacement.

Anyway, if you want to get a look at it before it's released, Andrew Connell will be doing a webcast on April 18th, and he'll go into what's new (everything, it seems!) and how to migrate from CMS 2002 (the last major release) to the latest and greatest.

If you're interested, check out Andrew's post for some more information, or skip that, and just register!

Technorati Tags: MCMS | WCM | Andrew+Connell

I didn't mention this when it launched a few weeks ago, mainly because I didn't work on the project. But I recently saw a review of Spout on Mashable, so I figured it was time to mention it. Spout was built by a few of my friends at NuSoft Solutions, so I got some early looks at what they were building over the past year. Anyway, what is it? Well, let's let the Spout guys describe it.

We want to fill the gap between what shows up at festivals and what shows up at the multiplex. In that gap is where we?re settling a community of film lovers. A place called Spout?Spout sells DVDs. It?s our bread and butter. We love going to the local music shop where the guy behind the counter knows what we want. We love finding out about films from a random conversation with somebody else who loves film. We believe the act of buying films and being in a community are connected, not two separate things. We hope you agree.

Basically, if you've ever seen a movie, this site is for you - you can tag the movie, say what you thought of it, find others who like the same movies you do, and then find other movies they liked. And of course, buy the movie.

Now, you know me. What it does is cool, but I'm also interested in the technology behind it - and this is no different. It's built on Community Server, and we were?lucky enough to have Nick McCollum,?one of the 13 original Community Server MVPs,?on the project. He's really taken a liking to Community Server, and that's what he's been talking about on his blog. The customizations made are extensive to say the least.

Obviously Nick wasn't the only one involved. Bruce Abernathy was part of the team too. He's also very involved in the Grand Rapids .NET User Group. Jim Becher was also involved, and here's his announcement. I know there were others, but these are the only ones that I could find blogs for. Well, except for Brian Anderson - he was involved throughout, but he never posted about the launch.

I signed up and played with it when it first launched, and I'd say they did an awesome job. They're still working on it, and I'm excited to see where it goes from here!

Technorati Tags: Community+Server | Spout

I got an email from Matthew Chen the other day, asking if?I would share my OPML file with Megite, and in return, he'd set up a personal Megite for me.

Well, today, I sent him a link, and here it is: My personal Megite page!

I first heard about Megite from (indirectly) Alex Barnett. He has a personalized Megite page, and something of mine was on there. How did I find out about that though? Well, Megite is my number one referrer for this month - I've been on memeorandum four or five times, and Megite still sent more people this way!

I'll definitely be keeping an eye on what happens with the personal homepage, but from what I've seen so far, TailRank's OPML filtering still beats it.

Technorati Tags: Megite | TailRank | Memeorandum

A while back, Kent Newsome?found a graphic of a bunch of Web 2.0 companies, and decided to put together a little competition. I found the site around Round 16, and went back and looked through all of the other first round match ups, and you defintely get a good look at some of the newer sites out there.

Anyway, he's finished round 1, and is moving on to the quarter finals, where he'll take a deeper look at each of the first round winners.

If you're interested in the first round archives, here's the final first round?match up in the Web 2.0 Wars, which has links to the other 19 match ups.

Technorati Tags: newsome.org+web+wars | Web+2.0

Talk about bad timing! This morning, I woke up to reports that Tourneytopia was down. I immediately checked it out, and sure enough, that's exactly what we were dealing with.

Digging deeper, our SQL Server went down - well, something like that. We don't know if went down or if it was a planned outage. Our host, WebHost4Life, informed us they were working on it, but three hours later, we still hadn't gotten any details about what was going on. We asked to be moved to a different server, but never heard anything. By the time we got a response, the site was back up.

While any downtime is upsetting for us,?I guess we have to look on the bright side - this would have been a killer (for us and our users) had this outage happened a couple of weeks ago, when we were accepting picks.

On the bright side, though, it's back up, and now the What-If scenarios are available. We even revamped the what if page - you now see the top five standings right on the scenario list page, rather than having to click through on each scenario to see the standings.

Technorati Tags: Tourneytopia

And just like that, it's final.

I'm sure the differences between RC2 and the final release are minor, but if you don't follow FeedDemon very closely, or you don't mess around with betas, then you're probably still running FeedDemon 1.5. If that's the case, go get 2.0. It is a huge step up!

Now, we just need to get synchronization of news bins!

Technorati Tags: Newsgator | FeedDemon