Posts filed under 'Mashups'
Works With
JackBe Presto is bundled with and runs on the popular Apache Tomcat server out of the box when you download and install it. But as a pure Java application, Presto is designed to run on any standard compliant J2EE application server that has JSP/Servlet support.
I wanted to deploy Presto on Sun’s open source J2EE application server, GlassFish, since a few of our friends at Sun were interested. If you are new to GlassFish, it is the name for the open source project for building a Java EE 5 application server sponsored by Sun & Oracle (more details here).
The process of deployment was very easy. If you have downloaded and installed Presto, it is easy to locate the Presto war files that represent different Presto capabilities and deploy them using the GlassFish administration console or the command line asadmin utillity that comes with the GlassFish installation. With just a click of a few buttons, the following Presto components were deployed on GlassFish:
- Presto Edge Enterprise Mashup Server with Service Explorer and Administration Console applications for managing Edge
- Dash, our user driven dynamic desktop application
- Sample applications to show mashup examples and data binding examples
That and an evaluation license key you get when you download our software is all you need to run Presto on GlassFish. Kudos to our development team for a great job in maintaining standard compliance and pure Java in our code. Pretty cool!
September 20th, 2007
[Cross-posted from http://blogs.jackbe.com]
In my last blog entry, I defined what I mean by a mashup. In this entry, I want to expand upon how I think mashups differ in the enterprise compared to some of the consumer mashups out there.
I mentioned in my earlier post that mashups based on maps are ubiquitous and something that the users can immediately grasp. But, once you step inside an enterprise, things can be a lot different for mashups. Enterprises are not greatly interested in map-based mashups, neither are they interested in RSS or ATOM services which I think are still not fully leveraged inside an enterprise. Over the past few years, enterprises have invested heavily in SOA and because of that, they are just about getting done with service orienting their enterprise with Web Services (primarily using WSDL). And there are many applications in the enterprise that are still very database oriented. It has become relatively easy for an IT developer to expose services as WSDL based web service. And almost every middleware product out there in the enterprise is capable of exposing services via WSDL or makes it really easy to do so. Hence if you start looking around in an enterprise, what you will find is what I call the Service Cloud.
So what you have in an enterprise is a cloud of services where some are WSDL based, some are REST based, some or XML/HTTP, some are database objects, and so forth. Now, the real challenge is how to mashup these disparate kinds of services, with different service contracts and data formats. Any respectable enterprise platform that offers to mashup services in the enterprise must negotiate these disparate contracts these services expose (e.g. while a WSDL based web service defines a service contract in a WSDL document, a REST based web service has no such contact definition). And not only that, it must be done so that that we can make it easy to access for developers and users alike, and to be able to do that securely and with high-performance and scalability. Some enterprises might regulate the service consumption of even public web services that most of us can freely access on the net (think of the ubiquitous RSS feeds for example). Enterprises might allow consumption of these services, but would like to do so with governance underneath to manage, monitor and secure such activity within the enterprise. This is why we built our enterprise mashup platform at JackBe from the ground up, to address the unique challenges of mashing in the enterprise so that we allow our users to do the following:
- Create and customize mashups that consume all kinds of services: RSS, ATOM, WSDL, REST, DB, SDO, Java Objects, etc.
- Securely govern the mashups: policies for who can mashup, what can they mashup
- Share the mashups to collaborate in the enterprise
My colleague John Crupi wrote about enterprise mashups becoming the new front-tier in the enterprise. I would like comment a bit on what he said in his post. While SOA efforts have been IT driven and IT oriented, even with involvement by the business units, the outcome has been primarily IT and developer focussed. It has neglected an important stakeholder in the enterprise, and that is the User. Therefore, I view the new enterprise mashup layer as a new service layer in the enterprise application architecture that finally begins to leverage SOA from the end user perspective and to make the services layer more user-friendly (and developer-friendly) to build, deploy, share the next-generation enterprise web 2.0 mashup applications.
What do you think?
July 30th, 2007
[Cross-posted from http://blogs.jackbe.com]
Over the last year, the term mashup has become extremely popular not only in the consumer software space, but also in enterprise software. It has been a little more than a year since I joined JackBe as VP of Engineering responsible for executing our vision. Over this time, I and our team at JackBe has been busy creating our enterprise mashup platform, which is a unique innovative offering in enterprise software today, by combining the benefits of RIA technologies such as Ajax/RIA, Web Services, Service Oriented Architecture and Mashups.
At the internal technology briefing last week, I and my team presented and demonstrated the features of Presto, JackBe’s enterprise mashup family of products, to 25 developers and consultants. One of the important areas of discussion was around what we mean by a mashup and how the term ‘mashup’ has evolved over the last year to mean almost anything. For example, the following is the definition of the term mashup on Wikipedia:
A mashup is a website or application that combines content from more than one source into an integrated experience.
The problem with this definition from my perspective is that it allows you to practically label anything as a mashup, including a portal application, composite application, and what have you that brings disparate content onto a single web page.
I don’t think I want to disagree with this or any other definition of a mashup floating around in the industry. However, I feel that all the existing definitions and explanations are lacking something so important about the real intent of these mashups. This was also apparent at the discussion a few weeks ago at the IBM Mashup Ecosystem Summit. So, now I feel compelled to offer you what we at JackBe mean by a mashup:
A mashup is a shareable software block created by a user, encapsulating ad-hoc user driven processing of disparate data sources, delivered with a user focused view.
Allow me to elaborate further using the following characteristics:
- Mashups are made up of user driven micro-orchestrations. In other words, when I access some data or service, I am performing small operations on the way data is computed and rendered in a very informal and iterative manner. For example, consider how one uses a spreadsheet which is a great example of a canvas where mashups happen in the enterprise when a user pulls in data from different sources, combines, sorts, computes, filters and visualizes by iteratively processing it until he gets the desired results. If you really think about it, what the user is doing is really orchestrating getting data from different sources and processing using one or more operations to yield an integrated view of the data.
- Mashups are user focussed, i.e. they are primarily created by the user for the user. They are not the product of some developer or IT guy writing a lot of code. However, current examples of mashups that we see are primarily developer oriented, it is just the beginning. The real value of mashups comes when we enable and empower our end users to perform these mashups the way they want to do it without having to call and rely on IT needs.
- Mashups are ad-hoc creations and are very situational based on users immediate short term needs. They are designed by the user to meet a specific need. These mashups have a very short life span varying from hours to days. This is the reason that the users cannot wait and demand IT to create and deliver these mashups.
- Mashups can be visual and non-visual. The most common kind of mashup that is out there is probably something that overlays some information on some kind of a map. However, there is more to mashups than just displaying pins on a map. I can mashup disparate data to create an integrated data view. I can mashup processes to create a new process. I can mashup domain models of different application domains to create a new application domain model.
- And finally, mashups can be performed on the client side and on the server side. However, I think the best value of a mashup is when we combine both client side and server side mashup functions since we can defer heavy lifting to the server and build intelligent clients that can enhance, complement and focus on user experience.
Before I conclude, I would like to emphasize a few points.
- Whether we do visual or non-visual, client-side or server-side, mashups must be user driven and user focussed.
- Just because mashups are user driven and user focussed does not mean that we no longer need IT. IT is still a critical part of the whole mashup infrastructure in an enterprise. However, instead of the users going to IT for every little thing they need which can be transient, situational and ad-hoc, they should be able to accomplish what they need without having to rely on traditional IT and experienced programmers to build what they need. For example, imagine what would happen if Microsoft Excel users needed IT help to write a macro or to create a chart from a table of data they put together. Mashups in the enterprise must address these kind of needs of enterprise users accessing disparate data and services to create and share new information in the Enterprise Web 2.0 world.
In my next blog entry, I will discuss more about our work in creating our comprehensive enterprise mashup platform that encompasses the above characteristics. It finally feels great to be able to talk about what we have been obsessively building over the past year!
What do you think? I am really interested to hear other opinions and thoughts around this.
July 22nd, 2007
[Cross-posted from http://blogs.jackbe.com]
[As a preface to this blog, I want to give my apologies for being away from blogging for the last few months. I’ve been busy creating Enterprise Mashup software here at JackBe. Now that our software is production-ready, I’m looking forward to getting back to posting regularly and getting your feedback on my development efforts. Deepak.]
I was at the Mashup Ecosystem Summit organized by IBM at their offices in San Francisco last week. Our CTO, John Crupi, and our Chief Architect, Raj Krishnamurthy, also attended with me. It was an interesting mix of people from different backgrounds and companies all converging on the concept of Mashups. Jeff Nolan (ex-Teqlo, ex-SAP) gave an interesting talk about his experiences in a starting up a mashup company. Some notable points were: (lack of) availability of APIs; Do-it-yourself Data Formats; Performance can be a challenge; Need for strong visual composition tools; Lack of Standards. I think these are questions that this group will be able to tackle over time. (At least, I hope!)
At one point during the end of the meeting, someone asked: “What really is a Mashup?”. This led to a brief but inconclusive discussion. Which goes to show how nascent this field is that even among the experts in the industry, there is still some uncertainty about how to define and qualify a mashup. (Coincidentally, JackBe has a webcast coming up on May 23 on this very topic: ‘Enterprise Mashup Bootcamp: What, Why and How’. You can register for that webcast here.)
I managed to slip in a question at the Mashup Summit about how the group feels about Composite Applications which were a hot topic a year or more ago and how they relate (or not) to mashups. Predictably, there wasn’t a big desire for this discussion. However, my own personal take is as follows. We in the SOA software industry have been busy implementing SOA in the enterprise over the last few years in our architecture and IT infrastructure. This effort in SOA has largely ignored the end users, and mostly focused on the IT and business stakeholders. Composite Applications are, in a way, IT efforts to provide integration of data, services and processes. While there has been a proliferation of services around the internet/intranet, users have no good tools to use them to do their job more effectively. Therefore, end users do not see much direct benefit of SOA or services or even composite applications.
These SOA/services/composite applications efforts are now undergoing an (r)evolutionary transformation. Enter mashups. And enter the users! The integration is now happening at a higher level in the application stack, much closer to the user. (This is also what Dion Hinchcliffe points out in his blog, where he talks about the 5 styles of mashups.)
There was also some question/opinions about security and how to govern mashups. I think there is no need to be overly paranoid about this. However, service access control is still important in an enterprise world of mashups. Consider that today users are already doing mashups, whether you like it or not. They are doing this mostly in their heads or in a spreadsheet, mostly manually and mostly in a tedious and time consuming way, and in a not-easy-to-replicate-or-teach manner. If the users have access to the data, you don’t really have control on what they do with it in their heads or spreadsheets. So, why not make it easy for the users to do this, faster, more efficiently, collaboratively (so they can share their analysis/knowledge), and to do all this with the least amount of programming skills required (leaning towards no programming required). We are aiming for this at JackBe, as I am sure other vendors in the mashup space are.
Other notable topics of discussion at the Mashup Summit were:
- Microformats. My favorite topic. I think Microformats (www.microformats.org) are currently under rated/under used in an enterprise. Expect to see a lot of interesting things in this space in the coming months. We have a thing or two in the works about this as well at JackBe. (Also see Jeff Nolan’s comments on this topic.)
- Mashup of Data vs. Processes. It is easy to confuse the two and it’s important to remember they are not the same.
- Offline & Synchronization: Ross Mayfield of SocialText asked how important this feature is and whether there really are good use cases that demand this feature. He blogs on this (and related) topics quite a bit and has a interesting perspective.
Bottomline, we at JackBe believe that a mashup has to be user-focused and user driven (not IT driven). Let’s stop searching for the killer app. The killer app is here and it is the User. Let’s enable and empower them to do what they really can do with mashups.
May 15th, 2007
