BizKnowledge

Watin => Selenium ?

2011-11-10T10:32:00.000-08:00

I've been using Watin for quite some browser automation projects. But it seems that Watin is a bit dead in the water. No Chrome support. No Firefox 4 or higher support. It also seems to be an heroic effort of a few people.

So it might be time to move over to Selenium. Active development, wide browser support...

Mercurial branching

2010-09-26T13:33:00.000-07:00

It takes time to get used to a new source control management system, but Mercurial HG visualization sure helps.

Branching default branch to 1.5.1 release and 1.6.1 release. Look at these rail tracks:

I'm build the 1.5.1 release and the 1.6.1 release from two different VM's. Just to keep everything separated.

</target>

External function calls

2008-04-25T10:23:00.000-07:00

The latest release of the Rule Manager allows to import external functions into the business vocabulary. As a little exercise I tried to get the current weather condition for a zipcode (maybe I can write some rules if I should bring my umbrella while I leave my house in L.A.)

Initially I intended to call a webservice, but it seems that all free weather webservice calls is something from the past. Yahoo offers weather information as an RSS feed. So a simple XPath query can select the information that I'm interested in:

Here is the code (note the FunctionAttribute decoration on the method)

using System.IO;
using System.Net;
using System.Xml;
using AcumenBusiness.IModel;
using Type=AcumenBusiness.IModel.Type;

namespace TestCallWebService
{
   [Concept("Weather info", "Try to get weather forecast from different services")]
   public class WeatherInfoProvider
   {
       private static readonly string YahooWeatherURLFormat = "http://weather.yahooapis.com/forecastrss?p={0}";

       [Term("workaround", "import function requires one field. (bug)")]
       private string dummyField;
       public string DummyField
       {
           get { return dummyField; }
           set { dummyField = value; }
       }

       [Function("Get temperature", "Get the weather info from Yahoo",
           ReturnType = Type.text,
           ArgumentTypes = new Type[] { Type.integer })]
       public static string GetWeatherInfoAsFeed(int zipCode)
       {
           HttpWebRequest request = (HttpWebRequest) WebRequest.Create(string.Format(YahooWeatherURLFormat, zipCode));
           // execute the request
           HttpWebResponse response = (HttpWebResponse) request.GetResponse();

           // we will read data via the response stream
           Stream resStream = response.GetResponseStream();
           XmlDocument rssFeed = new XmlDocument();
           rssFeed.Load(resStream);

           //set an XmlNamespaceManager since we have to make explicit namespace searches
           XmlNamespaceManager xmlnsManager = new System.Xml.XmlNamespaceManager(rssFeed.NameTable);
           //Add the namespaces used in the xml doc to the XmlNamespaceManager.
           xmlnsManager.AddNamespace("yweather", "http://xml.weather.yahoo.com/ns/rss/1.0");

           XmlNode weatherCondition = rssFeed.SelectSingleNode("/rss/channel/item/yweather:condition/@temp", xmlnsManager);
           if (weatherCondition != null) {
               return weatherCondition.Value;
           }
           return null;
       }
   }
}

With the Import Schema adapter I can import this function and call it from my business rules. The coolest part is that you can invoke this from the Interactive Rule Map. So you can see how your rules are executing with this external data. It seems to be 76 fahrenheid in L.A.
Nice weather to jump on the bike and cycle to work...

.NET SOA BizTalk: BizTalk Tools and guidelines

2008-01-10T21:36:00.000-08:00

Kishore Dharanikota has created a nice list of tools and guidelines for BizTalk developers and designers .NET SOA BizTalk: BizTalk Tools and guidelines. The Rule Manager is mentioned in the Development category. Interesting to see this classification. I probably would have placed it in the Design category. But that all depends on your frame of reference. Or it might hint that many BizTalk developers are playing a dual role of business analyst and developer.

RenewCert - Renew Expired Certificates

2007-10-30T21:32:00.000-07:00

It's been just over a year when I deployed the RuleManager with a ClickOnce certificate. Today it expired. Visual Studio 2005 would suggest to generate a new certificate file, however none of the existing users would be able to update the Application (because of different certificate keys).
The error you would get is:


System.NullReferenceException: Object reference not set to an instance of an object.
at System.Deployment.Application.ApplicationTrust.RequestTrust(SubscriptionState subState, Boolean isShellVisible, Boolean isUpdate, ActivationContext actCtx, TrustManagerContext tmc)
at System.Deployment.Application.DeploymentManager.DetermineTrustCore(Boolean blocking, TrustParams tp)
at System.Deployment.Application.DeploymentManager.DetermineTrust(TrustParams trustParams)
at System.Deployment.Application.ApplicationDeployment.CheckForDetailedUpdate()

There is a workaround made by Cliff Stanford RenewCert, which allows you to regenerate an expired certification.

Thanks Cliff!

Graphical Rule Editor for RuleML format

2007-10-14T14:31:00.000-07:00

In the last few weeks we have created the RuleML adapter for the Rule Manager. The RuleML adapter allows to export a business rules policy to the Reaction RuleML format.

Please bear with us that we are no experts in RuleML and certain rule constructions might be exported incorrectly. I hope the RuleML community can provide us with the feedback and we will incorporate any changes into our automatic update process as soon as possible. You can give feedback at the http://www.acumenbusiness.com/support forum.

Installation:
The Rule Manager product is available from the website http://www.acumenbusiness.com/

You can export to the RuleML format by installing the RuleML adapter module. See the screenshot [Menu: File\Options\Adapters\Rule ML]

The adapter will provide the new export format "RuleML (*.rrml)" in the Export wizard. [Menu: File\Export]
You can set .rrml as the default export type by changing the File Export type on the Import & Export options
[Menu: File\Options\Import & Export\File Export = RuleML (*.rrml)]

An example of the Driver Eligibility export is here

Paul Andrew : What to use Windows Workflow Foundation for?

2007-08-08T09:39:00.000-07:00

Paul Andrew has a nice write up on why you would use Windows Workflow Foundation. There are some excellent arguments for the use of the rules component: the visibility into the business logic and the ability to change this business logic.

That is exactly the reason why I'm currently designing a Windows Workflow Foundation architecture for a very large client. Performance will become critical...

Rule Vendors - Product Derby

2007-07-18T15:40:00.000-07:00

