Jeffrey Schlimmer's Blog

LINQ Framework Design Guidelines

jeffrey-schlimmer — Fri, 14 Mar 2008 01:56:00 GMT

You knew it was 'wrong' to define extension methods on object, didn't you...

http://blogs.msdn.com/mirceat/archive/2008/03/13/linq-framework-design-guidelines.aspx

Request for Input from WF

jeffrey-schlimmer — Thu, 13 Mar 2008 22:45:00 GMT

Request for input from the Windows Workflow Foundation Team:

“The Windows Workflow Foundation (WF) team is looking for YOUR input to help us prioritize our efforts around designer re-hosting scenarios. If you're interested in helping us shape the future of this feature, tell us what you think by filling in this survey.

https://live.datstat.com/MSCSD-Collector/Survey.ashx?Name=WF_Rules_Designer_Rehosting_Blogs

The survey will close on Wednesday, March 19th 2008.”

Long Live VSTS

jeffrey-schlimmer — Thu, 13 Mar 2008 22:29:00 GMT

I've become a believer in test-driven development, at least the part where you write the tests the code should pass _before_ you write the code itself. NUnit was a great tool for this -- and I loved seeing the green bar when all the tests pass.

Recently my team switched over to using VisualStudio Team System and converted our NUnit projects to VSTS test projects. As much as I like using NUnit, I like using VSTS even more:

It's very easy to debug a test -- just set a breakpoint (no more Debug, Attach to Process…)
It's easy to re-run only the failing tests
Tests are run on multiple threads -- which sometimes speeds up the process considerably

We've also replaced NCover with the integrated code coverage; there's nothing like editing the highlighted code.

Blog from the MSFT Rules Team

jeffrey-schlimmer — Wed, 18 Oct 2006 01:06:00 GMT

From the owners of both the BizTalk and Workflow Foundation rules engines:

http://blogs.msdn.com/rulesteam/

From the Horse's Mouth

jeffrey-schlimmer — Tue, 10 Oct 2006 19:32:00 GMT

Don McCrady now has a blog. He's the development lead for Windows Workflow Foundation's rules engine.

Recursive Linq Functions

jeffrey-schlimmer — Sat, 19 Aug 2006 04:57:00 GMT

You might have tried writing a recursive Linq function and run into problems. For instance, the following doesn’t work because ‘factorial’ isn't defined when the right-hand side of the assignment is being evaluated:

//Error: Use of unassigned local variable 'factorial'

Func<int, int> factorial =

n => n < 2 ? 1 : n * factorial(n - 1);

However, because you’re writing a lambda expression with Linq, you can use the Y combinator, a function that takes your code and returns a recursive version. It’s a bit odd, requiring no little attention to understand, but it works well. For instance, using the Y combinator, you can write the following code:

Func<int, int> factorial =

Extensions.YCombinator<int, int>(

fact =>

n => n < 2 ? 1 : n * fact(n - 1));

And then you can call it as you expect, e.g., factorial(5) returns 120.

Intuitively, the Y combinator works by calling your function on itself. Its ideas are closely related to self-reproducing code. For details, I recommend either “The Why of Y” or “Fixed Point Combinator.” Though cool, the Y combinator isn’t a panacea for all recursion – as Arvind et al note: “While the existence of the Y combinator is mathematically fascinating, fixed points [like the Y combinator] do not provide a simple encapsulation of recursion. For example, we would like to be able to declare mutually recursive functions and data structures in such a way that their definitions are clear and readable; the need to re-shape such definitions as fixed points plays havoc with such an endeavor.”

Here is an implementation of the Y combinator for Linq that Mads Torgersen and I wrote, for both delegates and expressions. (The expression implementation will be a lot simpler when Linq provides an invocation syntax for expressions.)

Updated WS-MetadataExchange

jeffrey-schlimmer — Wed, 16 Aug 2006 21:10:00 GMT

BEA, CA, IBM, SAP, Sun, webMethods, and Microsoft have updated the WS-MetadataExchange (MEX) spec. It adds the ability to 'push' metadata along with an Endpoint Reference (of either version), and it replaces its locally-defined "Get" request-reply message pair with the one from WS-Transfer.

