As I had said a couple of weeks ago, I started working a new blog engine and look & feel for my corner of the web. I didn’t really spend a lot of time on this. It was mainly attracting my attention when I wanted to take my mind off the book and Microsoft-related work :-) As a result, it took longer than expected but the result was a complete rewrite of pblog. The blog engine should now be faster, produce more Web-cache-friendly output, and allow me to further expand it with new social networking features. Some key new features:

• Images are no longer retrieved from the database. All images are stored both in the relational DB (for archival purposes) but also on disk, so that no code is executed on an HTTP GET request.
• The URIs are now shorter.
• Archives are better organized.
• Those submitting comments can now request to get notified for follow-ups (this feature is almost ready).
• Categories have been added.
• Feeds for categories are also available so that you don’t have to read my random travel-related ramblings :-)
• The web pages now make extensive use of divs for the layout and the XHTML should be better.

In the process, I’ve moved my web site from http://savas.parastatidis.name to http://savas.me, which is much easier to write and spell :-) All the permalinks of the old posts should be automatically re-directed through HTTP 301s. The only one that is not going to be redirected is the default page. If I’ve done everything correctly, you shouldn’t notice any changes. Even the old feeds will get redirected. Just for good measure, though, the new feeds are:

• http://savas.me/blog/feed/rss
• http://savas.me/blog/feed/atom

If you want feeds for the categories, the template URI looks like this:

• http://savas.me/blog/feed/rss/{category}
• http://savas.me/blog/feed/atom/{category}

For example... http://savas.me/blog/feed/atom/web. The web page of each category has the link to its atom feed.

I am planning to go through all my old blog posts and categorize them but this is going to take a while. This way the category cloud will emerge.

Please let me know if you encounter any problems at all or you want to send your feedback on the new look & feel. You can email me directly at savas@parastatidis.name or try to leave a comment here (if the comments work :-)

BTW... I am still looking for a name for the blog!

Geek details: The engine is now built on top of .NET 3.5 SP1 and makes extensive use of SQL to LINQ. The DB is SQL Server 2008 and everything is hosted in the 3rd of the hosting providers I tried over the last month.

Hmmm!

<br /> <a href="http://video.msn.com/video.aspx?vid=0bb6a07c-c829-4562-8375-49e6693810c7" target="_new" title="Laptop Hunters $1000 - Lauren Gets an HP Pavilion">Video: Laptop Hunters $1000 - Lauren Gets an HP Pavilion</a>

Interesting short talk by Barry Schwartz. His great presentation style reminded me of Jeremy Frey who also uses cartoons in his talks. I am not sure I completely agree with all Prof. Schwartz’s points but his talk definitely gives food for thought.

There is a lot of truth in his rhetoric around the plethora of choice and the impact on expectations but I think there should also be a discussion around the context and the environment that we live in, as this has evolved over the decades, over the centuries. Is it fair to say that we were better off because our expectations were lower? Isn’t our environment different now than it was only few decades ago? I guess I need to add his books to my reading queue :-)

Thanks to Anna for forwarding.

... about global warming.

I loved this...

At one point the discussion lit a fire under the Admiral, and the talk of human rights turned personal for Edward James Olmos. The "Old Man" launched into a passionate speech about casting off the idea of race as a cultural determinant, and said we were one race, the human race. His voice echoed throughout the chamber growing louder until - I kid you not - he was yelling, "So Say We All," and the crowd answered right back. Hell, even I yelled it, I was in the fraking United Nations with Adama, the gods themselves could not have stopped this moment. It was surreal - the entire audience turned into one massive optimistic/role-playing/saddened goosebump, because who knows when we'll ever hear those words again? And then we were doubly geeked out when, as if on cue, Mary McDonnell turned to Olmos and put her hand on his cheek. But the real chills came from realizing that this treasured television show had actually opened up the lines of communication between the audience and the United Nations. BSG has made people think about the troubling deeds happening in darkened rooms in the present day, not just on a spaceship in the future.

