Jeff and .NET

Abstracting away issues of HttpContext from your ASP.NET MVC controllers

Jeff — Fri, 03 Feb 2012 15:43:00 GMT

I've noticed that I write software in one of three modes:

For myself: Shortcuts, less testing, not well-factored.
For myself but in public: Mostly POP Forums, which I try to avoid letting it suck since others will use it and see the code.
For sharing: Any day job or gig where others will use or maintain your code. You don't want to unleash crapsauce on others.

I have to admit that second case isn't the most clean of endeavors. While I'm generally happy with the forum app and the feedback I get for it, it needs some refactoring in places. The thing that bothers me the most is that a lot of the controllers do way too much. This is particularly obvious because of all the mocking required for the tests. It's not like I've got inline SQL in there, but they could definitely stand to delegate stuff to other stuff.

One of the inevitable things you end up doing at some point in your ASP.NET MVC controller is access the HttpContext in some way. Because the cats that build the MVC framework are so smart, they actually used HttpContextBase as the type for the HttpContext property on the Controller base class. That already makes life a little easier, because you don't have to mock out a huge graph of objects to test what it is your controller is doing.

I suggest that you can take that one step forward. For example, say that you need to molest your model a little before you return it to a view, but only if the client is a mobile browser. It's actually pretty easy to check, but here's the Boolean that tells you:

var isMobile = HttpContext.Request.Browser.IsMobileDevice;

Simple enough, but it's also pretty deep in the object graph for mocking. It also assumes you'll never do any logic more complicated than checking the property. Since you're already using dependency injection in your controller (and if you're not, shame on you, go read up on it), it might be easier to hand off this logic to something else. So in this example, perhaps you have a class called MobileDetectionWrapper, which implements IMobileDetectionWrapper, and looks like this:

public class MobileDetectionWrapper : IMobileDetectionWrapper
{
    public bool IsMobileDevice(HttpContextBase context)
    {
        return context.Request.Browser.IsMobileDevice;
    }
}

Super simple example, and what might seem like a needless abstraction, but this is far easier to test. Inject the IMobileDetectionWrapper into your controller, and now you simply mock that. Your test might look something like this (using Moq here):

