Erik's Misadventures on BizTalk, .NET and Life

Observer Pattern in F# : Simplified/Enhanced

One of the commonly used design pattern is the Observer Pattern because its just so easy to use and implement.  The classic OO way of implementing it is to have a Subject class having the methods "Attach", "Detach"  and "Notify". The Subject class usually stores the observers in an ArrayList and then when it needs to update the observers then iterates on the list and invokes the "Update" method of each observer. See diagram below.

In C#, a more elegant way of implementing this is with Events and Delegates.  Here's a nice sample implementation.  By using using events and delegates, the code became a lot shorter and straight-forward 

In F#, implementation of the observer pattern became even more concise and elegant.  How come? Take a look at the code below.

line 11 : A clean and simple (one-liner!) way of creating events and triggers.  A call to IEvent.create is all it takes

lines 16 & 17 : calling "trigger" and passing the correct parameters notifies all listeners of the changeEvent.  We don't even need to check if there are listeners attached. If this is in C# we need to make changeEvent  != null otherwise a NullReferenceException will be raised.

lines 28 & 30.  In F# Events are first-class values , that means we can pass it around and more importantly we can do all sorts of wonderful things with it using the IEvent module.  For example,  in line 28, we filtered the event, basically saying that we are only interested in events of the Remove operation.  Now imagine if the Operation type (an enum actually, lines 5-7 ) contains more items such as Update, Delete, AddedThenRemoved, AddedThenUpdated, RemovedAddedAgainThenFinallyUpdated ... (you get what I mean).  If we want to a handle only the Remove operation then we'd have no choice but to break it down using an if-elseif-else or switch-case construct.  It would work but its not going to be pretty.  And this is where IEvent.filter shines. With just a single line of code (line 28, please ignore the comment above it.), we were able to filter out the event that we are only interested in. Apart from filtering, IEvent also allows us to map, partition, fold, split etc. events.

lines 25 & 30 : 2 ways of attaching to an Event.  I'm not very sure what's the difference between these 2. (TODO : Investigate)

Here's the output! Notice that the "observerForRemove" printed out only the message related to the Remove operation even though the Subject class raised 2 events (one for Add, another one for Remove) in the Notify() method at line 15.  Sweet.

posted @ Thursday, May 22, 2008 3:36 PM | Feedback (0) |

SoapBits is now open source!

posted @ Saturday, May 10, 2008 11:12 PM | Feedback (3) |

String.Replace() in XSLT

Here's a sample template that lets you have the String.Replace() functionality in XSLT 1.0.   The template "string-replace-all" takes 3 parameters and recursively processes the input text string.

•      text         : main string
•      replace : the string fragment to be replaced
•     by           :  the replacement string 

Here's how it is called: 

The resulting value of $myVar after {ReplaceMe} is replaced is "This is a sample text : String.Replace() in XSLT and String.Replace() in XSLT"

