The devReview.com website has put together The Big List of as many of the PHP frameworks out there they could find:
For the start of a new year, it was time to clean out the list of PHP frameworks. A few have fallen by the wayside, but many new ones have been added. It seems that patterns and MVC is still all the rage, but less are professing to being Rails clones, though the inspiration of convention is still strong. There are a wide variety of framework types. From full stack (cakePHP, Symfony) to components (eZ), a bit of both (Zend) and minimalist (LightVC, TinyMVC, Pluf).
Requirements to be on the list include that the framework must be PHP-based, have a recent code release in the last 12 months, needs to be available in English and not including frameworks that can be considered content systems themselves.
As of the time of this post, there are around 50 active frameworks listed - everything from CakePHP and the Zend Framework out to eZ Components and Prado. Links for each include their project homepage and some reviews the site has done.
DevShed has posted the fifth part of their series looking at CodeIgniter and its use to make a simple blogging application. The focus this time is on the output, working with the views to "pretty up" the resulting pages.
Although in its current state, the blogger works well, its visual presentation looks pretty primitive. Therefore, in this fifth part of the series I'll be adding some CSS styles to the view files that comprise this blog application to improve its look and feel.
They start with a review of the code so far - a simple blogging app with the ability to let users comment on each entry. The HTML and CSS you'll need to add to the views to make the output look more like this.
The eZ Components project has release their latest stable version - 2008.2 - for public consumption today:
The development team is happy to announce the release of the seventh
major version of eZ Components: version 2008.2. The main new development of this release is focused on the MvcTools (and
accompanying) components.
The MvcTools component implements the tools for a framework, providing a dispatcher, request parsers, routing, view support and a response writer. Examples of its use can be found in the subversion repository for the project. You can see the full Changlog for the release here and you can download the latest release here.
In an effort to dispel some of the rumors and myths around the CakePHP framework (as presented most recently by a different blogger) Chris Hartjes has made a new "mythbuster" post to his blog today with a rebuttal to the points from the other article.
I ran across an article comparing CakePHP and Symfony and found that the writer had a number of preconceived ideas about CakePHP. These same ideas keep popping up everywhere, used by people looking to get their hate on about CakePHP. I sent a very well-reasoned email to the writer clearing up some of those misconceptions [...] So, in the interest of clarifying things about CakePHP I thought I would share that email, slightly rewritten for this blog posting, but the content is roughly the same.
The post/email covers a few different topics some might have misconceptions about concerning the framework:
Lack of Documentation
Scaffolding
Models are tied to controllers in a 1:1 relationship
Cake's Ajax and Javascript helpers do not support graceful degradation
If you're looking for a framework to try out on your next Web 2.0 application, Knut Urdalensuggests you give Yii a try.
The Yii Framework is built for speed and the goal is to provide the best possible framework for your next large-scale web 2.0 applications. With it's superior performance, Yii still provides an easy-to-use and highly extensible feature set that is richer than most other frameworks.
If you haven't tried it, he points out the "getting started" tutorial offered on the Yii site as well as some of the performance benchmarks (including those for the next release, 1.0.1).
DevShed continues their series on using CodeIgniter to make a simple blogging application with this new article. It focuses on the next step in the blog's evolution - making it able to accept user comments.
A decent blog application, however, must provide users with a mechanism that lets them post their comments easily, and the simplest way to do this is via an HTML form. Therefore, in the next few lines, I'll be explaining how to modify the controller class and the comments view file created in the preceding article to incorporate a basic web form that permits users to post comments on a particular blog entry.
They start by reviewing the code and application so far, ensuring we're all on the same page. From there, they add code into the controller to handle the form input and make a view to create the form itself.
Mike Davies has posted a comparison he's worked up between the CakePHP and Symfony PHP frameworks:
Asking around in work (well, the extended group of web developers that used to be the phenomenal Yahoo Web Dev team in London, and Munich) for PHP framework suggestions, the most frequently recommended one was Django (go figure!), followed by symfony, Code Igniter, and one solitary suggestion of Cake PHP.
He gives overviews of each citing things like features, database integration, how they implement MVC and documentation. His comparison is quick, pointing out that the right tool for his job ended up being symfony - a bit more complicated, but more of what he needed.
Ray Cheung posted his comparison of the Zend Framework and CakePHP a little while back to share some of the thoughts and research he did to pick one over the other for his application.
A lot of people have been asking for some comparison articles for some of the popular frameworks. [...] Overall, both these frameworks are good to use as per your requirements. CakePHP is suitable for developers new to MVC and those who require stricter conventions. ZF is a choice for those who need better control over the application design and built-in support for renowned Web services. Both the frameworks are developing fast and the choice is entirely yours.
He includes brief overviews of each framework and comments on documentation and configuration issues surrounding them.
Commentors on the post include Nate Abele (of CakePHP) and Wil Sinclair (of the Zend Framework).
I'm still bored and lacking posting ideas, so I figured I'd give a hyper-critical breakdown of "Four reasons to hate CakePHP" by A.J. Brown. Let's get right into it.
He responds to comments on: CakePHP's "heaviness", the (in)flexibility the framework allows, alpha releases, changes between versions, no namespace considerations and its use of global functions.
The CakePHP podcast, The Show, has posted their latest show for download - a look at what's to come in the latest release of the CakePHP framework (the stable 1.2):
On the day CakePHP 1.2 goes stable, Rafael Bandeira and Nate Abele chat about what you can expect when you go download your holiday package.
You can either download the file directly from the site or you can subscribe to their feed and get the latest shows pulled right into your aggregator.
In this recent blog entryJani Hartikainen looks at the creation of generic actions for Zend Framework applications - methods that can be used to help eliminate code duplication:
Sometimes you will need nearly the same functionality in many actions. [...] There are several ways to deal with this, such as moving the code into a separate function, or an action helper. But in this post, I'm going to introduce so called "generic actions" - parametrized, easy to reuse actions - which is an idea similar to django generic views.
His example takes a generic action - one that grabs and output records from a table - and modifies it to take in parameters from the defining function as to which action/controller/model and ID to use. Then this action can be used over and over in multiple places without having to do any copy and paste coding.
Doug Hill has proposed a new project that he hopes to get the community behind - 60 Days:
60 Days is an idea I had while trying to decide what to do with the domains I have sitting around doing nothing - (well nothing but being a nagging reminder that I'll never have time for every idea that pops into my head, and that domain names cost money to keep).
The goal of the project is to take a domain you're not currently using (and you know you have some out there) and making something - a "real world project" - on it in 60 days. the catch is that, for each domain you use for the effort, it has to be a different PHP framework. Keep an eye out for the January 1 launch date for more details.
On NETTUTS.com, there's a list of twenty-five resources that can help you get started with PHP if you've never touched the language before:
PHP is a scripting language that is perfect for developing dynamic web pages and applications. You may be a PHP ninja, or perhaps you don't even know what PHP stands for. However, if you plan on or are involved in any kind of web development, you are bound to run into this fantastic and easy to learn web language. Today we will review 25 resources to get you started with PHP.
Alvaro has put together a post that lays out some of the design patterns that the Symfony framework uses to get the job done:
Much hasbeensaid this days about how modern web frameworks interpret the MVC architectural pattern. I'm my case those articles made me rethink how I use a framework, specially Symfony. This lead me to start a study on which patterns come into play while we develop a Symfony application. So while adding new features or refactoring existing ones I will know which class is in charge off doing the job.
Some of the design patterns mentioned include the Front Controller, Contaxt Object, Helper Object, Active Record and Single Table Inheritance. He includes brief examples of each of them in use (no code but plenty of description).
Douglas Brown is running a poll in a new post to his blog asking which of the six choices (of the major PHP frameworks) is your favorite PHP framework.
In a perfect world, I would suggest to learn them all! However, there are only 24 hours in a day, and prioritizing your PHP framework education might be a good idea. So above I added a poll that I plead to other PHP developers out there to vote on. Hopefully after a lot of participation we will see the most popular PHP framework.
His motivation is to provide a good resource to developers looking to choose a framework and wanting to find one of the best supported and most used choices. He also solicits comments on the post if you have opinions on why one framework shines above the rest.
Jani Hartikainenlooks at a certain something that's missing from several PHP frameworks offered today - a good library for working with the M (Model) in MVC:
While ZF provides data access classes in the form of Zend_Db and related components, it doesn't provide any concrete examples of how you would implement a model class. This often confuses especially beginners. Providing a common base model, or an interface for implementing models, does have certain benefits, but it also has some problems...
He defines what a good model interface should be and do before looking at the good and the bad of implementing them. A good reason to have an interface is to have a common method the classes could use rather than just using a database wrapper class. On the downside, this can also be very limiting and require you to be locked in to how that interface works without the flexibility you might be used to with a looser framework.
Just a quick note for the south american baker's and friends of cerveza: Some of the folks in Chile are having another CakePHP conference on Friday, Dec 19th(this week!). So if you want to check it out, the event is free and from my rough understanding of the schedule it looks interesting.
Speakers include Fabian Ramirez, David Riveros, Pablo Viojo and Julio Contreras M. and is happening down at the University of Chile. Check out the conference site for complete information.
On the PHP in Action blog this new post talks about something that's at the core of the front controller for most frameworks - a call to a user function based on the passed in action.
The core of your average web framework is a Front Controller. Front Controllers are commonly considered complex and esoteric. That's a myth. I sometimes brag that I can construct a Front Controller in 15 minutes. Actually, it's doesn't take quite that long. In PHP, a Front Controller can be simplified to just one line of code.
This one line of code, while a very dangerous thing to actually use in an application, illustrates what a front controller does to forward out the request to the rest of the framework. He revises it with a Zend Framework-ish example that splits the request out into a controller/action method.
Doug Brownasks a question on his blog today that is coming up more and more, especially on those programmers new to the language that don't quite get what frameworks really have to offer. Do you really need a framework for writing PHP?
The simplicity in using PHP sometimes acts against it. Since there are very few coding restrictions, developers tend to write a bad code. The answer to this is definitely to use a framework. There are various PHP Frameworks available today like Zend Framework, CakePHP Framework and CodeIgniter. They provide a strong organization for your application and follow the commonly used MVC pattern.
To help out those new to frameworks, offers a few things they have to offer that normal procedural/library-based development may not. These include maintaining code standards, attractive URLs and getting help when you need it from other developers using the same system.
In this new blog entryMarc Gear suggests a few things that you can do to help learn a new framework quickly and easily:
There are dozens of PHP frameworks around now, some attracting more attention than others. I am no expert on these frameworks and have not used a single one extensively so I wouldn't dream of recommending one over the other, nor do I want to enter the debate about what is or is not a framework (I'll work on the assumption that anything calling itself a framework is a framework). Instead I'm going to concentrate on how you can get started with a new framework as quickly as possible.
He suggests four examples that can help you get more familiar with each framework and how they're structured - a "hello world" as a first step, creating a simple calculator, making a guestbook and making a simple script to parse and paginate a remote RSS feed.
Mike Lively has a new review of a book from Packt Publshing (authored by Martin Brampton) - PHP5 CMS Framework Development.
Upon reading through the book I have found that it gives an excellent case study of Martin Brampton's approach to CMS design and implementation. [...] One might be concerned that the ideas in this book are slanted towards how Brampton decided to implement various aspects of Aliro. While it is true that much of the book uses code directly out of Aliro, I feel that he did take the time to make sure he explained the reasons for the design and development decisions he made.
The more he read through the book, the more Mike felt like it was a case study of the Aliro CMS rather than a true look at CMS building in PHP5. He (Mike) lays out some of the contents of the book including the look at common CMS functionality, code organization, extensions and internationalization.
DevShed starts off a new series today looking at making a blogging engine with the CodeIgniter framework. In this first part they get things set up and start work on the MySQL tables and views.
People love to communicate, which may be why one of the most popular web applications you can develop is a blogger. In this six-part series, you'll learn how to develop a blogging application using PHP and the Code Igniter framework. In this first article, we'll create the bare bones structure, with plenty of code samples to help you understand the process.
You'll already need a local copy of the CodeIgniter framework installed before you get going (download here). With that set up, you can follow along with their simple controller creation and making the view to pull out blog posts from their example MySQL database.
Kris Jordan recently posted five tips to help you get a "more correct" REST interface in your application.
As we entered a programmable web of applications with APIs the decision to ignore HTTP gave us problems we're still dealing with today. We have an internet full of applications with different interfaces (GET /user/1/delete vs. POST /user/delete {id=1}). With REST we can say /user/1 is a resource and use the HTTP DELETE verb to delete it.
This new post on Doug Brown's blog compares two of the more popular PHP frameworks - the Zend Framework and CakePHP - in an overview of features and general usefulness.
The Zend Framework, developed by Zend Technologies is an open-source, object oriented web-application framework implemented in PHP 5. It is widely known as ZF and is developed with the purpose of making things easier for PHP developers and supporting best practices at the same time. CakePHP too, is an open-source web application framework used for creating web applications written in PHP. It is developed by Cake Software Foundation, Inc. It is written in PHP and is based on the model of Ruby on Rails.
He touches on licensing, the components available for each, how both have an "install and go" mentality (little to no configuration required for a default install) and which he believes is good for what kind of developer/project.
Knut Urdalen has passed along the announcement about the 1.0 release of the Yii framework for PHP being released (by Qiang Xue).
The Yii Framework builds upon learnings and findings from over 5 years of development of PRADO. If you already know PRADO you'll get the hold of Yii quite fast. The framework is already documented quite well in The Definitive Guide to Yii (a good place to start for beginners), in addition to complete class reference and an active forum where you can meet other developers.
There is also an extension repository and a few benchmarks to help you compare it to some of the other popular frameworks out there.
Stefan Koopmanschap has a new post to the Ibuildings blog today about symfony's 1.2 release.
The first day of december started well: It meant the release of the new symfony 1.2.0 version. Aside from the additions and improvements in the code, this new branch of symfony also reinstates an old tradition in symfony: It comes paired with a huge amount of documentation in many forms. Let's have a look at what symfony 1.2 has to offer.
He mentions multiple updates and changes to the framework as well as three specific improvements in the realm of documentation - the jobeet advent calendar, a symfony + doctrine book and the constant stream of tutorials coming out of the community.
NETTUTS.com has posted the third part of their series on creating a simple PHP5 framework today:
Now that we've got a basic framework (see part 1 and part 2 of this series), we can start thinking about integrating designs with our PHP framework. For now, we'll concentrate on the front-end design, including how we can make it easy to 'skin' our new framework.
This part looks mostly at the HTML and CSS for the presentation layer (the views) to make a simple two-column layout with some basic image and text content.
On the Debuggable blog Tim Koschutzki has a new post showing how to get CakePHP to play nicely with a HABTM query and pagination.
The problem is that a user inputs some search criteria into a form, the resultset exceeds 30 rows for example and the user must be able to browse through the resultset via different pages. [...] This problem itself is in fact not much of a problem. We just need to store the form conditions somewhere and then hack it together. So what we are going to do is that we raise the difficulty bar a lot more by trying to get the pagination work over a HABTM relation.
Code is included for the model and controller to get the job done.
WebReference.com continues their series looking at user administration in content management systems. This time they look at the importance of user roles and some code to add to help manage them.
Although the operations are simple, it is vital that they be handled correctly. It is generally a poor principle to allow access to the mechanisms of a system rather than providing an interface through class methods. The latter approach ideally allows the creation of a robust interface that changes relatively infrequently, while details of implementation can be modified without affecting the rest of the system.
Their code includes methods to get all roles for a user, check to see which they are permitted to use, add a "permit" role and remove it back out. The tutorial is an excerpt from the Packt book PHP5 CMS Framework Development (Martin Brampton).
Douglas Clifton has put together a series of blog posts looking at several different types of categories that PHP applications and tools can fit into:
Rather than spending the time and effort to implement paging, I took another approach. And that was to get down to specifics. This was really a taxonomy problem, and the key was to break the page up into a top-level (general) category, and then divide the rest into sub-categories.
Douglas Clifton has taken some time to look at a group of the web application frameworks out there (not just PHP - Pearl, Python and Ruby too) and offer up some opinions on them. This new post is the result.
It just wouldn't be fair after my last post to ignore the tried-and-true server-side Web application frameworks. I am certainly familiar with all of them, though I haven't necessarily used every one in a production environment.
It's light weight, fast, and stays out of your way. There are any number of class modules to choose from, and you can discard what you don't need to lighten the load even more.
The AskAboutPHP.com blog has posted a helpful new tutorial for those using CodeIgniter out there - how to extend the native Model class to bend it to your will.
I'm in the process of creating models for my CI project, and realized that certain functions within the models were getting repetitive. Using CI's ability to create my own custom libraries, I was able to create my own custom 'Model' which extends from the core 'Model' object. How this simple architecture has cleaned up my code is simply remarkable.
Rather than overwriting the main Model.php file with some of your own changes, he suggests creating a new library, a "parent model" that can be extended instead to provide some common functions that all of your application's models might need. For something a bit more complex, he also points to this library that extends the models to give it CakePHP-like functionality.
In this new post to his blog, Manfred Webber shares an example he's put together to combine the PureMVC framework with the Zend_Amf component of the Zend Framework.
Since PureMVC is my framework of choice I could not resist creating a simple demo connecting PureMVC to the new Zend_AMF.
The sample application just responds to a button click by displaying a message inside of a text container. You can download the source that includes both the Flex and PHP sides.
New on the Solar blog is this post, a new part of their series looking at the Solar framework on the command line, focusing this time on the make-vendor command.
This entry is a continuation of the Solar CLI series--a series that aims to detail Solar CLI commands, available options, parameters, and usage examples. In this entry we take a look at make-vendor, a command to generate a new project, otherwise known as a "vendor space."
Their example shows how to make a new vendor for your application and all of the directories and files that are built out with it according to the standard Solar application layout. You can read more about this layout on the skeleton system page of the Solar manual.
The symfony blog has a new post spotlighting one of the new features of their 1.2 release - updates to its Doctrine functionality.
A lot of awesome stuff has been added recently to the next major symfony release, 1.2. Fabien has worked very hard to add without a doubt the most sophisticated features of any PHP framework that exists today. Not only are they nice features but he has implemented them in a OO way so that it is easy for me to implement the same features with another ORM, Doctrine. All this is done with very little work by me. So, give a big thanks to him if you enjoy this.
Included in the post is a real-world example showing how to use the symfony command line to build out an environment and create connections to the articles, categories and authors tables.
In a recent entry to his blog Andy Jeffries gives an overview of his site's transition over from one framework to another - away from Symfony and over to Rails.
I decided as I was learning/using Symfony at my contract at the time that it would be a good experiment to write it in Symfony. [...] The site did fairly well when I posted but I still posted in frequently.
After redefining the site's purpose a bit, he reconsidered the language (and framework) choice and decided to do a rewrite in Rails. He gives a comparison of the process on things like lines of code, time to build, performance differences, deployment and automated testing.
As this new post on the symfony blog points out, their next Plugin Developers Day is happening this weekend on Saturday, November 8th.
Preparations for the coming plugin developers day on Nov. 8th are proceeding apace. I've heard from a number of you who are planning to attend, some planning to start development on new, groudbreaking plugins, others looking to help update existing plugins to work with the latest and greatest version of symfony, and still others just hoping to learn from the lively discussion. All types are welcome!
The event will be centered around the #symfony channel on the Freenode IRC network and is broken up into different sections - creating and releasing a plugin, writing a customizable plugin and coding sprints on new/existing plugins.
A new post to the Solar blog takes a look at a set of included tools the framework offers for working with command-line applications.
One of the nice things Solar has to offer is its CLI (Command Line Interface), which can be used to accomplish tasks that would otherwise eat up valuable time, such as creating a new project, applications, models, tests, and documentation. In this entry, and others that will follow, I will be showing you how to use the current (Solar v1.0.0 alpha2) CLI, detailing commands, available options, parameters, and usage examples.
This entry is the first in a series on the subject and gives just the basics of the cli component - where to find it, how get help with its functionality (a "help" command) and some resources to get more information.
The SaniSoft group has announced a new event happening in the first part of December 2008 (in Buenos Aires, Argentina) - CakeFest.
Conferences are the forefronts of modern communications, more so when they are related to the FOSS world. Conferences and Open Source Fests are platforms where the developers meet, discuss, share and carry their work forward. [...]
SaniSoft is a sponsor for this year's event. CakeFest is a four day conference that gathers together the CakePHP community for networking and talks from speakers like Nate Abele, Garret Woodworth, Mariano Iglesias and Felix Geisendorfer. You can find out more information (as well as reserve your spot) on the main conference site. The Early Bird pricing of 50% off ends tomorrow, so hurry!
NETTUTS has posted the second part of their series looking at the basics of CakePHP and how you can get started developing.
In our last CakePHP tutorial we looked at setting up the CakePHP framework and introduced some of the framework's basic concepts and terminology [...] In the next set of tutorials we will build the blog application incrementally so that the basic CakePHP development process is laid out clearly instead of briefly mentioned as in other similar tutorials. In this tutorial we start with a basic authoring authentication component for the example blog application.
He's broken it down into a few steps - defining the goal of the application, creating the models to interface with the database, making the views to output the results and making the controllers to bind it all together.
On the Ibuildings blog today Marcello Duarte has a new review of the Packt Publishing book "PHP5 CMS Framework Development" (by Martin Brampton).
Martin left Mambo (before they announced to drop support for PHP4 last September) to write his own CMS and "evolve out of the Mambo history", by taking advantage of PHP5 OO enhancements. The result is Aliro: a CMS, a framework and an extension project with traits and genes of the Mambo family. Aliro code is used throughout the book to support and illustrate his presentation.
Topics of the different chapters include basic CMS system needs, organizing code, extensions and editing and presenting content.
New on the AskAboutPHP.com blog, this tutorial concerning CodeIgniter view organization has been posted:
Trying my hands at using CodeIgniter, one of the first obstacles I had was how to organize my 'blocks' on a page. Without knowing any better, I thought I had to reiterate the same view calls in every function within the controller, making the controller codes very messy. It turns out that CodeIgniter allows us to nest views within views, and that has made things a lot simpler for me.
Instead of loading and calling the view() method over and other in his actions, he chooses to make a "template" view with each of the other calls to view() contained inside. Then you just pass in the data you want the view to render and call that template view. This also allows you to easily create a site-wide template.
The PHP community definitely has its choice of frameworks to choose from - CakePHP, Zend Framework, Solar, Symfony - but according to Paul Jones there's some that "suck less".
I don't mean to put words in her mouth, but I'd prefer to extend Laura's phrasing a bit. I'd argue that "all frameworks from other people suck". The "other people" part is important here. It sucks to have to learn how someone else wants you to work, and that's a big part of what a framework needs from you: to learn how to use it. Learning someone else's code is much less rewarding in the short term than writing your own code.
He suggests that your framework is better because of just that - its yours. You know how it works, the ins and outs of the features and how its been refined down to just what's really needed. He does point out, though, that:
Sturgeon's law says 90% of everything sucks, and the development world is no different. Almost nothing is perfect for every developer: there's always significant room for valid criticism on any project, and even the best projects are lacking in at least one vital area (and that area is different for each project).
Kris Wallsmith has posted an announcement to the symfony blog about an upcoming event (happening Saturday November 8th from 3pm-9pm GMT) - Plugin Developers Day.
We will cover a number of plugin-related subjects in depth, including creating and naming a plugin, adding customizable model, form and action classes, unit and functional testing a plugin, packaging and releasing, and what's new in symfony 1.2.
If you've been meaning to try your hand at writing a symfony plugin or have been writing plugins for years, please join some of your fellow developers for a day of learning, collaboration and development.
Its an online event that'll be happening in the #symfony IRC channel on the Freenode IRC network. Nothing to sign up for - just show up ready to learn.
Gopal Vijayaraghavan has posted some opinions about the way that several of the popular PHP frameworks work internally, more specifically in their inclusion schemes.
In the development of things, there comes a point when it escapes the vision and control of one man/one mind. PHP frameworks are such ... beasts. But the simplicity a machine took away can be made to return. And such an attempt at zooming out of the complex file structure bureaucracy of most php projects was inclued.
He points to this image of the Zend Framework's structure as an example of the unneeded complexity several of the frameworks are guilty of (including CakePHP, Symfony and CodeIgniter).
He also includes a suggestion that could help keep the frameworks a bit more accountable:
Now, all that remains is a php-graphviz + svg mode which renders these in-browser as an iframe - or maybe someone can help me with the graph reduction to take a collection of the inclued dumps & create a "package".
Maxime Bouroumeau-Fuseau sent over a note about a project that's been started to try to port as much of PHP over to Javascript as possible - the Harmony Framework.
Nearly all of php features are already supported and the process is nearly instantaneous! Harmony also comes with Harmony XML, a Flex MXML like language to create components in xml and php.
The homepage even has a converter that you can use to make the PHP->Javascript transition for your own scripts. The framework is still in a Preview stage, but it already looks promising.
On the NETTUTS site today there's a new tutorial, an introduction to the CakePHP framework.
CakePHP is an open-source framework for PHP intended to make developing, deploying and maintaining applications much easier. CakePHP offers many useful design patterns, such as the Model-View-Controller pattern, seen in other popular frameworks like Ruby On Rails. The CakePHP framework also provides a slew of valuable reusable libraries for dealing with common tasks. An example is "Inflector" (a routine that takes a string and handles pluralization).
They step you through the download, installation and configuration of the basic CakePHP setup. Included are definitions for some of the common parts of the framework like models, controllers, plugins and the vendors directories.
In a quick new entry to his blog, Richard Thomas shows how to integrate the popular jQuery javascript library into your Solar application.
Going to go through a quick walk through of how to use a hacked together version of my old jquery library with solar. You can find the class source files here.
He sets up a callback in the Base controller (that all other controllers extend) for the jQuery calls so that any of the "child" controllers can just call "/controller/jquery" to make jQuery requests.
Richard Thomas has two new Solar framework posts added to his PHPJack blog - one talking about the new Firephp support integrated into the framework (similar to other frameworks) and a tip he's come across so far in using the framework.
There has been a flurry of work around Firebug recently including announcements that Zend Framework and Symfony both now have Firebug logging support through the use of the Firephp. As of this weekend Solar can be added to the list with its own support.
In the second post he looks at a simpler way to share information between all of your controllers without code duplication - adding it to the constructor of the Base controller your application is built on.
In a new post to his blog Jani Hartikainen wonders if, out of all the PHP frameworks out there, the Zend Framework is the right one for those new to the scene should be starting with.
I've heard some inexperienced PHP programmers say that Zend Framework is confusing to them. Until today, I have agreed: Zend Framework has a lot of classes and some of them are quite complex (such as Zend_Form). But does that actually make it more difficult for inexperienced programmers than other frameworks?
He argues a bit for and against, noting that the ZF docs can eb a bit thin in places but that the framework's architecture more than makes up for it (even if you're not completely sure how it works, you drop it in and it still does). He also mentions some of the hurdles they've had at his work trying to get yunger developers up to speed in their development with the framework.
Fabien Potencier has posted to the symfony blog today about a form handling enhancement they've introduced in the latest release of the framework (v1.2) - sfWidgetFormChoice.
When displaying a form, you often want the user to make a choice amongst a list of possibilities. In HTML, a choice is represented by a select tag. You can add a multiple attribute to make it accept several choices. [...] To unify all these possibilities, symfony 1.2 comes with a new widget called sfWidgetFormChoice. sfWidgetFormChoice is an abstract widget in the sense that it delegates the rendering to another widget (the renderer widget).
He includes examples of how to use the widget to make dropdowns, radio buttons, check boxes and even integrate some Javascript for handling multiple lists and autocompletes.
Stefan Koopmanschap has a recent post to his blog showing how to embed a distribution of the symfony framework in with the release of your application:
With symfony 1.0, one of the nice features was the freeze option, which allowed you to package the symfony libraries inside your project quite easily. This was very useful, for instance when deploying your project on a server where you couldn't install symfony. With symfony 1.1, it is apparently not advised anymore to use the freeze option (even though it is still available). So how should this be done then? Let's have a look...
He steps through the process, first setting up a subversion repository then putting a copy of symfony in to the lib/vendor directory and use the svn:externals to link to it.
In this new post to his blog Chris Hartjes suggests a new way to judge frameworks - how easy they make it to write unit tests against them and their resulting applications.
As a project for work gets ready for an alpha release, I've managed to eliminate all the serious bugs and now have some time for what should've been part of the project from the beginning: writing tests. [...] Since I'm using Code Igniter instead of CakePHP for this project (did I mention that I inherited the project and couldn't switch?) I started looking into the culture of testing surrounding Code Igniter. It's weaker than a newborn baby.
He tried to find anything he could use to write tests against the CodeIgniter application and finding fooStack as an easy to use tool for the job. This was what made him wonder how other frameworks stack up in the "has good unit testing functionality" category. He briefly covers four of them - CodeIgniter, Zend Framework, CakePHP and Symfony.
So now when you start comparing frameworks to each other, I think it's important you also consider how much effort has gone into creating tests for the core functionality of that framework. A well tested framework should mean far less surprises when using it.
Symfony developers out there will be happy to know that, since the release of symfony 1.1, writing unit tests for your models has been made even easier.
Writing unit tests for your Propel or Doctrine model is much more easier as of symfony 1.1. In this tutorial, you will learn some great tips and best practices to write better tests for your models.
The tutorial walks you through the creating of a simple test - evaluating a few criteria for the database contents. The entire thing is contained inside of YML files and is easily run via the sfConfig and integrated Propel functionality.
DevShed has finished off its CodeIgniter series today with this ninth part focusing on making a simple content management system with the framework.
Designed to allow programmers to create applications rapidly by utilizing the Model-View-Controller pattern, the Code Igniter framework lets you add many capabilities quickly and easily. This article will bring everything we've learned together for the creation of a content management system.
Their system combines the bits of knowledge from the previous parts (segments of specific functionality) and combining them into a MySQL-driven system to store some information about the user's favorite movies.
WebReference.com has the second part of their CakePHP introductory series posted, this time focusing on the actions in the controllers.
They talk (briefly) about how the call to the page is passed off to the controller's action and how you can get more information into it via POSTed values.
There's also a look at redirection, from action to action in a controller (or even to another one) and a look at a very handy method of sharing functions between the child controllers - a "master" parent controller (in their case, AppController).
At the end, they throw in a bit about components - module and reusable bits of functionality that can be passed around from controller to controller, action to action.
On the Solar blog Paul Jones has posted about a new database adapter they included in the latest Solar framework release - one that lets you connect to master/slave MySQL setups.
With Solar, you connect to SQL databases using the Solar_Sql factory class, which returns a Solar_Sql_Adapter class for you. Most developers only need to connect to a single MySQL server. [...] However, when you get into a situation where you need to scale up, you might need a replicated MySQL database setup. In such cases, there is one "master" server that handles reads and writes, and there are one or more "slave" servers that are read-only.
The Solar_Sql_Adapter_MysqlReplicated adapter does all of the switching for you, making it as simple as dropping it in and changing your configuration to point to the master and slave servers (examples included).
It's been eight months since the last broadcast... we lost the microphones. Tune it for some babbling info on CakePHP RC3 with Nate Abele and Marc Grabanski.
