This is an open source tool for testing web services, everything I wanted to do for testing some of the web services that we [...]]]>

Sometimes a you come across a tool that just makes you think why you never used it before, I ran across one such tool last month, it’s called soapUI (http://www.soapui.org/ ).

This is an open source tool for testing web services, everything I wanted to do for testing some of the web services that we were developing including unit testing and load testing was provided out of the box by this awesome tool. Also I think the UI is quite well thought out and mature.

Here’s a list of the features at a high level,

soapUI is a free and open source desktop application for

• inspecting Web Services
• invoking Web Services
• developing Web Services
• Web Services Simulation and Mocking
• Functional, Load and Compliance testing of Web Services

It is mainly aimed at developers and testers providing or consuming WSDL or REST based Web Services (Java, .net, etc). Functional and Load Testing can be done both interactively in soapUI or within an automated build or integration process using the soapUI command line tools.

Mock Web Services can easily be created for any WSDL and hosted from within soapUI or using the command-line MockService runner. IDE-plugins are available for

• eclipse plug in
• IntelliJ IDEA plug in
• NetBeans plug in

soapUI requires Java 1.5 and is licensed under the LGPL license.

See their features page http://www.soapui.org/features.html for some screenshots of the cool stuff you can do using this.

Posted via email from Sijin Joseph

Recently I had to work on a Java based rule modeling tool that was built on Java/Eclipse. The tool was pushing both eclipse and the JVM to the limits in terms of memory and I was getting a lot of OutOfMemory exceptions and out of heap space errors, usually these can be fixed by increasing [...]]]>

       -Xms6291456

       -Xms6144k

       -Xms6m

       -Xmx83886080

       -Xmx81920k

       -Xmx80m

Posted via email from Sijin Joseph

You can [...]]]> Recently I was reviewing some code written by a new programmer, this person had demonstrated good knowledge of his domain and was quite well regarded by everyone. However when I looked at his code I saw a familiar pattern that I had seen before which I like to call the “Enlightened Newbie Syndrome” (ENS).

You can detect ENS when you see code that is a mish-mash of good code intermingled with overkill on “best practices”. The Enlightened Newbie will focus on making sure that his code adheres to the latest naming conventions, follows TDD but doesn’t test the right things and applies design patterns too liberally

In this particular case the programmer had used different naming conventions for variables based on it’s usage, so for e.g. pascal case for params, all caps with underscroes for local variables etc. Another classic sympton was the elaborate comments about assignment statements complete with box decorations around the comment. Further the variables if named properly would have been enough to indicate their usage but instead the variable names were extremely generic and then had big comment boxes near them to describe what the variable was used for.

The saving grace of the code was that logically it was setup correctly, but it was clear that the programmer had not unit tested his code at all, my first invocation of the code gave me wrong results and upon further analysis it looked like a lot of the edge cases had been missed out.

I remember being an enlightened newbie once, I had read all the books on design patterns, refactoring, TDD etc. but had not yet written a lot of code. So when I worked on my real project it was very tough for me to find the style that worked for me and I ended up with a bit of everything at the start. However as I worked on that code for the next 3 years all the things that I had read started to make sense and I realized that the essence is to not follow a practice religiously but to make use of good judgement to see what applies where.

So in my mind there is only one cure for ENS and that is to just write a lot of software in a team environment. Note that I am not talking about just chruning out code but actual working software, and again not in isolation but in a team. Because

1. You can write a lot of code and only improve your typing and not learn a lot about programming, however when you build an actual product/service and then have users or other systems interacting with it, you get a lot of feedback on what works and what does not. Based on the feedback and other external requirements the software usually goes through a lot of changes and when you have to go back into your code and make changes then you really appreciate brevity, simplicty and the DRY principle.

2. Working in a team environment exposes you to code that is both better and worse than you, it gives you more exposure to the different ways something can be done and all the different ways you can use tools to make your work easier. Teams are just fantastic platforms for improving your skill, knowledge and productivity.

The launch of Windows Azure has coincided with the launch of the entire cloud computing initiative from Microsoft which makes a lot of business sense but it also makes it hard to differntiate the individual parts of the initiative, here’s my understanding so far.

This is the base platform that provides a generic cloud computing [...]]]>

