Stubblog

Last night we released Stubbles 0.16.0 which is mainly a bugfix release but still contains some new stuff. Most remarkable of the new stuff is the native support of Iterator instances to behave as arrays when serialized with the XMLSerializer. Another interesting feature is the possibility to configure the xml generators to be used by the XMLProcessor of the XML/XSL view engine, which allows you to add your own xml generator and have arbitrary data available on the dom tree of every page.

For the command line folks we added the possibility of asynchronous command line execution with the Executor. This way one can issue several commands at once and wait until they are processed while doing other things in the meantime.

Bug fixes focused on the input grid support, making it more usable for everyday usage of forms. For a full list of changes see the changelog.

On another note, this is the last minor release which contains the Memphis and Rasmus view engines. We will discontinue them in trunk and the next minor release will not contain them. However, we will do bugfix releases for the 0.16.x series if necessary and keep the support for 0.16.x until our own applications are migrated to the XML/XSL view engine later this year, meaning that support will be available at least until December 31st 2009.

New month, a new release: 0.15.0. On the last release 0.14.0 I said the next release will most likely be 1.0.0. Turned out, it is not. We don't have a new release date for 1.0.0 yet, as this highly depends on our demand to have its XML/XSL view engine proven in reality, which we do not have a new date for yet.

Beside this, the release brings some new stuff: One could have more then one master.xsl in the XML/XSL view engine now, which means the stylesheet for generating the stylesheet is now highly extensible by custom templates. We improved the net::stubbles::service::soap package by fixing inconsistencies and made it usable in conjunction with our Inversion of Control feature. Speaking about Inversion of Control, we added the @ProvidedBy annotation which can be added to interfaces and classes to declare the default injection provider for those types. This is similar to the @ImplementedBy annotation, but offers more possibilities on what has to be done to construct the requested object.

For a complete list of changes consult our changelog.

Once again, I have to mess around with SOAP, certainly not the last time. For the record: SOAP is for sure one of the first places on the top ten list of the most stupid inventions in software history.

Some minutes ago we released Stubbles 0.14.0. Most likely this is the last release before 1.0.0, which is schedules for end of March or early April, depending on how many bugs we will find until then. But back to the current release, what's new?

One highlight of this release is the introduction of support for JSON-RPC communication with qooxdoo applications. We improved the already existing JSON-RPC support to cope with some qooxdoo specialities, so it should now be possible to create RIA qooxdoo frontends with Stubbles as backend on the server. Compared to the YUI support we currently do not provide the possibility to create JavaScript stubs for the browser side, as this might not be worth the effort due to the ease of requesting data from the server with qooxdoo. At least that's what the programmer said - we will see if it stays that way, it's subject to discussion.

Most of the other changes are improvements of the Inversion of Control feature rework we did with 0.13.0, one is that there is no need any more to explicitly bind the mode, as this is an optional dependency now. Additionally, the net::stubbles::lang::stubMode class is now an interface, allowing users to have their own mode implementations. The implementation delivered with Stubbles can now be found in net::stubbles::lang::stubDefaultMode. Additionally it is now possible to create an application without binding the logger, all dependencies to it were changed to be optional.

As always, for a complete list of changes see the changelog.

Nearly about a year passed since the last release of vfsStream, and some bugs were found by users of vfsStream. This was quite a surprise for me since I did not expect that anybody would use it.
This evening I fixed another bug reported some days ago, and since a patch for another bug was submitted and committed about half a year ago I decided to release version 0.3.2 tonight, so these are the changes:

- added support for trailing slashes on directories in vfsStream urls, patch provided by Gabriel Birke
- fixed bug #4: vfsstream can only be read once, reported by Christoph Bloemer
- enabled multiple iterations at the same time over the same directory

A big thank you to the bug reporters for their help to improve vfsStream. This should give me some motivation to go for 0.4.0 and implement support for file modes, at least being able to store and read them - full file mode support will be a hell of a work, not sure if it is worth the effort.

