MarkItUp

I was sitting at Docklands tonight having dinner with Aymeric and talking about our respective web engines - mine: SingleUserBlog and his: AymericWeb  

We each had things that we liked about the others' engine.  Aymeric liked the web parts of SUB and I really liked two of the features that he had: Friendly Url's and the ability to provision new pages (ala Wiki's). 

I'm really hoping that I'll get some time later this week to pull down the latest code for SUB from CodePlex and start to think about how these things might get added into the core SUB codebase.  Before I integrate any code changes into the SUB codebase I'll prototype how these changes might fit in.  Basically I see SUB as now having a number of page types (which BlogML supports ) such as:

• BlogPost
• Article
• Wiki

I think that each page type would derive from a different page template and would be provisioned in a different manner.  For example, to create a new blog entry you would go into the Administration section and choose "New Post" from the menu.  Doing that would:

• Instance a page from the BlogPost Template
• Save the content of the page into the Posts data path
• Save one post file per page

To create a new Wiki page you would embed a special syntax into the content of any page - something like what Aymeric used:

[[pageid|pagedisplayname]]

So, for example, if I wanted to create a Wiki entry for Regex, I could embed the meta tag like so:

[[regex|Regular Expressions]]

In addition to having these Wiki pages provisioned on the fly, they would also:

• Use a friendly URL format
• Save historical versions

This means that each version would get saved as a different content file in the Wiki data path - i.e.: Regex, Regex(1), Regex(2), Regex(3), etc.  The reason for saving all historical versions of the Wiki entry is so that you can track the evolution of the thought/idea.

The friendly URL format would probably look something like this:

http://MarkitUp.com/Wiki/Regex.aspx

On the topic of friendly URL's, Aymeric shared this great link with me which discusses some of the benefits of having nice, neat URL's:

http://www.edition3.com/articles/friendly-urls

Over on the SUB project, each of us have a different web.config file requirement.  This is because each of us may be using a different:

• Theme
• Master Page
• Personalization Provider
• etc

Having a different config file requirement meant that we were constantly tripping over each other in the rush to make the config file suit our own needs/wants.  Thankfully Matt has come up with a great method that allows us to each have our own config files.  Read about it here:

    http://sticklebackplastic.com/Posts/Post.aspx?postId=3de6b68d-e518-4957-ba76-0603e3b6052f

Now that SUB is uploaded to the CodePlex repository and a team has been assembled, I'm starting to make plans for what I think the future of SUB might look like.  One of the things that I'd like to see is what I'm going to call "Live immersion". 

Because of way that Live integrates so well with all manner of client applications, it is going to be such an important member of the virtual toolbox that we carry around.  In fact, Live immersion means that Live is not merely a tool but an entire virtual body suit that we slip into.  Once inside the suit, Live will become part of your environment and your social network will be at your finger tips.

One of the ways that this is already happening is with the little Gleams that show up in Live Messenger when a contact has unread changes on their Live Space.  By quickly scanning down my list of Live contacts I can quickly see which of my friends has new photos, or links, or which of them has read a new book recently and their blog posts too.  This is great.  One of the two tools that I have permanently on and I can see all of my changes from right there within it.  One click shows me the little card which summarizes what type of change has occured, another click and I'm right there reading it or viewing it in your Live Space.  No longer to I have to jump off to another website or open another application to read my blog feed - it's all right there.

Applications that can learn to hang inside of the Live environment will do well while applications that exist outside of it will compete with the rest of the internet for your views.  While this is fine for some kinds of applications, it's not fine for an application such as a blog which you want to be at the fingertips of your friends at an instant. 

In its next incarnation, I envisage that SUB will be able to seamlessly integrate with your Live Messenger and all of the other parts of your Live environment too.  The real challenge for me now is to sit back and envisage what content I would put on my domain versus what I would locate on my Live Space - and what content would be co-located (and how).

From the very first moment when you utter the words: “All I need is a RichTextBox on a page and a Save button” you are on your way to writing your very own blog application.  That’s almost how SingleUserBlog (SUB) came about.  In the first version which was written using ASP.NET V1.1, the main goal of SUB was to be the simplest thing that would work.  Grab a bunch of files, copy them into a folder somewhere, create an IIS application which points to the folder, press Browse and you’re away.  Then along came ASP.NET 2.0 Web Parts and my book and suddenly SUB started to gain legs of its own.  Now it was a showcase of how to work with and customize the portal framework to build an architecture which is highly extensible.  Luckily, thanks to things like MasterPages and Themes, not too much was sacrificed in the way of simplicity.

Now I can happily announce the latest incarnation of SUB – open source!  As of today, SUB has been accepted as an open source project on CodePlex.

   http://www.codeplex.com/Wiki/View.aspx?ProjectName=SUB

Initially I was somewhat skeptical about the idea because I’m not keen at all to see SUB head down the predictable path of high quality, solid web portal applications such as CommunityServer, Subtext, and DotNetNuke.  I mean what would be the point of that?  Build another application which was essentially a “RichTextBox on a page and a Save button”?  No.  I’d like to see SUB head down a different path.  A path that allows SUB to stand on its own and where it remains as a unique showcase of web technology.  Where exactly that is will be up to the members of the team to decide but I’m thinking something a little Web-Two-Oh’ish or even better: Live, might make things interesting :-)

