iBeans = Dead Simple Integration for Web Apps

September 22 2009

10 comments 0
motif

I am very excited to announce that MuleSoft has launched a new open source integration product called iBeans (short for Integration Beans). provide a way to dramatically simplify common integration tasks for Web application developers.

Why did we create iBeans?

As I mentioned in a previous blog post, ESBs provides powerful integration capabilities, but not every integration scenario necessarily calls for an ESB; even a light-weight ESB like Mule. Some applications, including many web applications, require integration to only a few services, using standard protocols without any complex routing.

For example, you might be building a web app that just needs to poll an RSS feed for information and send an email alert when certain conditions are met. Or, another app might need to pull location information from a database and map it using Google Maps. In those cases, you want a solution that fits within your app rather than an ESB that sits outside of your app. The challenge is, in those simple integration cases, developers are left with few choices. They can either write hundreds of lines of code to communicate via those protocols and make the appropriate API calls to the service, or they can implement an ESB-type solution and have to overcome the concepts, architecture and nomenclature that introduces.

iBeans is all about hooking shit together. I’ve spoken with dozens of Web app developers, and it became clear that there was a huge need for something that bridged that gap – a tool that could help eliminate the “donkey work” of all of that manual point-to-point integration coding, without the need for learning ESB and its architectural concepts.

So, we created iBeans to allow your webapps, using Java or Javascript, to interact with other webapps and services by providing a simple API and annotations that enable your webapp to perform common tasks such as:

· Receiving and sending email

· Subscribing and publishing to JMS queues and topics

· Scheduling tasks, such as polling database tables or RSS feeds

· Publishing -style services using JAX-RS annotations (soon)

· Publishing web services using JAX-WS (soon)

· Interact with public APIs like Amazon AWS, Facebook or Flickr.

· Subscribing to and publishing AJAX events

iBeans dramatically simplifies these common integration tasks – developers can create an iBean for a particular application in literally minutes, and you can invoke those iBeans from a method using a few simple annotations in your code.

Yes, Javascript. One of the cool features is that you can use iBeans on the server in you web framework of choice, or JSPs or Servlets, but you can also use the same iBeans directly in the browser using the iBeans AJAX client. This means you can knock up data-driven HTML pages really easily.

Even more interesting, iBeans are ideal for sharing and reuse. We’ve created iBeans Central, which is a free repository of reusable iBeans that are built/contributed by the Mule community and hosted in the cloud. Some examples of iBeans already available for use include iBeans for Twitter, Amazon EC2, Flickr, and Gmail. These iBeans can be downloaded for free from the iBeans console, for use in any application.

iBeans

I’m hoping iBeans will transform the way people think about building web apps in the new era of the web. Rather than having to worry about the “plumbing,” developers can now focus their energies on creating useful applications with great user interfaces, letting iBeans do the heavy lifting in the background. But don’t take my word for it, download the beta and try it for yourself, at http://www.mulesoft.org.


We'd love to hear your opinion on this post

10 Responses to “iBeans = Dead Simple Integration for Web Apps”

  1. Looks cool! Is the license the same as Mule ESB (community and paid editions), or is it more in the lines of Tcat (free for developers but production requires a support license)?

    Assuming I have the notion of those other licenses correct, that is…

    Agree(0)Disagree(0)Comment
  2. Looks interesting. I’m curious though – is iBeans using the Mule ESB jars to do the message sending?

    Agree(0)Disagree(0)Comment
  3. Looks like a next-generation universal adapter to me. Interesting.

    By the way, please refrain from using profanity–it doesn’t reflext well on you, and it’s also gramatically rediculous. I don’t integrate sh&*(–I replace it with good stuff. If it’s excrement :-)

    Agree(0)Disagree(0)Comment
  4. […] Subscribe « iBeans = Dead Simple Integration for Web Apps […]

    Agree(0)Disagree(0)Comment
  5. Hi Thomas,

    iBeans uses Mule for the underlying communication. For Http inbound it binds directly to the Tomcat container.

    Agree(0)Disagree(0)Comment
  6. Hi Andy,

    Mule iBeans is licensed under the OSI approved CPAL license, the same as Mule.

    Agree(0)Disagree(0)Comment
  7. Hi Pete,

    Excuse the language, no harm intended. The term hooking “stuff” together has become a bit of a colloquial expression in the EAI world, iBeans does represent a really easy way of doing this. I hope you find it useful.

    Agree(0)Disagree(0)Comment
  8. Well, here goes my third attempt to post this, since I just got an e-mail saying my first comment in fact didn’t get through. Let’s see if the third time is the charm.

    In response to Andy:

    Andy, I believe you are in fact incorrect with respect to the Tomcat license. Tomcat is licensed under the Apache License 2.0, which is a valid Open Source license and considered compatible with GPL 3.0. I’m not entirely sure where you got the notion that Tomcat requires a commercial support license if you want to use it in a commercial setting (e.g., deploy in a corporate data center), but if you have a source for that, please share the URL with us.

    It’s true that SpringSource has a commercial version of Tomcat, called “tc Server,” but that is their own fork of the code, not something you would download from Apache.

    Of course, the Apache License does permit forking the code and creating your own closed-source derivative (as SpringSource has done), but the original open-source code would still be available. So I’m not sure how a commercial license requirement for the original could be enforced without dual licensing.

    For reference, you can check out good summaries of the state of Tomcat and its licensing from:

    [I had a couple URLs in here, but I suspect any comments with URLs are automatically deleted without being submitted for moderation. Basically, I referenced the Wikipedia articles for Tomcat and the Apache License.]

    …which include links to primary sources. You can also check out the license itself at [the Apache web site for licenses]

    That said, I think your question is still very important — licensing terms are important. I hope iBeans are licensed like Mule is, because I know my current employer is very cost sensitive and might not like being forced to pay a commercial licensing fee if we develop something innovative in-house and want to take it live.

    Agree(0)Disagree(0)Comment
  9. This is really interesting Ross. Hope this will make the integration very very simple.

    Agree(0)Disagree(0)Comment
  10. Hi Rob,

    Sorry you had issues submitting the comment, we’ll take a look.

    Andy was referring to Tcat, which is our vanilla Tomcat offering with enterprise features on top for managing servers, provisioning and diagnostics. Tcat is free for developers and QA but a license is required for production use.

    iBeans is open source under the same license as Mule (OSI approved CPAL).

    Agree(0)Disagree(0)Comment