Once a year, during the business rules symposium, vendors of rule engines can show how they implement a general use case that contains many business rules. This use case is known as the UServ Product Derby. You can read the specifications here.

A few years ago I was actively involved with the implementation using Aion (from CA). Last year I put together the web front-end for Corticon. And recently I've been examining the implementation from Microsoft with WF rules.

Microsoft's example (download here) illustrates the technical feasibility of using WF rules. Although this example shows that it's technical possible, it does not highlight the business rules management, rule audit trail and rule traceability.

For me it was a nice opportunity to see if the Rule Manager from Acumen Business could visualize the rules and perform rule verification on the policy to discover if the actual implementation was logically correct.

We start this blog series with a closer look at the 'Driver's Eligibility' policy as defined in the use case. After a few adjustments on the Rule Manager, I produced this report (PDF, XPS) from Microsoft's example implementation.

The part that got my attention right away was the discovered contradiction. On first look, the rule DA_7 is rather complicated. It is a typical programmer's construction to use a not (expr and expr)
Such a statement has probably a few nanoseconds advantage on your processor. However do we really want the business user to decipher this statement by applying De Morgan's law?

Just keep it simple stupid. Where possible, avoid negated nested expressions and split or-statements in multiple rules.

You might wonder if we found an error with the rules example? The example should work fine, however the example uses rule priorities to ensure that rule DA_7 (priority -1) , is executed after DA_8 (priority 0). The problem that I have with rule priorities is that you throw away the declarative features of a rule engine. Suddenly the rule writer has to be aware of priority values in order to achieve the desired result.

Also note that DA_7 does not halt the rules engine. In a case where we have a male driver of 71 years old, the rules engine first assign 'Senior' to the Driver class, and consecutively overwrites this value with 'Typical Driver'. Now we also have to make sure that rule 'DA_3' must be executed after DA_7 and DA_8. If DA_3 would fire before, we make the incorrect conclusion that a 71 year old senior is eligible without checking his training certificate.

A second problem related to the priority and overwriting conclusions is that a rule audit report would show incorrect results. So please use rule priorities careful. We will show below that the Driver Eligibility policy actually don't require priorities.

Finally, the generated rule graph shows two disjoint rule networks. We have to wonder what happened with the rules that determine the 'Training Certification'. Also how is the DUI related to the Training Certificate? It seems that the example is not a complete implementation of the specification. Visualizing a rule policy in a complete rule graph does make the business rules code review an easy task.

Again, Microsoft example was only illustrating the technical aspects of WF rules. And the example shows how you can achieve First Order Logic with WF rules. (For All Drivers do...)
I changed the Driver Eligibilty policy to remove the contradiction and remove the priorities to keep the rules 100% declarative. We let the rules engine decide which rule should be executed next. Here is a produced report of my rewrite (PDF, XPS).

There are no disjoint rule graphs, no self contradictions within the rules, and no rule anomalies among rules. We do discover some incompleteness. E.g. is a Female of 24 years old eligible?
This incompleteness can be a misinterpretation of the use case specification, or an actual incompleteness in the specification. But with this rule report it's very easy to get these issues clarified.

WebCast on Advanced Scenarios of WFRules

2007-07-04T11:54:00.000-07:00

Kavita (Microsoft) will give a presentation this Friday (7/6/2007) about some advanced scenarios using rules with Windows Workflow Foundation.

During this presentation you will see screenshots of Acumen Business Rule Manager as an example of an advanced Business Rules solution!

The Rule Manager provides the additional functionality of Rule Authoring, Rule Repository Rule Verification & Validation. Only by empowering the business users with a complete business rules tool set, you will achieve a truly agile business policy that becomes transparent within your organization.

Here are the details of the Live Webcast:

Event Name: Webcast: Introduction to Windows Workflow Foundation Rules - Part II

Start Date: 7/6/07
Start Time: 1:30 PM (GMT-05:00) Eastern Time (US & Canada)
End Time: 3:00 PM (GMT-05:00) Eastern Time (US & Canada)
Audio conferencing: +1 (866) 500-6738
Participant code: 7545634
Presenter code: 9070863

Click on this link for more information regarding this Webcast

A Test suite for business rules

2007-06-28T08:10:00.000-07:00

I mentioned in a previous posts that the rule validation in the interactive rule map (cause-effect graph between terms and rules) is part one of the rule validation.

In the image on the right (click to zoom) you see the second part that is currently being developed. Test cases that are created in the interactive rule map can be saved to a test suite. A test suite (a collection of test cases for business rules) can be executed in a batch process.

For every test record we compare the user defined expected value with the rules engine computed value. Any discrepancies are flagged with a red info, and the test record would be marked red to indicate a failure. Green test records have all computed values equal to the business users defined expected values.

In the output terms you have to indicate which term you want to set as a goal for the rules engine. One test suite can process multiple goals. But every test record can only have one goal defined.

Similar to the meta information on a business rule, a test record contains the meta information of who the author is, when it was created, a description field etc.

You can imagine that among business users a difference of opinion might exists what the expected outcome value must be for a particular situation. We can not say what is right or wrong withing a rule policy, but we can show there is a difference.

Finally, the test suite can be used perfectly for regression testing your rule policy and can give a good impact analysis what happens when you modify your rule policy.

Microsoft XPS format

2007-06-11T17:31:00.000-07:00

During a web demonstration of the Rule Manager I had to go for a full OS reboot. Not very pretty for a product demonstration. What happened? Not really sure, but it seems that the latest version of Adobe Acrobat (8.1.0) started to lock the generated Rule PDF report.

Few days later I started to get the forced updates from Adobe. Considering I have many VM installations to test all different platforms and configurations, you can imagine I'm not too happy with these forced downloads.

Finally the free PDF viewer started to contain advertisement to FedEx. These 'convenient' link buttons are always a big annoyance to me.

It was time to provide an alternative to the PDF format. The latest release of the Rule Manager (1.5.0.17) supports now the Microsoft XPS as an alternative.

The good part of this is that an XPS viewer comes pre-installed on Microsoft Vista. I'm not really sure if it is part of .NET 3.0 framework, but on my XP SP2 box I could use the XPS viewer as well.

Currently the Adobe PDF format is still the default report format, but you can easily change that (and we will store your preferences in your user settings)

The main shortcoming I currently see with the XPS viewer is that you can not rotate a page.