Anyways, go SingleUserBlog, go away and come not back.  Go to the world and do good!

 

Paul Stovell has been monkeying around in the SUB source (which is now being hosted on the Readify internal TFS repository).  I know this because I of all the check-in notifications I've been receiving :-)  So far, in just a couple of days he has:

• Added a new SQL Server data provider - complete with sql setup scripts.
• Refactored the code base and made it easier to re-theme.
• Got the MetaWeblog API stuff working - as was evidenced by his first post from Word 2007.
• Added a new standard theme named VistaBlue - which is the one that Paul is currently running on his own blog.

In addition to getting his check-ins (with associated useful check-in comments), I've also been seeing the successful build notifications coming through every time that a check-in is made.  This is because of the new continuous integration tasks that Chris Burrows has now got working on our TFS install - which I'll blog about later.

How many cool websites do you visit on any given day?  I'll bet that there must be some amazing sites and web pages that people visit on any given day that just go un-remembered and un-shared.  Not any more!  Today I added a new feature to my blog called "Daily Links" which allows me to arbitrarily add cool or interesting links via an administrative web part and have them appear on an RSS feed.  You can subscribe to the feed here:

    http://markitup.com/DailyLinksRss.ashx

This idea was originally an SUBV2 feature suggestion by Howard Van Rooijen as you can see in this comment:

    http://markitup.com/Posts/Post.aspx?postId=622ac040-d459-40dc-a66d-5478bbe2db8a#94085f1b-853d-4d1e-b1be-37f2ecc23448

I think that it would be great if this took off and we all started blogging our most interesting "visited links"; I think that this will turn up some real gems!

Thanks Howard :-)

Update: the new SUBV2 release is available here.

I've been running a new build of SUB for about a week now and things look pretty good so I'm planning to do a build and release it on ProjectDistributor later tonight.  This build has a bunch of performance fixes that should see your install go from "groggy" to "zippy" in one easy hit.

The other fixes in this build are:

1. Implementing the Cache Pattern
2. Url Mappings and Feedburner
3. Making better use of the UrlFormatter in SUB

I've also included a new web part in this release:

Quote of the Day Web Part: Simply add a bunch of quotes to this web part and it will randomly display a new quote each day on your site. 

Here's a screenshot of the QOTD web part:

As Brendan pointed out in his recent post, I got pretty slack with implementing the UrlFormatter class in SUB.  Basically, every data type in SUB inherits from a base class known as "ApplicationDataObject" which gives each item enough properties to be displayed within an RSS feed.  One of the classes that I implemented quite early on in the piece was the UrlFormatter whose job it was to take an instance of a generic ApplicationDataObject class and to produce a suitable URL from it.  Internally the code looks something like this:

public class UrlFormatter {
 
    public static string FormatUri(ApplicationDataObject item) {
        if (item is Post) {
            return string.Format("{0}Posts/Post.aspx?postId={1}", Globals.UrlStartPath, item.Id);
        }else if( ... ) {
            ...
        }else{
            return Globals.UrlStartPath;
        }
    }
}

Here we can see that the UrlFormatter is passed an ApplicationDataObject and then uses an if statement to determine the type of the object and then returns the URL for that particular instance.

Over the weekend I went through the SUB source code and identified several of the Repeater that Brendan mentioned in his post that were using independent logic for displaying the URL's for posts.  What I ended up doing was to remove the ItemTemplate code from each of the main display Repeaters that are used to display Posts on the Home Page, the Posts By Category page, and the Posts By Month Page and I put the HTML that was within those ItemTemplates into a User Control and I load that as the ItemTemplate of the Repeaters.  The code for the User Control looks like this:

