Jaspersoft Studio Review

TIBCO Jaspersoft is the force behind the JasperReports® Library, Jaspersoft® Studio and JasperReports® Server. At the core of this product suite is JasperReports, a Java based reporting engine and API. The JasperReports Server embeds the JasperReports engine and provides a user-friendly, web-based interface for end-users to run and view reports. Jaspersoft Studio is an open-source graphical design tool that allows developers to create report designs that can be run and rendered by the JasperReports library. Jaspersoft Studio replaces Jaspersoft iReport which we last reviewed in 2012. iReport will be supported through December 31, 2015 when it will reach its end of life.

• Changes Since Our Last Review
• Components
• General Impressions
• Strengths & Weaknesses
• Conclusions

Changes Since Our Last Review

"2014 was an eventful year for Jaspersoft. We launched two new versions of our flagship product, JasperReports Server: v5.6 and v6, both full of clever innovations. We reached new records for total number of customers, product downloads, and registered community members. Oh yeah, and we were acquired by TIBCO Software at the end of April."

- Brian Gentile Sr. Vice President & General Manager, TIBCO Analytics Product Group

 

Jaspersoft has had two major announcements since our last product review in 2012. First was the acquisition of Jaspersoft by TIBCO in Q2 of 2014. While still early, it does not appear that the acquisition will cause any major disruption to Jaspersoft's commitment to open source software. The bigger news for Jaspersoft report designers was the end of life announcement for Jaspersoft iReport. Jaspersoft Studio (JSS) is the supported report designer. We feel that this is good news for Jaspersoft report designers, given the number of enhancements and improvements that have gone into JSS over the last three years. The following features have been added that stood out for us:

• Plugins for version control including CVS, SVN, and GIT
• Improved properties editor including a search feature
• Full support for Google Maps as report elements.
• Full support for HTML Text component
• Improved SQL designer – now more stable and user-friendly
• New custom visualization component, Visualize.js, which allows developers to use JavaScript (e.g. D3) to include SVG content in a report
• New JasperReports Book Editor which simplifies linking of reports and Table of Contents creation
• Performance improvements
• Improved Java Report Server (JRS) integration
• Improved component layout options
• Added or improved out of box support for Cassandra, HBase, Hive and MongoDB data sources

Figure 1 - JSS includes a large number of pre-defined data source types

 

Components

Jasper’s product suite is fairly broad (although not as broad as Pentaho) including reporting and data integration/ETL. The open-source community edition includes the following components for reporting:

1. JasperReports Library – The JasperReports Library is an extensive library of Java classes and APIs that let you programmatically create report designs, run them against data sources, and render their output in HTML, PDF, Excel, and other output formats. You can embed JasperReports inside your Java applications. If you are using the JasperReports Engine to run reports, then JasperReports Server is not required.
2. Jaspersoft Studio (JSS) – a replacement report designer for iReport (which has had an end of life announcement) that is an Eclipse plug-in.
3. JasperReports Server – the JasperReports Server is a J2EE application that lets multiple users run reports and OLAP cubes through a web-based user interface. It is distributed using Apache Tomcat, but can use any Java application server. At the core of the JasperReports Server are the JasperReports engine, the Mondrian ROLAP Engine, web-based user interfaces for end-users and administrators, and a host of server capabilities including authentication, user management, logging, email notification, web services, and report scheduling.>
4. Jaspersoft ETL – Jaspersoft ETL is a data integration engine powered by the Open Source Talend* software.
5. Jaspersoft OLAP – Jaspersoft OLAP is a series of commercial and open source components that allow for the analysis of data.
6. iReport Report Designer – iReport has been replaced by JSS and will reach its end of life on December 31, 2015.

General Impressions

JasperReports is the most popular and widely deployed open source reporting project in the world. It has been deployed in hundreds of thousands of production projects, and its reporting capabilities are built into thousands of software products. As such, Jaspersoft Studio (JSS) is a solid, full-featured tool, capable of creating and running the gamut of traditional “real-world” report designs, from simple to complex layouts. However, we feel that JSS is less usable than both the BIRT Designer and the Pentaho Report Designer. We find that many simple, common operations - such as creating aggregates – are more difficult in JSS than the other open source design tools.
 

