1. 20 lines rule

Always try to write briefly and to minimize the general code amount. If you have 20 lines limit for your functions, as a result you will have something readeable and easier to understand and maintain.

2. Document your code, comment your functions

Write what you’d want to see if you were reading the code

According to that common principle your comments should look similar to this example:

<?php
/*

/*
 *  This function check if $param1 and $param2 are numbers and if they are
 *  - multiplies them and returns the results
*   The function was created to make multiplying in the application easier.
*/

function foo($param1, $param2)
{
    $test = $param1 * $param2;

    return $test;

}

?>

Very often good documentation is critical when you need to edit existing or add new features to the application. If you look around and read  about project documentation in general you will notice, that the recommended method for documenting applications is using tools like Doxygen, but I think that in addition we must add documentation that is more human friendly. 

3.  Write human friendly code

It is always a good practice to write applications according to the principle “From humans for humans”. If you feel that writing function a_c() {} instead of writing function access_check(){} will bring you to the world of ‘rapid and ‘agile’ development there is a big chance that possibly you are wrong. In short term you will write faster, but the ‘rapid’ aura will disappear when you close the file or return to the code next week or month later. 

4. Use understandable application structure

Application structure and architecture is something significant not only for web programming, but for programming in general. Always try to separate your application in layers. In web programming  they are many different ways to separate logic from presentation, but standards for the industry are the n-tier and MVC architecture. I am not saying, that they are the easiest ones, but at least they are recognizable. 

5. Learn new language

Learning new language is always good way to expand your programming knowledge and  naturaly
expand your code quality. If you want to know what are the most used programming languages in the moment, check the TIOBE index. If you are web developer and you haven’t yet tried  Ruby,  or Python , now is the time.

6. Learn new framework

if learning new programming language is too much for you, or you don’t have enough time, try something smaller - learn new framework in the language you already now. If you are Ruby developer, Ruby on Rails is great framework and everybody likes it, but Merb and Ramaze are great frameworks too. For the PHP guys - there are so many quality frameworks out there to choose from.

7. Think, think, think, write

That one is my favourite. When I write web applications I spend lots of  time thinking about application scalability, performance and reusability of the components. In long term that makes sense, because we never know how big our application will become when we write the first line of code.

you need on the first page. During my investigations around the web I had colected some not so visible and very useful posts and presentations:

12 quick PHP performance tips:

http://www.moskalyuk.com/blog/php-optimization-tips/1272

Enormous collection of slides and presentations about web architectures and scalabilty:

http://www.royans.net/arch/library/

Slideshow about overall PHP performance:

http://talks.php.net/show/hpp/0

40  tips for optimizing your PHP code:

http://reinholdweber.com/?p=3

Useful post about php performance and best coding practices:

http://atomized.org/2005/04/php-performance-best-practices/

Ilia Alshanetsky talks on different tematics, including PHP performance and security:

http://ilia.ws/talks.php

• Doctrine and Propel for PHP
• SQLAlchemy for Python

What exactly is ORM?

According to Wikipedia:

Object-relational mapping (aka ORM, O/RM, and O/R mapping) is a programming technique for converting data between incompatible type systems in relational databases and object-oriented programming languages. This creates, in effect, a “virtual object database” which can be used from within the programming language.

Everything should be Object

In our Object Oriented programming world  every bit of information must be encapsulated in object. That’s what the giants in industry say and I will no argue.From one point of view objects are slower than functions, but in general in object oriented applications it is easier to work with database objects. Usually that is one of the main reasons for looking around to find proper to our needs  ORM solution.

SQL is Bad?

Sometimes choosing Object Relation Mapping tool is excuse for not learning and generally avoiding raw SQL code. Writing SQL code is not something evil and ORM solutions are not always the answer. As a matter of fact when we need to optimize our “application - database” interaction we still need to write SQL. And for that reason most ORM solutions are supporting raw SQL code implementation.

Development made simple

Usually basic CRUD operations can be performed with  one line of code. Most ORM tools can create tables, sort and filter database queries on the fly and much more. In general they are simplyfiing database interactions and are saving a lots of development time.

Not so fast

And what about performance. Taking data from the database, converting it to objects, transfering the objects to higher layers in application and than  repeating the whole process backwards for sure slows down the application. Another problem is that ORM solutions in fact are something that is not listed in “Top 100 of all software inventions”. They are created to solve the diversions between the object models interpretation of state and the database schemes storage of state. And they will be not here forever i hope …

The future is bright

If we use Object oriented databases instead of relation databases in object oriented applications we will finally scale the object oriented programming approach to it’s maximum capacity.OODB are developed very actively and I hope that very soon we will see real world working solution.

First creating custom Controller:

<?php
class Base_Controller extends Zend_Controller_Action
{
        