<div class="post">
 <h5><a href='<%# UrlFormatter.FormatUri((Post) ((RepeaterItem)Container).DataItem) %>'>
            <%# ((Post)((RepeaterItem)Container).DataItem).DisplayName%></a></h5>
 <p><asp:literal runat="server" text='<%# ((Post) ((RepeaterItem)Container).DataItem).Description %>' id="Label4"/></p>
 <p class="postfoot">posted on <%# ((Post)((RepeaterItem)Container).DataItem).DateCreated.ToString()%>
  ( <a href="<%# UrlFormatter.FormatUri((Post) ((RepeaterItem)Container).DataItem) %>#Feedback">
                <%# ((Post)((RepeaterItem)Container).DataItem).CommentCount.ToString()%> Comments</a> )
 </p>
</div>

You can see that the Container must now be cast to a RepeaterItem before it is cast to a Post.  The code in the hosting Repeaters now looks like this:

<asp:repeater id="PostList" runat="server" enableviewstate="False">
    <separatortemplate>
        <hr />
    </separatortemplate>
</asp:repeater>

… and I simply put in some code to load the template at runtime:

protected override void OnInit(EventArgs e) {
    base.OnInit(e);
    this.PostList.ItemTemplate = Page.LoadTemplate("~/UserControls/PostItemTemplate.ascx");
} 

Now I can easily implement Brendan's cool idea for using the FormatUri function of the UrlFormatter as an abstraction for implementing friendly formatted Url's for posts in SUB.

The other day I posted a plea for subscribers of my blog to point the subscription for my feed to my feedburner link but today I'm asking that you change it back to the original Url of:

    http://MarkItUp.com/Rss.ashx

The reason for this is that in a comment to that post, Rick Klau who is the VP of Business Development with Feedburner mentioned that I'd be better off having people continue to point at my Rss.ashx page and performing a silent re-direct to the Feedburner URL under the covers.  This makes a lot of sense because it means that I'm not constantly asking people to change their link - like I am now :-) 

To implement the solution I created a special URL which still exposes my RSS feed and I point the Feedburner bot at that link.  The link for the bot is: http://MarkItUp.com/RssForBots.ashx.  Notice that if you browse to my http://MarkItUp.com/Rss.ashx page that you will end up at the Feedburner page but it you point at the http://MarkItUp.com/RssForBots.ashx URL you will see my raw feed.

Anyways, as with all simple programming tasks things quickly went south and it resulted in a major operation.  My initial thought was that I could simply use the UrlMappings service that comes with ASP.NET and re-target my RSS feed like so:

<urlMappings>
  <add url="~/Rss.ashx" mappedUrl="http://feeds.Feedburner.com/MarkItUp" />
</urlMappings>

Unfortunately it turns out that the UrlMappings service will not serve up URL's that are external to your site.  Damn!  I'm starting to hate that darned UrlMappings thing… me and it just don't hit it off.

So what I decided to do was to create my own UrlMappings service instead.  I iplemented my service as an HttpHandler that would read in a Mappings.xml file and handle re-directions to external URL's. 

First I created a mappings file named UrlMappings.xml which lives in ~/App_Data and which looks like this:

<UrlMappings>
  <UrlMapping url="~/Rss.ashx" mappedUrl="http://feeds.feedburner.com/MarkItUp"></UrlMapping>
</UrlMappings>

Next, because my feed is now served up at two locations I deleted the Rss.ashx physical file and moved it into the ~/App_Code directory and configured a couple of UrlMappings using that silly ASP.NET UrlMapping service like so:

<urlMappings>
  <add url="~/Rss.ashx" mappedUrl="Redirector.ashx" />
</urlMappings>

In this case, Redirector.ashx is the location of the custom HttpHandler that I wrote to manage my own UrlMappings file.  You can see that from the HttpHandler mappings that I created to handle the requests:

<httpHandlers>
  <add verb="GET,POST" path="Rss.ashx" type="MarkItUp.SingleUserBlog.Web.RssFeedHandler" />
  <add verb="GET,POST" path="RssForBots.ashx" type="MarkItUp.SingleUserBlog.Web.RssFeedHandler" />
  <add verb="GET,POST" path="Redirector.ashx" type="MarkItUp.SingleUserBlog.Web.Redirector" />