Here are the results:
XPS: http://www.acumenbusiness.com/portals/Loan%20Mortgage%20Approval.xps
PDF: http://www.acumenbusiness.com/portals/Loan%20Mortgage%20Approval.pdf

Rule Manager 1.5.0.x is released

2007-06-04T16:24:00.000-07:00

The new Rule Manager (1.5.0.x) is released! There are many new features and enhancements. Here are some of the highlights:

Rule Validation; in the interactive rule map you can let the rules engine resolve any term.
This starts an animated goal seeking process. The default waiting time is 0.5 sec. You can change this in the debug options.
Panning and zooming of the interactive rule map.
Creation of business rules and business terms are completely accessible during the trial period.
Export your rule policy to Windows Workflow Foundation, and you see the rules executing on top of Microsoft's Forward chaining rules engine. By default the rule tracing is on. You can see the rule execution in the output console of Visual Studio.

Existing users can follow the internal update wizard (except that you need the .NET Framework 3.0)

New users can start the installation wizard that is available here.

Suppress “A first chance exception of type…” Messages in VS 2005

2007-05-26T07:41:00.000-07:00

When writing an API framework, it's good practice to throw appropriate framework exceptions. I have several extended application exceptions in my rule engine framework. When executing all unit tests, or just stepping through the development code, I would see hundred of messages in Visual Studio of 'A first chance exception of type' ...
This is just perfect behavior from my development point of view. I'm throwing these exceptions myself from the framework. I've made several attempts to find how to disable these messages. And finally I found the answer on Peter Macej blog:

How To Disable “A first chance exception of type…” Messages in VS 2005

So how do we suppress the messages? You most likely see these messages in
Immediate Window because you have set Redirect all Output Window text to the
Immediate Window in Tools - Options… - Debugging - General. That’s why when you
right-click in Immediate Window, you cannot see any option to disable messages.
It’s Output Window text and thus you need to set it in the Output Window. So
open Output Window, right-click and uncheck Exception Messages from context
menu. Simple but it took me one hour to find it.

It was just a simple context menu option on the Output window: Uncheck the 'Exception Messages'.

I was always trying to do this somewhere in the Debug \ Exceptions form. Well I'm glad I found it. It makes the Output windows trace less convoluted with irrelevant messages.

WebCast about Windows Workflow Foundation Rules

2007-05-17T18:29:00.000-07:00

Tomorrow, there is a free webcast by Kavita Kamani (Microsoft) about using the rules engine that is part of Windows Workflow Foundation. You can register for this event here.

Microsoft's rules engine is a bare bones forward-chaining rules engine. The rule engine can also be invoked without using the workflow engine. When you export a business rule policy from the Rule Manager, it will generate a C# solution that illustrates how rules are invoked without the workflow engine.

Start Date: 5/18/07
Start Time: 2:00 PM (GMT-05:00) Eastern Time (US & Canada)
End Time: 3:30 PM (GMT-05:00) Eastern Time (US & Canada)

Rule Validation Video

2007-03-30T10:40:00.000-07:00

The Rule Manager will soon be enhanced with a new feature that allows the Interactive Rule Map as a Rule Debugger. See a video here: Rule Validation Video. It almost became an action movie :).

This is part one of providing Rule Validation (that is: testing your rules) with the Rule Manager.

Color legend for Rule:

Green: Rule fired
Red: Rule failed
Orange: Rule is pending

Color legend for Term:

Green: Term is assigned
Orange: Term is unknown

How it works? We use the backward chaining algorithm to resolve a goal. The user can select any business term as a goal.

When the user clicks resolve, the inference engine will try to resolve this goal by executing the rules.
When a term is encountered that can not be derived from other rules, an ask dialog will be shown to the user. The user value will be stored into an internal table, so consecutive runs will first use this table before asking the user. Internally the rule manager supports defining restrictions on business terms. This allows the inference engine to show input options when asking a value for a term.

About the user data value table:

The table can be cleared by clicking on 'Reset All Values' from the context menu.
You can change the value of one particular term by selecting the 'Reset Term' on the Term context menu.
Note: also business terms that are inferred by the inference engine can be overwritten by the user. Be careful with this because this would skip the backward-chaining of this rule branch.

13 years ago

2007-03-24T15:42:00.000-07:00

Found my old research paper from 1994 "An object-oriented approach to knowledge representation in a biomedical domain". Looked like they scanned the contents of the original paper.

It's pretty outdated. Note that this was before the existence of Java or C#, but there was good old Smalltalk.

One thing is still relevant. The construction of a hybrid knowledge based system. Translated to 2007; the semantic web 3.0. Defining a clear terminological component (vocabulary) in order to make assertions from basic facts.

Importing Biztalk rules and export to Windows Workflow Foundation

2007-03-14T19:45:00.000-07:00

The new Rule Manager (version 1.4.0.50) is released!

With just a few mouse clicks, the Rule Manager from Acumen Business imports a BizTalk rule policy and export the rules to the Windows Workflow Foundation format.

The export generates a complete Visual studio solutions. This includes the .rules file, the Business Object model and the code that calls Windows Worklow Engine.

And voila, here is the results of a CarDiagnosis example with the recommendation that I have to get 'Fuel'

It's just a console output, but you hopefully get the idea. It's an executable solution that can be incorporated into the IT infrastructure.

I don't think we can make it any easier.

What you need:

Microsoft BizTalk 2006
.NET 3.0 (this includes Windows Workflow Foundation)
Acumen's Rule Manager with the BizTalk and Windows Workflow Foundation adapters

What you get:

Your BizTalk rule policy converted to Windows Workflow Foundation. The best part is that the Windows Workflow Foundation is free and is included in the .NET 3.0 framework.

Business Rules for the Windows Workflow Foundation

2007-03-13T10:12:00.000-07:00

If you like to see the latest version of the RuleManager with support for Microsoft Windows Workflow Foundation, you can request to see the product in action at the Business Rules Forum. Fill in the form here.

The image shows the imported DiscountRuleSet from the Microsoft Windows Worklow Foundation advanced policy example.

How to understand a large ruleset?

2007-01-26T06:31:00.000-08:00

Peter Lin has a very valid concern :

My main caution to users is that no matter how nice the writing part is, how
does the tool make it easier to maintain and understand a large ruleset? Does it
have the ability to analyze the rules and show the relationship to the user?

