Pentaho Reporting 3.6 and the Pentaho Platform 3.5.2 are currently in their final stage of production. Its not long until the extended parameter capabilities, the Custom datasource support for MDX and myriads of bug-fixes become a blessed version to be used by everyone.

Kurtis Cruzada, product manager at Pentaho, will give a overview about what is new and noteworthy in the new release on Wednesday, 3rd of February. If you feel you cannot afford the outrageous costs for downloading Pentaho Reporting from Sourceforge (or if you’re living in one of the designated rouge-states and thus are blocked by US Law), you may at least want to join the Pentaho Community WebEx to see what you will be missing out.

Finally we compiled all recent changes together to ship the milestone release of the next release of the Pentaho Reporting System. The release, as usual, contains the Pentaho Reporting Engine, the Pentaho Report Designer and the Pentaho Reporting Plugin for the BI-Server.

This release centres around making the XAction-less mode more viable. The heart of the changes is made up by the new formula-parameter system. Formula parameters provide the ability to

• compute display-values for list-parameters
• post-process user-input
• derive new parameters out of the existing input
• validate the user-input against business logic rules

Parameter can now be hidden, so that they do not show up in the user-interface. Hidden parameters in combination with the post-processing formula provide the derived parameter ability.

The other major shortcoming of the 3.5 release circled around the ability to define the various security settings for SQL and Mondrian/MDX datasources. All data-sources now can define values for the username/password and Mondrian/OLAP4J role properties. These settings can be either given as static values, hardcoded by the report-author, or can be read from a field or parameter at runtime, and thus can originate from a hidden/computed parameter.

To read values from the server-side session, the ENV-formula has been extended to look for session-attributes. A formula like =ENV("session:my-attribute") will look at the session of the server and search for a attribute named “my-attribute”. If the attribute is a string, it will be returned and can be used in the report.

ENV can now also be used to retrieve Mondrian-roles from the platform. Roles can be returned as String (ENV(“roles”)) or as array (ENV(“roles-array”)).

And last bug not least, to reduce the manual work when setting up data-sources, all well-known environment properties are now automatically imported into the data-row. Environment-Properties like “roles” therefore available as a report-field called “env::roles”. Which environment properties are considered “well-known” is controlled via the global report-configuration, so it should be easy to adapt this schema to your organization’s defaults.

To see these changes in your BI-Server installation, you will have to update the reporting-plugin and the various reporting-jar files. The download for the reporting-plugin contains detailed instructions on how this is done.

We will stop with the development work on this release somewhere within the next 2 to 3 weeks. The final GA release should come shortly afterwards.

Pentaho Reporting 3.6 will be part of the 3.5.2 bug-fix release of the BI-Server.

The purpose of this milestone release is to gather as much feedback on the real-world viability of both the formula-parameters and the security setting enhancements as possible. When test-driving this release, please give us feedback on how well we hit the requirements of your organization and how easy it is to get reports up and running in your environment. Don’t hesitate to tell us all about any repetitive steps you have to take to get reports up and running, so that we can take steps to eliminate or at least minimize those.

And now grab your copy from Sourceforge at
http://sourceforge.net/projects/jfreereport

The next release of the reporting-package is in the forge and a milestone release seems to be unavoidable now. It’s amazing how many small bugs and issues add up once you make the decision to make the release. The minute after the commit-ban is in place to let the release build, bugs start to float in. Luckily, we are no evil mega vendor, so we can be agile about it and just make sure the next release hits the market faster than the bugs hit us. So far, we already squashed 68 cases, half of them bugs, and half of them new features that make bridge gaps we identified or just were easy to implement. (Yes, laziness is one of the deciding factors in what new feature should go in first.)

