August 21, 2007
@ 07:46 AM

UPDATE: The code has been updated. Ignore this post and go here.

I'm writing lots of code lately. I've rejoined the dasBlog community and I'm busy writing a prototype for the .NET Framework 3.5 version of dasBlog (we just released the 2.0 version, see http://www.dasblog.info/).

One of the goals of the prototype, which we'll eventually merge into the main codebase once the .NET Framework 3.5 is available at hosting sites is to standardize on WCF for all non-HTML endpoints. Since lots of the relevant inter-blog and blogging tool APIs are still based on XML-RPC, that called for an implementation of XML-RPC on WCF. I've just isolated that code and put it up on wcf.netfx3.com.

My XML-RPC implementation is a binding with a special encoder and a set of behaviors. The Service Model programming experience is completely "normal" with no special extension attributes. That means you can also expose the XML-RPC contracts as SOAP endpoints with all the advanced WCF bindings and features if you like.

The binding supports client and service side and is completely config enabled. Here's a snippet from the MetaWeblog contract:

[ServiceContract(Namespace = http://www.xmlrpc.com/metaWeblogApi)]
public interface IMetaWeblog : Microsoft.ServiceModel.Samples.XmlRpc.Contracts.Blogger.
IBlogger
{
   [OperationContract(Action="metaWeblog.editPost")]
   bool metaweblog_editPost(string postid,
                             string username,
                             string password,
                             Post post,
                             bool publish);

   [OperationContract(Action="metaWeblog.getCategories")]
   CategoryInfo[] metaweblog_getCategories( string blogid,
                                            string username,
                                            string password);
    ...
}

For your convenience I've included complete Blogger, MetaWeblog, and MovableType API contracts along with the respective data types in the test application. The test app is a small in-memory blog that you can use with the blogging function of Word 2007 as a client or some other blogging client for testing.

Of the other interesting XML-RPC APIs, the Pingback API has the following contract:

    [ServiceContract(Namespace="http://www.hixie.ch/specs/pingback/pingback")]
   
public interface
IPingback
    {
        [
OperationContract(Action="pingback.ping"
)]
       
string ping(string sourceUri, string
targetUri);
    }

and the WeblogUpdates API looks like this:

    [DataContract]
   
public struct
WeblogUpdatesReply
    {
        [
DataMember
]
       
public bool
flerror;
        [
DataMember
]
       
public string
message;
    }

    [
ServiceContract
]
   
public interface
IWeblogUpdates
    {
        [
OperationContract(Action = "weblogUpdates.extendedPing"
)]
       
WeblogUpdatesReply ExtendedPing(string weblogName, string weblogUrl, string checkUrl, string
rssUrl);
        [
OperationContract(Action="weblogUpdates.ping"
)]
       
WeblogUpdatesReply Ping(string weblogName, string
weblogUrl);
    }

I'm expecting some interop bugs since I've done a clean implementation from the specs, so if you find any please let me know.

The code is subject to the Microsoft samples license, which means that you can put it into your (blogging) apps. Enjoy.

Categories: MSDN | Indigo | WCF | Weblogs

February 9, 2007
@ 12:18 AM

I'm busy at a conference but just stumbled upon Yahoo Pipes via TechMeme and Dare. The little bits I read about it make that quite interesting to me (and put a big grin on my face) specifically because of this piece I wrote in 2003 and which also got some attention back then. I claim prior art ;-)

Categories: Weblogs | Atom | RSS

December 5, 2004
@ 02:33 PM

"My Lists", "My Photos", "My Profile" .... sounds all very familiar over there in MSN Spaces. So ... roll in the Web service interfaces, please.

Categories: Web Services | Weblogs | XML

I am currently writing an article for a magazine about dasBlog and I am also covering a bit of the history of RSS and similar formats. While looking up some links on Google, I stumbled over a blog entry by Don Box that I hadn’t read or which at least didn’t stick.

Don had an outrageously retro idea back in May of which I understood the complete coolness only today. The reason why that didn’t click earlier for me until today was likely that Don simply didn’t use the right picture to go with that blog posting. So, Don, as a special service from a friend I’ll do that for you here:

Subscribe to Don Box’ Active Channel
Add Active Channel


Even if there’s a chance that someone (from the Windows shell team, maybe?) is going to hate me for it, I firmly plan to add Active Channel and even Active Desktop support to the next revision of dasBlog; every copy of Windows with IE4.0 or later has built in support for the exact stuff that Weblogs are. Let’s just use that.

(Update: I just noticed that I must have been living under a rock in May)

Categories: dasBlog | Weblogs

August 8, 2003
@ 02:52 AM

James Avery suggests creating something new for topic-based aggregation. His idea is to allow aggregation of blogs by topic and not by person and wants new things invented for this.

I think they exist.

The item-level <category> element of RSS allows for setting a taxonomy on category items and that's sufficient to make James' idea work, if  (a) aggregators were looking for the domain attribute and allowed grouping by it and (b) blog engines would allow you to attribute your categories like that. Then, we "only" need to agree on common categories (or someone just writes some up) and were set. No need to register anywhere or with a central system. Here's an example of how the elements could look for .NET bloggers:

<category domain="urn:msdn-microsoft-com:netframework">ASP.NET</category>
<category domain="urn:msdn-microsoft-com:netframework">Enterprise Services</category>
<category domain="urn:msdn-microsoft-com:netframework">C#</category>
<category domain="urn:msdn-microsoft-com:netframework">VB.NET</category>
<category domain="urn:msdn-microsoft-com:serversystem">SQL Server</category>
<category domain="urn:msdn-microsoft-com:serversystem">BizTalk Server</category>

Categories: Blog | Weblogs | RSS

Dave Winer suggests an experiment:

Shall we run an experiment is to see if aggregators can work with RSS feeds that have a xmlns attribute at the top level, on the <rss> element?

... and continues with an example:

<rss version="2.0" xmlns="http://blogs.law.harvard.edu/tech/rss">

Now, the RSS spec doesn't say that this is okay, but neither does it say it's not okay.

Yes, the RSS spec may not but that doesn't matter, because it's just a vocabulary on top of existing specs that take matters a bit more seriously. The XML namespaces spec says: "If the URI reference in a default namespace declaration is empty, then unprefixed elements in the scope of the declaration are not considered to be in any namespace", which is true for all RSS elements as per RSS specification, because it ignores namespaces and is therefore subject to this default case. Therefore, setting a default document namespace like that may be permissible as per RSS spec, but recognizing such a document as valid RSS is just wrong. I would suggest to revise the spec and not to experiment.

Categories: Blog | Weblogs | RSS

BloggerAPI, MT API, MetaWeblog API, Comment API, Pingback API, Trackback  ...  are you nuts?

I must admit that until last week I didn't really pay much close attention to all the blogging related APIs and specs beyond "keeping myself informed". Today I copied my weekend's work over to this server and now I have all of them implemented as client and server versions. Sam's and Mark's validator is happy with my RSS 2.0 feed and the experimental Atom (Pie/Echo) feed.

I have to say ... the state of affairs in this space is absolutely scary. Most of the specs, especially for the APIs are lacking proper information detail, are often too informal with too much room for ambiguities and you need to be lucky to find a reasonably recent one. Sam laments that people don't read specs carefully and I agree, but I would argue that the specs need to be written carefully, too. It also seems that because the documentation on expected behavior is so thin, everybody implements their own flavor and extensions and not only do the APIs have huge overlap, but it seems like any random selection of offline blogging tools will use its own arbitrary selection of these APIs in any random order. Since my implementation didn't "grow" over time, but I implemented it all in one shot essentially only since last Thursday and had to look at this all at once and what I found was just saddening. All of this has to be consolidated and it will be.

I am all for the Atom project and creating a consolidated, SOAP-based API for all blogging functions that the aforementioned APIs offer. XML-RPC was a good thing to start with but its time is up.  I am also for replacing RSS x.x with a spec that's open and under the umbrella of a recognized standards body and not of a law school, that's XML as of ca. 2003 and not as of ca. 1998, and that's formally documented (with a proper schema). What's there right now smells all like "let's hack something up" and not very much like serious software engineering. Ok, it's proven that it all works, but how about dumping the prototypes now?

 

Categories: Blog | Technology | ASP.NET | Weblogs | Atom