http://www.h3rald.com/ H3RALD - Tag 'frameworks' (Atom Feed) 2010-04-09T17:30:39Z Fabio Cevasco http://www.h3rald.com tag:www.h3rald.com,2010-04-09:/articles/introducing-glyph/ Introducing Glyph 2010-04-09T17:30:39Z 2010-04-25T12:22:24Z I’ve been writing technical documents for a living for the past four years, and I can tell you: there is no easy way to go about it.

For example, you can use:

  • a Word Processor like MS Word, for example — anyone can do that, right? Sure, but no, thanks: I strongly believe that Word Processors should not be used for writing technical documents as I firmly don’t believe GUIs are suitable for doing this at a professional level.
  • a Document Authoring Software like Adobe Framemaker, Robohelp, etc. Still GUIs, only more complicated to use.
  • XML, like DITA or DocBook, or other markups, like ReStructuredText. Better, but still not easily extensible and flexible enough.
  • your company’s tools, if you have them. That’s great if they are usable enough and the result makes your boss happy.
  • LaTeX, and that’s probably your best option, if you know what you’re doing.
  • XHTML and CSS3, in conjunction with a PDF renderer like Prince XML — that’s great if you know HTML and CSS, and you don’t mind hand-crafting the structure of the document.

Lightweight markups

I love Textile and Markdown. When people aren’t looking, I even use them at work to generate HTML code, because it’s just so much faster. Textile in particular can be used as a drop-in replacement for HTML (and a bit of LaTeX, too), as it can produce most inline HTML tags effortlessly and some block-level tags, too.

For things like <div> tags and <tables> though, Textile is not the best thing in the world, so you normally end up falling back to HTML.

Another “problem” is that Textile or other similar lightweight markups cannot be extended easily, simply because they were not meant to be extended in the first place.

Moreover, if you are producing a book, Textile can’t help you if you want to generate things like a Table of Contents automatically or validate links: those things are simply not part of Textile’s job.

How Glyph can help

There are a few projects on the Internet that tackle structured document generation. One of them is Kitabu, which looks promising and is able to produce pretty documents using Textile and Prince for PDF rendering… but again, it’s not extensible because it relies too much on Textile and Markdown.

Glyph is different. For one, it is much younger than any other, therefore it is most likely full of bugs.

Jokes aside, Glyph follows a much more radical approach, which consists in using a macro language on top of Textile or Markdown. The good thing about it is that this macro language is very simple to learn and — most importantly — very easy to extend.

Here’s an example:

 1section[header[Something about Glyph]
 2You can use Glyph macros in conjunction
 3 with _Textile_ or _Markdown_ to
 4produce HTML files effortlessly.
 5  section[header[What about PDFs?|pdf]
 6Once you have a single, well-formatted HTML 
 7file, converting it to PDF is
 8extremely easy with a 3rd-party 
 9renderer like =>[http://www.princexml.com|Prince].
10  ]   
11]

Which translates to:

 1&lt;div class="section"&gt;
 2  &lt;h2 id="h_1"&gt;Something about Glyph&lt;/h2&gt;
 3  &lt;p&gt;You can use Glyph macros in conjunction with 
 4     &lt;em&gt;Textile&lt;/em&gt; or &lt;em&gt;Markdown&lt;/em&gt; to
 5     produce HTML files effortlessly.&lt;/p&gt;
 6  &lt;div class="section"&gt;
 7   &lt;h3 id="pdf"&gt;What about PDFs?&lt;/h3&gt;
 8   &lt;p&gt;Once you have a single, well-formatted HTML 
 9      file, converting it to PDF is
10      extremely easy with a 3rd-party renderer 
11      like &lt;a href="http://www.princexml.com"&gt;Prince&lt;/a&gt;.&lt;/p&gt;
12  &lt;/div&gt;
13&lt;/div&gt;

Glyph macros can be used to:

  • Generate block-level HTML tags not commonly managed by lightweight markups, like head, body, div and table.
  • Create and validate internal and external links.
  • Include and validate images and figures.
  • Automatically determine header levels based on the document structure.
  • Automatically generate a Table of Contents based on the document structure.
  • Store common snippets of text in a single YAML file and use them anywhere in your document, as many times as you need.
  • Store configuration settings in a YAML file and use them anywhere in your document, as many times as you need.
  • Evaluate Ruby code within your document.
  • Call macros from other macros (including snippets), carefully avoiding mutual calls.
  • Include text files in other text files.
  • Include the contents of configuration settings (author, title) in the document.
  • Filter input explicitly or implicitly, based on file extensions when including files.
  • Manage comments and todo items.

An example Glyph project? Sure, Glyph’s own guide (source — PDF output).

Technical Details

Glyph is built on top of the following Ruby Gems:

  • gli — For the high-level command line interface.
  • rake — For the mid-level interdependent task layer.
  • treetop — For parsing Glyph Language, whose grammar is ridiculously simple, but it seems to work so far.
  • extlib — Because I can’t leave without it.

Disclaimer

Glyph is alpha software (hence the 0.1.0 version number) — handle with care and be aware that everything could change tomorrow. If you want to keep up-to-date and/or provide feedback, feel free to join Glyph’s User Group.

For more information…

…head over to Glyph’s homepage.

]]> tag:www.h3rald.com,2007-07-18:/articles/akelos-interview/ An Interview with the creator of the Akelos Framework 2007-07-19T03:02:00Z 2009-09-06T18:10:54Z I already covered the Akelos PHP framework in the past, but for those who don’t know it, Akelos seems to be one of the few Rails-inspired PHP frameworks still worth mentioning, besides CakePHP and Symphony of course.

I recently has a look at their recently-relaunched community website and I noticed this phrase:

“Being port of Ruby on Rails to PHP Akelos is also optimized for programmer happiness and sustainable productivity”

Bermi Ferrer, Akelos creator, openly admits the framework is a port of Ruby on Rails to PHP, an attempt to help “Ruby on Rails developers who need to code in PHP”, among others. Of course Akelos is not Rails, simply because Ruby is (thank God for that!) not PHP, however I decided to find out more, and I asked Bermi a few questions, which he promptly answered.

There are a lot of frameworks for PHP, perhaps too many: why did you decide to create Akelos rather than using one of the existing ones?

I started coding Akelos back in 2004 for our internal developments. At that time I only found very few frameworks out there like Mojavi and eZ Publish. These frameworks were not my ideal of an Agile development environment, so I decided to brew my own solution.

After reading Patterns of Enterprise Application Architecture it was clear to me the kind of framework I wanted Akelos to become, so I started to implement some of the design patterns from the book into Akelos.

During the summer of 2005 I had a look into other PHP frameworks like CakePHP, PHP on Trax, and Biscuit but none of them was more complete or easier to use than what Akelos was already at that time.

Then I used Rails for one small personal project and immediately found that Akelos interfaces, conventions and philosophy were close to the Rails approach. Rails ActiveRecord implementation was impressive, better than mine and much much better than other existing PHP implementations, so I first ported the ActiveRecord code using PHP AdoDB as the database abstraction layer.

After that point, whenever I had a problem to solve while coding my customers applications I turned to Rails and they usually had the most elegant solution available. So I did like the idea of digging into Rails code to learn more Ruby and bringing Rails magic to the PHP world. It also helped the fact that Rails inline documentation is excellent so it could be easily adapted for Akelos.

What’s new since last time I posted about Akelos?

The biggest change is the direction that the project has taken. Until now we have not dedicated time to promote Akelos, we just used it for our internal projects and we have been adding features as needed without a fixed roadmap or advocacy.

Now this has changed. More and more developers are using Akelos and contributing functionalities they miss from Rails. After some serious contribution proposals and many developers telling us how much they like Akelos, we decided to take the time to build a nice community site which includes forums, a wiki, a new tutorial and a screen-cast.

There are also some improvements like:

  • Sintags, now accepts ruby-like calls to helper methods from the views.
  • Action Webservice, a component for creating and consuming Web Services easily.
  • Action Mailer, which allows you to receive and send (directly or in delayed mode) emails from within your application. (this is almost ready to ship)
  • Acts as tree behavior for Models.
  • Many performance improvements.
  • Many small contributions and bug fixes.
  • Code base reduced from 16MB to 9MB.

From the new site, it seems that Akelos is – or aims to be – a port of Rails for PHP. Is that true? Do you aim to target Rails developers as possible users of the framework in situations in which “they have no choice” but to use PHP instead of Ruby?

Akelos has ported many Ruby on Rails components keeping their interfaces and functionality whenever it was feasible to port the Ruby code to PHP. It might be considered a port in the sense of functionality, but there are some Rails strengths that rely on the Ruby language and that are impossible to port to PHP. However, Ruby developers will find that Akelos is the PHP framework with is the closest to Rails.

On the other hand, many PHP developers have moved to Ruby because PHP lacked a hyper-productive and fun-to-use framework like Rails for building complex applications. That is no longer the case, and those who excel at PHP can start being productive from day one by using Akelos. In this way, Akelos target users are those who already know PHP and need to build complex applications that can run on almost any cheap shared hosting using a solid foundation based on good coding practices and widely accepted conventions.

