The last time I wrote about the Lithium framework, the focus was on getting information out of a MySQL database. Once you have that information, in many cases you will want to show it to the user. In this installment, we are going to look at how Lithium implements layouts for your output in an effort to improve reusability of code, which ultimately improves the developer's ability to quickly get applications up and running and it makes maintenance down the road that much easier.

He talks about the basic structure of an application (on the file system) and where the layouts and views live inside it. He includes a sample layout that defines areas for things like title, scripts, character set and main content. Code is also included showing how to use it in your application. There's also a bit about setting up a default layout in your "_init" method if you'd like to use it across the entire application.

Enter my New Year's Resolution. I promised myself that I would pick up another framework this year and I had been introduced to Lithium at Codeworks in a presentation given by Elizabeth Naramore several months ago. So I downloaded it, and went through the obligatory blog tutorial, all of which seemed pretty straightforward.

He goes through a "checklist" of the things he'd need for his project (including autoloading, namespaces and integration with PHPUnit) and some of the "extras" he wanted hooks for during his development, several he was happy to find were already integrated. He does note a few places where the framework falls a bit short though, like in the quality of the user guide (it "needs some help") that seems incomplete in places.

That said, I still think it is worth the time and the effort to get to know Lithium better. The framework shows a lot of promise, and the architecture of it leaves me with the impression that the devs spent a lot of time thinking through what a developer needs to get the job done quickly.

Cal's three questions talk mostly about his work on the Lithium framework

• What started you on the road to building another framework?
• What makes Lithium special?
• What is your favorite piece of the framework?

You can listen to this latest episode either through the in-page player, by downloading the mp3 or subscribing to their feed.

Lithium is a framework for PHP 5.3+ that is focused on quality, speed, and flexibility. It's a set of no-nonsense philosophies and tools that enable you to build better applications, in less time, without sacrificing quality or extensibility. Lithium understands distributed storage and caching, queuing systems, micro-dispatch frameworks, with integrated support for document oriented databases like CouchDB and MongoDB, alongside relational databases like MySQL and PostgreSQL. Lithium's architecture allows you to get your application up and running quickly, and still allows you to take control of the framework to support the requirements of your application.

If you're interested, you can sign up for the webcast on the Engine Yard site. The event happens July 26th at 10am PST.

On the heels of our Lithium sponsorship announcement, Elizabeth Naramore interviews Garrett Woodworth (fondly known as Gwoo) about the roots of Lithium, where it's going, and how he develops it on a boat.

They talk about why he contributes to Open Source, his involvement with the Lithium framework project and how he does most of his development from his boat. You can listen to this latest episode either on the in-page player or by grabbing the mp3 directly.

We are proud to announce that Engine Yard is now the first official sponsor of the open source project, the Lithium PHP framework. We believe that Lithium holds a great deal of promise and we want to help it reach its full potential. Therefore, not only are we pledging our financial support, we will be working together to promote the framework to our customers and partners and the community at large through conferences, meetups and webcasts.

The post names some of the core development team (including Garrett Woodworth and Nate Abele) and suggests following the Lithium and EngineYard twitter accounts for future details.

Exceptions are and should be an integral part of any general purpose programming language. PHP introduced them long ago (with the release of PHP 5 or 5.1), but it still seems that many of the concepts are not fully understood or ignored by the community. This post aims to be a solid introduction to exception architecture, handling and testing. At the end of the post you should be able to know when to raise an exception and how it should look like.

He talks about situations when (and when not) to use exceptions, normalizing them for easier try/catch-ing and includes the exception class hierarchy, including the types pulled from the SPL. He shows examples (based on the Lithium framework's namespacing) how to create "namespaced exceptions" and how to use these in a bit of sample code. He also mentions the use of the custom error handling with the ErrorException as well as a quick look at testing these basic and custom exceptions correctly (PHPUnit-based tests).

The model relationship support in Lithium is one of the hottest topics on IRC lately, so I thought it would be a good idea to blog about it. Currently, Lithium supports 1:1 and 1:n relationships for relational databases. [...] This post gives you a little background on relationship types and their database representations before we implement a simple example in PHP.

He gives some code (and schema) examples of creating these relationships between tables for the two types - one to one and one to many. He also touches on the zero-to-zero relationships as well, nothing that they can be some of the most tricky to work with. He includes the SQL and the code you'll need to produce a blog example with models for Authors, Posts and Groups. Using the belongsTo/hasMany/hasOne variables he defines the relationships and uses the "with" keyword in the find calls to pull in those relations.

The li3_fixtures plugin was my first Lithium plugin ever, and while it works okay, I feel there is a lot I can do to make it better and more flexible. In this post I want to share my ideas for a new fixture plugin and also want to gather feedback from the community to make it even more awesome.

He gives three instance where fixtures can come in extremely useful - making effective model unit tests with predictable data, mocking models with shortcuts to the data and mocking out web services. Want to add in your own suggestions for his refactor? Comment on the post!

Composer is a command-line tool that helps you manage your application dependencies. It automatically fetches packages, resolves dependencies and is easy to configure. [...] Currently, Lithium doesn't provide Composer packages out of the box, but it's easy to write one.

He starts the post with an introduction to using Composer for those new to the tool, then moves quickly into setting up your "composer.json" file to pull in the Lithium updates from their github account. Additionally, he shows how to add a dependency for twig in the "require" section and pull it down at the same time (with dependencies).