Reporting Tales - release tag

Classic-Engine 0.8.10 and beyond

Tue, 03 Jun 2008 12:33:00 GMT

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.

Classic Engine Version 0.8.10 ante portas!

Thu, 22 May 2008 17:06:00 GMT

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.

We finally made it! Classic Engine 0.8.9 has gone GA

Fri, 09 Nov 2007 21:00:00 GMT

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.

Getting close to closing Release 0.8.9

Mon, 05 Nov 2007 11:53:00 GMT

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.

New releases of Pentaho Reporting in June

Sat, 30 Jun 2007 13:47:00 GMT

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.