As far as I can tell, Lithium is trying it’s hardest to be fast, lightweight, and use all the features that PHP 5.3 has to offer. I am unable to use it at work for a variety of reasons (not stable, required PHP 5.3 only, Nate is always picking on me via IM) but I am more interested in the ideas that are coming out of it.

It is using all the newest hawtness in the PHP world: namespaces, closures, Phar, late static binding. I could go on, but probably most of these things mean nothing to you until you actually need them. In the framework world, namespaces are a big deal, an essential tool to avoiding collisions with 3rd party code you might want to integrate into your project. Closures are very familiar to those who’ve done work with Ruby or Javascript. Phar allows for some unarchiving on the fly of code, even potentially distributing your application as an archive that can be run. Late static binding is something I’m trying to comes to grips with, as I have either never come across a need for it or never realized that I did and have implemented a workaround for it not realizing there is a simpler solution.

None of these are what I want to talk about. I want to talk about something that I feel is a very underrated part of Lithium, the ability to define filters. This is a concept that you find in Aspect-oriented programming, and one that I imagine most programmers have never considered. Here’s why I think it’s a big deal.

Most frameworks are designed around an OOP paradigm. Yes, some mix them together (I’m looking at *you* CodeIgniter), but by and large you get the job done by extending on a base model / controller / helper / whatever to create new functionality. Sometimes this is not avoidable. But what AOP says is that there is another way, a way that Lithium has adopted as well.

Hence the creation of “filters”. As far as I can tell (and I’m sure I will be jumped upon if I am wrong) the purpose of filters in Lithium is to allow you to add functionality without extending the class itself. When I saw that I immediately understood why that is so awesome.

The idea of callbacks is also very similar: if X happens, run code Y. A staple of jQuery, Rails and probably other projects I have forgotten to mention. The idea is still the same though. In Garrett Woodworth’s presentation about Lithium to the Orange County PHP Users Group he goes over some solid examples of filters including:

• automatic use of the XHProf for code profiling
• automatic setting of parameters upon saving a pasted bit of code

It’s also been used to automatically change string record ID’s into a MongoDB ID and graceful failing of an integration test suite when an error occurs.

These filters remind me of behaviors in Rails (and in CakePHP as well) and makes me wonder if signals are the same thing in the Django world. All in all, this looks to me to be a better way to extend functionality than actually overriding existing methods or hacking at something deep inside a class. Figure out what functionality you want, figure out where it needs to be called, and add your filter.

What it really became was a tool for me to learn how to write a solid web-app using Python and Django. I’m happy to say I finally have a version that I feel comfortable sharing with the rest of you. So feel free to check it out. Pound on it, try and break it and I will also read your feedback and comments. I’m sure you can figure out my email address…

Also, I’ve found it has been easy to pick up not only Python and Django itself. I’m ready to tackle some other applications using Django, and I have one just in mind.

Yes, I am aware at how spartan it looks right now. I’m more focussed on functionality than how it looks right now. I’ve already gotten some interesting ideas on expanding the app to include adding in images to go with locations, so we’ll see how that goes.

For those who are curious, I built it using the following:

• Python 2.6
• Django 1.2 beta 1
• CouchDB to store the trip plans
• couchdb-python
• GeoPy
• django-registration
• Google Maps services
• Django Debug Toolbar
• deployed using Nginx + Gunicorn, configured with the help of Eric Florenzano’s awesome Django Advent article about deploying Django using FastCGI because it mentioned how you could use Gunicorn

I am, for lack of a better phrase, a framework whore. I use frameworks to build all my web applications. Why? Because I prefer to stand on the shoulder of giants rather than constantly reinvent things. But in many ways, my addiction to frameworks is counter-productive because I find myself constantly wanting to use a new one. So I end up churning instead of pushing forwards. I’ve been learning Zend Framework, and I’m struggling. Too many ways to do things, too much documentation that provides me with a tease of what it is I’m trying to do but not the full solution. Then I have to ask people for help and feel stupid for not being the Rock Star Developer(tm) with all the answers.

So, even though I use Zend Framework now (unless I change my mind, get pissed off and go with the no-framework framework) I do watch other frameworks. While I might not agree with some features of Symfony, I am astounded at what Fabien Potencier continues to produce.

