In case you didn’t know, GotDotNet is shutting down. I recently got an email asking about my very old DevHawk Wiki project, which had been hosted on GDN. I didn’t realize anyone was still interested in this project, so I set up a new project for it on CodePlex. As part of the move, I decided to rebrand it “HawkWiki” and change its license to Ms-PL. (CodePlex doesn’t support the zlib license DevHawk Wiki was originally released under.)

I uploaded two versions to the HawkWiki source repository. The version that until recently was hosted on GDN is version 0.2. There’s also later version that I never publicly released before. This later version compiles the wiki markup text into an IHttpHander class, similar to how ASP.NET compiles web pages. I’m not sure if you’d ever really want a wiki built this way, but it does provide a good example for building your own compiled web page infrastructure. If you ever read my old MSDN magazine article, you’d know this is an approach I’ve been interested in for a long time.

I also used this project as an excuse to get to know CodePlex. Though CodePlex can integrate directly into VS via Team Explorer, I chose instead to use the CodePlex client. CPC provides an edit-merge-commit command-line experience like Subversion. I found it much easier than using Team Explorer, though adding new files was troublesome since they had to be added to the project and source control separately. If you like this approach, there’s also a version that works with vanilla TFS instances (CPC is hardwired to CodePlex).

So feel free to take the wiki code and mangle it to your heart’s content. If there’s interest, I’d be willing to grant some other folks checkin permission. However, it’s more a curiosity than a real project, so if you’re really interested in a .NET based wiki, there are better choices out there.

As expected, day two of the WSSF customization workshop was much meatier than day one. If you look at the technologies that power these p&p software factories – GAT and DSL – you’ll notice that they’re not very well integrated. They share a text templating engine and there are some docs, but that’s pretty much it. WSSF v3 is the first factory from p&p to heavily use both technologies, and they’ve had to do significant integration work to make them play nice.

In the new WSSF, there’s a special “model project” where you define data and service contracts independently of an implementation technology. This allows you to postpone your implementation decision as long as possible. For WSSF, this seems pretty pointless – if you’re starting a new service project from scratch, why would you build on ASMX instead of WCF? – but conceptually the idea is rock solid. But this requires a variety of cross-model and cross-project code generation and validation. The vanilla DSL toolkit doesn’t support that, so the p&p guys had to build it themselves.

I’d like to see p&p take their GAT/DSL integration work and package it separately from WSSF. As it currently stands, you’ve got to install GAT & the VS SDK (to get DSLs) plus the integration bits from WSSF. There’s also the GAX Extension Library (aka GEL) plus Clarius’ Software Factory Toolkit. How about a single install to get all that stuff guys?

BTW, there’s a new version of GAT coming soon that will support both VS05 and VS08 Beta 2. According to the VSX team, VS08 beta 2 SDK should also be available “early August”. So if you’re moving over to VS08 (I am), you can still get down and dirty with software factories.

Update: VS08 SDK for Beta 2 is now available. The new version of GAT is apparently done, but isn’t available for download yet.

Later Update: GAX/GAT July CTP is now available.

Thanks to Technorati, I found this post by John Heintz. He’s checking out John Evdemon’se-book on SOA and has a problem with this overview:

SOA is an architectural approach to creating systems built from autonomous services. With SOA, integration becomes forethought rather than afterthought. This book introduces a set of architectural capabilities, and explores them in subsequent chapters.

To which John H. responds:

I, for one, would rather build on an architecture that promotes integration as an afterthought, so I don’t have to think about it before hand!!!

Yeah, I’d rather not have to think about integration before hand either. On the other hand, I want integration that actually works. It sounds like John H. is suggesting here that REST somehow eliminates the need to consider integration up front. It doesn’t. Consider this: if you’re building a Web 2.0 site then you are expected to expose everything in your site via APP, RSS and/or RESTful POX services. In other words, the Web 2.0 community expects you to have the forethought to enable integration. If you don’t, Marc Canter will call you out in front of Bill Gates and Tim O’Reilly.

This integration by afterthought approach seems to be big among RESTifarians. John H. links to a REST discussion post by Nick Gall advocating the principle of generality, “unexpected reuse” and “design for serendipity”. Money quote:

The Internet and the Web are paradigms of Serendipity-Oriented Architectures. Why? Largely because of their simple generality. It is my belief that generality is one of the major enablers of serendipity. So here I immodestly offer Gall’s General Principle of Serendipity: “Just as generality of knowledge is the key to serendipitous discovery, generality of purpose is the key to serendipitous (re)use.”