The launch of Windows Azure has coincided with the launch of the entire cloud computing initiative from Microsoft which makes a lot of business sense but it also makes it hard to differntiate the individual parts of the initiative, here’s my understanding so far.

Windows Azure

This is the base platform that provides a generic cloud computing platform for developers to host applications on.  Azure basically offers two core services,

Compute Service

This is what people would normally associate with cloud computing. You write an app that conforms to the cloud hosting requirements and then deploy it to the cloud where it can be managed and scaled as per the load and performance requirements. Currently there are two types of compute services that can be deployed on Azure

Web Role – This currently is a WebForms ASP.Net application, but looks like support for ASP.Net MVC and other languages are in the works too. This is just like hosting your application with a hosting provider except that you get load balancing, failover etc. for free. One important caveat here is that the load balancing does not support sticky sessions(as of the CTP) which is a good thing but it does require the developer to use the storage service to store session data.

Worker Role – This is more like a Windows Service that is deployed on the cloud, it can make outgoing connections but incoming connections are disallowed. But again you get the benefits of load balancing and failover.

The compute services are different from other similar cloud computing options available because it does not require the developer to supply a VM image (unlike Amazon EC2) of the application environment to host,  instead the applications run in VMs that are built and maintained by the Microsoft Data Centers that host the applications.

This decision definitely has it pros and cons, it’s good because

- No licensing costs for the OS

- No need for updating of the VMs as the applications evolve

- Simpler deployment strategy

- API available for management of service instances and for reporting on application health

on the other hand

- it does restrict the flexibility of what software and services can be accessed from the host VM

This diagram from MSDN gives a nice overview

All though in reality the deployment internally looks like below with IIS7 and Windows Server 2008 VMs.

Azure Hosting

Storage Service

This is the second part of the base Azure platform and is the equivalent of Amazon S3, SQS and SimpleDB all rolled under one name. The equivalents in the Storage Service are called,

Blob - For storing binary data, most commonly file streams.

Queue  - For reliable persistent messaging. I found it strange that it was lumped with the storage services because the primary purpose of this seems to be inter service communication between the applications running in the cloud. 

Table - For storing tabular data, different from traditional database tables though.

The important thing to remember here is that these services are available to any application that can talk over HTTP so WPF, WinForms, and non-cloud ASP.Net applications can make use of the storage services as well and benefit from having their data stored in an easily scaled environment. The storage services expose a RESTFul API which makes it easy to access these services from any platform that can talk over HTTP but ofcourse if you’re using .Net you get some builtin support from the framework.

Azure Storage Services

The developer story for Windows Azure is as good as anything else from Microsoft, the SDK includes tools to simulate both the compute services and the storage services on your development box, further with the VS addin you can deploy your cloud application straight to the Azure hosting platform, talk about ease of deployment. Here’s a quick overview of the important tools included in the Azure SDK.

Development Fabric – Simulates the Azure Compute Services (aka Azure Fabric) on your dev machine complete with a load balancer and failover monitoring.

Development Storage – Simulates the Azure storage services on your dev machine, the CTP implmentation requires SQL Server 2008 Express but you can also work with SQL Server 2008 if you want.

CSPack – Command line tool that prepares a service for deployment either to the Development Fabric or to the Windows Azure Fabric.

CSRun - Command line tool that runs a service (generated from CSPack) on the Development Fabric.

So the development cycle for a Azure app consists of developing locally using the Development Fabric and Development Storage and then deploying to the Azure platform when ready.  Deployments would not normally bring down the sites because the instances are load balanced and are not sticky. 

The other good thing is that services can be configured manually be editing the service configuration file or programatically by accessing the ServiceHosting API at runtime, so no redeployment is required if only service configurations are changed (which includes things like number of instances to run).

That’s basically the core Azure platform, the rest of the stack (.Net Services, SQL Data Services and Live Services) are cloud applications built by Microsoft on top of the core Azure platform. Again all these applications expose their API in a RESTFul manner as well making them open to both any technology that can talk over HTTP.

Azure Services Platform

Personally for me the Windows Azure SDK section from MSDN and this document from David Chappel were the most useful pieces of documentation to understand the entire stack.

My first stab at it consisted of a brute force solution of looking at every natural number up to [...]]]> Last week I saw a wrap up from cedric’s coding challenge on his blog, the problem looked simple enough, “write a counter function that counts from 1 to max but only returns numbers whose digits don’t repeat”.