What Rails features are missing in Akelos?

A standalone webserver like WebBrick, RJS, has and belongs to many through associations, string/number/date extensions and Active Resource.

Ruby-powered features like modules, runtime class overriding and blocks will never be available in Akelos.

Scaffolds in Akelos work by generating code, I found quite useless to enable $scaffold = true; and have magic functionality that you can’t modify, so I decided not to invest my time on that one.

I noticed quite a few generators available for Akelos, do they work as a Rails developer may expect them to work?

The ones that are available do pretty much the same as in RoR.

How does Akelos compare to other similar PHP frameworks like, say, CakePHP? What features does Akelos offer which Cake doesn’t offer and vice-versa?

I’m not aware of Cake’s functionalities. At the time I started porting Rails my feelings about CakePHP were that they missed the simplicity point in favor of architectural discussions that lead to confusing code, but that was long ago.

Akelos (and Rails) do not implement ACL like Cake does, as that is a business logic component that varies too much from one case to other, it has no place inside the framework.

Akelos is built with internationalization in its core. You can even internationalize your Models by prefixing the column name with the locale.

I think that Cake only has an act_as_tree behavior on models while Akelos has Tree, Nested Set, and List. Akelos also implements handy features from Rails like optimistic locking, lazy loading, table inheritance, counters, automatic transactions, really powerful validations, calculations…, and I think most of these advanced features are still missing on Cake, but maybe I’m wrong.

Did you include unit tests for all the framework classes?

The main components are fully unit tested, and no new code or patch gets into the trunk without unit tests.

Did you or someone do any performance test or benchmarks on Akelos already?

During the last month a lot of code was refactored to improve performance with the help of Xdebug, Kcachegrind and ab. We significantly improved the performance in one of our most complex intranet applications, a basecamp-like system.

Akelos also implements caching at many levels, so it’s very easy to increase performance as we did with a new CMS that can handle +200 requests per second using Apache in a cheap shared server environment.

Why should a PHP developer choose Akelos over another PHP framework?

Akelos MVC implementation and workflow are really easy to understand.

In Akelos all the methods and interfaces are thoroughly selected, so whenever you need to do something you just need to type what you think. Default options are selected with care so you don’t need to set any configuration unless you want to modify the default behavior.

Coding multilingual applications, building complex relationships within models, distributing databases changes within your development team, building Ajax interfaces, unit testing your code and many other common tasks for PHP developers are really simple to accomplish when using Akelos.

Akelos is designed to work on PHP4 and PHP5 and it comes with an easy web installer you can adapt for your application. It has functions for working with files and directories in common situations when the web server runs as a different user.

And one of the main reasons for choosing Akelos is that it makes coding fun and lets you focus on solving user problems rather than wasting your time in repetitive technical annoyances. When coding with other developers the convention over configuration philosophy helps everybody to understand exactly how everything works and where to find things.

Is there any website using Akelos already?

The Chemical Brothers new website which has been developed by 3rd Eye Vision (3ev) is using Akelos.

The Akelos.org site is running a CMS named Editam which we will release as Open Source in a near future.

Some small websites like Fundacio Caixa Carlet and many intranet/extranet sites that we’ve been coding during the last 2 years.

What are your future plans for Akelos? Anything new on the way?

A new manual, and a better API interface are the main priorities right now.

Continuing bringing Rails functionality as needed.

Releasing our sister project Editam CMS which will help developers who need to add functionality on the top of a CMS using a solid MVC framework like Akelos.

]]> tag:www.h3rald.com,2006-08-01:/articles/38/ Akelos is real, after all... 2006-08-01T23:33:00Z 2009-09-06T18:10:53Z Bermi Ferrer kept his promise, and even if a few were skeptic on the pre-announced features of his upcoming Akelos framework, last week he sent me a “development preview” and a few days ago he opened the development SVN repository to the public:

svn://akelos.org/trunk

Go, get it: it’s worthwhile (see below).

“[…] The Akelos Framework is an open-source port of Ruby on Rails to the PHP programming language.
The main goal of the Akelos Framework is to help programmers to build multilingual database-backed web applications according to the Model-View-Control pattern. It lets you write less code by favoring conventions over configuration.”

At the Akelos Framework Features page you can find detailed information about what has been already implemented into the framework.

I think it says it all, well almost. Some people will undoubtedly be disgusted by yet-another-hopeless-Rails-clone: not again! I hear them crying…

Well, yeah, I think this – to be honest – should be the last attempt someone makes to port Rails to PHP or at least port some features and the overall philosophy, like CakePHP did: there are honestly too many for one single language. Look at Python, Django seems to be the only “Rails-inspired” framework available and everyone is happy with it, while as a general rule PHP folks are never happy with what they already got.

Bermi is undoubtedly one of them, and that’s the reason he decided to code his very own Rails-inspired framework for PHP, which is, to date, the most remarkable of the ones I left out (it wasn’t available at the time) in my article.

Confirmed Features & Contents

So well, although I didn’t really have a proper chance to play with Akelos I can certainly herald some of its – verified, this time – features.

For one, it’s huge. Take Cake, add every excellent, useful third party library or class you can possibly thing of and you’ll get Akelos. No kidding. The unzipped source of the whole framework is a massive 16MB, 8.5 of which constitute the vendors folder. What’s in it? Well, all this:

  • ADOdb
  • Domit
  • FPDF
  • Excel (reader library)
  • Hyper Estraier full-text search system
  • Inutio XML-RPC Library
  • Many PEAR packages
  • PHPCodeAnalyzer
  • PHPmailer
  • SimpleTest
  • A Simple PHP YAML Class
  • Textile

Then, similarly, all the state-of-the-art Javascript/AJAX hyper-hyped libraries are included:

  • AFLAX
  • Behaviour
  • Builder
  • various Scriptaculous packages
  • Prototype
  • FileUploader (by the author, using prototype)
  • Window
  • EventSelectors

Good, well, kind of: that’s just what others did, but it’s worth noting that it’s all there and – apparently – integrated with the framework, hopefully not too tightly. But people are fussy, and do not get excited easily anymore, long gone are the early days of Rails, when the whole Internet shake at hearing about code generators… Aye, there are in Akelos as well, of course!

Coming to the more juicy stuff, lo’ and behold, ye contents of /lib folder (with comments):

  • AkActionController (controller)
  • AkActionView (view)
  • AkActionWebservice (Web services)
  • AkActiveRecord (model)
  • AkAdodbCache (content caching)
  • AkCharset (utf8 support, includes all mappings)
  • AkConfig (load config settings)
  • AkConverters (conversions!)
    • DBDesigner > AkelosDatabaseDesign
    • Excel > Array (bi-dimensional)
    • Excel > CSV
    • HTML > RTF
    • HTML > Text
    • Word > Unicode
    • PDF > Text
    • Xdoc > Text
  • AkHeaders (HTTP headers, redirections)
  • AkImages (Image operations, resizing)
  • AkLocalize (Localization, countries and timezones)
  • AkInflector
  • AkLogger
  • AkFtp
  • AkInstaller
  • AkRouter
  • AkZip
  • …

Well, it’s all there, at any rate. The best way to know if it all works, and how it works, is simply to try it out: www.akelos.org.

Remarks

As I said earlier, Akelos looks like CakePHP on steroids: agreed, the Cake philosophy of “no we-may-use-it code in the trunk” has been completely (and intentionally) ignored, but this is our chance to peek at what CakePHP could have become if such philosophy didn’t become a lifestyle for the Cake Dev Team.
Akelos code is Rails-inspired, so yes, it’s very similar to Cake, although with some rough edges and some re-used parts, but it’s the work of ONE person with no community support (yet), don’t forget. Remarkable.

And he needs co-developers, by the looks of it, so there you are then: there’s your chance!

My personal opinion about it? Well, I think Akelos can learn from CakePHP and vice-versa: a merge? Well, at least it would reduce the number of Rails-inspired framework for PHP and possibly meet the needs of more people: those who want just the essentials, as a framework, and those who like to be virtually almighty and be able to do anything, if they wanted to.

Two flavours of the same framework? CakePHP and cAkePHP (note the case)? Bah, let’s stop raving now, shall we?

]]> tag:www.h3rald.com,2006-06-10:/articles/34/ Akelos Framework: too good to be true? 2006-06-10T09:26:00Z 2009-09-06T18:10:52Z Someone recently added a comment to my article about Rails-inspired PHP frameworks pointing out that I forgot another Rails-like framework, in my round-up. He obviously posted a link to this rather mysterious Rails port in PHP and spam or not, I’d like to thank this guy for letting me know of the existance of Akelos, a new PHP framework which seems simply too good to be true.

Let me just spend a few words more before writing more about it though. First off, it’s not available yet. OR at least it doesn’t seem to be: the author is planning to release his work to the Open Source community but… well, he’s a bit concerned about the current “PHP Framework War”: he wouldn’t like to end up like Subway or just be slagged off by those merciless reviewers who enjoy write round-ups and comparisons about frameworks. Bermi Ferrer is “just” a talented PHP developer who decided to create his own framework and he really enjoyed doing so, nothing more, nothing less.