At Acumen Business (where I work), we have addressed this issue by the introduction of the Interactive Rule Map. Sometimes also referred to as Rule Spider. This dynamic rulemap shows the direct dependencies of rules-to-terms and from terms-to-rules.

There is also a complete Rule Graph generation, however that will quickly loose it’s power when hundreds of rules are defined. The interactive rule map is an advanced browser that shows parts of the rule graph.

Currently we are doing some research to integrate the Rule Validation into the Interactive Rule Map. This allows step through debugging of the just the business rules. Our prototype is looking very promising.

What is missing in WWF rules

2007-01-26T06:07:00.000-08:00

There is an interesting discussion going on how WWF rules is different from a BRMS solution. Although some comparisions are more related to the comparison with QuickRules.NET, there are quite a few valid points.

The argument list WWF Rules vs. BRMS rules will soon have to be rewritten. Acumen Busines is in the process of providing their tool components for WWF. This will include

Rule Repository
Rule Validation and Verification
Rule Animation
Rule Reporting

Stay tuned.

Decision Tree Editor

2007-01-23T14:21:00.000-08:00

In previous posts I have mentioned the usage of Decision Trees or Decision Tables to represent business rules.

Acumen Business has developed an editor to create such Decision Tree rules. See the video here. The decision tree can be viewed in horizontal or vertical layout.

In order to effectively use such a format on rule execution; the runtime inference engine must support this kind of rule directly. Unfortunately BizTalk does not support this out-of-the-box. CA's RuleSp (or the new Aion) does support Decisions Tree natively in their inference engine. Corticon's rule sheets are also very similar to this Decision Tree format. Although it seems that it models a rule sheet like a decision table, the fact that certain branches can be overriden makes it more a decision tree. I'm pretty sure that Blaze and Ilog have something similar as well.

The article that started it all?

2006-12-04T17:56:00.000-08:00

Business Process Trends had an article posted by Steve Minsky who gave the example:

If a customer has good credit then assign a credit rate of 6
If a customer has good credit then assign a credit rate of 8

These rules, however syntactically correct, contradict each other; they would cause the arbitrary assignment of a credit rating of “6” to some customers and “8” to others. This intermittent kind of business logic error is extremely difficult to diagnose with even state of the art testing tools. After the system goeslive, it may be months with unknown losses of customers or unprofitable accounts until the error is detected and corrected.

Extremely difficult yes, but Acumen Business has put this functionality inside their Rule Manager. Discover your anomalies in Biztalk policies with the brand new Rule Manager here.

Note: that rules that use facts from assemblies in the GAC are causing problems on the rule anomaly algorithms. This hopefully will be addressed soon.

Rule Animation

2006-11-06T19:53:00.000-08:00

Business Rules Manager 1.4.0.20 showing the new enhancements in the Interactive Rule Map.

Discovery of new galaxies?

New Policy Verificator release

2006-10-31T21:30:00.000-08:00

Acumen Business has just released the beta version of the new Policy Verificator that supports BizTalk 2006.

Major enhancements are made in the Interactive Rule Map (rule spider). There is a new free text search. And of course all the previous functions of Printing BizTalk Rules and Merging Vocabularies are available.

BizTalk v.s. Windows Workflow Foundation

2006-01-14T14:35:00.000-08:00

I just got the MSDN in the snail mail box and was reading this morning about the new Windows Workflow Foundation (WWF). There is a strong similarity with Biztalk in regards to the Workflow part of BizTalk.

There are some other comments about this comparison. See Darren . Combine this with the news that Scott Woodgate has left the project, I wonder where the BizTalk product is heading to.

Brian Loesgen has published a nice comparison table of BizTalk features v.s. Windows Workflow Foundations.

New functions in BizTalk 2006 Rule Editing

2005-11-29T07:23:00.000-08:00

There is an excellent blog article writen by Richard Seroter on how to enable static methods in the BizTalk 2006 rule engine. Seems that for the time being you have to get into the registry. I wonder why these essential functions are always hidden? Are there any caveats?

You can read it here

Let's see if it will make it into the the final release. This would eliminate the need for all these simple .NET conversion functions that are needed currently with BizTalk 2004. No need to wrap it in an IFactCreator, and no need to create an instance to test the rules.

New features in the Policy Verificator

2005-11-14T15:57:00.000-08:00

Acumen Business has announced the next release of the Policy Verificator. The 1.3 release contains some interesting new features
1. Generation of a full rule dependency network graph.

2. Interactive rule dependency Graph

There is also a gettingstarted page that guides you through one of the examples.

You can download the product here

RPC server is unavailable

2005-10-05T22:26:00.000-07:00

SSO -> RPC server is unavailable.

I had problems with the Single Sign On (SSO) to get authentication to execute a SOAP request (or so I thought)
In one of my actions of trying to resolve it, I tried to reset the SSO server name to the machine name. This is something I absolutely should not have done!


C:\Program Files\Common Files\Enterprise Single Sign-On>ssomanage.exe –serverall Namgang

C:\Program Files\Common Files\Enterprise Single Sign-On>ssomanage.exe –server Namgang

This did result in the error “The RPC server is unavailable” for almost all of the ssomanage.exe and ssoconfig.exe commands:



C:\Program Files\Common Files\Enterprise Single Sign-On>ssomanage.exe -displaydb
Using SSO server : sso

SQL Server                                               : namgang
SSO database                                             : ssodb

ERROR: 0x800706BA : The RPC server is unavailable.

The google searches on “RPC server is unavailable” and “BizTalk” or “SSO” did not give me any clue what kind of trouble I just created. So here is my little contribution for others:

I thought the SSO server name would be my machine name, but after hours (almost days) I found out that the original sso server name was not my machine name, but the IP address!
I found this by running the rpcdump.exe utility. After resetting the SSO server name to the IP address for –serverall and –server, I had it up and running again.

C:\Program Files\Common Files\Enterprise Single Sign-On>ssomanage.exe -server 192.168.1.101
The operation completed successfully.

C:\Program Files\Common Files\Enterprise Single Sign-On>ssomanage.exe -serverall 192.168.1.101
The operation completed successfully.


C:\Program Files\Common Files\Enterprise Single Sign-On>ssomanage.exe -displaydb
Using SSO server : 192.168.1.101