Our fundamental issue with JasperReports has always been that Jasper seems to have taken paper reports as its starting point and worked to replicate them on the web. This complaint while mitigated in JSS, is still present. For instance, a common complaint with Jasper was the lack of a Table of Contents mechanism (TOC). JSS has addressed this through the Jasper book concept which uses Jasper's sub-report concept to build reports with a TOC. While this works, the workflow is relatively complex and requires a fair amount of effort to link the TOC to the hand built bookmarks in the other sub-reports. While effective, this approach is significantly more difficult than building a TOC in BIRT or Pentaho.
 

Despite this fundamental issue, we feel that JSS is a significant step forward addressing many of the issues that we found with iReport. All indications are that Jaspersoft will continue the progress towards a better report design tool with JSS.

 

Jaspersoft Studio (JSS)

JSS is a WYSIWIG tool based on the Eclipse 3.8.1 platform that lets you create reports using a graphical user interface, as opposed to creating reports programmatically using the Jasper Reports Library. These reports can then be run by the Jasper Report Engine or the JasperReports Server. JSS is available as both a stand-alone application or as an Eclipse update, available on the Eclipse Marketplace. Jaspersoft has done a nice job integrating JSS into the Eclipse framework, providing an interface that retains many of iReports best features, while leveraging the now ubiquitous Eclipse UI experience.

More importantly, JSS has added a number of well designed dialogs (Eclipse views) that allow a report developer to fine tune the properties of the controls within a report. Like BIRT, Jaspersoft's dialogs help guide report developers to the properties that they want to control. This is a significant improvement over Pentaho which lumps all of the properties for a control into a single grid structure.

 

Figure 2 – Screenshot of the Jaspersoft Studio Interface. It has the typical designer components – the report design with a preview tab, and panels for the report outline/structure, the report element palette, and the improved property editor.

 

JSS has much of the same functionality as the other report designers, as demonstrated by our Product Comparison Matrix. However, JSS is different from the other report designers in a few major ways:

1. JasperReports uses “pixel positioning” as its central approach, and at its core it emphasizes paginated reports, as opposed to web layouts. This is similar to Pentaho, but different than BIRT which uses a table based approach.  The limitations of the pixel positioning approach have been mitigate by the introduction of a Table element within JSS.
2. JasperReports rely on sub-reports to support reports with multiple queries and data sources.  This is different than BIRT, but the same as Pentaho.
3. Charting is middle-of-the road in JSS: more full-featured and easier to use than Pentaho, and more difficult and less full-featured than BIRT.
4. JasperReports must be compiled, which is different from both BIRT and Pentaho.

The JSS report designer is a solid tool that has seen steady refinement since its introduction in 2012 and is capable of producing fairly complex report designs. However, it can be difficult to use and the learning curve is steep. Much of this is due to Jasper’s underlying approaches to report design. Jasper, like Pentaho, is in the “pixel positioning” school of report design, where the report designer must explicitly place each control and field on the page and format them individually. This means drawing your own tables, handling borders and formatting for each cell individually instead of for the table as a whole. This makes things especially tedious if you want to add, delete, or reorder columns. “Pixel positioning” is very different than the BIRT’s approach, which is table and grid-oriented, much like how web pages and spreadsheets are usually developed. So with BIRT, there is a “table” element in the palette that makes it easier to create and format tables as a whole, and adding, deleting, or reordering columns is a snap.

 

Jasper’s emphasis on pagination and pixel-positioning gives report developers fine-grained control over the look report, but also limits the report’s ability to adapt to different-sized displays. So, for example, if you want a report to look good when printed on an 8.5”x11” sheet of paper, that the report will only be as wide as a sheet of paper even when displayed on a widescreen monitor with lots more horizontal screen real estate.

 