Creating a framework is an achievement in itself. Creating a framework in a language as your first real PHP project, like Fabien did, is nothing short of amazing. Symfony is a full-stack framework, the kind of comfy and warm blanket I like to use when building an application on a short timeline. Like many other full-stack frameworks, they also wrote stuff that other people had already written. It’s a common thing, everyone goes through the “not invented here” phase. Sometimes, that’s the only way you learn how to do something.

But as Symfony glides smoothly along towards a 2.0 release, imagine the shock of people when they see Fabien talk about how he is going to use parts of Zend Framework in the 2.0 core and dump existing components like their own unit-testing framework in favour of PHPUnit.

In the blog post about decisions about Symfony 2, he mentions the logic surrounding what appears to be a new public philosophy from Symfony: “Use what’s out there; realise it sucks; write your own; wait until others suck less; dump your own; use other.”

This is a very refreshing stance for the guiding power of a popular web application framework to take. It reminds me of when Rails and Merb decided to quit fighting and instead become the same project in Rails 3. The hater in me thinks that it’s because Merb was becoming what Rails wanted to be, so kudos to the effort to rework Rails to make it better. After all, that’s the goal — to produce better, faster software.

So why does Fabien make me feel stupid: His constant willingness to do the right thing for his project, even if it means tossing away stuff that spent a long time working on. Again, just like all the others I’ve talked about here, he does an amazing job of explaining what he did in a way that makes it obvious. His thoughts on dependency injection helped me to understand why it’s important to consider it when building your applications. I’ve written code that uses it and code that does not. I found it easier to refactor code when I used dependency injection, but that just might be me.

Thanks for following this series this week. I hoped I’ve exposed you to some people you might not have heard of or known about their work.

Next up is another prominent member of the Ruby community, one that I feel truly deserves the label “Renaissance Programmer”. He is Ezra Zygmuntowicz, co-founder of Engine Yard, probably the leader in helping people deploy Rails applications of all shapes and sizes. Ezra seems to have done it all, from Rails work, to Merb, to the Ruby VM Rubinus.

If I remember correctly, I first encountered Ezra and his work (and his awesome last name) during my Ruby on Rails research. Realizing that Rails was the dominate framework in that space, I wondered what the alternatives were. That lead me to Merb. Unfortunately at the time it was not well-documented, so I drifted into other things (like so many other times, I’m sensing a pattern here). Then I started hearing about the efforts to create an alternative to the standard Ruby virtual machine, with the goal of creating, I imagine, a faster Ruby environment.

Much as I cannot imagine writing my own programming language, I could not imagine creating a virtual machine based on running code in an already-established language. Then I saw this talk Ezra gave about Merb, Rubinus and the stack that Engine Yard uses. What blew me away was when he started explaining *how* he was going about implementing Rubinus. It made so much sense.

See, in the Ruby world you can use what they call Matz’ Ruby Interpreter, or CRuby as a reference point. Since there is no official spec, the MRI is used. So if you want to create your own Ruby virtual machine, it’s as simple as looking at how the MRI implements functionality and then copy it in your own VM. Repeat until your own virtual machine passes all the tests in the RubySpec project and bingo! You have a (hopefully as close to compatible with the MRI) virtual machine for running Ruby. It seems that YARV is a virtual machine (I believe it is a bytecode interpreter) that is included with the latest version of Ruby at this writing, 1.9.

So why does Ezra make me feel stupid: He has fully immersed himself in the Ruby world from the virtual machine to the language implementation to frameworks that sit on top of it. Like most of the people I talk about in this series, he also knows how to explain these things to people in such a way that you do not realize what awesome work he is doing.

I may not be doing anything with Ruby any more, but how can you not get interested in the nuts-and-bolts of a language and virtual machines in general when someone like Ezra explains it to you?!? In the PHP world, Facebook recently announced the release and open sourcing of Hip Hop for PHP. This project takes PHP code, parses it and generates C++ executables. This is a big deal for Facebook, who is the largest user of PHP out there. It lets them use approximately 50% fewer servers when delivering PHP-results. They did the same thing I talked about above: looked at how PHP implemented functions at the lowest level, and then figured out how to do it in C++. It’s a very unique project, and obviously not for everyone. But again, an awesome case study on creating virtual machines / alternate runtimes for an existing programming language.

As a person who learned the hard way about how tough it is creating web applications that can handle state and concurrency issues (if you’ve ever seen MySQL replication lag times as high as 30 *minutes* you can sympathize), the rise of languages designed from the ground up to support concurrency has caught my eye. If you’ve heard of Erlang or Haskell you are somewhat familiar with the topic.

