What are the benefits of using Iguana to write interfaces vs. using .NET or Java?

This is a question that is asked sometimes by programmers in organizations that are experienced in programming in C# with .NET or Java or other languages.

It’s a natural question to ask if you only focus on the concept of the Translator IDE vs. Visual Studio or Eclipse.

Eclipse and Visual Studio are very powerful environments with a huge amount of power and functionality which makes them well suited to heavy application development where you have long release cycles. The challenge with interfacing is that one is dealing with much more transient code. Interfaces are always changing which causes a lot of pain when it comes to going through all the standard patch, release and QA cycles that you need to go through with the full process of application development. Some good background on that problem can be found in a blog I made on the topic. It’s all about using the right tool for the job in hand.

At its highest level Iguana simply offers a much lower cost, lower risk, faster way to get interfaces up and running and maintain them using operations staff rather than developers.


It comes down to three core reasons:

  1. Operations, all the key features required for easy interface management.
  2. A complete proven standard solution.
  3. Optimization of the Iguana translator IDE for middleware.

Let’s go through each of these and discuss.


It’s easy to forget that interfaces need to be managed by operations staff who were not responsible for writing the interfaces. Iguana offers the complete solution in a manner that has been proven across thousands of sites. It’s taken a long time to get to the degree of polish, usability and stability that Iguana has. These are the key features:

  1. Simple standard dashboard to stop/start interfaces.
  2. Easy centralized monitoring through the dashboard.
  3. Simple centralized configurable alerting:
    • Easily customizable.
    • Maps to roles, groups and users.
    • By interface or by groups of interfaces.
  4. Role based user control:
    • Allows tightly locking down permissions for different staff in the organization.
    • Easy auditing of who did what which drives accountability.
  5. Intuitive logging:
    • High speed query capability. (full text index ala google)
    • Flexible querying with boolean and regex searching.
    • Easy to trace the complete history of any given message transaction (hey where’s my data!).
    • Ability with a mouse click to take a bad transaction and load it directly into the translator mapper IDE.
  6. Easy visualization of the status of every single interface:
    • See the operational state of the interface.
    • Level of traffic.
    • One click to see the live logged activity.
  7. The ability to re-submit failed transactions including entire queues of data.
  8. Built in, high performance, fault tolerant queuing.
  9. High quality, reliable socket and thread pool management.
  10. Integrated change and deployment management.
  11. Easy testing of sample transactions.
  12. Highly documented and well supported.

Iguana gives you all this, out of box ready to run and go. By using Iguana and the Lua IDE the focus can be 100% on solving the only part of all this which has business value: Actually moving and translating the data that is needed to solve the pain of real business problems.

The beauty of Iguana is that not only do you get much faster results than if you rolled your own solution together, but that once you deploy it, it just runs. It doesn’t become a big time sink that consumes your scarce time and resources. The best thing operations people have to say about Iguana is that they can ignore it. It allows focus to be maintained on where there really is value for the business.

Now it’s not to say that an organization could not put together a team of developers, glue together and build components to put together a similar solution. You certainly can but…

  1. It’s expensive.
  2. It’s time consuming which means business problems don’t get solved quickly, pile up and continue to haemorrhage money.
  3. It takes a lot of development management to get it right.
  4. Getting everyone to standardize on the same architecture is very difficult.
  5. Most organizations don’t get it right which means their IT people and developers end up losing a lot of time supporting the partly implemented solutions they have.

Any organization of scale finds that their home grown interface engines become a headache over time. It’s just very hard to keep focus on something which is not a core part of your business. Even if a perfect job was done, unfortunately all technologies turn over and require replacement. The numbers simply don’t work even for huge healthcare software companies to pursue this type of development. Check out our client list!

It can be a hard thing to realize if you love coding in Java or C# but these are simply not the best tools with which to build interfaces. Don’t worry, you’ll find that scripting in Lua with Iguana makes building interfaces fun, you can have your cake and eat it too (and have your weekends to yourself without a beeper).

Standard Complete Solution

The fact that Iguana is completely integrated and standard across thousands of sites globally from Asia, Europe and North America (even a few sites in Africa, China and India) is a huge part of the value of the platform.