The Night Battlestar Galactica Took Over The U.N.

It’s absolutely amazing! The guys over at MSR managed to bring the same experience from the Windows client into the browser. It’s beautiful. (Linux and Macs should be able to use WWT now).

Tip: Go and select one of the guided tours.

Earlier today, Jim and I were discussing the structure and content of our “Hypermedia Services” chapter for our book (tentatively titled “GET /Connected”). The book is getting along really nicely. I think we are way beyond mid-point, dare I say 3/4 of the way? :-)

A new idea about a pattern popped up during our chat. We both agreed that no one is currently making use of such a pattern (or, better... no one that we know of :-) so we weren’t sure whether we should dedicate any space in our chapter to discuss it. Furthermore, there might be some technical issues with the pattern that might not be obvious to us. We decided that we should reach out to the community to test the idea and also to get a feel on whether it has a place on a book about Web-based integration.

In our “How to GET a Cup of Coffee” article, we showed how the “hypermedia as the engine of application state” could be used in a machine-to-machine integration scenario. In the book, we expand a lot more on that idea.

In our Restbucks world (the example we use throughout the book), we have order resources with which consuming applications can interact. We use atom:link elements as part of a resource’s state representation to indicate the expected next steps in an interaction. For example, when a customer GETs the state representation of a particular order (e.g. http://restbucks.com/order/1234), the following representation will be probably returned as the content of an HTTP/1.1 200 OK response.

           1: <order xmlns="http://restbucks.com" xlmns:atom="http://www.w3.org/2005/Atom">

           2:   <consume-at>takeAway</consume-at>

           3:   <item>

           4:     <name>latte</name>

           5:     <quantity>1</quantity>

           6:     <milk>whole</milk>

           7:     <size>small</size>

           8:   </item>

           9:   <received>2009-02-26 12:07</received>

          10:   <amount>10.00</amount>

          11:   <currency>GBP</currency>

          12:   <atom:link rel="payment" type="application/vnd.restbucks+xml" href="http://restbucks.com/order/1234/payment"/>

          13: </order>

In addition to the order-related information (e.g. ordered items, received date/time, etc.), the Restbucks service also includes Atom <link> elements that could help the customer and the service make forward progress in their interaction. The Content-type header of the response would probably be something like “application/vnd.restbucks+xml”, indicating to the customer that they should use our Restbucks-specific payload processing rules. It’s these rules that define how to process/understand an order’s state representation, including the use of the Atom <link> elements.

Now, if you think about it, we do something very similar with the Atom Application Protocol. The returned representations contain Atom <link> elements that have very similar semantics. One could say that the equivalent happens with XHTML, since the returned documents contain links to support the state transitions in our “hypermedia as the engine of application state”-supported application – browsing the web.

We observe that clients receiving the resource representations with embedded links, need to extract those links from the payload and make use of them in order to make forward progress. Each client has to implement the hypermedia-specific behavior.

As with each pattern, we might be able to generalize the approach so that software support – through tooling/frameworks – can be introduced. We could, for example, define a Content-type like “application/state+xml” which would allow us to get the hypermedia-specific state representation of a resource. For the order above, an HTTP GET request with the “Accept" header set to “application/state+xml” would have returned something like this...

           1: <feed xmlns="http://www.w3.org/2005/Atom">

           2:   <link rel="payment" type="application/vnd.restbucks+xml" href="http://restbucks.com/order/1234/payment" />

           3: </feed>

This is effectively a way for a customer to just ask Restbucks “what do you expect me to do next?”. However, this is a generic question that is valid in many application integration scenarios. Multiple links may be returned, giving consuming applications options about what they could do. This way, a generic software stack could be implemented to support this type of behavior.

One can take it even further and include an Atom <entry> element for each allowable state transition, rather than just a list of links under the Atom <feed> element. Each <entry> will have its own <link> but would also carry a WADL document with more details about the linked resource.

So, what does the community think? Is this just wacky? Would you like to see this explored in a more detailed discussion in one of the chapters of our book? Do you think it can be useful?

As we were thinking about the above pattern, it occurred to us that the idea resembled some discussions Jim and I had some time ago with Andrew Harrison from the School of Computer Science, Cardiff University, on conversational state description for the Web. Maybe it's time to resurrect those ideas.

An interesting short article on Research’s fourth paradigm, something that Jim Gray used to talk about a lot. Here’s the concluding paragraph:

Data-intensive science will be integral to many future scientific endeavors, but demands specialized skills and analysis tools. In addition, the research community now has the option of accessing storage and computing resources on demand. The IT industry is building huge data centers, far beyond the financial scope of universities and national laboratories. These "cloud services" provide high-bandwidth access to cost-effective storage and computing services. However, there are no clear examples of successful scientific applications of clouds yet; making optimum use of such services will require some radical rethinking in the research community. In the future, the rapidity with which any given discipline advances is likely to depend on how well the community acquires the necessary expertise in database, workflow management, visualization, and cloud computing technologies. (“Beyond the Data Deluge” by Gordon Bell, Tony Hey, Alex Szalay)

We are on a roll. Lee Dirks, Alex Wade, and Pablo Fernicola are executing in an amazing rhythm :-) Well done guys!

