For those that haven’t heard, today is the Internet Radio Day of Silence, where many Internet broadcasters based in the United States have gone silent to protest the new federal royalty rates being imposed by the Copyright Royalty Board. Even large webcasters, such as Yahoo! Launch and Rhapsody are going silent. The new rates are completely ridiculous, easily putting all but the largest Internet radio stations out of business.

It even gets more ridiculous when you consider the fact that terrestrial radio stations aren’t required to pay nearly the same rates. (Although, the recording industry is working to change that as well.) The argument has always been that Internet radio must be charged higher fees, since the #1 enemy of the recording industry – their customers — might save the stream to disk and not buy the CD.

Internet radio stations can’t generate the same level of revenue from advertising, since most companies aren’t convinced that Internet radio has a large enough audience to merit the expense. Most of Internet radio stations’ revenue is generated through textual ads on their web site (which is only peripherally related to the music). The other major income stream? Referrals for CD sales through places like Amazon.

Let me recap. One of Company A’s main revenue streams involves a direct contribution to Company B’s main revenue stream. Thus, Company A’s essential business is to market Company B’s products. To thank them, Company B wants to charge Company A for the privilege. And, they want a cut of all of Company A’s revenue — not just the part that comes from the use of Company B’s products. In fact, Company B wants a cut that, in some cases, amounts to over 360% of the gross revenue of Company A! (See the second chart here.) The government reviews this arrangement, and vehemently is in support!

Give me a break. The only reason that this insanity is even a remote possibility is that the recording industry has a gigantic lobby in Washington.

And before you are deluded by the press, the artists are not receiving this money. It’s been well documented that the recording industry works on a bizarre system of advance payments. At best, the artists receive royalties on public performances of their work — and the RIAA is even trying to lower those.

Honestly, though, with the questionable quality of modern music, does anyone else feel like musicians are paid too much as it is? For example, I defy you not to be moved by what can only be described as the lyrical mastery of MIMS:

This is why I’m hot
This is why I’m hot
This is why
This is why Uh
This is why I’m hot (Uh)
This is why I’m hot
This is why I’m hot Whoo
This is why
This is why
This is why I’m hot

I’m hot cause I’m fly (fly)
You ain’t cause you’re not
This is why
This is why
This is why I’m hot
This is why I’m hot

Or this, from John Lennon T-Pain:

Im’a buy you a drank
Theeen, Im’a take ya home with me
I got money in the bank
Shawty what you think bout that
Find me in the grey cadillac
We in the bed like
Ooh ooh ooh, ooh ooh
We in the bed like
Ooh ooh ooh, ooh ooh

The dominance of ClearChannel assures that only the Billboard Hot 100 is played on the grand majority of terrestrial radio stations. Internet radio doesn’t even pull 1% of the audience of terrestrial radio, and yet it exists as the only alternative to the tripe that’s branded as hot shit by ClearChannel and MTV. The FCC’s continued deregulation of media is not only contributing to a dangerous monopoly of the dissemination of factual information, but of entertainment as well.

Please help to save Internet radio, if for no other reason to save my sanity.

I’ve been a follower of the Sopranos for many years. In the beginning, I didn’t have HBO, so I watched the episodes once they came out on DVD. I’m an organized crime fanatic, and a huge fan of The Godfather, Goodfellas, Casino, Scarface, Donnie Brasco, etc. Naturally, last week was a huge moment for me as a follower of the Sopranos. I saw the finale along with everyone else, but it’s taken a little while for me to decide what it really meant, and my feelings on the show overall. Reading this article from New York Magazine sealed the deal, and I had to write about it.

I can pinpoint the moment that the show changed for me. It was during season 3, an episode called University, in which Ralphie beats his goomar Tracee, who is pregnant with his baby, to death in a parking lot over an argument about whether she should keep their child. The episode was told with the story of Tracee in parallel to Tony’s daughter Meadow, who were the same age. It was easily one of the most powerful in the entire series. I still remember that after the episode ended, I stopped and thought about where the series was going. Tracee’s death was the first completely “unjustified” act of violence on the show — before, the victims had been rats like Fabian Petrulio from College, or violent attackers like Mikey Palmice and Richie Aprile. Even Big Pussy had it coming.

Tracee was the first real “innocent” death on the show, but it wasn’t her grisly demise that changed things so much as the reaction (or lack thereof) of the other characters. It was also the last time that Tony showed real remorse for an innocent, and the beginning of his downward spiral. Throughout the remainder of the show, Tony became the “golem” — or, the sociopath — that he was afraid of becoming. Ralphie, Tony Blundetto, Adriana… His fall culminated in his murder of Christopher, who may as well have been his son. Sure, Chris was a disappointment, but his most serious crime was trying to distance himself from Tony.