For those who are not familiar with XSLT syntax and here's the C# equivalent.  An excellent material for the thedailywtf! :)

 (Note: I'm not so sure, but I think in XSL 2.0 there is already a built-in replace function on strings)

posted @ Tuesday, April 01, 2008 8:36 PM | Feedback (1) |

F# Solution (By Factorization) : Project Euler Problems 5

Problem:

 2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.

What is the smallest number that is evenly divisible by all of the numbers from 1 to 20?

Solution:

Finding the LCM can be done via factorization.  Below is an excerpt from the wikipedia article.

The unique factorization theorem says that every positive integer number greater than 1 can be written in only one way as a product of prime numbers. The prime numbers can be considered as the atomic elements which, when combined together, make up a composite number.

For example:

Here we have the composite number 90 made up of one atom of the prime number 2, two atoms of the prime number 3 and one atom of the prime number 5.

This knowledge can be used to find the lcm of a set of numbers.

Example: Find the value of lcm(8,9,21).

First, factor out each number and express it as a product of prime number powers.

The lcm will be the product of multiplying the highest power in each prime factor category together. Out of the 4 prime factor categories 2, 3, 5, and 7, the highest powers from each are 2³, 3², 5⁰, and 7¹. Thus,

Code:

My solution for this one follows the steps outlined in the wikipedia excerpt above. It is a bit long but essentially it can be broken down into the following stages...

1 - Factor out the number 1 to 20.   

      This is done on function pFactors.  pFactors outputs a sequenct of tuples wherein the first value is the number being factored while the second value is a sequence of its prime factors. For example, the output of this function when applied to the numbers 2 to 20

      { (2, {2}); (3, {3}; (4, {2;2}) ; (5, {5}) ...,<snip> .. (12, {2;2;3}) ...<snip> .. (20, {2;2;5})       } 

    type : seq< int * seq<int>>

2 - Count the number of occurrences of each prime factor and consolidate into just one sequence

    This is done on line  let all = pFactors |> Seq.map (fun (num,s) -> s |> Seq.countBy (fun x -> x ) ) |> Seq.concat

   Seq.countBy counts the number of occurences of an item in a sequence.  For example, if we apply to the sequence of prime factors of the number 20, the output will be

   (20, {2;2;5} ) -> (2,2),(5,1) : where the 2nd value of the tuple is the number of occurences

   So for the number 2 to 20 the output is

  (2, 1)(3, 1)(2, 2)(5, 1)(2, 1)(3, 1)(7, 1)(2, 3)(3, 2)(2, 1)(5, 1)(11, 1)(2, 2)(3, 1)(13, 1)(2, 1)(7, 1)(3, 1)(5, 1)(2, 4)(17, 1) 

  (2, 1)(3, 2)(19, 1)(2, 2)(5, 1)

  type : seq<int * int >

3 - Sort the output of stage 2.

    The output of stage 2 obviously contains duplicates.  Referring back to the wikipedia excerpt above, what we need only are those factors with the highest power (or most number of occurences).  So in order for us to identify those factors, first we sort the sequence.  This is done on line

         let allList = (Seq.to_list all) |> List.sort factorSort |> List.sort powSort

     The output (though a bit confusing) guarantees that the for any number, the one with the highest number of occurences comes out on top.  For example (2,4) is on top of all the other tuple entries with first value of 2. And so is (3,2) for tuple values with first value of 3.                        

                         (2, 4)
                         (2, 3)
                         (2, 2)
                         (2, 2)
                         (2, 2)
                         (3, 2)
                         (3, 2)
                         (2, 1)
                         (2, 1)
                         (2, 1)
                         (2, 1)
                         (2, 1)
                         (3, 1)
                         (3, 1)
                         (3, 1)
                         (3, 1)
                         (5, 1)
                         (5, 1)
                         (5, 1)
                         (5, 1)
                         (7, 1)
                         (7, 1)
                         (11, 1)
                         (13, 1)
                         (17, 1)
                          (19, 1)

             type : seq<int * int>

4.  Filter the resulting sequence of stage 3 and take only those with the highest 2nd element.  This is done on line 

   let filtered = allList |> List.filter (fun (x,y) -> ...  <snip>...

     output is :  seq<int*int>

                   (2, 4)
                   (3, 2)
                   (5, 1)
                   (7, 1)
                   (11, 1)
                   (13, 1)
                   (17, 1)
                   (19, 1)

5. And finally we can compute the LCM.  This is done on the line

   let lcm = filtered |> List.fold_left (fun a (x,y) -> a * Math.Pow(float_of_int x, float_of_int y ) ) 1.0

Total execution time on my machine is 0.17 seconds  which a great improvement from the 25 seconds using the brute force approach described here

posted @ Tuesday, February 19, 2008 1:15 AM | Feedback (4) |

F# Solution : Project Euler Problems 4 & 6

These 2 problems have very short solutions so I'll put them together 

Problem 3:

A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99.

Find the largest palindrome made from the product of two 3-digit numbers.

Solution:

The problem asked for the largest palindrome of 3-digit numbers, hence the magic number 100 and 999.  The rest of the code is pretty much self-explanatory.

Problem 6:

The sum of the squares of the first ten natural numbers is,1² + 2²  + ... + 10² = 385

The square of the sum of the first ten natural numbers is, (1 + 2 + ... + 10)²  = 55² = 3025

Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 − 385 = 2640.

Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum.

Solution:

To compute the sum of squares, I've decided to use recursion,  which apart from lists and sequences, is another workhorse of functional programming.   One thing to remeber when using recursion is to always make sure you cover the base case in order to avoid looping indefinitely.  In this case it is the line x when x = 1I -> 1I

Because of the large resulting values, the type used was BigInt.

posted @ Monday, February 18, 2008 11:36 PM | Feedback (0) |

F# Solution : Project Euler Problems 1-3

Problem 1 : 

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below 1000.

Solution :

Problem 2:

 Find the sum of all the even-valued terms in the Fibonacci sequence which do not exceed one million.

Solution :

For this solution I had to put the guard statement "when y <  0" so that negative numbers won't be included in the generated sequence.  If that guard istatement s not there, negative numbers will be included when it goes over the maximum value of Int32.

 Problem 3:

 Find the largest prime factor of 317584931803.

Solution:

The function "primefactorsOf" takes a number and returns a sequence containing the prime factors of that number.  The prime factors are determined using Trial Division.  This of course is not very fast for ver large numbers but is sufficient enough for 317584931803.0 If it's not clear why the square root of the number being factored out was used instead of directly using the number itself, the wikipedia article explaining Trial Division is here. 

If you want to output only the largest primefactor you can just pass the value primefactors to Seq.fold like so

let largestFactor = primefactors |> Seq.fold (fun a x -> if x > a then x else a ) 0

Next time I'll post my solution to problems 4-6.

posted @ Monday, February 11, 2008 11:58 PM | Feedback (2) |

F# Solution : Project Euler Problem 25

The Problem :  What is the first term in the Fibonacci sequence to contain 1000 digits?

The sweet solution :

ahh... such power and elegance....

Let me breakdown the solution

(1I,1I) |> Seq.unfold ( fun (sqEntry, acc) -> Some (acc, (acc, acc + sqEntry)) ) 

This line creates an inifinite list of fibonacci numbers using Seq.unfold.  Let me say that again, it creates a in INFINITE list.  How is that possible, you'd ask ? The reason is that F# performs Lazy Evaluation. By that, I mean the program will perform only the computation it needs to do. So in our case, the program will actually compute only the parts of the list that it will need.   Here we used Seq.unfold to perform the computation.  The unfold function creates a list and uses an accumulator to maintain the state between computations.  The accumulator in this case is the tuple that contains the last 2 entries of the sequence

Seq.filter( fun x -> x.ToString().Length = 1000

This line applies the filter function to the sequence.  This function returns a subset of the original list that matches the condition.  In this case, the resulting list will contain only those numbers that is made up 1000 digits.

Seq.nth 0

This line retrieves the nth element in the sequence.  Since the problem ask for the 1st term, naturally we retrieved the 0th element.

And finally the construct that ties everything together and makes the code such a wonder to look at is the

|>  (the Pass-forward operator)

As its name implies, it passes forward the argument behind it to the function in front of it.  So the solution in essence means

Pass the tuple (1I, 1I) to Seq.Unfold, then pass the resulting infinite list to Seq.filter, then pass the filtered list to Seq.nth which finally retrieves the 1st element!

posted @ Friday, January 18, 2008 5:24 PM | Feedback (3) |

Extracting Raw Schemas from BizTalk 2004 and 2006 Assemblies

When BizTalk compiles a project that contains a schema it generates a wrapper class for each schema.  Take for example the typical Biztalk Project below.  It contains a PropertySchema + 4 other schemas. 

Compiling this project and opening it up with .NET Reflector, we'll get the following.  The important stuff to note from this are 

• A class was generated for each schema (including the Property schema)
• The generated classes inherit from "Microsoft.XLANGs.BaseTypes.SchemaBase"
• (See Figure 2) SchemaBase has a property called "XmlContent" which is overriden by the generated class.  This property contains the raw schema string!

Figure 1.  Reflector output

Figure 2. Properties Overriden by the Generated Class

 So to get the raw schema, all we need to do is open up the dll in .NET Reflector and do some copy-paste magic. :) But what if you have a huge schema project?  Extracting them all will be very painful (at least for me).   So being the kind of programmer that hates repetitive work,  and aside from the fact that I'm currently learning and loving F#, I hacked up this code to do everything automatically.  Here's the tool in action.  It creates the XSD files in the same folder where the tool was ran.

The tool can be downloaded here.  (p.s. easy-share.com deletes the file if it has not been downloaded for within 30 days.  Just drop me an email if you want me to send the file directly)

and here's the code  (How it works will be topic in a future post )

posted @ Friday, November 09, 2007 1:22 PM | Feedback (2) |

10 Types of Programmers : TechRepublic

Funny (but true) article from TechRepublic.  I gotta start looking for the Code Ninja in my team(!) but where do i start...

10 types of programmers you’ll encounter in the field

posted @ Tuesday, November 06, 2007 10:25 AM | Feedback (0) |

Hello F#!

I don't remember exactly where, but some years ago I've come across a book that said something like -- A "complete" programmer must know the 3 main programming styles, 1. C-based (C#, Java C++ etc) 2. Scripting (Perl etc) and 3. Functional (Haskell, OCaml etc).  Each style requires a different mind- set when writing code.    I started out as a Perl programmer (i know it's weird that my first language was Perl... ), moved on to C++ and now I'm doing .NET (C# and BizTalk mainly).  So, I've covered the first 2 "styles" and that leaves just functional programming. 

I've always been interested with functional programming but I somehow I've always found an excuse not to try it.  Add to that the facts that

1. Going from OO to functional programming is hard. By that I mean the learning curve is very steep!!!
2. I didn't want to throw away my existing knowledge on C#
3. I didn't want to throw away the libraries I've compiled and written over the years.
4. There are no F# jobs!! (at least there's none in Singapore)

A few weeks back Microsoft announced that it is productizing F#.  It is now going to be a supported .NET language. That is really great because now my excuses #2 and #3 are no longer valid!  Excuses #1 and #4 though it still has some weight, it is not enough anymore to keep me from learning functional programming with F#.  Yes, there will always be a learning curve.  And, the jobs...well, hopefully the bio-tech companies will soon adapt F# given that because of its functional nature, Microsoft is marketing it as a language for scientific reasearch and development.

F# is not a pure functional language like Haskell i.e. it allows side-effects.  This is perfectly fine (I'm not a purist) because this is actually allows interoperability with other .NET libraries.  Which means coding in F# will in no way greatly reduce my productivity.

For 2 weeks now, I've been reading up on F# while travelling to and from the office. Below is my first F# code.  Check out how System.Windows.Forms controls are available from the code.

#light
open System
open System.Drawing
open System.Windows.Forms
open System.Windows.Forms.Design

let label =
  let temp = new Label()
  do temp.Name <- "label1"
  do temp.Size <- new System.Drawing.Size(35, 13);
  do temp.Text <- "Hello F#"
  do temp.AutoSize <- true
  do temp.Location <- new Drawing.Point(26,27)
  temp

let form =
  let temp = new Form()
  do temp.Name <- "ErikForm"
  do temp.Text <- "EriKForm"
  do temp.ClientSize <- new System.Drawing.Size(292, 266);
  do temp.Controls.Add(label)
  temp

let ticker =
  let temp = new Timer()
  temp.Enabled <- true
  temp.Interval <- 1000
  temp.Tick.Add(fun _ -> label.Text <- DateTime.Now.ToLongTimeString())

do Application.Run(form)

posted @ Monday, November 05, 2007 6:14 PM | Feedback (6) |

SoapBits - A .NET Tool to Dynamically Invoke Web Services

 November 1 2007

          It's been 2 months now since I've made SoapBits available on this blog.  And I'm genuinely surprised that people had stumbled into it!  Google you're the king!!

         Here are some download stats from easy-share.com.  On the average, the tool gets downloaded twice a day.

         I've also received some emails regarding difficulties downloading from easy-share.  This most probaly because of the layout of the easy-share web site.  You need to scroll down a bit to get past the ads until you see the download part.  I know, this s*cks a bit but its still better than hosting it at rapidshare where you have to wait for ages.

   The latest version can be downloaded here :  SoapBits v.1.1.1

October 13 2007 UPDATE - SoapBits v1.1.1 Released!

     This release contains fixes to the following bugs

1. Fails to process web services whose WSDL had included external schemas wherein the schemaLocation is in the URI format. Something like: <xs:include schemaLocation="http://MyCentralRepository/MyExternalTypes.xsd"/>

             Fix: added to code to download the schema into the temp folder where all the other temporay files (wsdl, request and responses) are kept.  This temp folder is deleted when the tool is closed.

      2.   Response Tab fails to display very large soap responses.

             Fix:  Modified the way the http response is read so that the entire response can be displayed.

     3.   Cannot send cookies.

            Fix: Cookies are supported only via the "Send Raw Request" option.  I've added code to make this easier . Please see the modified the documentation (part of the download) on how sending/receiving cookies can be done.

          You can download SoapBits v.1.1.1 here.

Sept 25 2007/UPDATE

            Just got back from vacation and is now working on fixing a bug relating to "included" schemas in the WSDL.  I am also looking into implementing some feature requests. 

             I don't have specific date in mind yet for the new release but I promise I'll get to work on it whenever I'm free.   

            Guys thank you very much for reporting bugs and submitting feature requests.  This will make SoapBits a much better app than I hoped it would be.

Sept 8 2007 /UPDATE - SoapBits v1.1.0 Released

As promised, here's the new release of SoapBits! This release contains the following changes

1. More robust exception handling.  The reported bug(s) on unhandled exceptions are no more.  Plus, I've added a feature that automatically unhides the Logging Pane whenever an exception is written to it.

2. The "Quick Edit" tab Response pane is now synchronized with the current selected method.  Taking this synchronization fix further, I also synchonized the current selected web method with the" Test Data" tab Request and Response sub tabs.  To illustrate, Say you are testing a web service that has 2 web methods, method1 and method 2. If you invoke method1 first, then method2 and then you selected method1 again from the "Web Methods" pane the data that will be shown in the "Test Data" tab will be for method1 even though the last method that was executed was method2.

3.  "Quick Options" now includes  a) Toggling the Logging Pane, b) Viewing the WSDL and c) Viewing the Soap Request Properties

4.  The UI has a bit of an "MS Outlook" feel now. 

5. I've also added a label to display the time!  This is for my fellow devs who frequently forgets to have lunch or dinner! 

6. "Help/About" now contains more info.

Check out the new look!

As always, for any bugs or enhancement requests please let me know.

You can download SoapBits v1.1.0 here

Sept 4, 2007/ UPDATE

        I have received the following comments regarding the tool and i'll be fixing these over the weekend.  Let me know if there are more.

1. Unhandled exception is generated when the URL passed is incorrect.
2. The response output tree should refresh when another web method is selected
3. Add to "Quick Options" a link to the Soap request properties.

Sept 1/ Initial Release

SoapBits is an application used to dynamically invoke any type of web service. The inspiration for this tool is the amazing .NET Web Service Studio tool written by Sowmys of Microsoft at GotDotNet. That tool has been a great help to me.

* Test Data Tab

QuickStart Guide.

 

 * Invoking a web service by using the "Raw Soap mesage" option

 You can download SoapBits here.  Try it out and let me know how it goes!

posted @ Saturday, September 01, 2007 12:13 PM | Feedback (15) |

Configuring SubSonic for BizTalk

Every BizTalk developer knows that assemblies used by BizTalk must reside in the Global Assembly Cache and hence must be strong-named.  As such, if you are using an assembly that reads a config section then in the BTSNTSvc.exe.config, you must specify the specific type of assembly in the GAC that will be used to read that section.

Taking SubSonic for example. the config section should read like:

You can download SubSonic here. Generate your own snk file, compile it, then off you go!

posted @ Thursday, June 14, 2007 6:48 AM | Feedback (1) |

Turning point

Each one of us experience this at some point in our lives; a defining moment, a sudden unexpected event, a turning point - beyond which we are never the same again.  I just had mine a few days back and I'm still reeling from its effects. 

posted @ Thursday, December 14, 2006 3:49 PM | Feedback (2) |

Ramblings over coffee

Last night a friend and I were at Changi international airport having coffee and just wiling away the time. And of all the topics that we could have talked about, we ended up talking about love. Hahaha! yeah, love. Well.. I suppose its not that surprising  given that most of the people we know who came here to Singapore ended up with a messed-up love life.  That of course includes me. 

So how does moving to another country relate to  breakups?  Was it the distance? Was it the breakdown in communication caused by multitude of factors, primary of which is distance?  Was it because both persons are now living "separate" lives?  Or was it because they now are able to see the relationship from a different perspective now that their partner is no longer always around?

... *Sigh* ...

I wish I know the answer. 

I wish my friend knew the answer.

But sadly,  we were as just as clueless as everyone else.  When love happens, when it hits you, you just know it. You just feel it. No matter how hard you try to find a logical reason as to why you have this feeling, you'll just never find it.  It just happens.  Ironically, the same argument can be applied as to why love disappears.  One day you just realize that the feelings you had before is gone (or dying) without really knowing why.  Again, you just feel it. The realization hits you just as hard as when you realized you were in love.

Love it seems is a creature of whim. It comes and goes as it pleases.  And it doesn't even bother to explain.

posted @ Tuesday, November 14, 2006 1:09 PM | Feedback (1) |

Removing Parties Programatically

Here's how you can remove parties programatically.  It's quite easy.

I.  First, you need a reference to the Microsoft.BizTalk.ExplorerOM assembly.  You can find this assembly in the Biztalk install folder

II.. Create your code this way

posted @ Wednesday, May 03, 2006 7:25 AM | Feedback (0) |