SQL Server                                               : namgang
SSO database                                             : ssodb
SSO secret server name                                   : NAMGANG
SSO Admin account name                                   : SSO Administrators
SSO Affiliate Admin account name                         : SSO Affiliate Administrators
Size of audit table for deleted applications             : 1000
Size of audit table for deleted mappings                 : 1000
Size of audit table for external credential lookups      : 1000
Ticket timeout (in minutes)                              : 2
Credential cache timeout (in minutes)                    : 60
SSO status                                               : Enabled
Tickets allowed                                          : No
Validate tickets                                         : Yes

Sent the rpddump.exe to a output.txt file, and you can examine the dump with notepad.


C:\Program Files\Resource Kit>rpcdump.exe /V > output.txt

Or look specific at an IP address and notice the SSO servers


C:\Program Files\Resource Kit>rpcdump.exe /s 192.168.1.101
Querying Endpoint Mapper Database...
78 registered endpoints found.

ncacn_ip_tcp(Connection-oriented TCP/IP)
  192.168.1.101[1030] [1b6a54d8-0f2a-47b2-b934-e876b711eb19] SSOSecretServer :NOT_PINGED
  192.168.1.101[1030] [87632da4-2f1c-4e92-953a-41306b36c095] SSOCSServer :NOT_PINGED
  192.168.1.101[1030] [87a18bff-b7a4-4d79-a996-b9811cd73c94] SSOLookupServer :NOT_PINGED
  192.168.1.101[1030] [416767be-be19-433e-91c3-4ad2ed88dede] SSOAdminServer :NOT_PINGED
  192.168.1.101[1030] [906b0ce0-c70b-1067-b317-00dd010662da]  :NOT_PINGED
  192.168.1.101[1030] [fe1bcf2e-700c-47ca-b47b-7d1c8688307f] SSOMappingServer :NOT_PINGED
  192.168.1.101[1025] [82ad4280-036b-11cf-972c-00aa006887b0]  :NOT_PINGED

              […deleted…]

rpcdump.exe completed sucessfully after 1 seconds

Scalable Vector Graphs

2005-09-29T11:11:00.000-07:00

I've been searching a long time how to draw a diagonal line with just standard Web features (HTML, CSS, DIV, etc). Most of the time I end up at Scalable Vector Graph (SVG). However there has not been a wide spread support for this technology on the client side. Microsoft is betting it's money on it's 'own' standard Avalon.

The W3C has one little note, that diagonal layout might be done without SVG, but the follow up link to these details is broken.

Today to my pleasant surprise, I stumbled on the information that Mozila has native support for SVG! This is opening a big door to get .SVG files to the clients desktop. Here is a view of a rule network dependency graph. Probably of more interest is the automatic detected rule contradiction. This rule anomaly was detected by the Policy Verificator that supports rendering SVG files.

For those stuck with Internet Explorer: you can view .SVG files with the Adobe plugin.

2005-09-29T10:41:00.000-07:00

BizTalk Rules engine scalibility

2005-09-20T09:00:00.000-07:00

When exploring different rule base vendors, you probably encounter references to the RETE algorithm by Charles Forgy. This algorithm has proven itself to scale well for very large ruleset.
In all my years of experience, I've never encountered a client with more than 500 rules in a single rule policy. The reason is not any scalability issues on inference engines. The reason is simple. It is difficult for a business expert to

manage a very large rule policy
maintain a very large rule policy
verify and validate a large rule policy

As with any complexity, the divide and conquer strategy works very well. Split the large policy into smaller parts.
But for those who like to push the limits and see how well the BizTalk inference engine scales, you might like to read the article Microsoft's Rule Engine Scalability Results - A comparison with Jess and Drools, by Charles Young.

BizTalk Throughput and Capacity Tester

2005-09-20T08:33:00.000-07:00

In the category essential tools for the BizTalk consultant; here we have the Throughput and Capacity Tester made by Larry Beck. What else can we ask for?

Update: The new release has been renamed to BTSPerfTester 1.0

The BizTalk Performance Tester (the Tester) is an application intended to assist architects and developers quantify the performance characteristics of their BizTalk solutions. The application meets this objective by performing stress tests against the target solution and monitoring the application performance.

Policy Verificator 1.1 released

2005-04-16T20:54:00.000-07:00

Acumen Business released the Policy Verificator version 1.1. An all new UI is designed what should significantly increase the usability issues from the initial release. Specially of interest is the inclusion of Datetime support for rule verification as well as support for the standard Microsoft Biztalk functions and predicates.

log4net - 1.2.9 Beta release

2005-03-30T09:09:00.000-08:00

Log4net development is showing signs of life! After a long period of silence the 1.2.9 Beta has been released. Some highlights of the list of new features:

New logging contexts

GlobalContext
ThreadContext
LogicalThreadContext
LoggingEvent

.NET string formatting syntax
Customizable levels
RollingFileAppender roll once
SmtpAppender authentication
... and more

Instrumentation - Logging

2005-03-16T16:07:00.000-08:00

I started of with log4j in my Java days, and was quick with adopting another fine .NET port: log4net.

But for work, we had to consider Microsofts Enterprise Instrumentation Framework (EIF). But a little more reading revealed that this package is getting replaced with the newly designed Enterprise Library. This framework not only contains Logging, but also a design pattern for Configuration, Data Access, Exception handling, Security, etc.

The Enterprise Library is all looking pretty o.k. but it seemed to be overly designed, over complicated and getting pretty slow. Also on migrating from one Microsoft packages to another: there is no migration path. And no support is mentioned for the future. Seems like this is going for a Corba-death: Beautifully designed, complicated to use, and slow.
For a comparison overview see Daniel Cazzulino's EIF vs log4net feature comparison char

I always like fast and simple. So that takes me back to log4net. The only concern I have with log4net is that the latest view builds on Sourceforge all refer to beta releases that seems to be quite dated. But till so far I never had any issues with this latest beta release.

Scott Colestock also has been writing how log4net can be integrated with Biztalk 2004. So what else are we waiting for. Let me put in my 2 cents for some documentation on the conversionPattern:

The conversionPattern format

The conversion pattern is closely related to the conversion pattern of the printf function in C. A conversion pattern is composed of literal text and format control expressions called conversion specifiers.

You are free to insert any literal text within the conversion pattern.

Each conversion specifier starts with a percent sign (%) and is followed by optional format modifiers and a conversion character. The conversion character specifies the type of data, e.g. category, priority, date, thread name. The format modifiers control such things as field width, padding, left and right justification. The following is a simple example.