Yesterday, we announced the availability of Famulus Beta 2. Today, the team announced the release of two of my favorite projects: Creative Commons plugin and Ontology plugin*. Of note is the release of the source code of these two plugins under MS-PL. Feel free to take the code and evolve it, create even better tools!

• Microsoft Press announcement
• Sample commentary from the blogosphere (James Turner)

* I actually did the design and original implementation of the Creative Commons one, in which you can still find some of my original code (plus all the icons :-). I was also actively engaged in setting up the Ontology plugin project, together with Lee, and then closely followed the technical and architectural work in collaboration with UCSD, working with Lynn Fink over there.

Update: Some more links from Lee...

• Ontology Add-in for Word 2007 binary “tech preview” release .
• Ontology Add-in for Word 2007 source code on CodePlex .
• Creative Commons Add-in for Microsoft Office 2007 binary release v1.01
• Creative Commons Add-in for Microsoft Office 2007 source code on CodePlex
• Creative Commons Add-in for Microsoft Office 2003 & Office XP v1.2 binary

It took us a little longer than we would have liked but it’s finally live. LOTS of fixes from Beta 1, an API for introducing new data models either declaratively or at runtime, authentication and authorization support, modularization of data models and matching APIs, and much more. Here’s the announcement:

MSR’s Research Output Repository Platform (codename “Famulus”) aims to provide the necessary building blocks, tools, and services for developers who are tasked with creating and maintaining an organization’s repository ecosystem. Furthermore, it provides an easy-to-install and maintain experience for those who want to quickly set up a research-output repository for their project, team, or organization. The platform is based on Microsoft’s technologies (SQL Server 2008 and .NET Framework version 3.5 SP1) hence taking advantage of their robustness, their quality support infrastructure, and the plethora of developer-focused tools and documentation. New applications on top of the platform can be developed using any .NET language and the Visual Studio 2008 SP1 environment. The platform focuses on the management of academic assets—such as people, books/papers, lectures, presentations, videos, workflows, datasets, and tags — as well as the semantic relationships between them. In this latest release, developers can declaratively (or at runtime) easily introduce their own asset and relationship types. Support for various formats and services such as full-text search, OAI-PMH, RSS and Atom Syndication, BibTeX import and export, SWORD, AtomPub, RDFS, and OAI-ORE are included as part of the distribution.

We are still calling it “Research Output Repository Platform” even though we have finalized on its proper name. You’ll have to wait till Open Repositories 09 for the official unveiling.