Also, like Pentaho, Jasper is very dependent on sub-reports. If you want to use multiple data sources, use a query’s result set more than once in a report, or have side-by-side report components, you need to use sub-reports. While sub-reports are great for re-using report pieces across many different reports, requiring sub-reports for the above use cases adds unnecessary difficulty and complexity to the report design process:

• You need to gracefully hand parameters and sometimes query data between the master report and sub-report (and sub-sub-report, etc).
• From within the JSS, you cannot actually see how the sub-report will show up in the master report; instead a “sub-report” icon is displayed.
• Report developers need to manually manage the dependency between the master report and sub-report files.
• Too many sub-reports can result in very poor performance because each sub-report opens its own database connection, thread, and queries. So, for example, if you have a sub-report within a group section that expands into 70 different groups, then the sub-report will run 70 times, opening up a new database connection each time.

Unlike BIRT and Pentaho, Jasper requires that you compile reports prior to running them. This means that report developers must have the entire Java SDK installed. Compilation also adds an extra step to the process of deploying reports. Since the compiled Jasper report executables are Java byte-code, revision control is difficult since it is impossible to identify the differences between versions of a binary file.

 

JasperSoft excels at the way it can use Java objects (POJOs) as a source of data. While both BIRT and Pentaho have this functionality, Jasper seems to have the best interface that really encourages this type of data acquisition. This is particularly for cases where you have an application that has a Java data abstraction layer. Rather than query the underlying database, and having to recreate any business logic in the data abstraction layer, your app can simply pass the data to the JasperReports runtime.

 

On the other hand we are not big fans of the JSS SQL query editor. While the editor has had significant improvements since we last reviewed the product, it was still more difficult to use then either BIRT or Pentaho's query editors. Part of the issue seems to be that the JSS query editor has three interchangeable modes: Text, Outline and Diagram which all have their own modes of operation. We found it to be a bit clunky, although at the end of the day it is functional. Jaspersoft deserves kudos for trying to make them all work together (BIRT does not allow switching from Text to Graphical) but we hope that they spend another round of development on the editor to further improve it.

 

Pixel-Positioning Approach

Jasper, like Pentaho, is in the “pixel positioning” school of report design, where the report designer must explicitly place each control and field on the page and format them individually. This approach is the foundation of JasperReports and JSS, and you can see evidence of this throughout the tool. The result is that the report author can precisely control how a report looks when printed out on standard-sized paper, and the output can be precisely formatted and unvaryingly consistent. For projects that require a lot of printed reports, JasperReports might turn out to be the best choice. However, note that Jaspersoft’s emphasis on printed output detracts from its ability to dynamically adapt reports to the size of the web browser window and make the most efficient use of screen real estate possible.

 

Sub-Reports

JasperReports, like Pentaho, is very dependent on sub-reports. If you want to use multiple data sources, use a query’s result set more than once in a report, or have side-by-side report components, you need to use sub-reports. While sub-reports are great for re-using report pieces across many different reports, requiring sub-reports for the above use cases adds unnecessary difficulty and complexity to the report design process:

• You need to gracefully hand parameters and sometimes query data between the master report and sub-report (and sub-sub-report, etc).
• Report developers need to manually manage the dependency between the master report and sub-report files.

Charting

JSS like Pentaho uses JFreeChart as the charting engine in the community product (the commercial product provides additional charting engines). Charts are built in JSS using a simple wizard. First, you pick the chart type from the big diagram below.

Figure 3 - To add a chart in JSS, you first select the type of chart.

 

The wizard then prompts you to 1) select a dataset, or sub-dataset, to populate the report, and 2) specify which data fields that identify the series displayed in the chart and which are to be the data values, and out pops a chart. You then use the property editor to change anything else about the chart, such as its formatting, size, hyperlinks on pie slices, order of series, etc. While most of the necessary options appear to be available in the chart’s property editor, this process is not as usable as it could be due to the number of properties available and limited visual feedback in design mode when a property value changes.