var mobileDetection = new Mock<IMobileDetectionWrapper>();
mobileDetection.Setup(x => x.IsMobileDevice(It.IsAny<HttpContextBase>()).Returns(true);
var controller = new MyController(mobileDetection.Object);
var result = controller.MyActionMethod();
// test the result here for whatever

And just in case you're unclear about the way the controller looks:

public class MyController : Controller
{
   public MyController(IMobileDetectionWrapper mobileDetection)
   {
      _mobileDetection = mobileDetection;
   }

   public ActionResult MyActionMethod()
   {
      var isMobile = _mobileDetection.IsMobileDevice(HttpContext);
      // do stuff
      return View(resultModel);
   }
}

Get it? I freehand-typed that without Visual Studio or Intellicrack, so hopefully it's right. :) In any case, the dependency injection resolver you have set up in your MVC app news up the controller with the concrete implementation of IMobileDetectionWrapper and you use it in your action method. Again, trivial example, but imagine you had to do other special things, like check for a cookie and identify an iPad, and therefore return a false value instead of true for the IsMobileDevice question. The necessary mocking in the controller is significantly less.

Using the Scoring Game from POP Forums with your ASP.NET MVC app

Jeff — Fri, 27 Jan 2012 18:19:00 GMT

Let me tell you a story of HR-discouraged workplace fun. Back in the day, prior to the crash-and-burn of Insurance.com, we had this thing in the development part of the company called the Scoring Game. I wrote about it a couple of years ago on my personal blog. The long and short of it is that we kept a running total of +/-1’s for virtually anything you can think of, for each participant. This was back in 2006, before it became trendy to do it for everything else on the Internets.

Later, Digg started doing all kinds of voting, and it was really the first active example that I can think of that I used in terms of measuring value of content (yes, slashdot did it, but I never went there). Various forums started doing it. StackOverflow based much of its value on a scoring system, along with achievements. When I worked at Microsoft, I worked on the reputation system that feeds the various MSDN properties. It seems inevitable that I’d have to add something like this to POP Forums.

Originally, I was thinking just in terms of voting up posts, but then I realized that there were actually two things to build. The voting mechanism was one part, but the actual scoring was a second part that should be decoupled from the voting. So the workflow goes like this:

Process Event –> Publish to user profile (optional) –> Get associated awards –> Qualify awards –> Give award

To use the system, you only need only a few lines of code. Use the dependency injection container (Ninject) to get the implementation of PopForums.ScoringGame.IEventPublisher.

Note: Yeah, the forums are currently wired to use ASP.NET MVC’s IDependencyResolver to new-up stuff. I realize that this is suboptimal, and a future version will fix this so you don’t have to commit to the same DI container the forum uses.

var publisher = PopForums.Web.PopForumsActivation.Kernel.Get<PopForums.ScoringGame.IEventPublisher>(); publisher.ProcessEvent("message for feed", user, "TestEventID");

Pretty simple, eh? The first string is the text that will be published to the user’s feed (if the event is set to publish), the second is the PopForums.Models.User object to associate with the event, and the third is the actual event ID. Event definitions are really simple.

There are three events that are static, permanently built into the system. These are wired into the post voting, and the creation of new topics and posts. So for example, when someone votes up a post, a string of HTML is passed in to the ProcessEvent() method, with the user object associated with the post, and the event ID PostVote. The resulting mention in the user’s profile looks like this:

Events don’t have to be published to the user’s profile, and they don’t even need to assign points. New posts and topic events fall into this category. So what’s the point then? Awards! POP Forums leaves that up to you. Award definitions are super simple as well. Say we wanted to give an award for anyone who made 50 posts. The definition would look like this:

We can assign any combination of events to the award. In this case, we look for 50 NewPost events, but we could just as easily require 25 PostVote events as well, for a combined set of conditions.

That’s really all there is to it. You can set up stuff anywhere in your app to record events, and publish them to the user profile. Give points, give awards. Knock yourself out!

POP Forums v9.2.1 posted to CodePlex, adds only Spanish translation

Jeff — Thu, 26 Jan 2012 20:47:00 GMT

Just wanted to drop a quick note to say that I've got an updated version of our most recent POP Forums drop. The new v9.2.1 adds Spanish along side of Danish, German and English as available languages. It has no new features or bug fixes, so if you have v9.2.0, and you don't need Spanish, these aren't the droids you're looking for.

Want to translate to yet another language? Drop me a line: jeff@popw.com.

POP Forums v9.2 posted to CodePlex, with new languages, post voting and the scoring game

Jeff — Tue, 24 Jan 2012 02:38:00 GMT

POP Forums v9.2.0 is the third release for the ASP.NET MVC3 version of POP Forums. It is feature complete, stable, and ready for feedback. For previous release notes, see previous releases.

Check out the live preview: http://popforums.com/Forums

Setup instructions are available in the documentation section.

Upgrading?

If you're upgrading from v9.0 or v9.1, simply replace the existing files. You'll also have to run the PopForums4.xto4.2.sql SQL script against your existing database. That script can be found in the database project. It adds a number of new fields and tables.

What's new?

Localization: The app can now be easily translated. .resx files included for Dutch (nl) and German (de) so far, in addition to the core English. Can you help with another translation? Contact jeff@popw.com.
Vote up posts: Give credit to people who make good posts, see who voted on each post.
The Scoring Game: Extensible system that allows you to give users points, and issue awards based on repeated events. For example, you can set up awards based on a number of new posts or topics (both of which record these events).
Fix: Weird line breaks in lists when posting from Firefox parsed correctly.

What's next?

We'll get some sample documents around how you can use the scoring game functionality in your own application. Feel free to submit feature requests to the issue tracker or on the sample forum. We're particularly interested to hear if you have any desire for installation via NuGet, and if there's a desire to use a SQL CE database.

Wanted: Language translations for .resx files in open source POP Forums

Jeff — Fri, 06 Jan 2012 19:12:00 GMT

Starting with v9.2, POP Forums will be fully capable of localization. I'm looking for people who can help translate the .resx file in this open source project, which is fairly straight forward. I'll take help for any language, but I'm particularly interested in:

German
Spanish (es-ES and es-MX)
French
Russian
Chinese (zh-CN)
Arabic
Hebrew

If you can help, please drop me a line at jeff@popw.com. Thanks!

POP Forums v9.1.1 posted, update fixes bug in previous release

Jeff — Mon, 19 Dec 2011 20:23:00 GMT

There was a problem in v9.1.0 that prevented user views of a topic to be registered, meaning the "new topic" indicator would continue to glow "new" even though the user had viewed it. This has been fixed in v9.1.1.

See the previous post about the new version. Get the bits here. Sorry for the bug... I didn't have solid testing around this particular feature. I do now!

Microsoft uses open source? OMG, LOL and what not

Jeff — Fri, 16 Dec 2011 14:02:00 GMT

Sometimes I read something in the "tech press" about Microsoft and get endlessly annoyed. I may have decided to leave the company, but quite honestly it's a lot like the feeling you get when you graduate from college. For better or worse, it'll always be a part of you and you'll always identify yourself as some part of it.

So ZDNet posts some drivel about blogs and such from Microsoft, and gets it wrong right off the bat:

"But the Microsoft blogs are the 'official' place to get detailed information; sometimes prepared and checked by the lawyers, more often posted directly by the developers working on the technology."

Really? I know a lot of people who work at Microsoft who have blogs, and they're not bouncing anything off of lawyers. Believe it or not, the company generally seemed to trust people to not do stupid things. The company is not as dumb and slow as people might like to think. It's also worth mentioning that many Microsoft employees host and pay for their own blogs, and a lot of people on these blog sites (MSDN, asp.net, etc.) don't work there at all.

That was just the part setting the tone that annoyed me. It was later in the piece where they express shock and awe (and then backtrack) over the use of open source at Microsoft.

"There's always a lot of suspicion when Microsoft is involved with open source, but this is a classic example of what open source is really good for..."

I hate that statement, because it comes off as an underhanded compliment. I read, "The evil Microsoft is trying to crush something, but it's cool because open source is a good force in the universe." There is not "always" suspicion, just suspicion when you're link-baiting. Mission accomplished.

Let me break it down for you in real terms. People like Matt (the developer who posted his experience about developing and deploying RequestReduce) at Microsoft are not cogs in the machine who mindlessly do as they're told and chant "developers developers" all day. In fact, Matt was one of the guys I worked with. We'd all go to lunch together (we had a DL called "deveats") and talk about whatever, make fun of our coworkers and often talk about poop (several of us had young children). We used all kinds of open source stuff in our apps, and obviously many of us contribute to, or maintain OSS projects. And by the way, the people who work there are probably smarter than everyone you work with, but would never admit to it.

My point is that actual human beings work at Microsoft, and this perpetual stereotype of the evil Uncle Fester working at the top to crush everyone is stupid and lame. It's also very tired. For all of the unfounded toxicity directed at Microsoft, the same people sure do get excited to see it on your resume.

POP Forums v9.1.0 has been posted to CodePlex!

Jeff — Thu, 15 Dec 2011 15:22:00 GMT

Finally! After moving, being a dad and engaging in a great deal of home improvement, I finally managed to find time to an update out to POP Forums. I hope to not be that guy anymore, going forever between updates.

Release Notes

This is the first release for the ASP.NET MVC3 version of POP Forums. It is feature complete, stable, and ready for feedback. For previous release notes, see previous releases.

Check out the live preview: http://preview.popforums.com/Forums

Setup instructions are available in the documentation section.

Upgrading?

If you're upgrading from v9.0 to v9.1, simply replace the existing files. You'll also have to run the PopForums4.0to4.1.sql SQL script against your existing database. That script can be found in the database project. It adds a single field to the pf_Forum table.

What's New?

New "adapter" interface for forums. Using the IForumAdapter interface, a developer can plug-in code that alters the model and/or resulting view on topic lists and the actual threads. For example, you might add to or alter the model, then present a different view to display the data. See the comments on the IForumAdapter interface for more information.
Also new, users starting a reply will see a button indicating that they can load any new posts that have occurred since they started writing their apply, so they don't miss any of the conversation.
Fix: Moderating topic title doesn't update the UrlName.
SEO enhancement: Page links in topics and forums include rel="next" and rel="prev" to tell search engines there's more to look at.
Fix: User post list had broken markup, preventing topic preview.
Fix: Added missing permission checking on action methods to preview or load individual posts.
User name in top nav now acts as a link to the user's profile.
Fix: Cache key for caching view post roles was incorrect.

What's Next?

Next batch of work will include an extensible "vote up" system to measure the usefulness of a post, and recognize users who have popular posts. The idea will be to make it open enough to work with any "scoring" actions you might develop in your site.

XSLT is not the solution you're looking for

Jeff — Sun, 13 Nov 2011 04:59:00 GMT

I was very relieved to see that Umbraco is ditching XSLT as a rendering mechanism in the forthcoming v5. Thank God for that. After working in this business for a very long time, I can't think of any other technology that has been inappropriately used, time after time, and without any compelling reason.

The place I remember seeing it the most was during my time at Insurance.com. We used it, mostly, for two reasons. The first and justifiable reason was that it tweaked data for messaging to the various insurance carriers. While they all shared a "standard" for insurance quoting, they all had their little nuances we had to accommodate, so XSLT made sense. The other thing we used it for was rendering in the interview app. In other words, when we showed you some fancy UI, we'd often ditch the control rendering and straight HTML and use XSLT. I hated it.

There just hasn't been a technology hammer that made every problem look like a nail (or however that metaphor goes) the way XSLT has. Imagine my horror the first week at Microsoft, when my team assumed control of the MSDN/TechNet forums, and we saw a mess of XSLT for some parts of it. I don't have to tell you that we ripped that stuff out pretty quickly. I can't even tell you how many performance problems went away as we started to rip it out.

XSLT is not your friend. It has a place in the world, but that place is tweaking XML, not rendering UI.

My departure from Microsoft

Jeff — Wed, 14 Sep 2011 05:30:00 GMT

Whoa, I just realized that I never really announced here that I've decided to leave Microsoft. Actually, left, is more like it, since I'm currently on vacation. Nothing really exciting or controversial about it, just a list of reasons why it makes sense for me and my family. I wrote about it on my personal blog. I also summarized my experience there.

It was one of the hardest decisions I've made, but it was the right one. If I can say anything to the developer audience, it's that you are in good hands using Microsoft's technology stack. It just keeps getting better, and it was awesome to be a part of it.

Hopefully this means I'll have more time to mess with stuff and write more. My last position there was (and still is) all about stuff not yet ready for public consumption, which makes it kind of hard to write about. Meanwhile, I do have a point release for POP Forums for ASP.NET MVC in the pipe.

The business of assumptions and up front design is an inefficient way to build software

Jeff — Wed, 24 Aug 2011 06:40:00 GMT

This is actually a re-post from my personal blog. I'll make the usual disclaimer here that I'm not calling out anyone specifically, whether it be at Microsoft or elsewhere. It's just a topic that I feel very strongly about.

I have to admit that I've become somewhat of a process geek. Maybe even an anti-process geek, but that sounds negative, and wouldn't entirely be accurate. The process of software development has changed a great deal, and part of the reason for that is we rely far less on shrink-wrapped product, and more on the Web. Even your mom is comfortable calling the thing going on in her Web browser an application these days.

Back in the day, you wrote software, and you put it on some kind of media (floppy disks!), then you put it in a box that was shipped to a store. The Internet was not something most people had never heard of, though really fancy people had modems that connected to their phone so they could call another computer. The point is that the stakes were very high for developing software. If you got it wrong, fixing a problem would not only be costly, but it could tank your business.

To combat this risk, development was an enormous process that involved a ton of meetings, documents, a rigorous QA process, and worst of all, enough up front design to make any kind of change incredibly costly. It was really hard to be innovative this way, even in the days when computers were far less powerful and there was only so much memory you could fit your code into anyway.

The unfortunate thing is that a lot of organizations still build software this way. It's unfortunate because the rules have changed so dramatically. Most software truly does run on a server somewhere, and your interaction with it happens in a browser. What this means is that you, as a developer, are no longer bound to the high risk world of disks in boxes that go to thousands of people.

The real problems with the old way of developing software really boil down to two things. The first is that everything you do is based on assumptions. You assume that it will take a certain number of days to develop some component. You assume that your user wants to do this certain thing. You assume your business model will be readily adopted. You assume that your design is the right thing. You know what they say about assuming stuff.

The second problem is that all of this planning is really just guessing. Because you've made so many assumptions, the planning you do hasn't really been vetted against the real world. There will be problems you couldn't predict. You haven't received any feedback from users based on a real product. You don't know how the market will respond. You certainly can't know if your design, whether it be architectural design or a user interface, is ideal given the lack of feedback. The only thing you can really guess will happen is that stuff will change.

And yet, I've watched this unfold time and time again. Development organizations will put days, even years into designing the crap out of everything before they write a single line of code. I worked in a place where analysts would produce huge documents outlining a use case, a single action for a single feature, and it would be further analyzed by a committee. A developer wouldn't even see it until it was "approved," by which time the agreement that the document was supposed to solidify was already tainted by the fact that no one from the developers to the users gave any feedback on it. The assumptions already made it obsolete.

Massive attention to up front design is bad, and here's why. A proponent of up front design will argue that you need to spec-out things in detail, in part to build consensus about what you're doing, and also because you don't want to leave developers and others to interpret things for themselves. Fair enough, but you're still doing all of that design work based on assumptions. It doesn't matter how visionary you are, because your assumptions could still be wrong. If that's the case, all of the time spent on this design, and the subsequent work to build out that design, is wasted, and you're still far away from delivering value to your customer.

Now let me tell you how I would do it. I would describe the smallest thing in the simplest terms while keeping the big picture in mind, and work with developers to do that. None of that throw-it-over-the-wall nonsense. We'd break it down into tasks that only take a few hours each, and prioritize them. We act on the items with the highest priority, re-prioritize weekly, and after four weeks, "ship" what we have. Maybe that means getting it in front of customers, maybe it means using it ourselves, whatever, but the point is we have something real that we can act on. If we're getting it wrong, we can correct our course and move toward the right thing in as little as a few weeks, incorporating feedback, challenging assumptions and delivering value quickly.

The proponent of up front design will say that you've just moved the design work to a different stage of the pipeline (and maybe suggest that it's bad to "allow" other stakeholders to affect the design, but that's a different cultural problem). Yes, I did move the design, but what's so great about this is that I didn't invest a lot of time into it. I didn't waste time building consensus or creating documents that no one will read, I just went and built something. The price of getting it wrong is much lower, and the integration of feedback happens much faster. In other words, I'm building stuff that delivers value faster, and when I get it wrong, I can correct quickly. The risk, and therefore the cost, is lower. I've managed out assumptions as a source of risk and cost.

This is still a hard culture nut to crack. If you're a big agile fan, with a great deal of success under your belt, how do you convince successful waterfall process folks that they're doing it wrong? It's not that they're doing it wrong, it's just that they're doing it slower. When you move too slowly, your competition kicks your ass. Unfortunately, it's the part that goes with "u" and "me."

POP Forums v9 for ASP.NET MVC3 is done!

Jeff — Tue, 26 Apr 2011 17:23:00 GMT

The release candidate is the final version of v9.0.0. See my previous post for details. Get the bits here:

http://popforums.codeplex.com/

Be sure to check out the documentation for information on installation and integration. It will now create all of your database tables for you, for a little less friction in getting set up.

Thanks to everyone who offered their feedback and support, especially at Mix during the Open Source Fest. I really had a blast talking to everyone there!

POP Forums v9 Release Candidate for ASP.NET MVC 3 posted to CodePlex!

Jeff — Fri, 08 Apr 2011 05:57:00 GMT

Get the goodies here: http://popforums.codeplex.com/releases/view/63550

Release Notes

This is the release candidate for the ASP.NET MVC3 version of POP Forums. It is considered feature complete, stable, and ready for testing and feedback. For previous release notes, see previous releases.

Check out the live preview: http://preview.popforums.com/Forums

Setup instructions are available in the documentation section.

What's new in the RC? Since the second beta:

Database, e-mail and user setup added at /Forum/Setup, for easier install.
Dynamic loading of more posts, before and after the current page, with updated pager links as it goes.
Fix: Post paging was including deleted posts in counts, causing blank pages.
Fix: Image insertion was throwing a script error.
Fix: Image button appeared when inline images were disabled.
Fix: Text parser ignored img tags with TinyMCE attributes.
Refactored background processes to not initialize if the DB connection was broken (because it brought down the entire process).
Removed pinned topics from recent sort criteria.
Changed forum layout page to in turn use another layout page, for easier integration.
CSS/jQuery tweak to apply class to inline images, mostly to enforce max width.

What's next?

The app is running in production on MouseZoom today, so it's being actively tested. With this testing, and your feedback, the final version should be ready very soon.

Other notes

This is it... we're almost there! No features will be added at this point, and no major code reorganization will occur. Any changes at this point will be made only to fix bugs. It's more or less production ready.

I have been asked about a different data layer, particularly for use in Web farms or in Azure across many role instances. I'm looking into it, and I suspect I'll wait until the AppFabric caching is better defined. There's a detailed article in MSDN Magazine that I need to really read through, but it shouldn't be hard to do. The project is loosely coupled in terms of data access.

This isn’t the process you’re looking for

Jeff — Thu, 07 Apr 2011 22:25:00 GMT

There was a fairly awesome pissing match between “Uncle” Bob Martin and, well, everyone, on Twitter today. Twitter isn’t a great venue for this kind of thing, because it’s hard to read and hard to make a solid point, but basically Bob suggested that you should do everything possible to make sure you have 100% test coverage. He was making the argument that this was the cheaper way to go for the long-term quality and maintainability of code (or at least, that’s what I interpreted it as, in 140 characters or less).

Absolutes annoy me. That’s why I posted this:

What you describe (re: 100%) is akin to being a modern congressman, ignoring the continuum of possibility for one extreme.

The insanity of absolutes is certainly not limited to politics. I see it all of the time with regard to process in software development. It’s a bit of an absolute paradox that there are some absolutes, like death (though Walt Disney and Elvis would tell you differently if you could find them), but they’re very rare.

I like test-driven development. I like test-“influenced” development even better. I tend to find that the more I refactor stuff, the fewer things a class does, the less likely I’ll feel that I need a test. I mean, how often do you end up having a method that ends up looking like this?

public void Foo(int id) {
_someRepository.Foo(id);
}

I’m not going to write a test for that! OK, truthfully, I have written tests for that, but I don’t even like to own up to it. Every other method in the class may act on some piece of data, and you’ll end up with a method that just calls on one of its dependencies. But there are a lot of cases where it just doesn’t seem like writing a test adds value. There’s a point where there is little to no return on investment, and I think a good developer understands where that point is, so they can devote time and energy to a place where there is some ROI.

I like to think about the process of software development, to the extent that I’m always asking how there can be less of it. I instinctively want to fight any time someone says you “must” do it a certain way. I can remember the first time I sat in with consultants from a firm specializing in agile development, while working at a major auto insurer with a spokesperson named “Flo.” I believed in most of what they had to say conceptually, but didn’t care for their insistence that some of our adaptations were wrong. I really thought we were making the process better, and even leaner, without sacrificing our results.

When I was interviewing for my new job, one of the interviewers, a dev lead, asked what the best way was to communicate “specs” to him and his team. It could have been a make-or-break question, because you never know if you’ll work with someone from the old school who insists on pages of documents that no one ever reads. But I still told him what I think: There’s a broad continuum of what the “right” level of detail looks like. Sticky notes and kanban boards are often more than enough to build software. Sometimes, you need very specific information that has to be broadly agreed upon, understood and well documented (think legal text, like copyright notices or a terms of service page). The only rule I make is that there should be as little documentation as possible.

It all seems like common sense, but business has evolved (devolved?) beyond it in some ways. Engaging in the right process for the situation, instead of being dogmatic about what you “must” do is counterproductive. One of the things I learned early on in coaching volleyball to teenage girls was that I couldn’t just push my system on them the same way every time. Different girls and social hierarchies respond to it differently, so I have to adapt it for every team. The same can be said for development methodologies.

Adapt your processes. Use only what you need. Avoid declaring absolutes.

New job at Microsoft (and see you at Mix!)

Jeff — Thu, 07 Apr 2011 05:59:00 GMT

After almost a year and a half, I'm leaving my dev position in Server and Tools Online to be a program manager in the SQL Azure BI organization. My motivation for the change probably doesn't matter much to people reading this blog, but I will say that I'll greatly miss the people I worked with in STO. As a Web code monkey, it's not often that you get to work on super-high traffic apps (like the MSDN/TechNet forums) or build totally new stuff like the recognition/reputation service that you're already seeing in the code galleries. The recognition system is all Azure based, too, which was pretty neat.

I can't really say what I'm going to work on just yet, but will say that it immediately struck me as interesting. I technically start Monday, but since I'll be at Mix (you're going, right?), I won't even see the new office until Friday.

Speaking of Mix, I'll be at the Open Source Fest on Monday night, showing POP Forums. Dare I say that I might even have the release candidate ready by then. Hooray! Hope to see you there. This looks like one of the strongest agendas yet.