My first stab at it consisted of a brute force solution of looking at every natural number up to a given limit and determining if the digits were unique, the crux of which was this function that given a number determined if the digits repeated or not

private static bool DoDigitsRepeat(long num) {
····//Used to track which digits have already been encountered
····int used = 0;
····while (num > 0) {
········int digit = (int)num % 10;
········num = num / 10;

········int index = 1 << digit;
········if ((used & index) == index) {
············return true;
········}
········else {
············used |= index;
········}
····}
····return false;
}

The good thing about this solution was that it met the secondary goal for the problem which was to determine the biggest gap in the sequence of generated numbers, but in terms of performance it sucked! It worked well for the smaller limits defined in the problem but when you tried to push and generate all matching numbers till the max possible i.e. 9876543210 it just took too long (I think it was under a minute, but that was still too long)

I went back to the problem page and saw that the scripting weenies who had tried to use string functions to prune numbers had the worst performance of all solutions, that made me feel a bit better until I saw CrazyBob’s Java solution(the fast version), the comments indicated that the solution found the total count in under half a second. This solution was not able to determine the biggest gap though because the numbers were generated out of order but nevertheless this was an excellent solution.

So began my quest to come up with a faster solution. I felt sure that I could use the bit twiddling hacks to come up with a faster solution, it was just a question of hitting the right spot.

The first non-brute force solution that I tried was to enumerate all possible subsets of {0,1,2,3,4,5,6,7,8,9} and then to generate permutations from that set making sure that zero was never in the first place. Subset generation is pretty easy to do, all you need to do is count from 0 to 2^n where n is the number of elements in the set, the bit patterns of all the numbers in this range can be used to generate all the subsets. For the first cut I tried to be Object-Oriented and used the below class to implement a BitTable.

public class BitTable
{
····private uint _storage = 0;
····public BitTable(uint value) {
········_storage = value;
····}

····public void Set(int index) {
········Debug.Assert(index >= 0 && index < 32);
········_storage |= (uint)(1 << index);
····}

····public void Reset(int index) {
········Debug.Assert(index >= 0 && index < 32);
········_storage &= (uint)~(1 << index);
····}

····public bool IsSet(int index) {
········Debug.Assert(index >= 0 && index < 32);
········uint val = (uint)(1 << index);
········return (_storage & val) == val;
····}
}

Of course as I soon found out, all the method calls to BitTable were really slowing things down (and by slow I mean a 1-2 seconds slower than CrazyBob’s solution), so I dropped the class and moved all the operations inline, also I realized that since I was using value types to hold the state in the search/call tree, I didn’t need to set and unset the state after each recursive call. Here’s the final version of this line of thinking.