We have economies of scale and focus in this area that go way beyond what any of our users could get by themselves. That offers huge value through:

  1. The quality of the platform:
    • We test and deploy on multiple operating systems using best of breed tools on each to ensure high stability.
    • Obscure socket, threading issues? We’ve seen it all and solved those problems.
  2. Documentation:
    • Need a script to remove duplicates? Copy and paste. Done!
    • Instead of searching the internet for different solutions you have everything you need in this wiki.
  3. Support:
    • Our customers rave about the quality, knowledge and timeliness of our support.
    • It all comes down to razor sharp focus, high quality product and documentation.
    • We don’t do everything, we do interfaces, and we do them really well.
    • Training, either online or in person.
  4. User community:
    • We have a large, growing user community.
    • They are people just like you with the same challenges and problems.
    • Easy to meet and exchange knowledge through our forums and our annual user group meetings.

Iguana Translator IDE

The Iguana Translator IDE is optimized to be ideal for writing interface code.

It all comes down to focus on a single purpose. Eclipse and Visual Studio have to service a much broader set of needs. They can be used for large application programs which run for long times, with complex non linear execution flow. That means they need to be able to deal with all sorts of different events, mouse clicks, keyboard events and so on. They are certainly very flexible, but that flexibility comes at a cost.

Programming an interface is very different:

  1. Data comes in.
  2. It is transformed.
  3. It goes out.

And this typically happens thousands of times per second. It’s a linear process that happens in bounded time.

The translator IDE in Iguana built with Lua leverages these properties of interface development and works in a unique patent pending manner. You are always working off sample data which is conveniently accessed in a nice video recorder style interface. Every time you change the sample input data, or alter a line of script the translator:

  1. Instantaneously compiles the code.
  2. Runs it from start to finish.
  3. Renders rich visual feedback through annotation windows beside your blocks of code.
  4. See it for yourself!

The result is that it gives the IDE abilities you could only dream of in an IDE like Eclipse or Visual Studio. Debugging becomes so fast because you don’t have to go through a time consuming process of placing break points in the code and seeing what the values are at that point. Instead you can see the value of assignments and inputs and outputs into functions right in the annotations which are always present beside your code.

Expanding dialogs in Iguana to look at trees of data is simply amazing, you get synchronized views of the data as you alter it. You can open up dialogs showing input data trees and output data trees, it’s like the crazy computer visualization in Minority Report for interfacing. It’s makes it convenient and easy to test your interface code.

What’s really neat about the translator IDE is that the annotations replace the need for a traditional mapper that many legacy middleware products have. The annotations show how data is mapped between source and destinations in a clean simple way that integrates the use of live data in the view. It means rather than have lots of redundant, confusing screens in Iguana that all tasks can be performed using the same translator IDE, simple or complicated, it can all be done efficiently in one environment.

Auto-completion with the translator is a treat. Unlike traditional auto-completion, it works not just on the names of variables and functions, but also on the data they contain. The translator has a unique ability to do deep auto-completion which allows searching of deeply nested data within trees. It makes it hard to go back to using the limited form of auto-completion you have in Visual Studio and Eclipse.

Troubleshooting production problems is made easy with the translator since with a mouse click you can pull the bad transaction right into the Lua IDE using exactly the same version of the production code and diagnose the problem right there.

Version management and deployment is easy and painless. Iguana has it’s own integrated source code management system. It’s impossible to put an unversioned interface into production. It’s also simple to export that into your main enterprise source code control system using a simple script.

Picking up and learning to use Lua will take an average .NET or Java developer a day or two. The Lua language is a very small elegant language that is easy to learn for anyone who is comfortable with programming. In fact we have some users that came with zero programming experience before Iguana and quickly became proficient in the platform. For a professional programmer the environment offers no end of creative possibilities.

Hopefully that gives a good overview of the advantages that Iguana offers for interface development vs. using C# or Java. If you have any questions or comments please feel free to ask.

One Comment

  1. priya

    Interfaces are mainly used to provide polymorphic behavior. Interfaces function to break up the complex designs and clear the dependencies between objects.

Leave A Comment?

This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.