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 ;)

I listened to "Service-Oriented Architectures", presented by Clemens Vasters at the EMEA Architects Tour. Its a great description of SOAs and Clemens makes several thought-provoking points. Thanks to Harry Pierson for the link.

Best line of the presentation:

We owe XML to our children.

True. True.

[permalink: http://EraBlog.NET/filters/10375.post]

Microsoft sets Office bundling terms. Microsoft will not include InfoPath and OneNote as part of the Office suite sold at retail or installed on new computers. [CNET News.com]

There are things I will probably never understand. The Office bundling is one of them. I have a hard time figuring out why InfoPath shall only be an "Enterprise" thing.

Even more on UDDI.  UDDI provides the opportunity for metadata to describe the services, and the likely response here will be that "This will be one of the constraints you can establish when querying UPS, FedEx and DeutschePost for the service", but that presumes that I don't have some kind of partner-based relationship with one or the other; in short, it doesn't reflect the larger business concern that I want to cut deals with companies to give them exclusive access to my business in exchange for price breaks, priority service, and whatnot.  [The Mountain of Worthless Information]

That's just why I distinguish between global and local registries. You'll only dispatch from you local UDDI registry. That will only have services registered that you trust and that you have an estalished relationship (and SLA) with. The power is that you can add and remove services from there without having to change anything in your code and it is a consistent place and a consistent model to do so for any service. The global UDDI registries are yellow pages, the local UDDI registry (yours) is a Rolodex(tm).

There's an interesting comment on Ted Neward's blog which is related to what I've been saying here:

Ian Fairman wrote:

This whole approach of munging your own shipping request schema to the parcel company's schema reminds me of how some people would tout entity beans as reusable simply by using object-relational mapping tools to map them to 3rd party database schemas. Unfortunately the "magic" in these mapping tools can be quite easily fooled by extra fields in either the bean or the database table - what do you do with them? And that is probably the simplest problem you'd meet. This mapping magic is a pipe dream. The real solution is to define standard schemas. Getting everyone to agree on these schemas may be a pain in the arse but at least it will work when you've done it.

The problem with the standardization and agreement dream is that it is indeed much less realistic than doing all the mapping work. What we need are stable schemas that we can rely on and map from and to, but not necessarily standardized ones. Until you get people from all state-owned postal services around the world and all the private courier and parcel services to agree on a set of schemas to use in unmodified form (or all banks, or all whatever-you-choose-industry), XML has likely already been replaced by the next thing. 

Message standards are hard to agree on. If you look at EDIFACT or ANSI X.12, you'll find that neither really defines something like a schema. Both standards define "dictionaries" of segments which you can choose from when you assemble/trim message definitions. An EDIFACT ORDERS message is never caught in the wild as specified in the EDIFACT dictionaries. In fact, it's already a messy manual task to go from one user's ORDERS to another user's ORDERS, because the precise implementations of ORDERS may differ wildly.

Even worse ... what if industry A agrees on a standard format for exchanging purchase orders and industry B does the same for themselves and now a company from industry A wants to purchase something from a company in industry B. Poof!

The moment the first company came up with a graphical, easy-to-understand editor for XML Schema, the whole standardization hope was gone out the window already. Everyone can define schema and if they can, they will. Now with stuff like InfoPath, my Dad can even define schema. It's not going to be pretty, but it is schema.

If one out of 500 companies doesn't support a "standard schema" or even augments it with their own idea of certain things and that one company happens to be a big fish, forget standardization. You will have to understand what they mean and you will have to map between schemas. Schema standardization won't work on a grand scale and it will just not happen.

At the same time, "generic mapping" won't work, unless we take metadata much further than we do now and start to formalize semantics. The "semantic web" efforts go into that direction, but there's plenty of work to be done. In the absence of standardization, mapping between schemas is a growing necessity and while it seems like an ugly job -- it is a job. It's a manual job. There's no magic here. And it surely will create jobs. It's simply a necessary new field in programming and it's begging for better tools.

More on UDDI. [...] OK, UDDI-as-the-yellow-pages I'll buy, but this idea of "give me the WSDLs for those services" implies that I'm going to dynamically invoke a web service, meaning now essentially you're tying me into a loose-binding situation similar to writing Java or .NET Reflection code. Quite frankly, I don't buy this argument whatsoever--I *need* to have some idea of the service I'm trying to invoke, otherwise, how can I know what to pass where? I recognize this idea of "dynamic glue" is an attractive one, allowing me to walk up to any web service at runtime and consume it without any a priori knowledge whatsoever, but this is akin to suggesting that I can write a generic Java user interface that can gather any sort of data from the user without any sort of a priori knowledge whatsoever, driven by an XML file--you can do it, but boy will the UI suck. I'm still not convinced that UDDI is worth saving from the cliff; essentially we're talking about a naming/directory server (remember I can always attach attributes to an entry in an LDAP-like environment), coupled with dynamic binding at runtime of the endpoints. I still don't see the value here. [The Mountain of Worthless Information]

Get over RPC. Think messages. Get over coding and programming models. Think data.  

When you have a choice of three different services to call -- I will stick with my previous example -- one at UPS, one at FedEx and one at Deutsche Post, you will always know what data you have to give them and you know what you want from them. The challenge is to find those services by meaningful criteria and to map from your internal representation of data to their representation and back. Precisely, it's about mapping their idea of representing well-understood and agreed semantics into your representation of the same semantics. The global UDDI space (public registries) is the place where you can locate those services in general, the local UDDI space (enterprise registry) is where you can augment this information with your own metadata and mapping information.

All of this and Web services in general are not about taking someone's WSDL, code-generating a proxy and calling that proxy via reflection. That's RPC or Automation. That's last century's technology. That's old programming. The center of programming is shifting towards messaging. Enjoy.