“I considered other PHP ports of Ruby on Rails, but we could not find all we needed on them. One feature that I needed on the core was internationalization and Unicode support, so I decided to roll my own framework trying to keep most of the original rails interface so most of its documentation could work for it.”

Where did I hear that? Nothing new: it’s always the same story of frameworks not being as we want them to be etc., it’s human. And yes, it’s another attempt to port Ruby on Rails to PHP, and a damn good one — or so it seems.

Before proceeding any further, I’d like to write a short warning for a few people who may or may not want to pop in and start commenting about the Rails-is-better-than-any-PHP-clone issue: If I see a single comment slagging off this framework (or any other) only because it’s a port of Rails to PHP, it will be deleted, may it be David Heinemeier Hansson himself. Stop it, no seriously, I think it will be counter productive for Rails in the end: I really like RoR and I love the way it works, and yes, I think Ruby is definitely the best language to do that sort of things, EVERYBODY KNOWS THAT. Please, please, save us poor PHP developers the usual preaching.

Right, back to Akelos now. Curious as I am I immediately checked out the official page and all i found was a pretty long list of features which made me dribble, literally… ooops!

Let’s just quote the most juicy ones, shall we?

Active Record [“Model”]

  • Associations
  • Callbacks
  • Transactions
  • Finders [ $Project->findFirstBy('language AND start_year:greater', 'PHP', '2004'); ]
  • Versioning
  • …

Action Controller [“Controller”]

  • Filters
  • Pagination
  • Mime Type
  • Mime Response
  • Code Generation
  • Response handler
  • …

Action View [“View”]

  • Templates (using Sintags)
  • Web 2.0 javascript using prototype and script.aculo.us
  • Helpers
  • Partials
  • Template Compilers
  • …

And then more Akelos-only goodies:

  • Multilingual Models and Views
  • Locale alias integrated on URLS (example.com/spanish will load the es_ES locale)
  • Database migrations using DB Designer files
  • Pure PHP support for Unicode (no extensions required)
  • Unit Tested source code
  • Code Generators
  • Built in XHTML validator
  • Automated locale management
  • Clean separation from HTML and Javascript using CSS event selectors.
  • Ajax file uploads
  • AFLAX integration
  • Dojo Rich Text Editor
  • Format converters
  • File handling using SFTP for shared host running Apache as user nobody (as most CPanel server do)
  • Distributed sessions using databases

Impressed? I was, honest. And I’m talking as a CakePHP fanatic here, and I must say that if this framework can really offer all this and — and this is what really matters — is also as simple as Cake to learn and well performing… well, this is definitely going to be quite a promising player in the “PHP Framework War” (but is not a real war, is it?), although the author is quite worried about that:

“I’m also concerned about the PHP Framework war, I don’t want to play that game. Building this Framework was a great experience, it works great for me and it has helped me to become a better programmer so I don’t want to spend my time discussing about if this is better or not than other solutions. That’s the reason I’ll first look for great developers interested in the Framework to help me releasing it.”

Really, this will be an interesting project to check out, once it goes open source, and yes, I really wish Bermi all the best. Good luck, Akelos Framework.

]]> tag:www.h3rald.com,2006-05-06:/articles/26/ bake.php - Easy baking for lazy folks 2006-05-06T13:43:00Z 2009-09-06T18:10:51Z When I first tried Ruby on Rails I was literally amazed by the generator script. Yes, I was young and inexperienced then (six/seven months ago), but you must admit that getting a controller, a model, all the basic views generated automatically by

rails script/generator scaffold Posts

is not a bad thing. Especially if the same script allows you to create model, views and controller separately and other things. Symfony and PHP on Trax already tried to port this functionalities, with mixed results. What about Cake? Oh well, yes, we do have something like that… something rather different, but still something: the bake.php script.
This cute little thing is located in the cake/scripts/ folder and can be used – hear, hear – from command line. You can run Ruby and Perl scripts, so yes, you can actually run PHP from command line, although it’s not its primary purpose.

Cool then, let’s open a *nix shell, Windows command prompt, etc. etc., go into the cake/scripts/ folder and run:

php bake.php

Assuming that the php executable is in your PATH environment variable – if not, either you add it or you’ll have to type something like:

D:SERVERphpphp.exe bake.php

depending on where your php executable is. You’ll be be greeted by a “CAKEPHP BAKE” text, and then you’ll be asked a few questions. One thing to realize before proceeding any further: bake.php is not a generator, not in the traditional “Rails” sense, anyway. It’s rather a handy but more verbose dialogue-based configuration script – which will also generate something eventually if you provide all the necessary details.
A different approach, which may be good or bad according to your taste: personally I think we should also have something faster to use, like a Rails generator, and I opened a ticket about it, but let’s see what bake.php can do, for now.

The answer is… nearly anything. It annoying enough to please, but if you follow its directions it can do a prettu decent job in the end, it’s far from being sentient, but let’s say it’s smart enough for a script. First of all if you try it out on a fresh Cake install it will notice that you haven’t configured your database yet, so it will ask for a hostname, username, password, database name etc. etc. and generate your app/config/database.php for you, not a bad start.

Once that’s done – and it won’t go on unless you configure a (MySQL only?) database – you can proceed with the rest. You can start creating either a controller, model or view; I tried a Posts controller, for example. The script then asks quite a few questions:

  • The controller’s name
  • Whether it will use other models besides posts
  • Whether you want to include any helper
  • Whether you want to include any component
  • Whether you want to generate the base CRUD methods

Then finally it generates the damn thing. The result is good enough:



<?php
class PostsController extends AppController
{
	//var $scaffold;
	var $name       = 'Posts';


function index()

	{

		$this→set(‘data’, $this→Post→findAll());

	}


function add()

	{

		if(empty($this→params[‘data’]))

		{

			$this→render();

		}

		else

		{

			if($this→Post→save($this→params[‘data’]))

			{

				$this→flash(‘Post saved.’, ‘/posts/index’);

			}

			else

			{

				$this→render();

			}

		}

	}


function edit($id)

	{

		if(empty($this→params[‘data’]))

		{

			$this→set(‘data’, $this→Post→find(‘Post.id = ’ . $id));

		}

		else

		{

			if($this→Post→save($this→params[’data’]))

			{

				$this→flash(‘Post saved.’, ‘/posts/index’);

			}

			else

			{

				$this→set(‘data’, $this→params[‘data’]);

				$this→validateErrors($this→Post);

				$this→render();

			}

		}

	}


function view($id)

	{

		$this→set(‘data’, $this→Post→find(’Post.id = ’ . $id));

	}


function delete($id)

	{

		$this→Post→del($id);

		$this→redirect(‘/posts/index’);

	}


function postList()

	{

		$vars = $this→Post→findAll();

		foreach($vars as $var)

		{

			$list[$var[‘Post’][‘id’]] = $var[‘Post’][‘name’];

		}


return $list;

	}

}

?>

It’s more or less the same with models and views: it will still ask a lot of questions and in the end generate the thing.
This behaviour is more advanced than a standard generator, you can include helpers and components already, if you want, but do you really want that? For models it even asks if you want to include particular associations and validation rules! Personally, I’d rather a generator script which generates something immediately and accepts maybe some parameters to further customization, like:

php bake.php scaffold Posts
php bake.php controller Posts
php bake.php model Posts
php bake.php model Posts
php bake.php controller Posts helper +Html -Time,Javascript
php bake.php model Posts assoc +hasMany comments,tags

Bah… just some random thoughts. How about custom-made generators (Rails-inspired)?

]]> tag:www.h3rald.com,2006-05-03:/articles/rails-inspired-php-frameworks/ Rails-inspired PHP frameworks 2006-05-03T12:57:00Z 2010-09-23T11:56:33Z There are various articles online examining many PHP frameworks, providing short reviews or comparative charts, but I could not find yet an article examining the so called “Rails-inspired frameworks” anywhere on the web, so I decided to write my own…

IMPORTANT UPDATE: I do no longer recommend the CakePHP framework anymore due to the unprofessionalism of some member of its development team. My site is now powered by Ruby on Rails and I totally lost interest in PHP and any PHP framework. If you are looking for a decent web framework, try Ruby on Rails (for Ruby), Django (for Python) or Catalyst (for Perl).
I’m talking about those PHP frameworks who give at least part of their success to Ruby on Rails2, but don’t call them clones or ports as some of their creators may get offended.

Since Rails shocked the world with an easy-to-use, powerful and semi-sentient web development framework, web development is not the same anymore: everything must be done efficiently, quickly and you have to produce a Web 2.0 compliant public beta after X days/weeks/months or your work is simply not useful to anybody. Try doing that with the traditional PHP spaghetti code: you can’t, it’s too much, it will be too tangled up and in the end you’ll lose your mind trying to find that small insignificant bug which makes your web application completely useless.