</httpHandlers>

So now when a user browses to my Rss.ashx page they are redirected to the Redirector which reads my UrlMappings file and sends the request off to Feedburner.  Of course the upside of all this is that SUB now has a dinky little redirector that can map out to external links - whoop-dee-doo!

I mentioned recently that the performance of SUB has been quite poor and I've started diagnosing the cause of this by instrumenting my code to see what's going on.  I also wrote an introductory article on code instrumentation which can be found here:

     http://markitup.com/Posts/Post.aspx?postId=fa94c852-fd16-4ba9-a5f0-1f72437f7cd2

I'll talk more about the specifics of the instrumentation and diagnostics in a follow-up post when I have things totally sorted although the changes that I've made so far have improved things quite dramatically. 

While going through the SUB file handling code I've been taking the time to check some of my coding patterns to ensure that operations such as caching and how I'm handling resource locking is all sweet.  Because caching plays such a large and important role within SUB I decided that I should check my caching pattern just to be sure that things are cool there and that the pattern is solid.  Currently my caching pattern looks something like this:

Data GetData( dataID ) {

     string key = "GetData" + dataID ;

     if (Cache[key] == null) {
         Data item = GotoDatabaseAndFetchData( dataID ) ;
         CacheHelper.Insert(key, item);
     }

     return HttpRuntime.Cache[key] as Data;
}

To check my pattern I headed off to Steve Smith's blog since he is the caching expert that I know best.  While browsing Steve's blog I found the exact post that I was after here:

     http://weblogs.asp.net/ssmith/archive/2003/06/20/9062.aspx

As Steve pointed the correct pattern to use is this:

Data GetData( dataID ) {

    string key = "GetData" + dataID ;
    Data item = Cache[key] as Data ;

    if (item == null) {
         item = GotoDatabaseAndFetchData( dataID ) ;
         CacheHelper.Insert(key, item);
    }

     return item;
}

Notice that in Steve's pattern a local variable is populated and then inserted into the Cache but that it is the variable that is returned from the method.  In my original code I was returning the value held in the Cache directly from the method.  As Steve notes in a recent email, on a busy site where you have sufficient load/memory pressure the code in my original pattern can cause inconsistent behavior because the item can actually be removed from the Cache in-between adding the item to the Cache and returning it at the end of the method.

Thanks Steve!

In this post Brendan Kowitz talks about how he managed to implement friendly URL's for SUB - very cool!  He also pointed out that even though I had a FormatURL method that was initially created to do all of URL formatting in the application that I hadn't done a very good job at using it - too true!  My mistake there I'm afraid. 

There should be another release of SUB coming out in the next fortnight which will have some bug fixes and I'll try to include the cool stuff that Brendan has done for formatting friendly URL's into the core source code.

Recently I noticed that my blog was running really slowly even though SUB was running at a fine clip on my own development machine. In addition to the general application slowness, Mitch and I discovered that when we went to import the BlogML for his NotGartner site that we experienced some unhandled exceptions relating to file locks on the XML index files.

My suspicion is that as the size of the XML files gets larger that the time to acquire and release file locks is taking longer to the point where my logic becomes fragile and unstable. I'm going to have to revisit the FileHelpers class and refactor it to ensure that files are handled in a much more error resistant manner. FileHelpers has always been in need of a good refactoring and some Health Monitoring code so taking the time to go through that code should do it the world of good I suspect.

During the refactoring I'm going to normalize the architecture of the file writing api's so that I have a more normalized structure of a business logic wrapper which calls through to a data storage engine. Architecture diagrams and details pending :-)

NOTE:
If you are suffering from these performance issues then I can advise you to check out Brendan Kowitz's new SQL Lite Data Provider for SUB.  This should speed things up a whole heaping lot:

    http://www.kowitz.net/Posts/Post.aspx?postId=34

I'm currently right in the middle of preparing a new release of SUB and I should have the source code up on ProjectDistributor later tonight.  If you are running an existing build of SUB remember from yesterdays post that the XML index files that used to live in the \data folder now live in the \App_Data folder although all of the post content folders still live under the old \data path.

I just wanted to mention three of the new features that I've added in this release that I'm real happy with.

1) Posts Archive Web Part

If you look on my website you will notice that, on the left side of the page there is now a web part that lists each month and shows how many posts exist for the month.  Clicking on a month takes you to a new page which displays the entries for that month.

2) OPML Web Part