http://schemas.xmlsoap.org/ws/2004/09/mex/

Programming Whimsy

jeffrey-schlimmer — Mon, 07 Aug 2006 18:49:00 GMT

From Why's (Poignant) Guide to Ruby:

"Think of it [the argument list] as an inner tube the method is pulling along, containing its extra instructions. The parentheses form the wet, round edges of the inner tube. The commas are the feet of each argument, sticking over the edge. The last argument has its feet tucked under so they don't show."

http://www.poignantguide.net/ruby/chapter-3.html

New WF Rules Sample

jeffrey-schlimmer — Tue, 25 Jul 2006 19:08:00 GMT

Demonstration of custom action types c/o my favorite rules PM.

http://wf.netfx3.com/files/folders/rules_samples/default.aspx

Custom Rule Expressions in WF: Sample

jeffrey-schlimmer — Thu, 13 Jul 2006 20:13:00 GMT

Just in from one of the original BRE developers and my favorite rules PM: This sample shows the definition and use of a custom expression in the Windows Workflow Foundation rules engine. Custom expressions are used to model specific predicate types or functions and can be used directly in the rules object model and editors.

http://wf.netfx3.com/files/folders/rules_samples/entry4315.aspx

Understanding Policy

jeffrey-schlimmer — Thu, 06 Jul 2006 22:17:00 GMT

Asir and Dan just published a nice white paper (almost tutorial) on WS-Policy and WS-PolicyAttachment.

Using WF Rules Outside a Workflow

jeffrey-schlimmer — Mon, 26 Jun 2006 23:46:00 GMT

Moustafa demonstrates how: http://blogs.msdn.com/moustafa/archive/2006/05/21/603415.aspx .

European Business Rules Conference -- Day 2

jeffrey-schlimmer — Thu, 15 Jun 2006 01:25:00 GMT

http://www.eurobizrules.org/

Net: Another dose of concrete data and experience at a well-run conference.

Memes: Office is the most widely used business rules tool (if not the best), complex business policies drive adoption (e.g., government compliance).

Michael Azoff (Butler Group), Realising the Potential of Business Rules Automation: Covered a wide range of trends, alternating between laudable goals and candidate feature lists. He repeated a now-oft citation to eBay's adoption of rules.

Tom Debevoise (Business Knowledge Architects), Open-Source Business Rules: A Cast Study: Covered three Java-centric open-source rules efforts: OpenRules, Drools (now JBoss Rules), and his own OpenLexicon. On one hand, OpenRules has an Excel front-end, making it the most approachable of the three for a business user, and on the other, JBoss Rules is the most powerful engine, perhaps most appealing to a developer. Bonus: Tom autographed free copies of his book Business Process Management With a Business Rules Approach!

Caspar Fall (ELCA), Applying an Open-Source Business Rules Engine to Validate Questionnaire Responses: Hearing that customers want flexibility, system integrator authored some 50 rules in Visio (!) using NxBre on .NET to validate annual census data required by the Swiss federal government for some 2,300 health-care institutions.

Ronnie Keiser (SD Worx), Integration of Business Rules - A Case Study: To calculate salaries for some 600,000 Belgian employees, system integrator built their own rules engine (5 man years): existing engines don't focus on implementing legislation, by definition, rules are active during specific windows in history, and they want to target field experts. The result integrates with Word doing integrated calculation on forms, and with Outlook filing incoming calculation requests and replying with PDF reports.

Qusai Sarraf (Ivis Group), Business Rules in the Real World - The Tesco.com Story: The largest online retailer uses rules technology, but apparently of a fairly different sort than other applications because rules map unstructured into structured data (for example), allowing so-called 'semantic search'.

European Business Rules Conference -- Day 1

jeffrey-schlimmer — Wed, 14 Jun 2006 02:45:00 GMT

Here's a synopsis of my first day at the conference (http://www.eurobizrules.org/).