Yes, you could use Rails, but maybe you don’t know or don’t want to learn Ruby, your host doesn’t support it, your boss loves PHP etc. etc. If you’re in this situation or you simply would like to know what’s going on at the PHP front of the Rails Clone War, you should keep reading this article.

I’d like to introduce – briefly – six Rails-inspired PHP frameworks and compare them with each other, to point out their features, their pros and cons.

Disclaimer: I’m a CakePHP3 fan, this site has been built with CakePHP and I even wrote something4 about it in the past. This makes me inevitably partial and more familiar with this particular framework, but I’ll try my very best to provide a relatively objective analysis. Obviously frameworks which are not based on the MVC architechture and that weren’t inspired by Ruby on Rails have not been included, so forget things like PRADO, Qcodo, eZComponents, or even Mojavi: it’s not that they are “bad”, they’ve just been left out because they are not pertinent to this article

CakePHP

Website: www.cakephp.org
PHP version: PHP4 and PHP5
License: MIT5
Download size (.tar.gz): 184KB
Supported Databases: MySQL, PostgreSQL, SQlite, MS SQL + any other supported by ADOdb or PEAR::DB database abstraction layers
Beginner’s Tutorial: Blog Tutorial

Official Description:
“Cake is a rapid development framework for PHP which uses commonly known design patterns like ActiveRecord, Association Data Mapping, Front Controller and MVC. Our primary goal is to provide a structured framework that enables PHP users at all levels to rapidly develop robust web applications, without any loss to flexibility.”

PROs:

  • Lightweight, not bloated, containing only essential code
  • Runs both on PHP4 and PHP5
  • No configuration needed – except for a stupidly short database configuration file and a few constants which can be modified. You can literally start baking in less than five minutes
  • Extended table association support, allowing the creation of complex database architechtures
  • Extremely logical and functional directory structure: better than Rails, if you ask me.
  • Enhanced AJAX support through the AJAX and Javascript view helpers
  • useful “bake” command line script to generate parts of the code automatically
  • Very active community and plenty of satellite sites
  • Suitable for every kind of website, from the small personal site to the advanced e-business application.

CONs:

  • No “official” internationalization support for now, but it will be included in the next milestone.
  • It does not take fully advantage of PHP5 features
  • Official documentation still needs some some improvement, although now it seems pretty complete and exhaustive.

Comments:
CakePHP is my personal favorite: easy to learn, easy to use,multi-purpose and not bloated. Cake’s philosophy is not to include unnecessary code in the framework unless it’s absolutely necessary for the framework itself, as a result, 3rd-party libraries are not included in the official releases, but may be seamlessly integrated with the framework if developers need them.
Cake’s success is partly determined – at least initially – by the fact that it can run fine with no limitations on PHP4, while other similar frameworks don’t. Although this may still be one of its most obvious strengths, it must be said that Cake seems to go in the right direction, taking only the best from Rails, without forcing developers into complex and pointless adaptations, and evolving into a great framework created in PHP, for PHP.

Symfony

Website: www.synfony.project.com
PHP version: PHP5
License: Symfony6
Download size (.tgz): 1255KB
Supported Databases: MySQL, PostgreSQL, SQLite, Oracle, MS SQL + any other supported by Creole database abstraction layer
Beginner’s Tutorial: My first project

Official Description:
“Based on the best practices of web development, thoroughly tried on several active websites, symfony aims to speed up the creation and maintenance of web applications, and to replace the repetitive coding tasks by power, control and pleasure. […]
Symfony is an object-oriented PHP5 framework based on the MVC model. Symfony allows for the separation of business rules, server logic and presentation views of a web application. It also contains numerous tools and classes aimed at shortening the development time of a complex web application."

PROs:

  • Fully featured framework, includes everything you might ever need (see CONs, below)
  • Full native internationalization support
  • Truly excellent documentation, tutorials, wiki, book, screencasts, API, real-world examples, etc. etc.
  • Code generators
  • Various “pre-built” modules/libraries for the most common tasks
  • It was not inspired only by Rails, but borrows concepts and practices from various other frameworks
  • Good community support

CONs:

  • Seems too big compared to the others, too many “extras” which may not be useful to all developers
  • PHP5 only
  • Confusing and disorganized directory structure
  • Uses too many configuration files, not suitable for simple projects
  • Steep learning curve

Comments:
Symfony is really an interesting framework: it’s perhaps the most complete in terms for features and documentation. The only problem I have with it is that it just seems too complex and rather difficult to learn if compared to the others, which can do almost the same things (or will soon be able to) in a MUCH simpler way. A nice blend of MVC, pre-built components, command line generators and YAML/Propel configuration files, but perhaps a bit disorganized in its internal structure, unlike its wonderful documentation and support section.

PHP on Trax

Website: www.phpontrax.com
PHP version: PHP5
License: MIT
Download size (.tgz): 843KB
Supported Databases: Any database supported by PEAR::DB
Beginner’s Tutorial: How to create a Trax application

Official Description:
“Php On Trax (formerly Php On Rails) is a web-application and persistance framework that is based on Ruby on Rails and includes everything needed to create database-backed web-applications according to the Model-View-Control pattern of separation.”

PROs:

  • Simple, logical, essential: a true RoR port to PHP5
  • Code generators, like Rails
  • Zero configuration (like Rails and Cake
  • Easy and logical directory structure (the same as Rails)
  • Supports table associations, but more in a way which is more similar to Ruby on Rails than Cake.

CONs:

  • Lack of documentation compared to the others
  • Trying to port Ruby on Rails to PHP, ignoring why RoR was not built in PHP in the first place7
  • No internationalization or other advanced functionalities
  • PHP5 only
  • Small community
  • DBO class based only on PEAR::DB

Comments:
In my opinion this project aims too much to be a Rails-clone to acquire a proper consensus. Trying to port something to another language is not good, especially in the case of Rails and Ruby. This framework looks somehow like an old version of CakePHP, which evolved slightly but always remained anchored to its beliefs of building a Rails port for PHP (even in the name!). Some may say that this is a lost battle since the beginning – or better, since before it started – but others found that PHP on Trax can be the easiest way to switch from Ruby on Rails to a PHP equivalent. Who is going to do that? Well, Ruby programmers forced to develop in PHP, maybe. Not too good, but not too bad either.

Code Igniter

Website: www.codeigniter.org
PHP version: PHP4 and PHP5
License: CodeIgniter8
Download size (.zip): 609KB
Supported Databases: MySQL, PostgreSQL, SQLite, MySQLi, MS SQL + ODBC
Beginner’s Tutorial: Hello World! Introduction to Code Igniter [video]

Official Description:
“Code Igniter is an Open Source Web Application Framework that makes writing kick-ass PHP programs simple as apple pie. […] Designed to enable, not overwhelm, Code Igniter is a powerful PHP framework with a very small footprint, built for PHP coders who need a simple and elegant toolkit to create full-featured web applications.
If you’re a developer who lives in the real world of shared hosting accounts and clients with deadlines, and if you’re tired of ponderously large and thoroughly undocumented frameworks that require rocket science to understand, Code Igniter might just be the right tool for you."

PROs:

  • Good and organized documentation
  • Zero configuration (like Rails and Cake)
  • Includes various classes and libraries for common tasks
  • Compatible with PHP4 and PHP5
  • Medium-sized community
  • Intuitive directory structure
  • Ships with the full user guide included in separate HTML files

CONs:

  • No full (“written”) tutorials except the videos!
  • Relatively new to the scene, but growing
  • Does not seem to support table associations.

Comments:
People on the Net seem to be rather enthusiastic about this framework: where there’s a thread about the big ones (Cake and Symfony), there’s always, someone who pops in suggesting to try out Code Igniter. I personally think this can be a true bless for small/medium sized projects, however, I’d opt for CakePHP or Symfony for a large scale application: something is missing, e.g., most notably, table associations.

Biscuit

Website: biscuitproject.tigris.org
PHP version: PHP4 and PHP5
License: MIT5
Download size (.zip): 240KB
Supported Databases: Any database supported by PEAR::DB
Beginner’s Tutorial: Creating a simple application using the Biscuit MVC framework

Official Description:
“The mission of this project is to port Ruby on Rails to PHP5 (minus the Ruby part ;-)”

PROs:

  • Zero configuration, easy to deploy
  • Runs both on PHP4 and PHP5
  • Simple to learn

CONs:

  • Still under development and incomplete
  • Offers a limited subset of the features and functionalities offered by competitors: no internationalization, no table associations, no scaffolding…
  • “Documentation coming soon”
  • Almost non-existent community

Comments:
This project started as an attempt to create something simpler than CakePHP and more similar to Rails. I’m not sure whether the project is still active or not, since the last “release” on the former’s developer site is dated August 2005. Still in early stage – or dead.

Pipeline

Website: livepipe.net/pipeline/
PHP version: PHP5
License: Pipeline9
Download size (.zip): 288KB
Supported Databases: SQLite
Beginner’s Tutorial: none

PROs:

  • Simple directory structure
  • Suitable for small projects
  • Comes with various ready-made components
  • Supports table relationships

CONs:

  • PHP5-only
  • Too restrictive: only SQLite supported, kindly suggests developers to use its built-in features only
  • No documentation or tutorials, just the API
  • Not suitable for large projects
  • Almost non-existent community

Comments:
This project mainly borrowed the MVC architecture and some basic concepts from Rails, creating a simple PHP5 framework with personal/small websites in mind: it offers various built-in components which can be handy to most of us, supports only SQLite, and basically tells developers what to do. In my opinion it’s not flexible enough to be compared to the others, and it’s simply not suitable for anything other than small websites.

Conclusions

My favorite framework still remains CakePHP, it’s simple and yet powerful, easy to learn and use, mature, well supported and continuously improving. Symfony – at the moment – seems to be the one with most features and the best documentation, and it is an excellent and well supported project. The only problem I have with it is the scary amount of configuration files necessary to create an application: CakePHP doesn’t need any and can be used for (almost?) equally complex projects.
Although I didn’t have a chance to try them out, PHP on Trax is certainly the most faithful port of Ruby on Rails to PHP, but it lacks some of the features CakePHP and Symfony offer. Code Igniter may not be as advanced as the others, but its community seems to grow and its simplicity may appeal more users in the future…

At any rate, developers should always choose the best framework for their needs: I tried to write a quick comparative analysis of these six Rails’ “PHP children”, now it’s your turn, try out some of them, if you choose wisely you won’t be disappointed.

Notes

1 They are all distributed according to various Open Source licenses.

2 Ruby on Rails – Ruby framework for web development

3 CakePHP – Rapid [PHP] Development Framework

4 CakePHP – A ‘tasty’ solution for PHP programming, originally published on zZine Magazine

5 Open Source MIT License.

6 Symfony License:


Copyright © 2004-2006 Fabien Potencier
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

7 Read the comments by David Heinemeier Hansson on Ruby on Rails to Basecamp

8 CodeIgniter License Agreement

9 Pipeline is licensed under the same terms as the Symfony framework [Copyright © 2006 Picora Pipeworks LLC].

]]> tag:www.h3rald.com,2005-12-08:/articles/cakephp/ CakePHP - A 'tasty' solution for PHP programming 2005-12-08T16:03:39Z 2009-09-06T18:10:49Z Is this really true? If so, is there any possible way to write a PHP application in a logical and clean way? Read on...Every web developer has certainly heard of PHP. Some people like it and consider it a powerful and easy-to-use way to create complex websites or web applications, while others are convinced that it is merely a bad copy of Perl. Opinions are certainly mixed on the matter.