Then one day I ran across Clojure, a language that is a dialect of Lisp but runs on the JVM. My, my, what in interesting combination. I’ve talked about Clojure before, but I have not talked about the amazing person behind it, Rich Hickey.

The idea of creating your own programming language is one that I find extremely intimidating, not having a formal background in computer science. I have a vague idea of how you would do it: write parsers for your code and then compile them into byte code that can be run by something. Very simplistic, I know.

So Rich Hickey is a one of these programming gurus who I am sure is a super-nice guy but I would be totally intimidated to have any sort of meaningful programming-related discussion with. First of all, he’s a Lisp hacker. Some of my friends have described Lisp as “the cockroach of the programming world, which will be around long after the sun of other languages have dimmed” and I can’t say that I disagree much with that statement. For someone who learned to program by teaching himself PHP, Lisp’s syntax takes a lot of getting used to.

But then I think the best trick was making Clojure run on the JVM. Why do I think this is significant? It means that if there is a feature or a library that doesn’t exist in Clojure, you can always use a Java equivalent (if such a one exists). In Tim Bray’s “Concur Next” series he showed an example where he used a Java library in Clojure to help him speed things up.

So not only does he have a well-designed and well-thought-out programming language, he is also great at explaining programming concepts. Go and watch this video on the topic of basic principles like state, identity, value, time, and many others in order to understand how to build concurrent and parallel systems. Fascinating talk, and I highly recommend seeking out other talks that he’s done as well.

All this stuff is absolutely fascinating to me, because my entire programming career has been spent in the stateless environment of the web. Oh sure, we can fake state and concurrency using sessions and cookies, but they are really just hacks. Does a web application need to be stateful and/or concurrent? The answer is, of course, it depends. Online games with multiple participants definitely need to worry about sharing state across multiple clients, and any web application that is taking large amounts of data and processing it (like munging it together based on aggregate conditions) could benefit from being able to crunch the data concurrently, with all jobs reporting stuff as they go. Any task that would benefit from being broken down into smaller tasks that can be run at once is a candidate for concurrency.

So, why does Rich Hickey make me feel stupid? Not only is he also capable of explaining the hows and whys of a concurrent programming language, he is encouraging people to think ahead to the next generation of programming problems and potential solutions to those problems.. It’s highly unlikely I will ever create a full-blown, general-purpose programming language. But Rich Hickey’s work has gotten me thinking about programming in event-driven environments, and wondering what tasks that my current applications perform could benefit from concurrency and parallelism.

Antirez is the driving force behind Redis, which is described as “an advanced key-value store” where it holds your dataset in memory at all times but writes them out to disk in a couple of different ways depending on your choices (either from time-to-time or all the time to an append log, depending on what level of consistency you need from the data).

When I first started watching the whole NoSQL movement, I remember seeing Redis in there as an option there. However, I didn’t know much about Redis until I noticed that my friend Joel Perras was following this guy with an awesome mop of hair in his Twitter avatar and a cool nickname. When I also saw he was the creator of Redis I knew this was a guy I had to follow and see what he was up to.

I won’t go into the whole rationale behind the NoSQL movement, but what makes me feel stupid is not just the *way* Antirez has chose to implement his key-value storage solution, but the man himself. He is one really smart dude.