Please download, play with it, break it, and let us know of the issues you find. You can email me directly or, even better, post to our forum, where the team is eagerly waiting to answer your questions.

The next release is going to be v1.0, which is going to include a brand new and theme-enabled Web User Interface, integrated authorization functionality, and minor adjustments to the platform APIs that didn’t make it to Beta 2.

I had seen this some time ago. A posted link by one of my contacts in Facebook reminded me of it. Great presentation style.

Remember those experiments with MGrammar and Famulus?

• “Building an MGrammar-based application for Famulus”
• “Famulus and M - Added symmetric relation”

As part of some more coding effort on knowledge graphs and inferencing, I thought that it’d be cool to evolve my Domain-Specific Language so that it modifies itself.

As part of my investigations, I needed to check whether the entered predicates (I am working with First Order Logic these days) have been previously defined. When using the “knowledge console”, you define a predicate by just entering it on its own. I also have an XML-based representation but for the moment I am concentrating on the interactive console for playing around with the knowledge graph.

Well, instead of having to query the knowledge graph every time to check whether the entered predicate is available, I thought of just dynamically changing the grammar and have the MGrammar compiler do this for me. This was just out of curiosity. Of course I am not suggesting that this is used seriously when interacting with large amounts of data but the approach could definitely be used when writing a DSL that can change itself (e.g. introduce new keywords). It turned out to be remarkably easy.

Here’s an example…

• The predicates “savas” and “knows” are entered in the knowledge base
• The predicate “knows(savas jim)” is entered
• The grammar does not accept it as valid input
• The predicate “jim” is entered in the knowledge base
• The grammar now accepts “knows(savas jim)”

This behavior is trivial to implement with MGrammar. All you need is the DynamicParser, which i was using anyway. You rewrite your grammar every time a new predicate is introduced. I have an MGrammar token that maintains a list of all the predicates that have been entered. Using that list, I recreate and then re-compile the following grammar.

           1: module Aristotle.PredicateLanguage

           2: {

           3:     language Predicate

           4:     {

           5:         syntax Main = e:Expr => e;

           6:
      

           7:         syntax Expr = precedence 1: p:Pred => p

           8:                     | precedence 2: p:PredicateExpression => p;

           9:  

          10:         syntax PredicateExpression = i:DefinedPredicate => i

          11:                                    | i:DefinedPredicate "(" e:InternalExpression+ ")" => id(i) [valuesof(e)];

          12:         syntax InternalExpression = p:PredicateExpression => p

          13:                                   | l:Literal => l;

          14:  

          15:         token DefinedPredicate = p:("_") => p;

          16:  

          17:         token Literal = l:Language.Grammar.TextLiteral => l;

          18:         token Pred = (Language.Grammar.Identifier ".")? Language.Grammar.Identifier;

          19:         interleave Whitespace = Language.Base.Whitespace;

          20:     }

          21: }

The trick is done with line 15, which evolves at runtime to look like this...

p:("savas"|"knows"|"jim") => p

Enjoy!

Simon Woodman and Einar Volset were visiting during the week. We went out for dinner, together with David Ingham. I took them to my favorite pizza place in Queen Anne, Via Tribunali. It was a lot of fun seeing them.

At the end of the dinner, Einar took all our credit cards and put them in hat. Apparently they play “credit card roulette” sometimes when they go out for dinner. The waitress picked one credit card from the hat for the entire bill. Since I don’t like gambling, I paid part of the bill to Simon (who was the unlucky one). Yes, I am not fun sometimes :-)

Einar was staying at my place. I was working hard on a demo we are preparing for senior executives when Simon called him and asked for my address. Didn’t know why. At some point a little bit later, Einar starts laughing. Simon had forwarded us the confirmation of an order that he placed on my behalf. He used the money to buy me a goat as a gift :-) What a wonderful gift. :-)

Of course, it’s from Oxfam so the money was given to a good cause.