I noticed something as the show continued. It became difficult for me to watch. It was harder and harder to root for Tony, even though he was set up as the protagonist. The things he allowed to happen, and did himself, were harder to accept. In the first season, the show was great fun, with funny characters and a chess game for a story line. As time went on, the stakes got higher and higher. As an audience, we started to realize that being a mobster was more about honor and Omerta — and the picture of the end continued to get more and more bleak. It was a lot like the arc in Goodfellas. In the beginning, it was all fun and games… and then as time went on, both Henry Hill and the audience started to realize what was really going on.

On to the finale. I can understand why people didn’t like the way it went out. I was expecting a bloodbath, or Paulie to stab Tony in the back, but I understand why David Chase made the decision he made. It took me a little while to accept it, but the open-ended finale was actually a fantastic piece of cinema. The tension was palpable throughout the entire episode, and we finally got the full picture of what it meant to be Tony Soprano. Every moment, every person that came into the frame, was a potential assassin. We finally were able to see that no matter how glamorous the mob life is, how nice Tony’s house and cars are, or how much cash he had tucked into bird feed in the backyard, the cost was just too high.

And yes, the abrupt black ending means that Tony is dead. If not in body, he’s certainly dead in spirit — dead inside, if you will, the textbook sociopath that so many people had “wrongly” (or so we felt) called him throughout the series. If you’re not convinced, read this excellent deconstruction.

The Sopranos is more like an epic movie than a television show. It meandered at parts, and definitely had some strange pieces that could have been taken out (Melfi’s drinking problem? Almost all of the first half of season 6?) Taken as a whole, though, it carried one of the most powerful messages of any show that I’ve seen.

It remains my favorite television show, and probably will for a very long time.

For one of the projects I’m working on, I’m setting up a virtual server for QA purposes. To allow testing, we created a virtual hard disk of each platform that we deploy our application on. Nothing else was installed on these images, except for the OS and (possibly) an associated version of Office.

The numbers say it all. Vista is at least 5 times the size of a comparable XP installation. And for what? Aero? This is why I’m sticking with XP for now.

Don’t ask me how the Vista image without Office is actually larger than the one with Office 2007, though…

I just read this post from Jeremy Miller, and was happy to see that he suggested adding embedded domain-specific languages (EDSLs) to Roy Osherove’s ALT.NET Hot/Not list. For those not familiar, an EDSL is a creative use of a programming language that makes the code required for a specific task more like natural language. (Fowler has a much better definition here.) The first time I really saw the power of an EDSL was when I used NUnit 2.4, which lets you type things like:

   1: Assert.That(foo, Is.Not.Null);

   2: Assert.That(bar, Is.Equal.To(42));

After seeing the way Guice used the Builder pattern and an EDSL to drive its type binding mechanism, and after reading this great paper on the evolution of the JMock EDSL, I decided to implement my own in Titan.

Titan’s EDSL is really what gives the contextual binding system its power. For example, compare this:

   1: Bind<IService>().To<ServiceImpl>().When.Member.Type.Namespace.StartsWith(“MyCompany.ProjectA”);

To this (similar to an early version of Titan’s XML configuration):

   1: <binding

   2:   service=”MyCompany.ProjectA.Services.IService, MyCompany.ProjectA, Version=1.2.3.4″

   3:   implementation=”MyCompany.ProjectA.Services.ServiceImpl, MyCompany.ProjectA, Version=1.2.3.4″>

   4:   <condition

   5:     type=”Titan.Kernel.Conditions.MemberNamespaceStartsWithCondition, Titan.Kernel”

   6:     value=”MyCompany.ProjectA”/>

   7: </binding>

The latter is much uglier, slower, requires much more effort, and blocks you from using the power of the IDE for statement completion and type-checking. Not only that, but I (or more likely, an unlucky developer that decided to use Titan!) would have to create a different condition type for each possible condition. There wouldn’t be the slick reusability that Titan’s EDSL has via its ConditionBuilders. The way the internals of Titan’s EDSL works is particularly interesting, and may be the topic of a near-future post.

EDSLs are starting to gather steam in other developer communities, particularly Ruby. I think it’s very important that when you’re looking for a fresh solution to a problem, that you look outside your comfort zone.

Ugh… I’ve been busier than usual for the past few weeks, which probably has something to do with me letting my blog be half-broken for a good two weeks or so before fixing it. Then this past week we just landed a major new project at work, and I’m going to wear two hats: architect and project manager. Exciting, but as you might imagine, I’ve been busy for the past few days. :)

In spite of that, I’ve been scrounging some time to work on the Beta 2 path for Titan. One of the primary things that I’d like to support before getting around to release is generic type inference. Basically, generic type inference lets you bind a generic service type definition, such as IService<T>, to a generic implementation type definition, such as ServiceImpl<T>. Then, when you asked Titan for an IService<string>, you’d get a ServiceImpl<string>, and if you asked for an IService<Foo>, you’d get a ServiceImpl<Foo>. This (obviously) can greatly simplify your modules’ binding definitions. Windsor has this, but I originally felt that it was one of those features that landed on the short side of the 80/20 rule, and left it out to make the system simpler.