Figure 4 - Step 2 of the JSS chart wizard. Selecting keys & values.

 

Selection of individual properties to create a uniform chart type would grow quite tedious for developers that are implementing a large number of charts. JSS provides two additional mechanisms that allow a user to modify the appearance of a chart. Themes allow a developer to set the value of multiple properties in a single file and the apply that theme to multiple charts. JSS has a theme editor that allows developers to configure a large number of properties and then see the result a large selection of sample reports. Themes expose even more properties than those exposed through the single chart property interface and provide a high level of control over the charts appearance.

 

In addition to Chart Themes, JFreeChart supports customization of the chart layout through a Chart Customizer interface. Chart customizers are quite powerful allowing developer to fully leverage the full JFreeChart library function. Developers wishing to exploit the Chart Customizer interface create a Java class that implements the JRChartCustomizer interface. The chart class must then be compiled and exposed to JSS and the runtime environment as a jar file. This process is well documented, but goes well beyond the skills or patience of many report developers. JRChartCustomizer Documentation.

 

Figure 5 - JSS Chart Theme Editor

 

Report Compilation

Finally, unlike BIRT and Pentaho, Jasper requires that you compile reports prior to running them. This means that report developers must have the entire Java SDK installed. Compilation also adds an extra step to the process of deploying reports.

Strengths and Weaknesses

Below are some of the strengths and weaknesses of JSS, as compared to BIRT and Pentaho’s report designers. Note that some of these strengths and weaknesses are really due to the behavior of the underlying JasperReports library, not JSS itself. However, we include them here because the report developer is most likely to encounter them.

Strengths

• Has excellent out-of-the box data connectivity. JSS and JasperReports Server both include many database drivers that BIRT report developers would be required to track down and install. Jasper also supports more data sources through the user interface, instead of requiring the report developer to use the scriptable data source adapter.
• JSS has out-of-the-box support for connections to Cassandra, MongoDB, H2, Hadoop Hive and JSONs.
• Can create “newspaper layouts” reports with of multiple columns, side-by-side on the page. Neither BIRT nor Pentaho can do this.
• Although not free, JasperReport’s documentation is much better and more comprehensive than Pentaho’s, but not as good as BIRT’s.
• JasperReports has better, more fully-developed cross-tabs than Pentaho, but worse than BIRT’s.
• JasperReports has better, more fully-developed and usable charting than Pentaho, but worse than BIRT’s.
• JSS is the only report designer that supports Google map components. While all these report suites can be made to use Google Maps, JSS is the only designer that has them as an element in the report design palette, so report authors can include a Google map in a report as easily as including a field from a database.
• JasperReports is exceptionally easy to install and get running with common data sources. A Windows installer is available that includes many common database drivers. If you install the JasperReports Server, it will also install a copy of JSS that is all configured to publish directly to the JasperReport Server.
• JasperReports is the most widely deployed of the three BI platforms, boasting over 175,000 production deployments worldwide, demonstrating its flexibility and stability.
• JasperReports provides excellent integration with third party JavaScript libraries through the Custom Visualization Control

Weaknesses

• JSS is the most difficult to learn and to use of the three designers. Many common tasks, such as specifying sub-totals for a grouped report, are easier in the other two report designers.
• Jasper requires that you compile reports prior to running them. This means that report developers must have the entire Java SDK installed. Compilation also adds an extra step to the process of deploying reports. Jasper provides integration with Ant, but this is a step not required in the other products.
• Jasper’s charts are superior to Pentaho, but inferior to BIRT. There are several ways to customize your reports in Jasper through the user interface, but it is not an easy task and goes beyond the skills of most report developers.
• With JSS, it is difficult to create Top-N, Top-N%, Bottom-N, and Bottom-N% reports.
• Jasper has attempted to create a SQL query editor that provides a textual, structural and visual diagram to build queries, unfortunately at this time the query editor is difficult to use. In particular, management of table joins is difficult and switching between modes (e.g. textual to diagram) causes changes to the SQL text that many developers may not appreciate.