One thing to keep in mind when reading criticisms of PHP is its origins, as therein lies the crux of the matter. PHP was created as a form interpreter, initially offering only a very limited range of functionality. Its main purpose was to make life easier for web developers who wanted to do simple tasks, like manipulating form data.

People liked the concept - PHP was free and it quickly became popular among developers. More functionality was added and continues to be added with each new release, and PHP is now one of the most popular and powerful programming languages available for web development.It is relatively easy to learn, compared to Perl, ASP, or JSP, and it can be used for almost anything[1].

The sheer simplicity of the language was most likely the cause of the enormous amount of exploits discovered through the years which earned PHP the label "too dangerous to use in 'proper' applications". The danger, however, lies not in the language itself, but rather in the way developers make use of the language: PHP's simplicity makes writing bad or exploitable code extremely easy. Furthermore, PHP's ability to be placed within any HTML page with the greatest of ease tempted developers to write ever-increasing amounts of 'spaghetti code', which by its very nature is neither organized nor clean code, and certainly does not help a developer learn how to write organized or clean code.

These problems, however, can be solved. There are many ways to go about doing this, but the easiest, most effective way is to create a framework[2].


Bringing Order to Chaos

After learning some PHP myself, I remember noticing that my applications were growing in a disorganized and uncontrollable manner. Things tended to be added at the last minute, and bugs were fixed and patched 'on the fly' wherever they occurred. PHP lacked the structure that is present in most other programming languages. I remember reading the word framework for the first time not too long ago while I was downloading a Windows Update of the .NET framework[3]. That inspired me to start searching the Internet for a 'PHP framework'. That led me to an interesting blog entry[4] where a solution was proposed - a solution to bring order to chaos:


[...] The answer is simple: create our own class library, some kind of framework, the PHP framework. The similar in many ways to that one which is already well known to Java or .NET programmers. We could set the standards, structure and main guidelines. [...]


That blog post made me think about developing my own framework, until I noticed that there were many projects already in progress, and some in fact completed; the end result being a fully functional PHP framework. I read a lot about some of them[5], and abandoned the idea of developing my own, because as a good developer, I believe I should never re-invent the wheel. So I kept looking. I found Pear[6], although that's more a repository of PHP classes with a common standard than a framework, while I was looking for THE solution to developing many types of applications, not merely how to do one thing in particular.

I came across a very promising project named Prado[7], which won the latest Zend contest, and was considered the best PHP5 application of the year. It is a masterpiece of coding and PHP5 usage, so I tried to learn it. I even developed a website with it.

Prado lets the developer design the application without imposing any ready-made components, but I found its event-driven[8] approach neither easy to learn nor suitable for everyday web applications. I did not like the idea of having to code a reaction to every event (like a click on a button or different phases of page rendering): that is the approach that ASP takes, and at least in that respect, Prado seems to be inspired by the .NET framework. Event-driven programming is suitable for GUI development and desktop-based interfaces, but not for web applications.

After trying Prado, I was still unsatisfied, so I once again began my search for a solution to improve my programming. My meanderings took me to Ruby on Rails[9], one of the most recent examples of technology hype on the Net. At the same time,to a certain extent, it is also a successful tool.


The Rails Phenomenon


"Rails is a full-stack, open-source web framework in Ruby for writing real-world applications with joy and less code than most frameworks spend doing XML sit-ups."


That sounded like what I was looking for, and I started reading more about it in the vast and varied help sections[10] available both on and off of the official site. The Rails team did an outstanding job promoting and marketing the framework, and also in providing comprehensive textual documentation (and even video tutorials) to help both beginners as well as experienced programmers get started with it.

Briefly, Rails uses Ruby's object oriented programming, in conjunction with the MVC pattern and various automated scripts (generators), to help developers program their applications quickly and in a solid and organized way. However, as that is neither clear nor convincing, let's spend a few moments on the MVC Pattern[11], which will also be useful to understanding the following sections.

MVC stands for Model View Controller: these three words enclose - and this is just a personal opinion - all the wisdom and philosophy of web development, describing - once again, in my opinion - the three most logical parts a web application should be divided into to achieve code robustness, order and power, all at the same time. Let's look at what each of the component parts mean in detail:


    [*]Model: The model represents the very essence of the information and content of a web application. Imagine this as an object able to gather the information and content of your webpages from a particular resource, such as a database. The model is the only entity able to access resources.
    [*]View: The view is an attempt to separate the most unstable part of an application: the user front-end. A view is only responsible for presenting the information that the Model gathered. A view does nothing but format the output, and can be compared to a template or report. In all MVC frameworks for web applications, only view files contain (X)HTML code, and mostly only that. They can therefore be changed at any time without having to touch a single line of the business logic of your application.
    [*]Controller: The controller is the 'brain' of the application. Consider it to be the only part of your program that can 'think' and manage the other parts. Controller files are the only ones able to order the Model to gather information and then pass the information obtained to the view for display.


Although the MVC seems to make things more complicated, that is part of the objective. Since one of the advantages (and weaknesses) of PHP was its simplicity, the MVC adds complexity to bring more order and logic to the design process. The three entities are separated for just that reason, and trying to put them together can result in potential disasters, since it causes the whole pattern to fail.

Coming back to Rails, I was quite impressed by the features it offered, but there was a small problem: the Ruby programming language itself. I experienced some difficulties in setting up the environment properly, and I also discovered that most standard hosting companies do not offer Ruby hosting plans as standard. Hosting issues aside, I would have had to learn Ruby in order to master Rails, and I really did not have the time for that: I had to develop a website quickly and easily, preferably with languages I already knew.

After deciding to abandon Rails (for the moment, anyway), I was amazed by the number of projects in other programming languages that try to emulate the famous Ruby framework, to the point of being considered clones or ports of it to another language. To my knowledge, the Rails disease contaminated the following programming languages:

  • PHP
    • [12]
  • Python
    • [13]
  • Java
    • [14]
  • Perl
    • [15]


I said disease because Rails developers think that Ruby on Rails was made in Ruby for a reason, namely that Ruby offered some unique features that were not available in other languages. I will not delve into that topic here; more information is available[16] for those who are interested. However, suffice it to say that there are some Rails ports in PHP that were immediately attacked because of the fact or legend that the creator of Rails originally wanted to develop his framework in PHP and then switched to Ruby. Let's examine one of those PHP frameworks in detail.


CakePHP: Just Another Rails Clone?

