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.

No, I’m not talking about this blog, which also went dead quiet during the last month ..

Back in december, after the release of the Flow-Engine (JFreeReport 0.9), I declared that the classic engine now is dead. I wanted to let it die directly after the release of version 0.8.8.

I dug its grave, called the carpenter to make a cheap coffin for it, went into the neighbours garden to steal some flowers (you can’t have a burial without flowers, right) and shoved earth on it.

But like every Zombie the thing came back from its grave. Bug-fix after bug-fix went into it. I’m quite sure somewhere in the swamps of Florida, there’s also a voodo witch (paid by Pentaho, of course :)) who casted her own dark magic to resurrect the thing. So finally it was back alive.

I’ve seen enough B- and C-Movies to know how to handle such a situation.

In April I’ve drawn the final card and ripped out the heart of the engine. Blood everywhere. Organs and meat flew around – just think of the worst horror movie you’ve seen, multiply it with the sum of evil of 7 years of unrestrained development and you could come near to what this monster was now. But the parts kept moving. They crawled and reunited – and finally reached the jars where I kept the replacement parts of the Flow-Engine. And in true horror I’ve seen how this old and undead monster ate the very heart of the Flow-Engine and implanted itself the renderer of that sacred child.

And now the classic engine is back! Stronger, bigger, and eviler than ever. It now shares major parts with the Flow-Engine, and if one grows, the other one will receive the good as well.

Watch out for the final version of Pentaho Reporting Classic 0.8.9 coming to a network node near you at the end of the month.