The surely most needed improvement was the page-setup dialog. For some foolish reason, we made the assumption that when the JDK comes with a Page-Setup dialog, then it would be usable. But JDK 1.5 is badly broken and the fixes in JDK 1.6 just made this functionality broken in other interesting ways. So far, Sun hasn’t managed to deal with missing attributes in responses from a CUPS server that breaks printing on Linux, and likewise wasn’t able to test whether a printer-driver is installed on Windows (which gives a NullPointerException if you haven’t one installed). Well, I cant fix the JDK, and printing with Java might be a adventure I dont want to get back to any time soon.

But Pentaho-Reporting has some nice features that have been hidden in the past. One of them is our ability to print on a large virtual page (also known as poster-printing). So if you ever wanted to see your company presentation on a 10 by 10 meter paper but only have ordinary desktop printer available, we can make that dream come true.

After a long, long time of development, and a healthy amount of hacking and slashing, Pentaho Reporting 3.5 is now ready to download from Sourceforge.

Let the world hear our battle-cries:
“No more XML editing!”
The report-designer is now able to edit every aspect of our report-definition-format. There are no blank spots in our tool any more – if the reporting engine can do it, you can define it inside the Report-Designer.

“No more redundant XActions!”
Simple, standard reports with or without parameters should not need an extra document to maintain. With Citrus, the report-definitions contain both the data-definition and the parameter-description so that XActions can be omitted. Now you only need one tool and create one artefact to get your parametrized reports on the BI-Server.

“One Fileformat to rule them all”
Gone are the days where publish produced a incomprehensible XML file that cannot be edited safely from the report-designer. Beginning with the Citrus-Release, the report-designer uses a single fileformat for both client-side editing and server-side execution. This finally enables true round-trip processing, where you can download/open report-definitions directly from the server to edit them locally to re-publish them later in one go.

This release is centred around the all-new and all-shiny report-designer. The most visible features of this release are:

• Side-By-Side sub-reports
• Parameters in the report-designer
• New datasources: Scripting, PDI and a static Table-datasource
• Expanded formula-capabilities
• Bar-Code and Sparkline elements

This release also features a new XAction-less mode of operation for simple parametrized reports. For the more complex cases, XActions are still available and the new report-definitions can be used via a new XAction-component to solve all the mind-boggling complicated use-cases.

Go grab your copy from SourceForge today!
https://sourceforge.net/projects/jfr…/3.5.0-stable/

This weekend, we finally released Version 0.8.10 of the Pentaho Reporting Classic Engine. This release is yet another infrastructure release (yes, sounds boring) that prepares the ground for going to 1.0.

Aside from the already covered Unified Fileformat and the full support for all kinds of meta-data, this release also ships with a totally revamped parametrization API, support for Barcodes (great job, Mimil!) and Sparkline support.

The next development cycle will be a shorter one. In the upcoming Version 0.8.11 we will finally add crosstabbing and Pivot-tables, speak with Mondrian datasources, provide a sensible interface for the rich-text capabilities, add free-form subreports and will add a first version of the multi-column support. If everything goes right, this version will enter its Release-Candidate state at the end of the month.

One major change already happened on this version: All engine and library classes contained in org.jfree-packages now have been moved into corresponding org.pentaho-packages. This move was necessary so that we do no longer pollute the org.jfree-namespace. At the same time, it allows us to move the Classic and the Flow-Engine into separate packages, so that they can co-exist in the same Java Virtual Machine.

As usual: Users of the XML fileformats are safe from any changes, the XML report definitions continue to work unchanged. API users will have to migrate their code to the new package space. But as the change involves only moved packages, a update of the import-statements should be the majority of the conversion work.

As the APIs of the libraries seem to be stable and sane now, along with the release of 0.8.11, all libraries will be labeled 1.0 versions.

Today I uploaded the release candidate for the upcoming Classic Engine 0.8.10.

This release started as a pure infrastructure release, that was aimed to help us to prepare the battle field for the side-by-side subreports, multi-column reports and the long awaited cross-tabbing. But as usual when humans make plans, the Gods interfered.

And therefore (Btw: Thanks for messing up my plans again, Gods! Life could be so easy!) our list of new features is huge again.