<appender name="FileAppender" type="log4net.Appender.FileAppender">
    <file value="c:\\log\\My.log">
    <appendtofile value="true">
    <layout type="log4net.Layout.PatternLayout">
        <conversionpattern value="%-5p [%t]: %m%n"/>
    </layout>
    </appender>

Then the statements


private static readonly log4net.ILog log = log4net.LogManager.GetLogger(typeof(MyType));
log.Debug("Message 1");

would yield the output

DEBUG [MyType]: Message 1

Note that there is no explicit separator between text and conversion specifiers. The pattern parser knows when it has reached the end of a conversion specifier when it reads a conversion character. In the example above the conversion specifier %-5p means the priority of the logging event should be left justified to a width of five characters. The recognized conversion characters are

Conversion Character	Effect
c	Used to output the category of the logging event. The category conversion specifier can be optionally followed by precision specifier, that is a decimal constant in brackets. If a precision specifier is given, then only the corresponding number of right most components of the category name will be printed. By default the category name is printed in full. For example, for the category name "a.b.c" the pattern %c{2} will output "b.c".
C	Used to output the fully qualified class name of the caller issuing the logging request. This conversion specifier can be optionally followed by precision specifier, that is a decimal constant in brackets. If a precision specifier is given, then only the corresponding number of right most components of the class name will be printed. By default the class name is output in fully qualified form. For example, for the class name "org.apache.xyz.SomeClass", the pattern %C{1} will output "SomeClass". WARNING Generating the caller class information is slow. Thus, it's use should be avoided unless execution speed is not an issue.
d	Used to output the date of the logging event. The date conversion specifier may be followed by a date format specifier enclosed between braces. For example, %d{HH:mm:ss,SSS} or %d{dd MMM yyyy HH:mm:ss,SSS}. If no date format specifier is given then ISO8601 format is assumed. The date format specifier admits the same syntax as the time pattern string of the `SimpleDateFormat`. Although part of the standard JDK, the performance of `SimpleDateFormat` is quite poor. For better results it is recommended to use the log4j date formatters. These can be specified using one of the strings "ABSOLUTE", "DATE" and "ISO8601" for specifying `AbsoluteTimeDateFormat`, `DateTimeDateFormat` and respectively `ISO8601DateFormat`. For example, %d{ISO8601} or %d{ABSOLUTE}. These dedicated date formatters perform significantly better than `SimpleDateFormat`.
F	Used to output the file name where the logging request was issued. WARNING Generating caller location information is extremely slow. It's use should be avoided unless execution speed is not an issue.
l	Used to output location information of the caller which generated the logging event. The location information depends on the JVM implementation but usually consists of the fully qualified name of the calling method followed by the callers source the file name and line number between parentheses. The location information can be very useful. However, it's generation is extremely slow. It's use should be avoided unless execution speed is not an issue.
L	Used to output the line number from where the logging request was issued. WARNING Generating caller location information is extremely slow. It's use should be avoided unless execution speed is not an issue.
m	Used to output the application supplied message associated with the logging event.
M	Used to output the method name where the logging request was issued. WARNING Generating caller location information is extremely slow. It's use should be avoided unless execution speed is not an issue.
n	Outputs the platform dependent line separator character or characters. This conversion character offers practically the same performance as using non-portable line separator strings such as "\n", or "\r\n". Thus, it is the preferred way of specifying a line separator.
p	Used to output the priority of the logging event.
r	Used to output the number of milliseconds elapsed since the start of the application until the creation of the logging event.
t	Used to output the name of the thread that generated the logging event.
x	Used to output the NDC (nested diagnostic context) associated with the thread that generated the logging event.
X	Used to output the MDC (mapped diagnostic context) associated with the thread that generated the logging event. The X conversion character must be followed by the key for the map placed between braces, as in %X{clientNumber} where `clientNumber` is the key. The value in the MDC corresponding to the key will be output.
%	The sequence %% outputs a single percent sign.

By default the relevant information is output as is. However, with the aid of format modifiers it is possible to change the minimum field width, the maximum field width and justification.

The optional format modifier is placed between the percent sign and the conversion character.

The first optional format modifier is the left justification flag which is just the minus (-) character. Then comes the optional minimum field width modifier. This is a decimal constant that represents the minimum number of characters to output. If the data item requires fewer characters, it is padded on either the left or the right until the minimum width is reached. The default is to pad on the left (right justify) but you can specify right padding with the left justification flag. The padding character is space. If the data item is larger than the minimum field width, the field is expanded to accommodate the data. The value is never truncated.

This behavior can be changed using the maximum field width modifier which is designated by a period followed by a decimal constant. If the data item is longer than the maximum field, then the extra characters are removed from the beginning of the data item and not from the end. For example, it the maximum field width is eight and the data item is ten characters long, then the first two characters of the data item are dropped. This behavior deviates from the printf function in C where truncation is done from the end.

Below are various format modifier examples for the category conversion specifier.

Format modifier	left justify	minimum width	maximum width	comment
%20c	false	20	none	Left pad with spaces if the category name is less than 20 characters long.
%-20c	true	20	none	Right pad with spaces if the category name is less than 20 characters long.
%.30c	NA	none	30	Truncate from the beginning if the category name is longer than 30 characters.
%20.30c	false	20	30	Left pad with spaces if the category name is shorter than 20 characters. However, if category name is longer than 30 characters, then truncate from the beginning.
%-20.30c	true	20	30	Right pad with spaces if the category name is shorter than 20 characters. However, if category name is longer than 30 characters, then truncate from the beginning.

Below are some examples of conversion patterns.

%r [%t] %-5p %c %x - %m\n: This is essentially the TTCC layout.
%-6r [%15.15t] %-5p %30.30c %x - %m\n: Similar to the TTCC layout except that the relative time is right padded if less than 6 digits, thread name is right padded if less than 15 characters and truncated if longer and the category name is left padded if shorter than 30 characters and truncated if longer.

References:

Loren Halvorson's Blog: Microsoft Enterprise Library Logging Block compared to Log4net
Daniel Cazzulino's Blog: EIF vs log4net feature comparison
Scott Colestock Blog: Diagnostic Tracing with BizTalk 2004
Log4j API: Pattern Layout

Book Offer: Microsoft BizTalk Server 2004 unleashed

2004-10-15T07:54:00.000-07:00