Take a look at the following image:

 

This is a web part that allows you to specify the URL of an OPML feed and an optional path to an XSLT and then displays a list of all of the bloggers on the OPML.

 

3) Catalog Dialog

Take a look at the following image:

The pop-up window that you can see with three tabs is called the CatalogDialog.  Basically, this is a Catalog Gallery that reads a list of web parts from an XML configuration file and displays them within a category.  You launch the CatalogDialog by clicking a button which is rendered at the head of each WebPartZone if you are authenticated.  When you click on one of the web part links in the CatalogDialog that web part is added to the zone in the main window that you launched the CatalogDialog from. 

Because this feature reads from an XML configuration file you can easily upload assemblies that contain web parts and then add a configuration entry to have web parts that are in the assembly that you uploaded appear within the catalog.  This makes it extremely easy to add your own web parts without having to redeploy the site. 

I created the CatalogDialog for the WebParts book that I'm currently writing and which will be finished next month!

 

I've just installed a new build of SUB on my server and I'll let it settle for a few days before I package it up as a release onto ProjectDistributor.  If you take a look at my web page you will see that I've now added a "Posts Archive" web part that allows you to view posts listed by month. 

In this release I also have the pop-up Catalog browser working.  Basically this catalog allows you to add web parts to your blog by simply adding an entry to a new XML file called CatalogData.xml while lives in the App_Data folder.

Speaking of which, I've moved all of the XML configuration files into the App_Data folder so I'll have to add a release note to let people who are upgrading know that the XML configuration files that used to live in the \Data folder must be copied into the new App_Data folder location.

I also fixed a couple of bugs.  One of the bugs was that the RDF tags in the pages were pointing to the wrong trackback location.  They were pointing to Trackhandler/Default.aspx when they should have been pointing at Trackbackhandler.ashx

http://www.runpartners.com/blog/Posts/Post.aspx?postId=75297c71-6c00-406f-8e7f-cedb141d32ce

The other day I noticed that all of the controls in SingleUserBlog do not display nicely within the design view of Visual Studio.  Whenever I bring a page up in the designer, each of the controls appreas with its Error chrome visible, as can be seen in the following image:

The trick here is that when you declare your controls in the web.config file, you must specify which namespace and assembly they are in - specifying a namespace will not do.  So what assembly do you specify when your classes are contained within the current web project?  Why the __code assembly of course!  Apparently specifying App_Code for the assembly also works.  Here is a sample config entry taken from SUB which shows the correct entry to get designer support:

 

<pages styleSheetTheme="Default" validateRequest="false" masterPageFile="~/SUB.master">
  <controls>
    <add namespace="MarkItUp.SingleUserBlog.Web" tagPrefix="blog" assembly="__code" />
    <add namespace="MarkItUp.SingleUserBlog.Web.WebParts" tagPrefix="portal" assembly="__code" />
  </controls>
</pages>

Paul Stovell has installed SUB V2 for his blog and has written a post about how he went about personalizing the theme. 

    http://www.paulstovell.net/Posts/Post.aspx?postId=1348228b-da36-43d9-844b-e70fabf4c8ad

To quote a very enthusiastic sounding Paul:

...this new SingleUserBlog is amazingly customisable. The first time I put this site up with SingleUserBlog 1.0, I spent hours slaving over a hot IDE, changing the layout to get it just how I wanted. It was a case of opening each ASPX page, editing the code, and crossing my fingers and hoping it would compile.

But SingleUserBlog 2.0, put simply, rocks! The only thing I had to do was add a new Master Page (PaulStovell.master), a new Theme folder (App_Themes/PaulStovell), and drag and drop my old stylesheet. Then I played with the master page for a total of about 20 minutes, rearranging the elements to suit my layout, and tada! Instant customisability.

I'll be adding Paul's .master file and Theme files to the base install of SUB so that users will now have a choice.

OK, so I've just uploaded the source code for this blog (SUB V2) to ProjectDistributor.  To download it go here:

     http://projectdistributor.net/Projects/Project.aspx?projectId=182

The biggest features in this release are that the blog uses MasterPages, Themes, and has a pretty cool WebPart framework which is coming into shape.

To run the blog just open the solution file and do a build.  You also need to configure a database to use the ASPNET SQL Server tables because this version uses Profile to store some user information.