• The reporting engine now supports a new, unified fileformat based on the ODF standard.
• The massive number of different Report-Elements for dealing with images, shapes and drawables got reduced to the total number of two elements, which now cover everything.
• All report elements can carry attributes and attributes can be computed at runtime now. Due to the report attributes, we are now able to support interactivity, inject code into HTML pages, add Excel-page-header and footer and insert Excel-Formulas into the Cell.
• The data-sources transfer Meta-Data from the data-layer into the report. This enables reports to utilize the Pentaho-MetaData system.
• Report-Definitions now manage their own parameters, inclusive the ability to auto-generate parameter-pages and to validate the parameter values (and all of that without XActions or any other expensive magic).
• All report elements and expressions/functions ship with machine-readable meta-data, so that tools like the Report-Designer know what features the engine supports and how to use them.

The full ChangeLog

If everything goes as planned, the final GA-Version of the Classic-Engine will follow one week later.

Finally, after weeks after weeks of coding, version 0.8.10 is feature-complete. During the next weeks, we will enter a stabilization cycle fixing bugs after bugs until we can safely declare the engine ready for production use again.

Bugs we found in the 0.8.10 codeline that also exist in 0.8.9 will be fixed in both branches. When we finally reach GA-state, we will produce two releases; 0.8.9-5 to bring the fixes to the Pentaho-Platform 1.6/1.7 users, while Platform 1.8 surely switches to 0.8.10 as soon as we can get it integrated.

The feature set of this new version is impressive now.

We ship with  6 data-source-types now:

• TableModels
• Static Datasources( calling Java-Methods using reflection)
• SQL (using plain drivers, JNDI or java-beans as source for the JDBC-connections)
• Hibernate HQL
• Kettle-Transformations
• MQL-queries (using the Pentaho-Meta-Data system)

And of course, we have some more exciting new features:

• The brand new ODF-based Unified-File-Format
• Complete End-to-End Meta-Data system integration
• A structural Meta-Data layer to make all of our elements and expressions introspectable
• Attribute-Expressions to compute Element-Attributes at runtime
• Sparkline-Elements
• CLOB support
• Complete SVG-Support using Batik
• a interactive SwingPreview (Hyperlinks for drill-down and drill-across reports)
• a greatly extended HTML-Export that allows to embed own raw-content for interactive HTML-files
• Group-wide Keep-Together and group- and report-wide styles

and as mentioned earlier in this channel:

• A re-born Report-Wizard-Core

If everything works as planned, we shall see the final release in four weeks from now.

After nearly one year of hard work, we finally completed the huge task to write the next big version of the Pentaho Reporting Classic Engine.

This release contains a lot of great new enhancements, which make the life easier for everyone:

• Sub-Reports
• Style-Expressions
• Value-Expressions
• Formula Support
• Enhanced Layout-System with borders, background-colors and paddings, page-break control and unique page-spanning capabilities.

In times where memory is cheap and diskspace is even cheaper, we stem against the trend. Version 0.8.9 is only 400kb larger than our last stable version, 0.8.7-10. Although it is now roughly 10% slower on long running reports, its advanced caching make it a lot faster for repeated smaller report-runs.

Finishing up this release would not have been possible without the great grumbling of Klausb, who patiently went trough and tested every single aspect of the pagebreaking code. Without his effort, I’m dead sure these bugs would have hit us in the back the day after we went GA. And whenever you use the formula-support and think: How did we survive without that? then send a Thank-You-note to Cedric Pronzato for building the great LibFormula library.

But we wont stop here. Now we are working on the roadmap for the next version, making the Classic-Engine feature-complete by adding real charting and OLAP support. At the same time, the Report-Designer will undergo some major changes to be the Number One Choice for all the reporting needs. But for now, we are still throwing ideas on each other. Expect the final road-map at the end of this month.

After more than 6 month of development and one year after the release of our last stable version 0.8.7-10, we are now approaching the next stable release.

