Aspects in Bucharest.

Tomorrow (today, strictly speaking), Steve and I will be doing the second round of talks on our tour speaking about scalable systems. Microsoft Romania expects 700 (!) people and on Friday we're going to have another 700 in Moscow. Add the 200 people we had on the first event yesterday in Warsaw (which went really well) and we'll have had 1600 people altogether in a single week. Fantastic! Great fun.

On of the things I'll be showing tomorrow (in the context of "programming model extensibility") and which you can build yourself using VS.NET 2003 and my new set of libraries is a little custom "aspect" (or "interceptor" for more old-fashioned thinking people):

using System;
using newtelligence.Aspects;
using newtelligence.EnterpriseServices;
namespace AspectComponentServer
{
 [Serializable]
 public class MonitorData
 {
  private string data;
  public MonitorData( string data )
  {
   this.data = data;
  }
  public string Data 
  {
   get
   {
    return data;
   }
  }
 }
  public class MonitorAspectAttribute : Attribute, IAspectServerContextLeave, IAspectServerContextEnter
 {
  public MonitorAspectAttribute()
  {
  }
  
  public void OnServerContextEnter(object transparentProxy, System.Runtime.Remoting.Messaging.IMessage message, 
                                   System.Reflection.MemberInfo member, System.Reflection.ParameterInfo paramInfo)
  {
   Console.WriteLine( "Enter context for method {0}", message.Properties["__MethodName"] );
   Console.WriteLine( "  -- Setting property into context" );
   ContextUtilEx.SetUserProperty( "AspectComponentServer.MonitorAspectAttribute.MonitorData", 
                                  new MonitorData("Test information") );
  }
  public void OnServerContextLeave(object transparentProxy, System.Runtime.Remoting.Messaging.IMessage message, 
                                  System.Reflection.MemberInfo member, System.Reflection.ParameterInfo paramInfo, bool ReturnValue)
  {
   Console.WriteLine( "Leave context for method {0}", message.Properties["__MethodName"] );
   MonitorData monitorData = 
          ContextUtilEx.GetUserProperty( "AspectComponentServer.MonitorAspectAttribute.MonitorData") as MonitorData;
   Console.WriteLine( "  -- Property value found: {0}", monitorData.Data );
  }
  
 }
}

and use it like this

 
using System;
using System.EnterpriseServices;
using newtelligence.EnterpriseServices;
using newtelligence.Aspects.Constraints;
using newtelligence.Aspects;
[assembly: ApplicationActivation( ActivationOption.Library)]
[assembly: ApplicationAccessControl( false )]
namespace AspectComponentServer
{
 [Transaction(TransactionOption.Required)]
 [EventTrackingEnabled]
 [MonitorAspect]
 public class FlightReservation : AspectServicedComponent 
 {
   [ContextState]
   int jitaSessionState;
   public string ReserveSeat( 
            [Match("[A-Z]+")]     
            string Airline, 
            [MinLength(1),MaxLength(4),Match("[0-9]+")] 
            string FlightNumber,
            [Between(1,100)] 
            int Row,
            [Match("[A-K]")] 
            string Seat,
            [MinLength(3),MaxLength(3)] 
            string DepartureAirport,
            [LaterThanToday]
            DateTime DepartureTime,
            [MinLength(3),MaxLength(3)] 
            string ArrivalAirport)
  {
   ...   
  }
  public bool ConfirmSeat( [MinLength(1),MaxLength(8),Match("[0-9]+")] string ReservationCode )
  {
    ...
  }
  public bool CancelSeat( string ReservationCode )
  {
    ....
  }
 }
}

Steve said yesterday that the capability to add your own interceptors and my extended "ContextUtilEx" class that allows you to flow arbitrary items in the context is enough to build your own services on top of the Enterprise Services infrastructure much in the same way as COM+ does it internally.

The [ContextState] attribute sits on top the ContextUtilEx and gives you custom "session state" for just-in-time activated components, which means that you can have fields that have context scope and whose values will survive the recycling of the actual object instance across activations. That brings Enterprise Services and ASMX one step closer together in terms of programming models.

If Microsoft wouldn't be grumpy with me if I did it (and they would), I would name my stuff not "newtelligence SDK for Enterprise Services" but rather "COM+ 1.75" ;)

"Resistance is futile". Someone said that to me at a dinner a few weeks ago, and it seems that happened to Chris, too. Seems like Chris gave in straight away and got assimilated ;)

newtelligence SDK for Enterprise Services.

Here's the first drop ("RC0") of the library that I am releasing along with our tour. The ZIP file contains a single MSI, which installs into Visual Studio .NET 2003. There will be more drops during the next two weeks, which will mostly add more documentation and more samples.

Greetings from Warsaw...
PS: Does Aspects, too.

Steve in the house