Aside from using the major new ASP.NET 2.0 features such Themes, MaserPages, WebPart, Profile etc, and the new runtime feature - Generics - it's a parity release with the ASP.NET 1.1 version of SingleUserBlog.  Here is a screenshot of the features that will appear in the next version (Iteration 1) of the software:

If this message has popped into your aggregator then I've most certainly done something right because today I changed my blog over to a brand new version of my SingleUserBlog blogging application which I affectionately refer to as SUBV2.  SUBV2 is a significant jump from the previous version in that it's built using ASP.NET 2.0.

Built using ASP.NET 2.0

Running on top of ASP.NET 2.0 has allowed me to introduce some extremely advanced features while possibly reducing the overall size of the codebase.  Some of the new features include MasterPages and Themes which are used to give the site its look and feel.  Another of the significant changes that have come through using ASP.NET 2.0 are Web Parts and Personalization.  By using these "portal" features I have been able to implement almost all of the content that is visible on this page by using web parts.  To get a feel for how web parts are used on this page, consider the following:

• The Hosted By Orcsweb image is a web part
• The Google Search Form is a web part
• The Posting Categories list is a web part
• Each of the Link Categories on the right are web parts
• The Recent Posts listing is a web part
• The Horizontal Rule just above the Recent Posts is a web part

As you can see, the web parts that are included with SUBV2 are a mixture of application web parts (Posting Categories and Recent Posts) as well as functional web parts that allow me to add any arbitrary image, link, or even HTML to the page at will.  The power of web parts is that they can easily be personalized at runtime.  This means that I can move any of the web parts around by simply dragging them with my mouse and placing them to almost anywhere on the page.  I can also add new web parts too.  As an example, I could easily add a new HTML web part that displayed a welcome message to visitors of my blog and place it at the top of each page on the site.  I could even add my own CSS or Javascript too!

Advanced Portal Framework Features

In addition to the "out-of-the-box" web part features, this blog also uses some pretty advanced portal customizations - such as a CatalogZone that is displayed in a pop-up dialog (ala Sharepoint V3).  The popup CatalogZone will be used to display web parts that are housed in custom web service galleries.
 
The blog also features:

• Custom WebPartManager to implement common authorization filter logic
• Custom EditorZone to display editor parts in expandible/collapsible regions
• Custom WebPartZones to perform custom rendering on web part chrome and to add custom zone verbs to web parts
• Custom PersonalizationProvider so that all personalization is stored against a common key (not the page url) so that changes made to a web part are applied right across the portal site

Migrating my content

Migrating the content from the previous version of my blog was simple and took me less than twenty minutes.  To migrate the content I opened the administration section of the previous version and saved the blog to BlogML format; then I opened the administration section of this version and imported it.  That's the power of BlogML!  The content that migrated included all of my internal links, attachments and images - so no content was lost at all.

Making SUBV2 publicly available

Over the weekend Paul Stovell - who is currently running SUBV1 for his blog - will be migrating that blog over to use SUBV2.  During that migration he will write a blog article that explains the steps that are involved in setting up SUBV2 and customizing it with your own MasterPage and Theme.  When he has posted that article I'll upload the source code for SUBV2 to ProjectDistributor so that it is publicly available.  In addition to Paul's article I'll be posting some tutorials to my blog that explain some of the features that are there.

Over time I'm hoping to build a small community around SUBV2 so that we can share Themes and WebParts.

Chris Frazier pinged me this morning to let me know that he has written an HttpHandler to expose SUB via that MetaWeblogAPI - woohoo!

This means that users will certainly be able to connect to their SUB blogs via Chris's PostXING tool but will hopefully mean that they can post from other MWB enabled tools such as w.bloggar and BlogJet.