Today we released Stubbles 0.13.0. This release is a major breakthrough regarding integration of the Inversion of Control functionality. All web applications build with Stubbles can now be created via our Inversion of Control features, resulting in less code for the same power. In Stubbles this means we were able to throw away around 200 lines of code without loosing any functionality. Moreover, we got only slight performance penalties regarding runtime in our applications (around 0.01 seconds more), but experienced less memory usage (up to 512 K) especially in situations were we heavily relied on XJConf configurations before.

Beside this the release contains bugfixes and feature improvements. As always take a look at the changelog. However, don't look too much into our current documentation, it still needs to be updated to reflect the latest changes.

Books, tutorials and other design pattern featuring articles often tend to present the Singleton Design Pattern as the first one. This is for two reasons:

• The Singleton is a very easy to understand design pattern, even for developers new to design patterns or relatively new to the object oriented world.


• The Singleton solves a problem that 99% of these developers have, namely to provide a global access point to some class they make use of everywhere in their application.

However, the Singleton design pattern is fundamentally flawed. This is nothing new and is discussed amongst developers since some years now (just search for "evil singleton"). The Singleton violates several rules of good object oriented design. Code using the Singleton class depends on that class. It is not usable without this class, which in turn makes the client code hard to test. The client code is not programmed against an interface but against a concrete class, though promoting tight coupling between the client and the Singleton, instead of the desired loose coupling. Additionally, classes implementing the Singleton pattern itself are hard to test. Singleton just replaces a global variable and hides it in a class - the global state stays in your application. So, when everybody agrees that global state is bad and that its appearance as Singleton implementations does not make the code any better, why is the Singleton design pattern so often used then? Continue reading "How to get a Singleton right"

Some minutes ago we released Stubbles 0.12.0, containing various API improvements and bugfixes. Most notable changes are the introduction of the bootstrap.php file and the net::stubbles::lang::stubPathRegistry class, which in combination replace the old stubConfig file. This is a major improvement especially for command line scripts, as you may now change the pathes for cache, configuration, log and page data files during runtime, allowing a better way to create maintenance scripts for example.

The other new feature is the introduction of the input grid for the XML/XSL view engine, mainly contributed by Andreas Lehr. This feature allows fine-grained control over forms and their elements, ranging from placement of label elements and input fields to special information markers, but creates valid HTML markup as output. If used in conjunction with the delivered ingrid.css file you will get very fast valid and accessible forms. Unfortunately the documentation for this feature is still missing, but we hope to provide this soon.

For a full list of changes see the changelog.

Annotations are a really helpful feature in present-day development. An annotation is a special form of syntactic metadata that can be added to source code elements such as classes, methods, properties and parameters. They do not affect the program semantic directly, but can be used by tools and libraries to handle such annotated code in a certain way. Examples for such usage are marking classes or methods as accessible via web services, marking methods as unit test methods, or to define how an object should be persisted.

Annotations are mainly known from the Java programming language, and since Java 5.0 annotations are a language feature. More important, these annotations are accessible at runtime, which allow various new meta-programming approaches where the domain object stays very clean and does not have any references to the handling code, i.e. when persisting domain objects or rendering them into XML.

Today I want to take a look on the state of annotations in the PHP world. PHP itself does not offer such a feature, so we have to take a look at userland implementations. Such implementations are possible using the reflection API introduced with PHP 5. When looking at userland implementations one has to differentiate between specialised and generic implementations. Continue reading "State of annotations in the PHP world"

Today we shipped Stubbles 0.11.0, one month later than originally planned and hurting our monthly release cycle. This is mostly due to vacation and time constraints. Unfortunately we have to delay the 0.12.0 and 1.0.0 releases as well, but this fits better into our current time schedule.

But as consolation 0.11.0 brings some really cool new features beside the usual bugfixes. One improvement is within the rss package, which now allows to annotate any entity with the newly introduced @RSSFeed annotation. This makes it much easier to create an rss feed from any object you have in your application.

The streams package experienced some improvements like the new memory stream wrapper and better checks for handles so that resources which are not of type stream will now be rejected.

Richard contributed an implementation of the FirePHP protocol which allows kind of var_dump() debugging in AJAX applications without breaking the functionality of the application itself when the value is dumped.