I chose to learn CakePHP (or "Cake")[17] mainly because it offered more features than the other two PHP alternatives. It also seemed to be a more original and actively developed project. In particular, I'd like to quote one of CakePHP's developers, from when he introduced the framework in a comment to a blog post[16]:


"While it's difficult to copy Rails in PHP, it's quite possible to write an equivalent system. I like the terseness of Ruby code, but I need the structure that Rails provides, how it makes me organize my code into something sustainable. That's why I'm ripping off Rails in Cake."


Cake's developers (bakers?) are developing their own framework which uses many principles of Ruby on Rails, revisited and re-proposed in an extremely flexible and easy to use PHP tool, rather than simply trying to port Rails to PHP. I also liked the fact that they bothered to choose an original name for their project, unlike others: there are too many "<insert language here>-on-Rails" frameworks, and while the whole "Rails" thing is innovative and catchy the first time, it loses its appeal quickly when people use the word everywhere just because it is "fashionable".

Quoting from CakePHP's website:


"Cake is a rapid development framework for PHP which uses commonly known design patterns like ActiveRecord, Association Data Mapping, Front Controller and MVC. Our primary goal is to provide a structured framework that enables PHP users at all levels to rapidly develop robust web applications, without any loss to flexibility."


That sounds like the Holy Grail for PHP developers, and I must admit I'm quite impressed myself after using it on various little projects, but is it really all true? What are Cake's features? Are there any limitations?


The Ingredients

So what is Cake? In the previous sections, I introduced some general concepts and ideas common to Ruby on Rails and CakePHP, but nothing in particular was said about the structure of the framework itself. Let's now turn to that and discuss it in some detail, particularly as it pertains to Cake.

The first thing to understand about Cake (and Rails as well) is that one of their aims was to avoid editing long and complex configuration files in order to run the environment. The approach in this sense is to use conventions over configuration. This may sound terribly restrictive, but in reality it proved to make things much simpler. After all, I said I wanted to use a framework because I needed a solid structure to base my applications on, not that I needed to be able to create and personalize my own structure and system. Cake uses some simple rules in order to run properly, and the easiest way to explain them is through Cake's directory structure, which represents the skeleton of every CakePHP application.

/
---app/
------config/
------controllers/
---------components/
------models/
------plugins/
------views/
---------elements/
---------errors/
---------helpers/
---------layouts/
---------pages/
------webroot/
---------css/
---------files/
---------img/
---------js/
---cake/
------config/
---------inflections/
------docs/
------libs/
---------controller/
---------generator/
---------model/
---------view/
------scripts/
---tmp/
------cache/
------distro/
------logs/
------tests/
---vendors/

I expanded only the first three levels of the tree, although there are more levels in the /cake/ directory. They won't be considered here simply because the /cake/ directory contains CakePHP's internal libraries, which normally will not be modified when developing an application. The /tmp/ directory also will not be elaborated upon either, because it is only used to store temporary files. However, the /vendor/ directory should contain third party scripts and libraries that you may want to use in your application, but they are not normally integrated with Cake's framework. 95% of your application will reside within the /app/ directory, which we therefore need to examine in greater detail.

/config/
When I said that Cake strives to use conventions over configuration, I really meant it. This directory does not contain thousands of configuration files, only five very small ones. They represent the only items which might need to be configured.

[list]
[*]acl.ini.php: This file must be edited only if you plan to use Cake's default ACL (access control list) system for your application. It sets permissions for the application, so it should be used to list every group, user, and their respective rights. This can be useful for small sites with a few well known users, but for anything else, you should develop your own ACL or authentication system that relies on a database.
[*]core.php: This file can be edited to change some default options, such as the level of the error messages and notices that the application will output. This comes in very handy while developing an application.
[*]database.php.default: This should be renamed to database.php and edited if you plan to use any databases with Cake. The settings are fairly straightforward, and include the type of database used (mysql, postrgres, sqlite, or any other supported by the AdoDB library[18]), username, password and database name.
[*]paths.php: Unless you are very particular, you should leave this file alone. It tells Cake where to look for CSS files, images, controllers, etc. If you are planning to adopt Cake's directory structure - which is the most logical option - you can ignore this.
[*]routes.php: Following Rails' example, CakePHP features a "routing system" for user-friendly URLs. By default, your URLs will look like this: http://sitename/controller-name/action-name/eventual/action/parameters, which is a really nice way to organize a site, but you may want to change something if you have particular requirements.
[/list]