Net: with about 75 in attendance, it's a cozy gathering of the faithful, an excellent environment to get up close and personal with those who are inventing or using the latest in rules technology. I love it!

Memes: rules add consistency to business decisions, distinct roles of business user and IT developer.

Ron Ross (Business Rule Solutions), Business Rules - Getting to the Point of Knowledge: Emphasizing the need to help front-line knowledge workers, Mr. Ross encouraged the audience to adopt a rules approach even if they weren't ready to invest in a rules engine and even for rules that wouldn't be automated on a computer. (E.g., "A hard hat must be worn on a construction site.") He used the OMG's Semantics of Business Vocabulary and Business Rules (SBVR) categorization to highlight key rule distinctives.

Mark Harrison (Dresdner Bank) and Julian Fowler (ILOG), Accounting Compliance in Your Financial Architecture: Motivated initially by the need to comply with new legislation, Mr. Harrison explained how Dresdner is now motivated to continue with their global rules solution to improve efficiency and to support new business opportunities. Their near-term architecture normalizes input from each of 6 trading locations to a single input format to about 3,000 ILOG rules that then generate postings into a subordinate ledger.

Jan Vanthienen (Katholieke Universiteit Leuven), Mastering Quality and Agility by the Business: Reminding of the value of different representations for different purposes, Dr. Vanthienen highlighted advantages of decision tables over text rules, including how decision tables are complete and consistent by construction and how such tables can be divided into orthogonal tables (using something like Karnaugh maps). Viewing process control as an application of rules, he noted wryly that flowcharts were replaced with structured programming (for good reasons) but that we now seem to be going back to flowcharts as a way to specify processes.

Pierre Haren (ILOG): An impressive demonstration of authoring environments for "business users" (Web based forms) and for "IT developers" (on Eclipse) showing how easily they could collaborate to update decision logic behind an on-line insurance quote system.

Anne Braidwood (UK Ministry of Defence) and Peter Still (RuleBurst), A New Armed Forces Compensation Scheme: Covering some 500,000 people and dispersing some GBP 1.3 B annually, Braitwood and Still have had success with authoring rules in Word, where the user takes existing legislation and progressively rewrites it to have a single idea per line and uses styles to add markup.

Peter Gugelmann (Pulinco), Bringing Business Rules to Business People: Using an architecture consistent with how Windows Workflow Foundation integrates process and rules, Mr. Gugelmann described their now four-year along project to automate health car claims, wherein a critical decision was to identify and staff the role of "rule manager". They have taken Mr. Ross' suggestion to heart and defined a process for approval and deployment of both automated and "manual" rules. Among many interesting recommendations is the pragmatic "make sure your tools set integrates with Microsoft WORD and EXCEL [his caps], they are still the main tools of business users today."

Patrick Graessle (KnowGravity), An Integrated Business Rules Approach: Precariously close to the start of the Swiss football match, Mr. Graessle led off with a reiteration of the gap between business users and IT developers. From there, they began an impressive survey of modeling standards targeted at these two audiences, capped off with an extensive demonstration of how they have been integrated in their tooling. If you like the idea of UML, you'll love the sort of layered modeling KnowGravity is up to.

Anecdotal Business Policy Failure: Rx Externalization

jeffrey-schlimmer — Fri, 09 Jun 2006 18:43:00 GMT

Due to a glitch in their business rules implementation, his insurance company lost Ross as a happy customer.

http://www.BRCommunity.com/a2006/b293.html

If they're like other companies, they've got one set of people -- analysts --who make business decisions (but don't code) and another set -- programmers -- who code (but don't make decisions), and this leads to misunderstandings and inconsistencies. After the fact, only programmers can figure out what's implemented (but not without some effort). (Changing business decisions is left as an exercise.)

This gap in roles / skills is a big reason folks promote "externalizing" business models. By this they suggest closing the corresponding gap between specifying decisions and implementing them, by making the specification written / read by analysts executable (and manageable). This is a key reason for interest in business process and rule engines (and business process and rule management systems). It's not that programmers couldn't implement the decisions; it's that the analysts can't get their head around the resulting code, and that inevitably leads to business mistakes.