Specifically, leaving out generic type inference made it so the concrete implementation type for a given binding would be known before activation, which in turn meant that binding directives could be collected by the Binder before an instance of the service was actually activated. Because of this, Titan could fail faster if there was a problem with the way the bindings were declared. Also, I had the idea that binding declarations could be serialized and cached to persistent storage (like a file) to speed subsequent executions of the application.

Like I said, I was convinced that this was something I could sacrifice for simplicity’s sake. Since the beginning, I’ve seen Titan’s niche as being ultra-lightweight, in contrast to Spring.NET and Windsor’s bulk. Titan could never compete in terms of features, but I think that there’s a vacuum in the “market”, so to speak, for dependency injection in small (”non-enterprise”) applications.

Speaking of small applications, I plan to create .NET Compact Framework 2.0 build of Titan for use in a project at work. It’ll have to use reflection-based injectors rather than the lightweight delegate system that’s available in the standard build, because there’s no DynamicMethod support in .NETCF, but otherwise it should be a direct port. Another thing I’m planning for Beta 2 is improved MSBuild support, to target multiple platforms at once.

Anyhow, as I continued to work with Titan, this binding decision turned out to be more of a limitation than a feature. I had inadvertently tightly coupled the service type and the implementation type (from Titan’s perspective). That is, once the binding for a given service type was registered, the implementation type was fixed in perpetuity — at least in a context that matched the binding’s condition.

To get around this limitation, Beta 2 will delay the collection of binding directives until the binding’s provider actually creates an instance of the type. The directives will then be cached, so the type won’t be re-analyzed for services with transient behavior. There will be a new GenericProvider to supplement the StandardProvider, that can do generic type inference.

I’m also working to pull the binding API out of the kernel itself using the Builder pattern. This means that instead of:

kernel.Bind<IService, ServiceImpl>(If.InjectionPoint.Tag.EqualTo("foo"));

You’ll write (tentatively):

Bind<IService>().To<ServiceImpl>().When.InjectionPoint.Tag.EqualTo("foo");

There’ll also be a couple of other changes, which are intended to let you work with types that you can’t modify:

1. You’ll be able to specify the behavior of the service when declaring the binding, which will override any behaviors declared via attributes.
2. You won’t have to mark a constructor with [Inject], if there is either a default parameterless constructor, or just a single constructor period. (I was tempted to get into heuristics like Castle’s MicroKernel has, but I opted out of it because there’s no deterministic way to figure out which constructor will be called.)
3. I might add auto-wiring support as a kernel option, so Titan will automagically try to figure out what you want injected. Again, I’m not a fan of this because I think you should be able to look at your type definition and understand what Titan’s going to do.

If you’re a glutton for punishment, there’s a Beta 2 branch in Subversion:

http://titan-ioc.googlecode.com/svn/branches/beta2

Be forewarned though, that this is even less stable than usual, since I’m making daily changes to it. If you’re looking to try out Titan, you might be better suited to work with the trunk build instead. That’s available at:

http://titan-ioc.googlecode.com/svn/trunk

If you’re interested in learning more about Titan, check out:

• Google Code Page: http://code.google.com/p/titan-ioc/
• Users Group: http://groups.google.com/group/titan-ioc-users
• Developers Group: http://groups.google.com/group/titan-ioc-dev

I’m still working on the manual, but since Beta 2 is going to be significantly different, I’ve been working more with the code than the docs. Bad developer! As always, if you have questions or ideas on ways to improve Titan, by all means post them to the Users Group.

I’m moving my blog back to Wordpress. I originally moved to Mephisto because I was impressed by its quality and ease of use. It has a good design, was well thought-out, and sat on the Rails stack, meaning it was easily extensible. Wordpress, by contrast, is implemented as a gigantic for loop, relying on “hooks” to support extension, and basically forcing users into implementing their work as bizarre mashes of code and layout, without the nice MVC separation that Rails provides.

So why am I back to Wordpress? Simple: Mephisto is dead. There hasn’t been any active development on the project since the end of 2006, and while that may not seem like a long span of time to its developers, six months of dead air on a beta-quality project is unacceptable. With its market share, Wordpress will always have the active support of a vibrant community and development team.

I understand that Mephisto’s developers have been working on something pretty cool, and that there’s probably more money in it than in a blogging platform, so I can’t blame them. The important lesson here, though, is that the end-result of software is more than the software itself. I need to remember that myself as I work on Titan… (beta 2 with a real-live manual is coming soon, I swear!)

Edit: By the way, articles were imported, but it nuked all of the comments. I’m way too lazy to try to recover them. Sorry to anyone who spoke wisdom therein. :)