The book (by Scott Woodgate, Stephen Mohr, Brian Loesgen ISBN 0-672-32598-5) seems to be getting into it's final stage. There was a page advertisement in the MSDN magazine of November 2004 (Vol 19 NO 11 Page 108) offering a 30% discount for ordering the book from SamsPublishing.com (plus free shipping).

On Sams website I could not find any link or discount coupon. I opened an issue with Customer Service and they are contacting the Sams Marketing to inquire how we can get the 30% discount.

Update (18 Oct 2004):

I received an email from the Sams Marketing with the following information: In order to get the 30% discount you have to use the coupon code BIZTALK (note it must be all caps!). You enter the coupon code on the 'Payment Method' page in the order process. A review of the discount will be shown on the 'Place Order' page. The offer is valid till the Dec 15.

In a couple of days Sams website will provide a direct link.

Biztalk Competition Winners

2004-09-16T07:59:00.000-07:00

Scott Woodgate published the list of Biztalk Competition Winners. The vocabulary upgrader got mentioned at point F!

The Vocabulary Upgrader is also available at Acumen Business. Also available on this site is the automatic Business Rule Verification;
the Policy Verificator.

BizTalk Vocabulary Upgrader goes beta

2004-08-31T12:21:00.000-07:00

The BizTalk Vocabulary Upgrader has gone into beta.
The Vocabulary Upgrader enables to replace multiple references to different versions of a vocabulary to a single vocabulary version.

Have a look at the documentation, screenshots, getting started guide.

The tool is submitted to the Microsoft BizTalk Developers competition.

Dilbert on Circular Reasoning

2004-08-04T09:02:00.000-07:00

With BizTalk 2004 it is possible to end up in 'execution loops', often this is referred to as circular reasoning. I was looking for some examples. Dilbert had the following illustration. Although it doesn't beat the example in the previous post.

Bush on Circular Reasoning

2004-08-04T08:43:00.001-07:00

In the New York times [published June 18,2004]:

The New York Times > Washington > Bush and Cheney Talk Strongly of Qaeda Links With Hussein: "Mr. Bush, responding to a reporter's question about the report after a White House cabinet meeting yesterday morning, said: 'The reason I keep insisting that there was a relationship between Iraq and Saddam and Al Qaeda' is 'because there was a relationship between Iraq and Al Qaeda.' "

A great example of circular reasoning!

Download details: BizTalk Server 2004 Product Documentation

2004-07-27T06:43:00.000-07:00

There is a new updated product documentation for BizTalk Server 2004 (7/23/2004).
Download details: BizTalk Server 2004 Product Documentation. There is a lot of new material about the Rule Engine, Engine Control Functions, Rule Action Side Effects etc.

BizTalk Server 2004 FAQ

2004-07-14T11:25:00.000-07:00

A great resource for all those BizTalk 2004 server questions you have not found an answer for yet:

BizTalk Server 2004 FAQ - netologi.se

Windows XP SP2 - BizTalk 2004

2004-07-14T07:48:00.000-07:00

The Service Pack 2 release for Microsoft XP has a lot of improvements on security settings. As a side-effect the regular install of the BizTalk 2004 Developers edition will fail at the Single Sign-On service.
It is all well documented by Microsoft, and easy to google if you know that the SP2 is responsible for the install failure, but just in case you did not make the link, read the article

The install failure is:

An unexpected error occurred while configuring the Single Sign-On server.
The service cannot be started, either because it is disabled or because it has no enabled devices associated with it.

Microsoft support article 841893 explains in detail how to resolve the issue by:

Using Gpedit.msc to enforce the authentication of client calls

Using Registry Editor to enforce the authentication of client calls

Watch your type

2004-06-28T12:21:00.000-07:00

A simple rule:

Conditions:

  Case:/Root/Income/BasicSalary 

    is less than or equal to 75.000

Actions:

  Case:/Root/IncomeStatus = approved

Would a basic salary of only 800 be approved? Or rephrasing: would the rule fire?
I expected it would. But the answer is "It depends". It depeneds on the type of BasicSalary! If the BasicSalary is of type System.String it will not!

CONDITION EVALUATION TEST (MATCH) 6/28/2004 12:29:10 PM

Rule Engine Instance Identifier: 29fea928-...

Ruleset Name: Simple

Test Expression: TypedXmlDocument: Case:/Root/Income.BasicSalary <= 75.000

Left Operand Value: 800

Right Operand Value: 75.000

Test Result: False

It seems that the rule engine allows string comparison. And in case of string comparison "800" would be larger than "75.000"! So watch your types! An interesting item to explain to the rule writer!

What about converting the BasicSalary to an Int32?
I tried to add a .NET class in the Business Rules Composer. Selected the mscorlib to add as an assembly and changed the condition to:

Conditions:

  Int32.Parse(Case:/Root/Income/BasicSalary) 

    is less than or equal to 75.000

Actions:

  Case:/Root/IncomeStatus = approved

Don't know how to handle exceptions here, but let's see what happens:
I reloaded the policy, and mysteriously the 75.000 value was changed to 75! But hey, they also changed the type from System.String to System.Double. Close, but no cigar.

Should I put in 75,000? No: that got interpreted as an error where a string can not be compared with an Int32. And the policy could not be saved.

Let's continue and remove any thousand separator:

Conditions:

  Int32.Parse(Case:/Root/Income/BasicSalary)

    is less than or equal to 75000

Actions:

  Case:/Root/IncomeStatus = approved

Reloading the policy and we notice that the 75000 literal has type System.Int32. So we got the right type in place now.

Enterering the next stage: Testing if the rule actual fires. We can not define an instance of System.Int32 because of a missing interface. We need a fact creator. Although the Int32.Parse function is just a static method, we still have to assert the fact in the rule engine. Testing without the fact creation results in no rule-firing.

Hang in there, we are getting close. We only have to create a helper class that implements the Microsoft.RuleEngine.IFactCreator (located in the Microsoft.RuleEngine.dll)


namespace MarcoSoft.Utils

{

  /// 

  /// Summary description for Converter

  /// 

  public class Converter: Microsoft.RuleEngine.IFactCreator {

    public Converter() {

    }



    public int stringToInt32(string value){

	return Int32.Parse(value);

    }



    #region IFactCreator Members

    public object[] CreateFacts(RuleSetInfo ruleSetInfo) {

      return new object[]{new Converter()};

    }