Steve Swartz and myself have been preparing our "Scalable Applications" tour over the last three days, and in between things we spent some time at Patricia's and my families' houses for holiday lunches and afternoon coffee, opened the BBQ season on our balcony, watched the sunset at Düsseldorf's Rhein riverside over some Alt-beers and are now getting ready for travel. Tuesday we'll speak in Warsaw, Thursday in Bucarest, Friday in Moscow and next week we'll be in Oslo (Monday), Copenhagen (Tuesday), Paris (Wednesday) and Lisbon (Friday). Just in time for this tour, Steve has now set up his own blog at gotdotnet and we're planning to write about the tour here and over there as we go along. 

Update: You can download our slide decks from www.thearchitectexchange.com (under "Scalable Apps Tour"). Mind that PPTs only tell half of the story, of course. A bag of binaries and sample code should be there Tuesday, the latest.

AspectServicedComponent, NETFX 1.1 and GC

This morning I had the first chance to compile my AOP framework for Enterprise Services on the RTM versions of VSNET 2003 and the Framework 1.1. At first sight, the stress tests showed that something was still leaking memory, but -- oh, wonder! -- about 10 minutes into the stress test run, it all seems to stabilize and the heap sizes in all GC generations including the critical Gen 2 actually start to shrink and grow in a saw-tooth shape in the perfmon-charts as expected. I guess that means that you can expect bits in time for TechEd 2003 Dallas, where I will do a "400 level" talk on AOP and will finally give away some better hints at how this was done.

A search for "definately" yields "about 686.000" links on Google, but none in the dictionary. Last time I looked, it was definitively spelled "definitely".

Content Pipelines?

On the flight from Athens to Madrid this last week I had an idea that I'd like to float in order to see what other people think.

The weblog infrastructure that I am (still, due to little free time) building, has its own aggregation system that flows aggregated content though a pipeline until it's pushed into the storage system. So, what the system does is to pull content from RSS feeds, from Exchange public folders, websites and others sources (the "feed readers" are pluggable), maps everything into a common representation and flows articles through the pipeline. The stages in the pipeline can look at the content and make adjustments (fix up HTML), do filtering (assign categories) and, most importantly, can enrich the content with metadata. So, when the system is pulling information from an RSS source, it may invoke a stage that runs all the words in the article against a dictionary and add links to a site like dictionary.com, it may invoke a stage that find relevant books on amazon.com or a stage to get Google links or even a stage that translates the original Russian text into German for me, and add all that additional information to the "extended metadata" of the article, etc.  Everything is pluggable.

Here's the idea: I really don't want to write the Amazon, Google, Dictionary and Babelfish stages, myself. What I rather want to do is to enlist those sites as web services into my pipeline. Using one-way messaging and <keyword>WS-Routing</keyword> I could say "here's an article, add your metadata to it and send it back <to> me or <via> the next pipeline stage here at my system or <via> elsewhere when you're done". Or I could just walk up to an RSS provider and say, "don't reply to be directly, please route back to me <via> these stages".

So, if such a distributed infrastructure existed, and you'd aggregate this entry "backrouted" through a pipeline of filters provided by Weather.com, Google.com, Dictionary.com and Amazon.com, you'd have the weather for Athens and Madrid, all relevant Google links and books on "content" and/or "pipelines" and WS-Routing, and links to explanations of all non-trivial words in this text. How's that?

• Use the BCL type names
• Don't redefine your type's names to match your old habits

[Ingo Rammer's DotNetCentric]

Sorry.... string, int, char and long are part of the language. Int32 is just some detail of the underlying platform. The fact that C# and VB.NET very convienently map onto the CLR type system doesn't mean that all languages do. Using BCL types also takes away the flexibility only a high level language and its abstraction over the platform can provide. Mind WPARAM and LPARAM in Win16 (16bits,32bits) vs. Win32 (32bits) vs. Win64 (64bits). (For the younger amongst us, the "W" in WPARAM used to mean "WORD" as in "16bit processor word" and "L" used to mean "LONG" as in, ahem, "long" or "double word"). Been there, hated that. If a language can fix those problems for me by providing a layer of abstraction ... thank you, will buy.

Fresh look. I got bored with my blog template at last and designed a new one. I used the only graphics editor that ever really made sense for me (a matter of taste, really) in terms of handling and which wasn't too bloated: Microsoft Image Composer 1.5. Unfortunately discontinued.

My conference schedule for the next weeks....

I guess "busy" is the right word to describe this table. However, I am not complaining. A lot of this will be fun.

TechEd!

So.... I just got the word that I am confirmed as speaker at TechEd Dallas (my first major U.S. Microsoft conference) Of course I'll be at TechEd Barcelona, too. I may even go to TechEd South Africa in Sun City. We'll see.

Anyways, the title of my session ".NET Web Services Internals: I didn't know you could do that!" promises more whacky demos, more attributes, more WSDL hacking (I use while it lasts ;) and more black magic done by the ASMX runtime. The other session is about AOP and may come with some surprises as well ;)