Good code is maintainable, reusable, and testable. The following tips address how you and/or your development team can handle various coding tasks and how to keep everything as neat as possible. I will introduce you to some "best practices" that will help you write better code and help make you and your team happy and efficient.

Among the suggestions on the list, there's things like:

• Use a Coding Standard
• Refactor
• Use Meaningful Names
• Use Automated Build Tools
• Use a Testing Framework

Links are provided in several of the tips to other resources/tools that can provide you with more information about how to use it in your development.

In the case of PHP development, you'll need to add some configuration and plugins to speed up your activities. Most of the responsibilities of an IDE - like testing and version control - are outsourced to the terminal while running Vim; however, there are some tweaks that make writing and editing code faster, along with aiding in discovery classes and methods in a PHP codebase.

He includes settings for your .vimrc to detect and load the right PHP functionality, using Command-T, functionality for autocompletion and the snipMate plugin for managing and using reusable code snippets.

The World-Wide Web offers more PHP performance tips than can be comfortably discussed in one article, so the following is merely a list that can be used for reference purposes. The tips are divided into categories to group similar things together and make it easier to find what we need. The author's search for tips was extensive, but completeness still cannot be guaranteed.These tips fall into category #3.1 (the server executes a script) in the taxonomy of tips that we have been working with.Because of the sheer volume, these tips have not been tested. The reader is expected to test them in his own production environment before relying on them. This is not unreasonable, though, because the value of most tips depends on the unique environment within which PHP operates.

Sections in the guide include:

• Caching
• Session handling
• Compression
• Memory Leaks
• Code optimization
• Using services

Also included in the post are a list of links that were references for the tips in the list..

One of the things about the PHP field is that developers are highly sought after, and good developers are prized. While anyone can slap "PHP Developer" on their resume, most companies have gotten good at weeding out the pretenders from the real deal. This means that for a highly qualified developer, interviewing should be an easy step towards receiving an offer.

He's broken it up into a few different main points:

• Know your technical details thoroughly.
• Know the role of the person interviewing you.
• Be able to turn technical answers into non-technical answers, and vice versa.
• Learn how to be personable.
• Ask thought-provoking questions.

Each point comes with some thoughts on how to accomplish it and even points to two resources to help you on your way.

Some of the conversations I had during the weekend were around technical presenting at conferences and usergroups, so I thought I'd collect a handful of the tips that were discussed into a post, and use a few of my favourite speakers at the event to illustrate them.

He has it broken up by speaker, first David Zülke, Rowan Merewood and David Coallier, each with their own highlights of what they did well in their presentations. The list includes:

• Make concepts concrete with examples and demos
• Care About The Visuals
• Project Confidence
• Engage The Audience

Ian provides summaries for each of the points, describing what the speaker did to accomplish it and how it could be put into practice by other presenters.

Why do SQL injections happen so often? The shortest answer is that SQL injections are so popular because of poor programming. Hackers know about the potential of a successful SQL injection attack and they search for vulnerabilities. Unfortunately, very often they don't have to search hard - vulnerabilities pop right in their face. [...] The good news is that fortunately, SQL injections are also relatively easy to prevent.

They list nine easy things you can do to help prevent the attacks:

• Patch your SQL server regularly
• Limit the use of dynamic queries
• Escape user input
• Store database credentials in a separate file
• Use the principle of least privilege
• Turn magic quotes off
• Disable shells
• Disable any other DB functionality you don't need
• Test your code

Hopefully the most important lesson you can learn here is to understand what you will need to do to scale in the future. By knowing this, you can do only what you need at each phase of your project without "coding yourself into a corner", ending up in a situation where it's hard to take the next scalability step. [...] In this two-part article I will share some of the lessons learned, and take you step by step through a standard process of scaling your application.

He touches on a few different topics in this first part of the series - performance vs scalability, tuning your PHP installation and database load balancing through master/slave replication.

Some of the tips listed so far include:

• How to free Symfony2 from the sandbox tutorial (with some help from Git)
• Doctrine in the Real World - Presentation from Symfony Live 2011
• The Path to Symfony in the USA- Presentation from Symfony Live 2011
• Form naming
• Translate form labels inside Twig templates

Check out the full blog for more tips and links to presentations.

I have started compiling a notebook of tips and answers to commonly asked questions to Zend Framework questions, and common patterns of Zend Framework application design. I'm kicking it off with two notes, one for modules setup, and the other for how to route your requests so that you can divide your controllers up further with subfolders (no hacking required!)

The notebook can be found here. Have some tips of your own you have a post about? Let us know!

PHP is a very versatile programming language that can achieve the same objective in multiple ways. You can read more about that in my 'The Art of Programming' post. Below are a few tips I've picked up from past projects that can improve your code readability and maintainability and make you a neater, more organized PHP programmer.

There's lots of useful hints included - most of them are relatively basic, but they can even be helpful as reminders for those seasoned developers:

• Separate Configuration Files
• Use Indentation and Spacing
• Give your Variables Meaningful Names
• Use Ternary Operators
• Use Assignment Operators
• Use Objects instead of Functions
• Aim for Loose Coupling, Strong Cohesion