Sponsored By

Mashups can be whiz-bang simple, but in the enterprise, data management, application security and control, and complex user needs can complicate matters. JackBe's Presto 2.5 provides professional-grade tools that streamline mass mashup production.

Nelson King

February 2, 2009

4 Min Read

Building Mashups, then Mashlets The JackBe Presto platform's 'Wires' data management tool.
The JackBe Presto platform's 'Wires' data management tool.
(click image for larger view) In the lingo Presto uses, information (filtered and selected data) in a format ready for a user interface is a 'mashup.' The display of mashup data is another element, typically a Presto "mashlet" -- a mini application or widget that uses mashup data. Mashlets package both data and user interface, and can be embedded and used as-is in Web pages, wikis and mobile applications. Mashup data can also be fed to more elaborate user interfaces via the Presto API into rich Internet applications (RIAs), portals, Adobe Flash or AIR applications, Excel spreadsheets, VBA, Windows Automation applications, and applications written in Java or C#.

For the non-developer, Presto provides "Composers" -- Service Explorer, Wires, and Mashlet Maker -- to locate data sources, link them to appropriate user interface elements, and package the whole thing as a mashup and then a mashlet application. The main tool is the Wires composer, which currently runs only in the Firefox browser. (This is an unexpected limitation, though indicative of other loose ends in Presto.) Wires has a slick GUI; it's essentially a data management tool that helps identify and process data. It's intended for people unfamiliar with data queries, but a non-IT user would need to be schooled about how data is filtered and displayed. It's common for companies with mashup technology to speak of "technically savvy" users who can create their own mashups, but even with a helpful tool such as Wires, this is only going to work under certain conditions. Those conditions, where the right data correctly fits the appropriate user interface, will need preparation by a programmer/developer. This is also true of Presto. If You Speak the Language Fortunately JackBe seems to know that Presto will mostly be in the hands of developers. In addition to the advantage of a dedicated mashup server, Presto also offers a dedicated mashup programming environment and, most significantly, a domain-specific language called EMML (Enterprise Mashup Markup Language). To use EMML, the developer jumps with Presto into the world of Eclipse (the IDE of the Eclipse Foundation) and specialized Presto APIs. Presto Mashup Studio is an Eclipse plug-in, which like most Eclipse-based approaches, uses the Eclipse Workbench interface and other developer tools (such as the debugger) in conjunction with a specific language, in this case EMML. JackBe's implementation of Eclipse is solid and unexceptional (that's good). Anyone who has used Eclipse before will have few difficulties with Presto Mashup Studio. EMML provides commands and operations common to mashups in a very efficient form, and it produces extremely compact output code to run in the JavaScript browser client. EMML provides a satisfying way to have more control over mashup applications. Of course, EMML is yet another language with a learning curve and its own quirks and frustrations. As developers are discovering, a mashup as an individual application can be whiz-bang simple, but in the enterprise mostly they're not. Data management, application security and control, and the sometimes ill-defined or complex needs of users make the production of a whole series of mashups anything but simple. That's where JackBe's Presto comes in: It makes mass-production of enterprise mashups possible and it provides professional-grade tools for managing the job. The appeal of Presto all comes down to the priority an organization gives to mashups. Like any kind of specialized tool, Presto increases its effectiveness with consistent use. Some organizations may be content to dabble with mashups, for which limited tools or tools peripheral to a larger platform may be sufficient. Enterprises that are convinced of the value of mashups, that foresee using them extensively, will find JackBe Presto 2.5 not only capable but also advantageous -- in short, a competitive edge. This may justify the learning curve of yet another programming paradigm (and language) to integrate into the enterprise shop. Operating Systems: Windows (Vista, XP SP2); Linux (Fedora Core 5), OS/X (10.4.6), Solaris 10 x86
Application Servers: Apache Tomcat 5.5 (distributed with Presto), Sun JBoss (4.2.2GA), IBM WebSphere (6.1), BEA WebLogic (10.0), Oracle Containers for Java (10.1.3).
Browsers: Internet Explorer 6, 7; Firefox 2.0.
Pricing: Negotiated perpetual or subscription pricing; perpetual license is $20,000 per production CPU (server).

About the Author(s)

Never Miss a Beat: Get a snapshot of the issues affecting the IT industry straight to your inbox.

You May Also Like

More Insights