This release contains more changes than any other release before. The diff between 0.8.7-10 and the current SVN-version is about 10 MB, and it does not even contain the sources and changes for the new libraries (which sums up to another 3MB).

What did we achieve?

• We have Sub-Reports and parametrizable DataSources now.
• We have a new layouter*, which gives us paddings, borders, backgrounds, better text-processing capabilities and most important: A layouter that allows to have page-breaks inside elements.
• We have support for OpenFormula-Compatible formulas, which simplifies the computation of values in the report.
• We have style-expressions, which simplify the dynamic formatting.� In most cases, no one needs to write extra functions in Java now – just add a formula to a style-property and you are done.

There are a lot more things in this release, way to many to be listed here. Download the Pentaho Reporting Classic engine and see it by yourself.

So whats next?

We will continue on the classic track for a while. The most important change for the next release will be an organizational one: The Report-Designer now moves closer to the Report-Engine. Treating it as a separate Sub-Project at Pentaho yielded horrible results – the Web-Centric heavy-weight Pentaho-Platform is not a good guiding light for a Swing-based Java-Application aimed to create reports for a lightweight embeddable report-engine. So Martin Schmid and I teamed up to bring the Classic Engine and the Report-Designer closer together. Our users see the Report-Engine and Report-Designer as a single unit, technically our projects cant survive without working with each other – and now, we did the last logical step and joined forces.

During the next weeks, we will compile the road-map for the Version 1.0 of the Class Reporting Engine and for the Version 2.0 of the Pentaho Report Designer.

But to create the best report-designer and the greatest report engine we need your help. JFreeReport – and now Pentaho Reporting Classic – would not have been where it is today without the constant input and feedback from our community. If we dont know what *you* need, we cannot provide you the things you need. Or in the words of the wise man: “If we don’t know, we don’t know!”

* The first time since a very long time, our Layouter passes the Wine-Based Complexity Test (WBCT). The WBCT is simple: Drink a whole bottle of wine, and then try to explain how your code works. If you can explain it (and more important: your colleagues understand you and the code) , your code is simple and logical enough to be called sane.

A horrible month has passed by and finally better times appear at the horizon: David Kinkade has joined the development efforts for Pentaho Reporting. Now development can proceed twice as fast.

The OpenOffice Reporting project finally hit the QA, and so the first half of the month was spend in fixing bugs. Although not all of them are resolved yet (the full list), we made some great progress there. All the remaining bugs are related to the OpenDocument-Fileformat processor we wrote for this project; the flow-engine itself, that drives the reporting as data-processing backend, is now ready for the show.

It’s actually amazing: Although most of the demos are not working flawlessly, people start to pick up this engine and work with it. Thanks for your faith, folks! All you early adaptors greatly help to drive the development of this engine even faster.

The second part of the month was dedicated to the Classic-Engine. Although our first pre-release was somewhat bug-ridden, we now exterminated most of the bugs in the renderer and the report-processors. The engine finally produces all demo-reports without crashing and (despite some known bugs we’re going to address during the next weeks) its new renderer behaves like the old one. The funny thing is: The renderer of the Classic-Engine is now more advanced than LibLayout, the renderer of the Flow-Engine. So once we have reached a stable state here, we have to update LibLayout to reflect all these changes we’ve made in the Classic-Engine.

A list of all known open bugs can be found on the SourceForge Project Page for Pentaho Reporting

The next pre-release (or milestone build, to use some commonly accepted terminology) of “Pentaho-Reporting Classic 0.8.9” is scheduled for Friday, the 13th. (I always wanted to make a release on such a lucky day.) At this point, all the engine-bugs should be fully fixed, the new parser-extensions (for rich-text and the new text-processing capabilities) will be in place and the GUI will work better. (Don’t judge us based on the progress dialogs yet. :))

Download the latest release, test it with your reports and send us your bug-reports. With your help, we can create the most stable version of the Classic-reporting engine ever.