Here is a blurry picture (sorry Chris, didn't really do you justice here) of SUB being managed from Chris's new V2.0 version of PostXING:

 

I'll be adding Chris's MWB HttpHandler to the core SUB Solution so it will appear in the next release within the next couple of days.

I've started a list of links on the right-hand-side of this blog titled: "Blogs using SUB".  I'll keep this updated as I find more people that are using SingleUserBlog.

I cut over to the latest version of FreeTextBox on SingleUserBlog today because I noticed that it wasn't working in IE7.  This was fixed in FTP version 3.0.6.

The good news is that, because of the change I'm now no longer dependant on the scripts folder for FTB as all of the resources - scripts and images - are now served via an HttpHandler.  This means that SUB is truly an x-copy deploy story again!

---

Update: I originally used version 1.1.0 of FTB but have since moved back to 1.0.6 because I couldn't get the latest version working properly; for some reason, when I used v1.1.0, the .Text property of the ftb instance didn't contain a value on PostBack.  This meant that I could never get at any of the text that I'd entered into the textbox.  V1.0.6 still has all of the cool stuff working that I mentioned initially in my post.

I've been blogging quite a bit about BlogML recently and how it will allow users to finally perform important operations on their blog such as:

• Import/Export
• Backup/Restore
• Migrate (between environments)
• Migrate (between blogging engines)

The schema is now pretty solid and I've created a workspace so that a couple of parties can fine tune it and collaborate over what tools are needed to support it.  The workspace location is http://codegallery.gotdotnet.com/BlogML and final tools and artefacts will ultimately be published on http://www.BlogML.com.

Initially the site will contain the schema file for the spec., an online Validator and also sample code which explains how to work with it.  From what I've heard so far it looks as though we might get support for this from a couple of blog engines fairly quickly and, for the others I imagine that we might publish standalone HttpHandlers so that you can easily add the functionality to your engine of choice.

I'll get things happening on the GotDotNet code gallery site after TechEd this week and then probably start getting the BlogML site up and running soon after that.

New Providers for SUB

The other cool news this week is that fellow Readify guy Rocky Heckman has written an Access data provider and a Sql data provider for SingleUserBlog.  This means that you can now run SingleUserBlog off of either of those databases or directly against the filesystem simply by changing a configuration entry.  Of course, because SUB now supports BlogML you can easily change between those at any time and have your content automatically migrated between them.

Now tell me... does that sound nice? :-)

 

Seems as though Visual Studio removed the event handler wiring which allows my blog to "Save" comments after the CommentForm has processed them and raised its CommentAdded event.  Anyways, I've fixed it up so if you had any comments to leave... leave away!

I was chatting to Peli tonight about this and he showed me something which looked quite interesting.  I hope to have more about this soon.

This weekend my friend Thomas "Aylar" Johansen has created the following logo for my SingleUserBlog site:

I've added the logo to my rss feed so, if your aggregator supports it you should see it in there when you subscribe to my feed.  Adding an image to your feed is accomplished by adding an "image" element to your "channel" and then populating a child url node.  View my feed to see what it looks like.

I'll add the logo to the pages on this site when I return from my trip to Melbourne this week.  Thanks Thomas!

During the week I put the first public release of the SingleUserBlog (SUB) source code online here:

    http://projectdistributor.net/Releases/Release.aspx?releaseId=220

If you've downloaded that code you need to know about a bug which is in the CommentForm user control.  The CommentForm is a form which is displayed at the bottom of each post and is also displayed on the Contact page of the blog.  Its purpose is to provide a form for feedback input, provide field level validation and also to display a CAPTCHA image.  The form also provides the service of optionally "remembering" your name and url when you check the "Remember Me" checkbox.  The remembering is stored in a client-side cookie and then read out again and applied during the initialization of that control.  Unfortunately I'm not checking whether or not the cookie values exist before I display them so I get a object reference exception when I call ToString() on a cookie key which is not present.  To fix you can alter your OnInit method in the \UserControls\CommentForm.ascx.cs file to look like so:

override protected void OnInit(EventArgs e)
{
  InitializeComponent();
  base.OnInit(e);

  if( !IsPostBack ) {
    try {
      Personalization p = new Personalization("CommentForm_ascx") ;

      if( p.Items["chkRememberMe"] != null ) {
        this.chkRememberMe.Checked = bool.Parse(p.Items["chkRememberMe"].ToString()) ;
        if( this.chkRememberMe.Checked ) {

          if( p.Items["txtName"] != null )
            this.txtName.Text = p.Items["txtName"].ToString() ;

          if( p.Items["txtUrl"] != null )
            this.txtUrl.Text = p.Items["txtUrl"].ToString() ;
        }
      }
    }catch( Exception ex ) {
      Console.WriteLine( ex.ToString() ) ;
    }
  }
}

 

Bruce Mack is a guy that I "know" through virtual collaboration over the past year or so.  We "met" after Bruce got interested in ProjectDistributor and then wrote a smart client which uses the PD web services to expose all of the functionality.

Throughout that time Bruce has also spent time showing me the benefits of software patterns.  Anyway, Bruce has now installed SingleUserBlog and is blogging.  You can find his blog here:

    http://blog.brucejmack.biz/