    public Type[] GetFactTypes(RuleSetInfo ruleSetInfo) {

      Type converterType = this.GetType();

      return new Type[]{converterType};

    }

    #endregion

  }	

}

This code has to be compiled with a strong name, and be placed in the Global Assembly Cache. On the Facts Explorer view of the MS Business Rule Composer we can add the created .NET assembly.
We update the condition with:

Conditions:

  Converter.stringToInt32(Case:/Root/Income/BasicSalary) 

    is less than or equal to 75000

...

And in the Test Dialog we add a Fact.Creator of the MarcoSoft.Utils.Converter
Running the code, and voila:


CONDITION EVALUATION TEST (MATCH) 6/28/2004 5:22:18 PM

Rule Engine Instance Identifier: 52c89cd5-...

Ruleset Name: Simple

Test Expression: MarcoSoft.Utils.Converter.stringToInt32 <= 75000

Left Operand Value: 800

Right Operand Value: 75000

Test Result: True

The result what I was expecting all along.

Mike Taulty's WSE 2.0 Tracing Utility.

2004-06-24T13:33:00.000-07:00

So you got all the certifications in place, and finally your secure SOAP service is receiving signed encrypted messages. Are you sure?

An essential tool to figure out what is happening (behind the SOAP scenes) when you use WSE 2.0: The WSE 2.0 Tracing Utility.

WSE 2.0 configuration challenge

2004-06-18T07:22:00.000-07:00

Security is important, especially when we have a B2B scenario where sensitive information has to be sent. Not too long ago, Microsoft released the Web Service Enhancement 2.0 package(WSE 2.0). Among other features like sending attachments with SOAP messages, it enables us to sent secure SOAP messages.
The amount of code to achieve this is not too much as shown with the shipped examples, but it’s the configuration of the client and server machine what is the challenge. There is good documentation what will get you a long way. But I ran into a little issue on “How to: Make X.509 Certificates Accessible to WSE”

Give the account under which WSE is running read access to the file containing the private key associated with the X.509 certificate.

Open the WSE X.509 Certificate Tool (WseCertificate2.exe)
Set the certificate location and store name where the certificate is located.
Click Select the certificate from the store, choose the certificate you
want to set the permissions for, and then click OK.
Click Open Private Key File Properties, click the Security tab, add the ASPNET or Network Service account, depending on which version of IIS the Web service is running under, and then select the Read option.

The missing documentation is that if the Security tab is not showing you have to make sure the following:

You need the NTFS file format.
Open the explorer and go to ->Folder Options, click on the View Tab, and deselect “Use simple file sharing [recommended]”

Step d. should now show the Security tab, and the Read access to the security file can
be set for the IE account (ASPNET or Network Service for IE 6.0)

XML rule engine - QuickRules

2004-06-15T18:18:00.000-07:00

Another Java based XML rule engine - QuickRules, I was not aware of. They also have a DecisionTable editor. The .NET integration goes through COM, so that is just a marketing line. There is also some workflow editing provided. But not on the level as the BizTalk 2004 orchestration. Anyway have a closer look at this product if Java (J2EE) is your target application server.

Idiom's: Decisions and Formulas

2004-06-09T11:20:00.000-07:00

So who was first Idiom or Microsoft? They both use the concept of defining the datamodel by XSD schema's and use drag-and-drop to place these elements in rule constructs. The advantage of Idiom here is that you seem to be able to show multiple rules at once. This is really missing in the Business Rule Capturing environment of MS Biztalk 2004. They also seem to be able to integrate with BPEL so that must be pretty close to Biztalk rules format. Have a look at their Decisions and Formulas demo.

What still surpise me is that also Idiom expects the Rule writer to define XSD schema's. Why can't we leave the technical binding to XSD, Databse, Java beans or C# components out of the Rule Definitions? Writing good business rules is already complicated enough!

A Basic Introduction to Messaging with Microsoft BizTalk Server 2004

2004-06-06T10:48:00.000-07:00

For a great introduction on Messaging in BizTalk 2004, read this article by Christof Claessens A Basic Introduction to Messaging with Microsoft BizTalk Server 2004. It is posted on MSDN Belgium - LuxemBourg.

NAnt for BizTalk 2004

2004-05-27T09:12:00.000-07:00

Continuous build and testing are essentail. Scott Colestock has a good article how NAnt (with extensions) can be used to handle the stop, unenlist, undeploy, redeploy, enlist, start, bounce BizTalk routine. Follow his article for downloading the extension and setting up the environment.

Power to the Business Expert

2004-05-26T10:00:00.000-07:00

With BizTalk 2004, Microsoft has entered the market of Rule Based solutions. For a first release I am quite impressed. Although the rule expressiveness is not on the level as the current established rule based providers, BizTalk 2004 has much more features than just expressing rules.

The data orchestration, security, single-sign-on etc is where the established rule based providers have been struggling with, and BizTalk 2004 has this all nicely integrated.

What kind of surprised me is that the Business Rule Composer (a tool that ships with BizTalk 2004) is still way to technical for the average Business Expert. And I really wonder why the Business Expert should make the mapping of the business vocabulary to the existing data structure.

The business expert definitely need a vocabulary, and he is the one who should create and maintain these terms and descriptions. But the mapping to a Database, XML document, or C# class implementation, is really for the IT person.

This is not the "what-is-first-chicken-egg-question". Whatever is available in the current datastream (database, xml-documents), should not influence the business logic (or policies how Microsoft refers to it). If the Business Experts want to express that e.g.
Hummer-SUV's are a much higher risk than regular SUV's for approving a car insurance, than it's not relevant if the data is currently already stored in a database, xml-document, or is not available yet. The Business Expert should be able to define the rules, and test the rules.

Also it could be that existing database structures are moved into XML documents, or are only made available through secure webservices. No matter what the IT-strategy is, the Business Rules should stay independent of the IT-strategy.

What I would like to see is that the Business Rules Composer has different user level entries.

One for the business expert: Purely defining it's logic, and be able to test this.

One for IT people (or Knowledge Engineers) who will map the used Business Terms to the appropriate datamodel, or generate functional requirements from the Business Users expressed needs on Terms what can not be mapped directly to an underlying data structure.

If I'm not mistaken the BizTalk API's are quite open, and this Blog will see how we can use the API's to further enhance BizTalk 2004 rule capturing environement.