        /** 
         *  DISABLE DEFAULT ZEND FRAMEWORK VIEW  
         */
        public function init()
        {
        
        $this->_helper->viewRenderer->setNoRender(true);        
        
        }
        
        /**
         *  LOADING SMARTY ON DEMAND
         * 
         */
        public static function LoadSmarty()
        {
                
        include ('smarty/Smarty.class.php');    

        $smarty = new Smarty();
        
        $smarty->template_dir =  template dir ;
        $smarty->compile_dir  = compile dir;
        $smarty->config_dir   = config dir 
        $smarty->cache_dir    = cache dir;
        $smarty->plugins_dir = and plugins ;
        
        
        
        /**
         *  SMARTY CONFIGURATION
         * 
         */
        $smarty->debugging = false;
        $smarty->force_compile = true;
        $smarty->compile_check = true;

        
        /**
         *      SMARTY PLUGINS 
         * 
         */ 
        //include various smarty plugins 
        
        Zend_Registry::set('smarty', $smarty);
        
                        
        }
        
}


?>

This is example of the custom Base Controller, if we want to include Smarty in particular Controller we extend Base Controller

<?php
include ('kernel/Base_Controller.php');

class IndexController extends Base_Controller 
{
     public function indexAction() 
    { 
                
        $this->IncludeSmarty();
        $smarty = Zend_Registry::get('smarty');
        $smarty->assign('title', 'Test Page index');
        
        
        /** DEFINE PAGE TEMPLATES */
        $smarty->display('includes/header.tpl');
        $smarty->display('demo.tpl');
        $smarty->display('includes/footer.tpl');
        
         
        }

/**
         *  FUNCTION FOR LOADING SMARTY
         * 
         * @return smarty object
         */
        
        public static function IncludeSmarty()
        {               
        Base_Controller::LoadSmarty();
        }
}

If we are building some pages, that doesn’t require Smarty or we want it to use Zend_View component the only difference is that the custom controller extends the default Zend_Controller

<?php
include ('kernel/Base_Controller.php');

class IndexController extends Zend_Controller_Action
// ALL LOGIC HERE

With this approach Smarty will be used only when it is needed and.If we completely skip Zend_View in our custom framework we can avoid the frustrating for me default Zend Framework View directory. structure.

CakePHP

CakePHP for PHP frameworks is like Apple in computer world. It is very cool and trendy to develop web sites with Cake and of course it’s a piece of cake. In addition to the trend is the fact that CakePHP is porting features from Ruby on Rails in PHP.

So inspired by the trend and all the talks in web development forums i gave it a try. But after 3 or 4 days intense work and learning i found that CakePHP is not that shiny knight everybody loves.

During my tests i encounter several problems and i found that Cake doesn’t have good documentation and i think that documentation is a MUST for such a popular framework.

I tried Google Groups and there i found the answers i have been looking for, but i have already lost two days. CakePHP have some very strong and appealing feautures for rapid development if you have time and patience.

Cons

1. Backward incompatibility
2. No documentation, but improving
3. It is still PHP 4 framework
4. If you don’t have database you still must create dummy model

Pros:

1. Active record pattern
2. Friendly community
3. MVC / Model - View - Controller /

Codeigniter

Codeignter is my personal favourite for small and medium sized web sites. It has great documentation, great and responsive community and in 80% of the cases,  it is the perfect tool for the job.

But when I tried to build some advanced features using two-dimensional array I had to overwrite some code in Codeigniter’s core.

Finally Codeigniter is using one CI super object, that is carying a lots of stuff all the time. If I have to develop web applications where speed and performance are critical I will think very carefully about implementing Codeigniter .

Cons:

1. Again - it is not native PHP 5 framework
2. CI super object

Pros:

1. Great documentation
2. Very easy for developing web sites
3. Short  learning curve

Symfony

Symfony is the so called enterprise framework. It has almost perfect documentation, but for me it has too many third party modules that are slowing up development process and the overall framework performance

If you want to use Symfony you must gain additional knowledge in Propel and Creole . Symfony automates some of our development tasks with its  great PHP code generator.

After a little research about Symfony overall performance here and here i decided not to use Symfony for now.

Cons:

1. Low Performance
2. Long learning curve

Pros:

1. Great documentation
2. Active community
3. Great code generator

Zend Framework

As you can guess Zend Frameworks is created by Zend - the PHP company. Zend is loosely coupled component library and you can use as many components as you wish.

If you stay away from Zend autoloader you can easily achieve great application performance. Zend framework can be extended very easily.

Cons:

1. Requires intrermediate PHP knowledge, cannot achieve anything out of the box

Pros:

1. Again Great documentation
2. Full PHP 5 support
3. Great performance
4. Web Services support

Right now I am developing my applications using customized  Zend Framework for big projects and Codeigniter for the smaller projects.

In my next post i will write about Full stack vs. Loosely coupled frameworks, so stay tooned.