Controllers
As mentioned previously, a controller represents the "brain" of the MVC pattern, the part which controls what the other parts are doing. Imagine a controller like a section of your site: its name will be present on the address bar, and each of these sections will have a file named <something>_controller.php, and will also contain a class named SomethingController that extends the AppController class. This class will have some methods that correspond to some standard actions like index (the default action called when you access the http://sitename/controller/ page) or other user-defined ones like add or list or admin, depending on the application. As a general rule, you want to add any 'business logic' you want to implement in your application in controllers - for example, calculations or a database query that produces a result. Then once all the mess is done, the result (usually an array or a variable) is passed to the view (see views below).

If this is starting to sound too technical for you, I recommend reading a tutorial[19] available on the CakePHP website about creating a simple blog application. The tutorial will explain most of Cake's basics, including how to pass a variable from a Controller to the corresponding view ($this-set('variableNameInView', $variable)) and other useful things.

Recently Components have been added to CakePHP, and quoting from the corresponding wiki page[20]:

"Components are the preferred way to provide additional functionality to your controller. To make a component available you would add var $component = array('myComponent') inside of your controller's definition, add your file to the /app/controllers/components, name your class MyComponent, and create your methods."



Models
A model is an object able to access the database. In Cake's terms, that is any class extending the AppModel class. That class is directly under the /cake/ directory (along with the previously mentioned AppController class), and can be moved to the /app/ directory and modified if you want to add some particular site-wide behavior to it which will be inherited by all models extending it.

In even simpler terms, you need to create a Model class for every table you're planning to use in your database. A convention in Cake says that database table names should be plural and that the corresponding model should be singular. If you use a table named 'mice', your model should be named 'mouse': Cake is smart enough to understand irregular plurals through an Inflector class.

Creating a model class for basic use is trivial:


class Post extends AppModel
{
var $name = 'Post';
}


Then you'll be able to access the model (and therefore the database) from a controller via simple instructions like $this->Post->findAll(). This instruction will query the database and return all records within the Posts table in your database. You can also perform more complex operations, and also specify SQL queries to execute, if you need to, but remeber that models can only be accessed through controllers! If you need some information stored in your database to be displayed on a view, execute the query from the controller and pass it to the view as per the MVC pattern. It can prevent you from cluttering views with business logic and thereby making code updates much harder.


Views
Views are used to present information gathered with a model and a controller to the public. They are mostly HTML pages with some PHP tags in them, prints of variables and maybe some foreach loops. Nothing more than that should be used in a view!

Views must be placed in this directory and obey the following conventions:

1. They must be named after a controller's action to allow the controller to refer to a particular view automatically. The same view can be used by multiple controllers, but it must be either set manually or through a layout (see below).
2. Views referring to an action of a particular controller must be placed under a subfolder named after the controller.
3. All views must have a .thtml extension.

Any site-wide view, like the site's template, must be placed under the layouts subfolder. In particular, the default.thtml file in the folder represents the global template for your application: page titles and specific pages (views) will be invoked automatically by using $title_for_layout and $content_for_layout respectively.

Similarly to what was said about components, helpers can be used to extend views functionalities[20]:


"Helpers are all about the view. You know about the helpers in Cake, but you need a little bit more. You want to have your own methods to display formatted info. To achieve this, you need to add var $helpers = array('myHelper').

Now, throw your myhelper.php file into the /app/views/helpers/, create the class MyHelper, and $myHelper is available in the view."


Cake comes with some very useful default helpers to create links and HTML tags, import JavaScript, create forms, and use AJAX code easily. Unlike most other frameworks, Cake neither has nor uses a third party template engine (like Smarty[21]) for views, but helpers can be used to achieve similar results more quickly than an engine can.


Plugins

Plugins are user-developed enhancements for Cake. Unlike the files placed under the vendor directory, a plugin is an application specifically made to be used within the CakePHP environment. At the moment this feature is still under development.

Webroot

If you read carefully what I wrote above about routes, you might be wondering if every page must have a controller and a view in order to be displayed properly. What about images, JavaScript and CSS files? The answer is this directory: everything you place here will not be seen as part of the MVC-based environment; CSS files can be stored in the /css folder, Javascript under /js, and so on. Additionally, some helpers can provide a easier way to access or display images, scripts, CSS, etc.


Other Features
Cake offers even more than this; the latest releases have introduced a few more Rails-inspired features:

[list]
[*]Scaffolding: Do you want to test your application without spending time writing all the CRUD (Create, Read, Update, Delete) code? That's where the concept of scaffolding comes in: by setting a few variables in the right places[22], Cake will generate basic mechanisms to add, edit, list, and delete records in your database, along with all the associated view files. You won't have to code a single form, as everything will be generated automatically by the framework according to SQL field types.
[*]Bake: Another Rails-inspired feature revisited in PHP. Rails uses a set of scripts and in particular the rake utility to instantaneously create the foundation for a Rails application with scaffolds already in place. CakePHP offers the same functionality through the bake utility, which is currently available as either a batch file or a PHP script.
[*]ACL: As previously mentioned, Cake comes with a ready-made Access Control List (ACL) system, which can be extended and used to restrict particular areas of a Cake application to certain users or user groups.
[*]Compatibility: CakePHP is fully compatible with both PHP and PHP5.
[/list]


Meet the Bakers

After reading all these things about CakePHP and its framework, you may have some questions, or be curious about some aspect of the project. PHPNut and gwoo, two of CakePHP's creators and lead developers, offered to answer some questions exclusively for zZine readers. This interview took place on Oct. 26th, 2005, in #dev-cakephp on irc.freenode.org.

h3rald: Thanks to both of you for allowing me to interview you about your project, CakePHP. Where did the name come from, anyway?

PHPnut: The original project was started by Michal Tatarynowicz aka Pies (hence the name), and when I saw his release, last March, I decided to contact him. I told him that the company I own supports projects like Cake, and also that I was in the process of developing something along the same lines.

h3raLd: Is Cake released under the GPL? How many developers are helping out?

gwoo: Cake is released under the MIT license, and the development team is composed of me and PHPnut, plus four other contributors. Then there's the Documentation Team, currently 3-5 people. Documentation has to follow the releases, so it usually lags behind a bit: we made so many modifications in the recent release that the Doc Team has a lot to catch up on, but it's getting there.

PHPnut: With this release you will see that the docs are going to be much better. The code is very stable now, and hopefully very little changes on that.

h3raLd: Some people, at first glance, may think that Cake is a PHP port of Ruby on Rails. How true is that? What are the differences and similarities between these two frameworks?

PHPnut: Cake started as a port, but has evolved into something more: we discussed using the concepts that RoR offered and including them in a framework for users of PHP. I have used PHP for a number of years, and I am comfortable with it; this is where my passion is, and I think people who use Cake have those same passions as we developers do.

h3raLd: I read once that Rails was developed in Ruby because only Ruby can offer certain functionalities and features...

gwoo: I would disagree, and I think that is proven in what we have done: sure RoR has a built in server and some other nice things, but PHP is everywhere.

h3raLd: Some developers, especially Perl programmers, tend to consider PHP an "inferior" language sometimes. What do you think of that?

PHPnut: My name says what I think about them all.

gwoo: PHP is a web programming language; that's what it was designed for, and that's what it does best: It all boils down to what you are comfortable with.

h3raLd: Did you try any other PHP frameworks, MVC-based (Mojavi, for example), or event-driven, like Prado? What do you think about them? In what ways can Cake be better or worse?

gwoo: They are all so complex, in my opinion, and I tried nearly all of them. Cake breaks apart the MVC and handle the CRUD in a logical way, and Cake syntax is super easy to learn.

h3raLd: Ruby on Rails has been ported to various languages, including Java and Python. There are three PHP frameworks inspired by the famous Ruby project: Biscuit, PHP on Tracks and CakePHP. What do you think of that? Any chance of a merge? Did you have a look at them?

gwoo: You forgot Symfony[27], a PHP5-only port: I tried it but it seems much harder to learn than Cake.

PHPnut: I could be wrong, but I think these other projects are behind us in ease of use, in what the framework is capable of doing, and in features, not to mention community support.

gwoo: I tried all of the PHP ports of Ruby on Rails and none of them has the features, the community,or a lexicon as good as Cake's.

h3raLd: Why don't you consider CakePHP a port? In what way is it evolving from Rails?

PHPnut: Rails and CakePHP share a lot: MVC pattern, Active Record pattern...but we're not strictly following Rails, and we're able to think by ourselves. Recently we changed the directory structure, and in my opinion our is more functional than the Ruby on Rails one.

h3raLd: What can Cake be used for? What kind of projects? Are there any limitations?

gwoo: Personally I think that Cake is the most extensible framework out there for PHP: with components, helpers and vendor access you can do anything you want!

PHPnut: We are limited only by what a web server (generally Apache, but IIS seems to work as well) and a database can do. We may be limited by PHP itself, but we twist that in our own little sick ways sometimes.

h3raLd: Any thought about AJAX? I saw some nice demos made with Cake. What do you think of this new trend in web development? Some people consider it the future, while others are concerned about compatibility, and still others are relatively indifferent to it. What about you?

gwoo: AJAX can be very useful in creating an application, but should not be overused. People have become very comfortable with how the Web works:i f you start doing tons of drag and drop and no refreshes, users will feel lost in how to operate the site.

h3raLd: Thank you very much for your time, both of you. Is there anything you'd like to add to this interview? Something you'd like to say to users interested in trying out Cake?

PHPnut: Come and enjoy: we are here to help...

gwoo: ...And plan to be here for a very long time!


Let's cook...

One of the most positive things about CakePHP is that even though it is a fairly new project (most of the code is 100% useable already,but they still consider the projectto be in the 'alpha' stage), it's maintained by many dedicated developers and PHP enthusiasts. I was amazed to see how the whole documentation evolves and is quite literally updatedon a daily basis.
Anybody can contribute to the framework or simply test it and share their experiences.

CakePHP Wiki

Anybody can register an account for free and contribute tutorials and documentation to the new CakePHP Wiki[23]. This is currently the most up-to-date source for documentation files and tutorials.

CakePHP User Group

If you need assistance or you want to contact the Cake developers or other Cake users, you can post a message on their Google User Group[24]: people will reply with useful comments, usually on the same day, and the developers do listen to user suggestions.

CakePHP IRC Channel

If you want to offer (or receive) real-time assistance, feel free to join #cakephp on FreeNode (irc.freenode.org). I went there disguised as a total newbie (it wasn't much of a stretch) and they helped me a lot, explaining basic concepts of the framework and pointing me to the right documentation files.

CakePHP Development

Experienced PHP developers are more than welcome to contribute to the project. People may be accepted to the core development team if they have sufficient knowledge and spare time, or alternatively,components or code can be submitted through the newly created CakeForge[24].


...Or Just Eat [small] by Marc Abramowitz[/small]

If you don't feel ready to contribute and you'd like to try out the framework first, it can be downloaded directly from the CakePHP site[25] as either a release or a nightly build: the zip file is less than 300KB.

I wanted to include a success story written by Marc Abramowitz, an experienced PHP programmer who decided to adopt CakePHP as a framework to use in a production environment: he persuaded his colleagues to use it and they all seem happy with it. He writes:

For the past few years, I've done quite a bit of work in PHP, working on production code that runs on a very high traffic web site. PHP has served us well, as it is easy to write and read, quite efficient, and easy to integrate with existing C++ code as the site grew.

Lately, there has been a lot of buzz in the web development community about Ruby on Rails. Like many others, I took some interest in Ruby on Rails because I was intrigued by the apparent power and elegance of Ruby and because I wondered if a Model/View/Controller (MVC) framework like Rails would help enforce a more consistent code structure that would make the code easier to understand and maintain. Additionally, I wondered if an MVC framework would enable very rapid prototyping.

Some people are very wary of frameworks that impose structure, as they like to have the freedom to do things however they want. However, there is a tradeoff between structure and flexibility. If you're working on a small team or a relatively small project, then you may not find structure to be very helpful; you may even find that it gets in your way.

However, as teams and projects get larger, structure becomes more and more valuable, as it enforces consistent patterns of how to do things and rather than being something that limits, it in fact liberates, because it abstracts away the small details and allows us to therefore concentrate on the larger problem. Think of the lines that are painted on our roadways - although they add structure, we don't find them to be limiting. On the contrary, they help us to drive without worrying about crashing into each other at every moment - they free us from being concerned with small details so that we can concentrate on getting where we're going.

Rapid prototyping appeals to me, because I find it helps me to better present my ideas for new apps and features. A mockup can only go so far - there is no substitute for a working prototype. When clients get their hands on a functional prototype, they get a better idea of what is possible and it forces them to clarify their requirements for the product. This results in a better dialogue between the developer and the client, which leads to better upfront decisions, more stable requirements, less stress, and a better product.

So, Rails appealed to me not only because of the potentially valuable structure that it could add, but also because it could enable rapid prototyping. However, I knew that there was no chance of Rails being used for production code in my organization, because we run some very high traffic web sites that require the utmost in efficiency. We are also by and large a PHP shop.

However, when my manager approached me and asked me to develop a database-backed internal tool, I thought of Rails again. I then considered the fact that I would probably someday have to hand this app off to someone else, and that someone would probably know PHP but not Ruby. Heck, even I had several years of experience with PHP (including writing some PHP extensions) but I had only done a little bit of reading about Ruby, and I also had no practical experience with it.

Furthermore, with PHP I had access to a large number of PHP extensions that wrapped various internal libraries. So PHP was the natural choice. Ideally, I wanted to use PHP with a Rails-like MVC framework that would facilitate rapid development, and this is what led me to CakePHP.

I began by downloading CakePHP 0.9.2 and following the sample tutorial that walks you through creating a simple blog application (note that at the time of this writing, the current version of Cake is now 0.10.0.1076, so some of the details of using Cake have changed). I was pleased to find that the process was quite similar to the process for Rails. One difference that I noted was that Rails tutorials always emphasize using scripts to generate models, controller, and scaffolds, whereas the Cake tutorial walked me through explicitly writing out all the code. I noticed that the Cake download came with a script called "bake" which looked like something that could potentially do some of the code generation, but since it wasn't mentioned in the tutorial, I chose not to use it.

The process of creating a first application using the tutorial was quite easy. Here are the steps in brief (consult the tutorial for more details):

1. Create the database table. Cake requires tables to have some extra
fields:
- id, an auto_increment primary key
- created, a datetime
- updated, a datetime
2. Configure Cake to access the database by editing the config/database.php file
3. Create a model class which extends AppModel (a Cake provided class)
4. Create a controller class which extends AppController (a Cake provided class) and write one or more controller methods
5. Create a view which is a PHP file with a .thtml extension and is meant to be mostly HTML with very little embedded PHP - typically just echoing of variables and some simple control structures like [i]foreach.
Cake also provides some simple convenience methods that write out certain HTML constructs for you.

That's it! That alone is enough to create a basic but functional application. The tutorial goes on to show you how to add additional functionality to the blogging app. After that there's a shorter, more advanced tutorial that shows you how to add a few more things to the blogging app.

Once I had gotten comfortable with Cake by following the tutorial, I proceeded to write my own application. Getting started was easy - I followed the same steps as in the tutorial to create my first table, model, controller, and views, then my second table, model, controller, and views. Then my app got a bit more complicated. I needed to have many-to-many relations and more elaborate queries than the default ones that Cake provides. I began to worry that Cake would break down here. I had heard people grumble that MVC frameworks like Rails and Cake were great for little toy apps that only do CRUD (Create, Read, Update, Delete), but that they couldn't handle complex queries using joins and the like. I poked around in the Cake source code and was pleased to find that there were nice lower level methods that allowed me to bypass the Cake defaults and do whatever custom queries I liked. For example, I wrote something like this in one of my models:

function index(){
return $this-findBySql(
"SELECT id, title, AVG(rating) avg_rating, MIN(rating) min_rating, MAX(rating) max_rating, COUNT(rating) num_ratings " .
"FROM ideas LEFT JOIN ratings ON ideas.id =
ratings.skill_id " .
"GROUP BY id " .
"ORDER BY title");
}


So what I have is a model that does not have a one-to-one mapping with a single table. It actually retrieves data from more than one table.

Over time, I picked up a few more Cake concepts. For example, at some point we decided that every page of the app would have a similar look and feel with a particular masthead and logo, and all the pages in one section of the site would show tabs for all of the various views with the currently selected tab highlighted. At first, I just used the same code at the top of each of my views to display the masthead, logo, and tabs. This, of course, became a pain when I needed to change the layout, since I needed to make the same change in several different views.

Then one day I realized that Cake had a concept of layouts, which are high level templates in app/views/layouts that define the basic structure of pages. The individual views are just content that gets embedded in these high level layout templates. So I took the common masthead and logo, put it in my default layout, and removed it from the individual views. Now when I wanted to change the look of the masthead, I only had to do it in one place. For the tabs, I discovered the concept of elements. I placed the code for my tabs in apps/views/elements/tabs.thtml. Then the tabs could be displayed in any template using:

<?php echo $this-renderElement('tabs') ?

Rather than stick the above statement in all of the many pages that were supposed to display tabs, I created a new layout in apps/views/layouts/tabbed.thtml (which uses renderElement to render the tabs). Then I used

$this-layout = "tabbed"

in the controller to tell it to use the tabbed layout rather than the default (non-tabbed) layout.

After a couple of days of work on this application, it was time to demo it to the VP, who was very impressed with what I was able to accomplish in such a short period of time. It was brought up that before I took on the project they had asked some other folks how long it would take them to build it in Java and they had said that it would take on the order of months what I had built in a couple of days. Morals of the story:

1. Cake is very lightweight and productive
2. Cake might be very beneficial to your career

Eventually, I was assigned to another project and my manager wanted me to transition my Cake project to another engineer, who was experienced with PHP but not with Cake. I sat down with the new engineer and in about 20 or 30 minutes of explanation and walking him through the code,
he felt ready to code. Not only did he feel that he knew enough to start working with the application, I could tell from the smile on his face that he was very impressed by the power and succinctness of Cake, which was the same reaction that I initially had. After a couple of days, I checked back with him and he had made a remarkable amount of progress on the application - there were a ton of new pages and features.

So you see, Cake is a very productive environment. For a very small investment in the initial learning curve, you can get a significant increase in productivity.
[/i]

...And the icing?

So that's what CakePHP is about. The project may only have just entered alpha stage, but the code is already very stable and useable, as PHPnut, gwoo and Marc said. So what's going to be included in the beta and stable releases? I researched a bit and asked the developers, and here's how Cake will probably evolve in the following months:


  • Cake's built-in
    • data-validation capabilities will be extended. A validator class - which already exists, by the way - will be extended to include more data types and expressions to be validated before being stored in a database.
  • A new default
    • ACL system will be included and will support database access and .ini files as well.
  • The
    • AJAX helper class and AJAX support will be enhanced, featuring unobtrusive JavaScript and ALA behavior[28].
    • Multiple applications with the same core files. In the future developers will be able to create their own Cake application which could be placed in the app/plugins directory and be seamlessly integrated and auto-linked to other Cake applications.


After learning all this about Cake and after trying it out myself, I really think that I have found the solution to all of my PHP web development problems. CakePHP can really help PHP developers a lot if properly used and understood. Still not convinced? Just try it out then, will you?[17]


Notes and Related Resources

Special thanks to:

    [*]Larry E. Masters aka PhpNut and Garrett J. Woodworth gwoo for providing all the answers to my questions and contributing to create such a wonderful tool for the PHP community.
    [*]Marc Abramowitz for sharing his experiences with the CakePHP framework and providing the content for the '...let's eat' section.


[small]
[1] PHP functions reference, http://www.php.net/manual/en/funcref.php
[2] Framework, Wikipedia Page - http://en.wikipedia.org/wiki/Framework
[3] .NET framework overview - http://msdn.microsoft.com/netframework/technologyinfo/default.aspx
[4] "PHP Framework", delorian's blog, PHP Community - http://www.phpcommunity.org/node/100
[5]Some popular PHP frameworks: Mojavi (http://www.mojavi.org/), phpMVC (http://www.phpmvc.net/), BlueShoes (http://www.blueshoes.org/), Seagull (http://seagull.phpkitchen.com/).
[6] PEAR - http://pear.php.net/
[7] Prado - PHP Rapid Application Development Object-Oriented, http://www.xisc.com/
[8] Event Driven Programming, Wikipedia Page - http://en.wikipedia.org/w/index.php?title=Event_driven_programming
[9] Ruby on Rails, Official Page - http://www.rubyonrails.org/
[10] Ruby on Rails, Doumentation - http://documentation.rubyonrails.com/
[11] Model View Controller, Wikipedia Page - http://en.wikipedia.org/w/index.php?title=Model-View-Controller
[12] PHP frameworks inspired by Rails: http://phpontrax.com/, http://flinn.activeintra.net/biscuit/, http://www.cakephp.org/
[13]Python frameworks inspired by Rails: http://fanery.sourceforge.net/, http://fanery.sourceforge.net/, http://subway.python-hosting.com/
[14]Java framework inspired by Rails: https://trails.dev.java.net/
[15]Perl frameworks inspired by Rails:
http://search.cpan.org/dist/Catalyst/lib/Catalyst/Manual/Intro.pod, http://perlonrails.org/index.php/Main_Page
[16] "Rails Clones: Blood suckers or useful drones?", RedHanded - http://redhanded.hobix.com/cult/railsClonesBloodsuckersOrUsefulDrones.html
[17] CakePHP - Rails-inpired PHP framework, http://www.cakephp.org/
[18] AdoDB, PHP Database Abstraction Layer - http://adodb.sourceforge.net/
[19] CakePHP blog tutorial - http://wiki.cakephp.org/tutorials:blog_tutorial_-_1
[20] Extending CakePHP - http://wiki.cakephp.org/tutorials:extending_cake
[21] Smarty, PHP Template Engine - http://smarty.php.net/
[22] Scaffolding a Blog, CakePHP Wiki - http://wiki.cakephp.org/tutorials:scaffolding_a_blog
[23] CakePHP Wiki - http://wiki.cakephp.org/
[24] CakePHP Google User Group - http://groups.google.com/group/cake-php
[25] CakeForge - http://cakeforge.org/
[26] CakePHP Downloads Page - http://cakephp.org/downloads/
[27] Simfony, PHP5 framework - http://www.symfony-project.com/
[28] ALA behavior - http://bennolan.com/behaviour/
[/small]]]>