Serendipity means “the accidental discovery of something pleasant, valuable, or useful“. “Serendipitous reuse” sounds an awful lot like accidental reuse. Most enterprises have been there, done that and have nothing to show for their efforts or $$$ except the team t-shirt. Yet Tim Berners-Lee believes “Unexpected reuse is the value of the web” and Roy Fielding tells us to “Engineer for serendipity”. What gives?

First off, enterprises aren’t interested in unexpected or serendipitous reuse. They want their reuse to be systematic and predictable. The likelihood of serendipitous reuse is directly related to the number of potential reusers. But the number of potential reusers inside the enterprise is dramatically smaller than out on the public Internet. That brings the chance for serendipitous reuse inside the enterprise to nearly zero.

Second, enterprise systems aren’t exactly known for their “simple generality”. If Nick’s right that “generality of purpose is the key to serendipitous (re)use”, then enterprises might as well give up on serendipitous reuse right now. As I said last year, it’s a question of context. Context is specifics, the opposite of generality. Different business units have different business practices, different geographies have different laws, different markets have different competitors, etc. If an enterprise operates in multiple contexts – and most do - enterprise solutions have to take them into account. Those different contexts prevent you from building usable – much less reusable – general solutions.

Finally, I think the amount of serendipitous reuse in REST is overstated. If you build an app on the Facebook Platform, can you use it on MySpace? Nope. If you build an app that uses the Flickr services, will it work with Picasa Web Albums? Nope. Of course, there are exceptions – pretty much everyone supports the MetaWeblog API – but those exceptions seem few and far between to me. Furthermore, the bits that are getting reused – such as identifier, format and protocol – are infrastructure capabilities more suitable to reuse anyway. Serendipitously reusing infrastructure capabilities is much easier than serendipitously reusing business capabilities, REST or not.

The problems that stand in the way of reuse aren’t technology ones. Furthermore, the reuse problems face by enterprises are very different than ones faced by Web 2.0 companies. REST is a great approach, but it isn’t a one-size-fits-all technology solution that magically relegates integration and reuse to “afterthought” status. Serendipity is nice, when it happens. However, by definition it’s not something you can depend on.

No morning coffee posts for the first half of this week, because I’m in training thru Wednesday. Day one was mostly overview of GAT and DSL, which was review for me. Today we’re starting to dig into some of the new stuff they’ve build for the new version of WSSF, so I’m paying much more attention today.

This isn’t your typical workshop in that the content is sort of being generated on the fly. As I type, we’re voting on what we’re going to cover for the next two days. Most classes I’ve been in are pre-programmed, the teacher doesn’t ask the class what topics should be covered and what order. There isn’t even one “teacher” - there are five folks from p&p including the architect, dev lead and PM of WSSF that are tag-teaming. Even the hands-on labs aren’t completely ironed out – they’re evolving the lab directions as we do the labs. It’s atypical, but it works.

Lots of meetings today, so my coffee post is late…

• The Big News^tm: Visual Studio 2008 and .NET Framework 3.5 Beta 2 is available for download. Soma and Scott have more. Silverlight 1.0 RC and the Silverlight Add-in for VS08 will apparently be available in a couple of days. Finally, there’s a go-live license for the framework, so you get a head-start deploying apps before VS08 and NETFX 3.5 RTM. Time to build out a new VPC image.
• Next week, I’m attending the p&p Service Factory v3 Customization Workshop. I’m looking forward to playing with the new Service Factory drop, but I’m really interested in learning more about building factories. I wonder if they’re going to discuss their VS08 plans.
• Nick Malik recently wrote about making “middle out SOA” work. I hate that term “middle-out”. It feels like we’re pinning our hopes on middle-out because we know top-down and bottom-up don’t work. My old boss John DeVadoss (who assures me he’ll be blogging regularly again “soon”) big vs. little SOA, with big SOA being “dead”. I like the term “little SOA” better than “middle-out SOA”, but just because big SOA is a big failure, doesn’t mean little SOA will make any headway.
• There’s a new F# drop available. Don Syme has the details. Looks like they’ve got some interesting new constructs for async and parallel programing.
• ABC announced yesterday that they are streaming HD on their website. So you can check out the season finale of Lost in HD for free. They embed commercials so it’s not really “for free”, but you don’t have to pay $3 an episode like you do on XBLM. I wonder if XBLM might offer this capability in the future? Certainly would increase my use of XBLM. (as would an all-you-can-eat pricing scheme)