I will not be moving all my old blog articles over, however, a few articles of a more lasting relevance will be pulled over by hand.  I have moved my blog to WordPress after years of defiance.  I am excited and very satisfied so far with the experience.

It probably took under 10 minutes to get this blog up and running, and the UI is great.  Things are much better than they were even a year ago.  Anyway, this is my new home, welcome.  Stay a while, grab an RSS feed and I’ll try to make it worthwhile.

Here’s one little snippet that I’ve been working on to learn some Scala, another sieve of eratosthenes.  It will work if pasted into the scala interpreter, and then just call the primes function.

def primes_aux(currentList:List[Int], stopNumber:Int) : List[Int] = {
  if(currentList == Nil)
    Nil
  else {
    val H = currentList.head
    if (H <= stopNumber)
       H :: primes_aux(currentList.tail.remove(num => (num % H) == 0), stopNumber)
    else
      currentList
  }
}

def primes(maxNumber:Int) : List[Int] = {
  primes_aux((2 to maxNumber).toList, Math.sqrt(maxNumber))
}

I tried really hard to shrink the code from the erlang version, and I was successful. It is much more succint.  I will probably find some better functions that can help me get rid of or at least simplify the logic.  I have a feeling this can be done in a few short lines of code.

I had to modify the algorithm, as the original algorithm uses arrays, and arrays aren’t really used in Erlang.  I suppose this is probably due to the functional roots that Erlang has.  Scheme in practice tends to stay away from vectors and uses lists more.  I decided to use lists in Erlang, and was able to do some nice recursion, as is normal with Scheme.

-module(sieve).
-export([primes/1]).

%% Removes the multiples of a number from a list
remove_multiples(_, []) -> [];
remove_multiples(N, [H|T]) when (H rem N == 0) ->
        remove_multiples(N, T);
remove_multiples(N, [H|T]) ->
        [H|remove_multiples(N, T)].

%% Generate primes by creating a list of numbers from 0 to N.
%% Then recurse through the list, eliminating multiples off the tail at each recursion.
primes(N) ->
        primes(lists:seq(2,N), math:sqrt(N)).
primes([H|T], StopNumber) when H =
        [H|primes(remove_multiples(H, T), StopNumber)]; %% Does this blow your mind?
primes(L,_)-> L.

I’m not experienced with Erlang yet, so my apologies if I have bad Erlang style.

http://en.wikipedia.org/wiki/Tail_recursion – Great resource

I decided to code up a quick experiment of how this can work. I have a simple recursive add function that will add up all the sequential integers up to and including num. This is also a proof of Pythagoras’ tetrad. So if I do add(4) the return will be 1 + 2 + 3 + 4 = 10:

add-recursive.c :

int add(int num) {
   if(num == 0) return 0;
   return (num + add(num - 1));
}

int main(int argc, char** argv) {
   int count;
   if(argc > 1) {
      sscanf(argv[1], "%i", &count);
      printf("Result: %i\n", add(count));
   }
}

Ok, let’s try it out

$ ./add-recursive 4
Result: 10
$ ./add-recursive 100
Result: 5050
$ ./add-recursive 100000
Result: 705082704
$ ./add-recursive 10000000
Segmentation fault

Uh oh. Looks like we overflowed the stack at 10000000. The solution to such a silly problem would be to use tail recursion, which is a special form of recursion where your final operation is a recursive call. Normally, each recursive call will add a stack frame for each call to add(), but since you’re only returning the result of the next recursive call, the compiler can re-use the same stack frame, and reload the recursive call onto the same stack frame, thus averting any stack overflow problems.

Here’s a modified function that will do the same thing, but allow for the tail recursion optimization.

add-tail-recursive.c :

int add(int num, int count) {
   if(num == 0) return count;
   count += num;
   return add(num - 1, count);
}

int main(int argc, char** argv) {
   int count;
   if(argc > 1) {
      sscanf(argv[1], "%i", &count);
      printf("Result: %i\n", add(count, 0));
   }
}

Here’s the new results:

$ ./add-tail-recursive 4
Result: 10
$ ./add-tail-recursive 100
Result: 5050
$ ./add-tail-recursive 100000
Result: 705082704
$ ./add-tail-recursive 10000000
Result: -2004260032

Hey, we got a result, our integer overflowed, but that’s beside the point, we got an answer, which means the recursion ran to completion without a stack overflow.