First of all, he might be the most prolific hacker I’ve seen out there who actually lets people know what he’s been up to. His Twitter stream is full of comments about stuff he’s been working on in Redis, some of which I understand and some of which goes right over my head (especially the stuff about the Virtual Memory work he’s done with Redis just shows me what I missed by not taking computer science courses. Too busy teaching myself the new and shiny I guess.

Second, he spits out this volume of information in English. Which is NOT his first language. I couldn’t imagine translating technical terms into my second fairly proficient language (which is German, and I understand it spoken way better than I speak it, read it or write it). I have a hard enough time understanding technical terms written in English, never mind translating them in my head from another language.

So back to Redis now. So not only is it a high-performance key-value store, using memory (the fastest storage medium) to store your data, but it also suited for use in a master-slave replication setup (claiming very fast replication speeds, and given the torturous bench marks I have seen Antirez talk about on twitter and his blog, I believe him) but can also do something that a lot of post-relational data stores (perhaps that’s a better name than NoSQL) can’t do: unions (am I correct in assuming that is the equivalent of JOINS from the SQL world?), set intersections, comparisons between sets, and even generating sorted results. I could see using Redis as the data store for the web front end of the corporate fantasy draft application at work. I’m using a lot of key-value pairs in it, so a hybrid approach would probably work the best if I were to try it.

I mean, when you read that Virtual Memory post how can you *not* feel stupid for failing to see why Redis needs such a thing: if you are storing everything in memory (remember, disk is the new tape) then you need your use of that memory to be as advantageous as possible and not rely on the operating system to do it for you. For Redis, you want to keep as much memory available for your data so Antirez felt that he needed to find a way to free up the memory being used by the least-frequently accessed data. A hard problem to solve for sure, but reading about what he did is just so inspiring. As a bonus, you also learn some computer science skills along the way. I felt the same way when I listened to a lecture about building virtual machines for Ruby: awed and wondering if they teach that sort of stuff in computer science courses.

While Redis might not be a solution I ever use at work (I am trying to keep our stack from adding too many new components just because I feel like playing with them) it’s worth the lost hours reading Antirez’ blog to understand all that goes on behind the scenes to make a cool piece of technology usable outside some very narrow scenarios.

So, in the end, why did Antirez make me feel stupid? It was because he made me realize that you could take a simple idea (the key-value store) and add all sorts of very desirable features onto it without compromising it’s main goal.

Some of this is due to my desire to always push myself to learn new things, so sometimes the joy of discovery tramples the ability to get things done as quickly as I would like. So I’ve been looking around at how other people have been solving problems in an attempt to discover blind spots I’ve developed. The first person I found that made me say out loud “boy, does this guy make me feel stupid” during this process is Geoffrey Grosenbach.

About 5 years ago I was looking to get into the Ruby on Rails world. I had bought the Pick Axe Book and the 1st edition of the Rails book. Through my online digging I discovered the Ruby on Rails podcast, run at the time by the previously-mentioned Geoffrey Grosenbach. It was all cool and interesting, and he seemed to have a knack for asking the right kind of questions. Either that or he was really good at the editing.

Alas, things didn’t work out. I built a Rails site, but it had some problems due to my n00bishness with the framework and the language. Let’s just say I wasn’t using Ruby best practices. The final nail in the coffin for my Ruby aspirations was when I turned down a Rails gig to instead take a telecommuting PHP gig (life choices dictated that one) and I drifted off into other things. But I kept an eye on what Geoffrey was doing anyway and was happy to see him find success with Peepcode along the way.

Then I came across an awesome blog post from him where he talked about how he builds the Peepcode Blog. I read it and was totally blown away, and totally humbled by the simplicity of what he has done. Rather than simply do some link bait and show you everything he used, you can go and look at it

He explained that his goal was to produce an “art blog” for Peepcode, where every blog post would have it’s own unique look to it. In order to do this, he had to think about what goes into building something like this:

• A CSS grid layout system, because it’s really too hard to always come up with your own unique layouts. A grid makes it easier to make interesting content I think.
• A very simple application framework for spitting out static images and HTML. (This was the lightbulb-went-on thing for me, as a blog that does not have comments can be totally static)
• A modified version of an existing lightweight blogging engine to fit his needs.
• Storing blog content in flatfiles on the system. Again, without dynamic content why bother with the overhead of storing posts in a database (says the guy using WordPress, one of the favourite targets of criticism by PHP developers who like their code clean and modular)
• The use of a markup language to reduce the actual HTML he had to write
• The use of a CSS framework to again reduce the need to write actual CSS
• A sprinkling of Javascript to add unique features to each page

I’ve read that blog post at least a dozen times now, and still marvel at how frickin’ obvious it was to do things the way he did. It’s also obvious that he put a lot of thought into what he needed and the best way to couple things together to make it happen.

Compare his methods to my current set of decisions as to the various tools to build a web front end for a corporate draft

• A glue framework with lots of components that can be legitimately accused of starting to become bloated
• Use of an ORM to spare me from writing SQL to pull in dynamic sports data
• Table-driven HTML layouts from the previous generation of the application

When you start to factor in the time to actually learn not only the framework itself (and also heavily relying on a particular module of it to give me the MVC features I wanted) but the ORM itself, I wonder if it was the right decision.

Because if I were to break it down in a similar fashion to how the Peepcode blog was built, I’d say I need the following

• lightweight scripting language front-end (in this case PHP because that’s what all our other client-facing applications use)
• a component to handle dynamic routing of requests, although I could really use web server rewrite rules instead of making the front-end code figure it out. My mod_rewrite skills have gotten a little better in the last year or so.
• An RDBMs because the source data is in a database already, and so few NoSQL solutions allow you to do the kind of grouping and aggregate math functions I need to do that MySQL can handle for me.
• An authentication component. I’ve written enough of these to know it’s easier to use someone else’s that just works
• An access control component. I’ve written enough of these to know it’s easier to use someone else’s that just works too.
• Grid-based CSS framework for layouts so we can use as few tables as possible.
• An easy-to-use Javascript library to take care of everything else that I cannot do in the scripting language or via CSS.

Man, I’m starting to think that Rasmus was right with apologies to my friend Kevin Beckford. Kevin is of the opinion that main reason to use a framework to build something is because unless you will be the only one ever to write and maintain that application, the rules and structure that a framework gives are essential to help your fellow coders stay on track. It’s like having a common language that you both speak, and easy access to a dictionary (the documentation for that framework).

In my case, I am using PHP + Zend_Framework + Zend_Application + Zend_Auth + Zend_Acl + Doctrine + MySQL (plus Python on the server to do some data munging) to build this thing out. Luckily, no Javascript needed at this point. So what could I strip out to build it the way I put it above? We could end up with PHP + Apache rewrite rules + Zend_Auth + Zend_Acl + MySQL + Python, with Blueprint CSS thrown in to help me with the layouts. Not a *whole* lot of difference from before.

But of course, I was able to quickly build out admin functionality for the front end due to the ability to map out relationships between tables and having Doctrine pull in all that data and return it to me in a ready-to-go package for easy display. Also, to be realistic, we are too far into the project to rip all that stuff out and quickly refactor it. I mean, how do I justify stripping out Doctrine and writing all the “query, process and stick into variables” code now? It’s a delicate dance, and it’s obvious those decisions need to be made before you start, not when you’re experiencing some mild Buyer’s Remorse.

So, in the end, why did Geoffrey Grosenbach make me feel stupid? It was because he made me realized that I have a tendency to what to overengineer things a bit, wrapping them in framework solutions when perhaps the more direct route is to couple existing modules together to have a more flexible solution.

But I have at least considered that the tools I was using were going to make it easier to build out the behind-the-scenes stuff. Sure, I could write all the SQL code myself (I’ve finally understood the power of joins), but once I’ve learned how Doctrine does things it becomes super simple to build on the existing work.

Look at the Peepcode blog setup shows that he was using a bunch of tools already in widespread use in the Ruby and Rails communities. There are not many equivalences for that stuff in the PHP world (HAML and SASS only have incomplete implementations for use with PHP as far as I can tell) but the approach he used is the one to really think about. I mean, what would this blog look like if I decided to go the minimalist route, but with tools that I am more comfortable with? Could I do it with Werkzeug + a simple blog engine + Textile + Blueprint CSS + jQuery? I have no spare time as it is, what would this type of project do to me?

I have stared into the belly of the beast that is the Zend Framework documentation and have discovered the following truth: there always seems to be two ways to do something. For someone just starting out learning a framework (never mind their actual level of experience with PHP itself) this is not a good thing. For example, let’s look at creating a new base controller to extend controllers off of. Via twitter I found the following ways:

• no, don’t do that, use custom action helpers
• sure, just put it somewhere and use autoloading to find it

So I proceeded to start digging around and figure things out. Hrm, an action helper is not what I need, so let’s create that new base controller. Oh, you mean you can have more than one way to lay out your project, even if you are using Zend_Application? How come it’s not finding the new controller even though I put it in a common place. Why won’t this work?!? DAMNIT, I AM GOING TO QUIT PROGRAMMING AND RUN A DADDY DAY CARE OUT OF MY HOME.

Fortunately the custom routing thing was easier to figure out. Hey, here’s an example of adding code to your bootstrap. Oh wait, I’m using Zend_Application so things are different. WTF, I am overriding my existing routes and everything is broken?!? You can put this stuff in XML?!?! But I am using the .ini format…. Nice, MWOP pointed me in the right direction. Good thing he’s on twitter.

Look, I’ve talked about this before. It’s awesome to have lots of documentation. The Zend Framework documentation is awesome…but seems to only have 80% of the solutions I was looking for. Digging around using Google just seemed to point me at the same 80%-complete documentation.

Writing documentation is a thankless task, so do not interpret my comments as a slam against those who are contributing. I work best when I see FULL examples on how to do something, and then I can “extend and embrace” that to produce the customized solutions I always end up needing. My complaints are solely my own, which is why I usually blog the solutions when I come up them. I certainly cannot be the only one having problems sifting through the documentation.

As someone who had invested a lot of time in another framework, I am painfully aware of how much you take for granted when using a familiar tool, and then try to help people solve a problem. My own experiences have ranged from “you are most definitely doing it wrong” to “I’ve never done it that way, and I can see how that will work”.

Special thanks to @weierophinney, @elazar and @andriesss for their actual help and offers of help as I stumble around using Zend Framework.

I've been using Doctrine 1.2 for the project (integrated with Zend Framework), and I found it quite easy to setup the relationships I needed between my models. Oh, except for finding out that I really needed a field called 'id' in one table in order to make a relationship work properly. Sometimes convention triumphs over configuration.
So I thought to myself "I wonder if I can configure things so that when we're pulling in the related results, it is sorted?"

So I started digging around via search engine. Took me about an hour to find the solution. First, it took me half the time to dive deep enough to find out WHERE I can define the default sort order. Surprisingly, it was in an area that made total sense but I could not find before. Weird. Probably due to me not fulling understanding the API.

Oh, what's all that other stuff? That's what took the other half of the hour to figure out. See, I couldn't use any sort of natural sorting order. I had a specific order that they needed to be displayed in. As usual StackOverflow came to my rescue. I'm pretty sure that what I am doing is MySQL-specific but I imagine you can figure it out for other RDBMS'.

So now when I pull in info about a Team, I get the associated Player records sorted to my heart's desire. Awesome. This does raise a question: how would you accomplish this sort of trick if you were using a non-relational database like CouchDB. Research for another day I guess.

As I begin working on the admin area for a work application being built with Zend Framework, I've been spending a lot of time starting and stopping on it. Why? Chalk it up to the extensibility of Zend Framework, who have clearly taken the "configuration" side of the "configuration vs. convention" philosophy when it comes to frameworks. Before you get all worked up, remember that (a) I last used Zend Framework 3 years ago and (b) I got very used to relying on framework conventions to help me speed things up, a tactic used with great success in building CakePHP and CodeIgniter applications. Alas, those days are behind me and I am getting schooled in the wonders of "figuring everything out" and "object chaining is cool" and "why are there always more than one way to do something with this framework?!?".

So one of my first tasks is to create a form to allow people to create new leagues for a fantasy sports league. Need a very simple form with three things in it: league name, sport and scoring period (which is how often we need to compile standings). Sounds easy right?

After searching around online for some examples of building simple forms, I was dismayed to discover there were two different ways of building the form. I could (a) do it the long way and create specific instances of the form elements using Zend_Form_Element_X or (b) do it the short way and add them to the form by use of Zend_Form::addElement() and pass it the type of form element I want via an array. For reasons I cannot explain initially, I decided to do things the long way. Later on, I found out that doing it this way saved me from rewriting.

So, the approach I decided to use was to create a separate file that contains the form I want to use. Why? Because I wanted to reuse this form for both "add a new league" functionality and "edit an existing league" functionality. After figuring out that I needed to create a Bootstrap file for the module that the form was in (otherwise auto loading wouldn't work) here's what I cranked out:

Perhaps you've noticed something different about this example compared to others you might have seen elsewhere? Okay, I won't keep you in suspense about it. I'm using the $options parameter when creating an instantiation of this particular form to pass some dynamic information. Without this, it would be very difficult to reuse this form. In this case, I pass in up to three different parameters: the target for the form, the label I want on the submit button and (in the case where we're editing an existing record) the primary key of that league in the database.

So, then the next step is to tell my controller I want to use that form. Ignore the database related stuff as I'm using Doctrine and my use of that probably deserves it's own blog post down the line.

Nice and simple, and effective. I also have another action that is for the editing or deleting an existing league. Here's the controller for that

Nothing too earth-shattering I would think. Armed with this, I can now display my form in two different places:

So I do that, and load up the form and...what the? Damn, the default decorator for these elements is ugly. I want my form fields to line up nicely inside my table (shut up, I know I should use CSS but this is an admin panel and I am in a hurry) so after finding this article by Zend Framework architect MWOP I figured out how to create the exact decorator I wanted. Here's the final version of my reusable form.

I'm pretty sure that if I dig around some more, I can find info on how to automatically apply that decorator to ALL my form elements if I needed that. Maybe in the next revision. Hope you find this example helps you to create your own reusable forms and to tweak the decorators yourself.