class Beust4
{
private static int _total = 0;
public static void Run() {
····_total = 0;
····//Generate all possible subsets of a set of 10 elements
····//2^10 = 1024
····for (int i = 1; i <= 1024; ++i) {
········Permute(i, 0L);
····}

····Console.WriteLine("nTotal: {0}", _total);
}

private static void Permute(int digits, long current) {
····for (int index = (current > 0) ? 0 : 1; index <= 9; ++index) {
········if ((digits & (1 << index)) == (1 << index)) {
············if ((digits & ~(1 << index)) == 0) {
················//Console.Write("{0}, ", (current * 10) + index);
················++_total;
················return;
············}
············else {
················Permute(digits & ~(1 << index), (current * 10) + index);
············}
········}
····}
}

I felt really good about this attempt but to my surprise when I ran it, I took 1.2 seconds on average which was still more than 2 times slower than CrazyBob’s Java solution. I got really stuck at this point and I had to make sure that there was not something obvious that I was missing. The first thing I did was to port CrazyBob’s solution to .Net so that I could compare both solutions, I’ve uploaded the C# version of CrazyBob’s solution here in case anyone wants to take a look.

On the surface it looks like the bit twiddling based solution should run faster because it does not make all those method calls, the other thing that I suspected was causing problems was the number of recursive function calls that were being made, so I put in some code to check the number of recursive function calls that were being made and to my surprise I found that CrazyBob’s solution was making 8877691 recursive calls as compared to my solution which was making almost 10 times that number. Also the actual soultion count is 8877690 which meant that the number of calls in CrazyBob’s solution was near optimal. So it was clear that it was the number of calls that were costing me the half second. Btw CrazyBob’s C# version still ran in 700ms on average on my laptop, which was still 500ms faster than my C# version.

I then started to think about alternate ways to attack the issue, one track I went down was to consider all the digits as a complete graph and then coming up with a way to enumerate all paths in the graph, traversing a n edge in the graph would remove other edges from the graph and make them not available. This reminded me on Knuth’s Dancing Links Algorithm and I read up on that a bit, this paper from Knuth on the subject was an excellent read. It looked to me that CrazyBob had used an approach similar to the DLX algorithm, but after reading the entire paper from Knuth it still didn’t strike me as to why using a DLX approach would provide such excellent performance as compared to my version.

So I went back a bit to comparing both solutions and I think the two key observations that I saw that

1. CrazyBob’s solution went down the search tree to one level above the last and then just generated all the solution from there instead of recursing down to the last level, so for e.g. supposing it was generating 5 digit numbers and it had already generated 4321, then at that level it didn’t make additional recursive calls to add the final digit, it was able to add the last digit at the same level pruning the search tree quite a bit. In contrast my solution was basically doing a method call for every digit of every number in the solution set.
2. The above optimization was made possible by using the length of the final solution as the key, so first all 1 digit solutions were generated, followed by two digit ones and so on.

Cool, so now I ported my bit twiddling version to generate based on the length of the numbers and the optimization to prune the search tree one level above the last came naturally. I ran my solution and guess what, it was still 200 ms slower than CrazyBob Aaaarghhhh!!!!!

for (int len = 1; len <= 10; ++len) {
····Generate(len, 0, 0xFFF >> 2, 0);
}

private static void Generate(int maxLen, int currentLen, int availableDigits, long currentValue) {
····bool last = (currentLen == maxLen - 1);
····for (int digit = (currentValue == 0) ? 1 : 0; digit <= 9; ++digit) {
········if ((availableDigits & (1 << digit)) != (1 << digit))
············continue;

········if (last) {
············++_total;
············//Console.Write("{0}, ", (currentValue * 10) + i);
········}
········else {
············Generate(maxLen, currentLen + 1, availableDigits & ~(1 << digit), (currentValue * 10) + digit);
········}
····}
}

But I knew I was getting close, at this point I knew what was killing me basically to determine which bits were set I was iterating from 0 to 9 and then testing if that bit was set in the number or not, this test was killing me because most of the times the bit was not set and I was doing a huge huge number of unnecessary tests. So I needed a way to iterate through only the set bits. The first solution I tried used a hashtable but that caused a even bigger degradation in performance. Finally for a lack of a better way to express this in C# I had to waste 4KB of memory and use an array to allow me to iterate through the indexes of the set bits in a number.

The final solution ran in 350ms on average, almost a 50% improvement over CrazyBob’s solution, woot!!!!! A further optimzation to move the if statement from inside the loop to outside which makes the code more readable but incredibly smelly because of the near duplicate code in both the if and else blocks shaved off another 50ms. Here’s the final version without the optimzation for moving the if statement outside which makes the code a bit shorter.

class Beust5
{
····private static int _total = 0;
····private static int[] _pre = null;
····public static void Run() {
········_total = 0;
········_pre = new int[(1 << 10) + 1];
········for (int i = 0; i <= 10; ++i) {
············_pre[1 << i] = i;
········}

········for (int len = 1; len <= 10; ++len) {
············Generate2(len, 0, 0xFFF >> 2, 0);
········}

········Console.WriteLine("nTotal: {0}", _total);
····}

····private static void Generate2(int maxLen, int currentLen, int availableDigits, long currentValue) {
········bool last = (currentLen == maxLen - 1);
········int x = availableDigits;
········while (x != 0) {
············//digit will contain the lowest set bit
············int digit = _pre[x ^ (x & (x - 1))];
············x &= (x - 1);

············//Avoid starting with zero
············if (digit == 0 && currentValue == 0)
················continue;

············if (last) {
················++_total;
················//Console.Write("{0}, ", (currentValue * 10) + i);
············}
············else {
················Generate2(maxLen, currentLen + 1, availableDigits & ~(1 << digit), (currentValue * 10) + digit);
············}
········}
····}
}