So, the obvious response is, “that’s a dumb idea to use recursion for adding like that, you should use a for loop”. Yes, I know, I was just trying to test out this tail recursion in hopes that I will one day find a great use for it.

Note that when you compile your C, you’ll want to turn on optimizations, I used -O2 for gcc, without that option, it has the same effect of blowing the stack up.

I won’t be posting much of any code here, sorry, but will tell you of my experience, and leave the invitation open for those who may need assistance interpreting the API, or debugging impossibly cryptic certification errors.  Interested persons may contact me about purchasing the PHP interface class that I wrote, along with my own documentation.

It seems the Web Service API is brand new at the time I attempted to create an integration module for our system.  The date posted on the documentation was 5/2007, and it became clear very soon that it had not gone through rigorous revision, as my printed copy of the API has many handwritten notes on things that are not clear, warnings that were not made, and even blatant errors as to what methods to use.

The certification guide is a noble attempt to provide assistance and it does to a great degree, but not enough to effectively guide a programmer unfamiliar with the certification process, and web service methods of the WWD(Wild West Domains) API.

Java Daemon Nonsense

The first documentation that was available to me was an old API that to me was a very outdated method of doing things.  Most APIs today are of the SOAP or XML-RPC type, but the method that was described in this document was installing a Java Daemon that you ran on the server on a particular port, and then you communicated with it through your web application.

They also kindly provided a sample PHP website that used what they call the WAPI Daemon.  I was able to install this daemon on my linux box and got the sample website to work, which was partly a miracle because there were many command line options I needed to set on the daemon that weren’t documented, and so I had to do trial and error to figure it out.

WAPI vs. Web Service

I almost began implementing my domain registration module using this Java Daemon, but I noticed a new web service API guide appeared in the ote extranet for WWD.  I was very excited to see this new document pop up, along with its companion the certification guide which appeared a couple weeks later.  I knew this was the way I wanted to do business, now to get it to work.

As excited as I was, I printed out the API for quick reference, and started on a class that would act as the interface.

Customer Support

Needless to say in writing the certification driver I found complications early on, as in step 2 of 7.  It took a couple of weeks to get past step 2, and about a month to get to step 3(we had other things to do than just work on this).  Of course this involved the wild west technical support guys, who weren’t the quickest responders, and had nice canned responses for the old WAPI style XML responses, but not any for the new web service method.

Also forget about talking to an advanced customer support technician, I tried calling in to talk to someone about the API, told them about the problems I was running into with a Poll request using the web service method, and the man on the phone had no clue what the API consisted of.  He said I had to e-mail to get advanced support.

So, I emailed patiently to get answers, finding very few.  There were also bugs in the certification script, which the support team acknowledged they were aware of, this also frustrates me because it’s like I was trying to hit a moving target.

I felt like I am the only person who is trying to use their new web service API.  There were no real resources or additional guidance aside from the official manuals which were good as a reference, but did not clearly walk you through the process of coding up a certification script, in my opinion.

Trial and Error

Debugging can be a straightforward, and not a painful process in many cases when you have clear error messages and feedback to work off of.  Do not expect any of that with the certification process.  The certification script will tell you what data on an XML node is incorrect, but it will not tell you that you’ve used the wrong method to call the web service, or what XML nodes you are missing, or what the structure of your SOAP request should be.

The debugging process for this project was painful, and involved almost entirely trial and error, and also carefully reading the WSDL file, which I found was more helpful than the web service documentation, as the documentation has missing and misnamed fields in certain instances.

Certification Success

Finally after a couple of months of learning the ins and outs of the API, I passed the certification.  Maybe if I was using ASP.net, it may have done everything for me, if this is your situation, good for you, but using PHP, I had to rely on the WSDL file, and needed to know exactly how to structure my SOAP objects so the correct XML would be generated.

If you are looking to integrate with Wild West Domains on any level, you’ll need a good abstraction layer. Contact me if you would be interested in saving yourself lots of time.

Update 2/2010

I have mostly polished the interface and it is available for purchase, contact me for details.  If you would like more information, I have attached the generated documentation and usage examples here: WWD-Integration-Docs.  I know how much of a waste of time it can be to re-invent the wheel when a solution is already there. I charge $400 for the source code for the interface. Just message me, it may mean slicing a couple of weeks off of your development time.