However the coolest new feature from my point of view is the new support for handling dates. We introduced a new net::stubbles::lang::types::stubDate class, which eases handling of dates. This would not be worth that much of enthusiasm for itself, but the coolest thing about this is that we added filters for transforming request input values into date instances, and moreover our persistance API supports date instances as return values from entities, persisting those into the database and returning them back from there into the entity. This way the developer only has to work with date instances as input and output values, and Stubbles takes care to provide the instances and to persist or serialize them.

As always, for a full list of changes see the changelog. Have fun!

Today I gave a short talk about Stubbles' website cache in our weekly team meeting. The talk explains what the website cache is good for, how it basically works, and what a developer should take into account when developing new page elements. You can find the slides of the talk in the manual for the website cache, see attachments.

Continuing our end-of-month release plan we released Stubbles 0.10.0 today. The release contains fixes and improvements regarding dealing with UTF-8: the string length validators now correctly work with UTF-8 strings, and console streams now deal with input-/output conversion from environment charset to internal charset.

As we are at streams, the streams package experienced an update with two new classes and a new interface: net::stubbles::streams::stubMemoryInputStream and net::stubbles::streams::stubMemoryOutputStream allows to deal with memory streams, and net::stubbles::streams::stubSeekable allows to mark streams as seekable. Both net::stubbles::streams::stubMemoryInputStream and net::stubbles::streams::stubFileInputStream implement this interface.

Another new interface is net::stubbles::peer::stubURLContainer which allows better unit testing of classes having net::stubbles::peer::stubURL or net::stubbles::peer::http::stubHTTPURL as typehints on methods.

An API breakage was made to the net::stubbles::console::stubExecutor interface and its net::stubbles::console::stubConsoleExecutor implementation. The executor now accepts a net::stubbles::streams::stubOutputStream to stream the output of the executed command to instead of returning the output of the executed script from its execute() method. This breakage allowed us to make the API more fluent and allow better method chaining.

Grab the release from our downloads page.

As requested I did my homework today and tested Stubbles against PHP 5.3 alpha1. Well, actually alpha2-dev, but that should not make that much difference. I don't know whether 5.3 is PHP on drugs, but runtime of our unit tests dropped from around 45 seconds with 5.2.5 to around 15 seconds on 5.3. Down to one third! This is really impressive. We will have to see how 5.3 will perform with the applications itself, but this raises expectations.

The other good news is that we only had two forward compatibility issues, which I instantly fixed. One of them was in a unit test and not relevant to the framework itself, the other had to do with a new check on callbacks which now forbids using private methods in callbacks, even if the callback is triggered from inside the same class.

Update
At first I thought of just another check for the callback thing, but the comments lead me to reinspect the code. I now think it might really be a bug in PHP 5.3, therefore I created a small script to reproduce the effect, see repository. I sent it it to Lars, who will make sure it gets fixed in the final release.

Today I managed to put together some informations for Stubbles developers. These informations contain informations on how to access our repository and how to get commit access, information on our mailing lists, and our coding guidelines. Please take a look at our developer pages. If you have any suggestions for improvements of the contents or about which other informations to add feel free to leave a comment on this entry or to write a mail to our developer mailing list.

Yeah, mailing list. Today we created two real mailing lists: the developer mailing list for discussions about Stubbles and its development, and a commit mailing list. For more informations on how to subscribe see our mailing list info page. A big thanks to Alex Kiesel for helping us to set up both mailing lists and the XP development team for hosting the mailing list technology.

Due to the fact that the user community of Stubbles currently is not that big we decided that any user related discussions should take place on the developer mailing list. If one day for any reason the volume of user-related questions gets bigger we may create a separate mailing list then.

One month over, time for a new version. As always we aim to release a new version at the end of a month, this time it took a couple of days more due to being busy with other things. However, today we shipped Stubbles 0.9.0 as our second version in beta status, containing a bunch of fixes and minor improvements. We made quite some steps forward to handling all string as UTF-8 internally, but we are still not finished with this yet as there are still some places where we have to put our hands on. I'm quite sure we will have this issues addressed with the next release.

Improvements with this release are the introduction of being able to overrule annotated filters, support for HTTP caching, XSL callbacks for formatting dates and timestamps (unfortunately not complete, the current implementation lacks support for dynamic values from the document tree) amongst other minor improvements. For the complete list see the changelog.

You can get the latest version from our download page.