About a month back Samuel Levy wrote up a post sharing some of his thoughts on PHP, mostly centered around one idea - that PHP is the right tool for the job (for all the wrong reasons).

When people complain about PHP being a horrible language, not fit for human consumption, they will often talk about how the features of their favourite language are far more refined; have been designed with elegance in mind; are consistent and secure. And you know what? They're right. But PHP is still a better tool. [...] And it shouldn't be. It really shouldn't. I want another language to knock PHP out of the way. [...] I can't, though, because PHP does one thing really well that no other language seems capable of doing. It works, out of the box, for people who don't know what they're doing.

He goes on to talk about the "installation" required with running PHP scripts and how it makes it mostly "idiot-proof" to use. He points out that PHP has a definite niche in the world of web development languages - one that has a larger need that some others.

This is the challenge for all the people who want to complain about PHP - if your chosen language is so much better (and I have no doubt that in many ways, it objectively is), then make it accessible in the way that PHP is. Until then, keep that double-clawed hammer in your shed in case you want to make... burgers...

The PHPClasses.org site has posted a humorous look at the PHP language with several reasons why PHP is a "hobbit" (a Lord of the Rings series reference):

Sometime ago a user of the Quora site asked a question if there was a language war, which languages you support and why. Another user gave a very creative response comparing programming languages with characters of the Lord of the Rings story of JRR Tolkien.

There's six reasons listed in the post:

• PHP is Scripted C
• PHP is not Teaming with C++ Evil
• PHP is Not particularly Beautiful but it is Very Useful
• PHP is Not the Fastest Language to Execute but is Agile
• JavaScript could be a Hobbit too but Asynchronous Programming is a Hell
• PHP Success Causes the Envy of Others

If you're interested to see the thread where the idea for this post came from, you can read it here on Quora.

In what's sure to be a "flame bait" kind of post, Jani Hartikainen has posted five reasons PHP is better than Node.js - some simple one-liners and others a bit more complicated.

All hail Node.js! Boo PHP! Except there are various things where PHP is better than Node…

His five reasons are:

• Easier to find hosting
• It's easier to get started with PHP
• If your PHP code breaks, it doesn't bring your whole server down
• PHP processes are short lived
• Bigger standard library

There's a few comments on the post already, one noting that some of the points could be turned around to make PHP fall more on the "bad" side.

In this recent post from Charles Sprayberry he explains why using dependency injection (DI) in your application is a good idea and can help make things easier in the long run.

Dependency Injection is just a fancy term for passing dependencies to the object needing them instead of letting the object create its own. Hopefully, you've watched this great Google Clean Code talk about dependency injection by Misko Hevery where he talks about why you should ask for things instead of looking for them. I'm gonna talk about some reasons to use DI beyond just those presented in the video.

He breaks it up into a few different sections:

• It helps in the battle against global state
• It helps your design
• It makes using the single responsibility principle easier

In this new article from Web Developer Juice giving fourteen (descriptive) reasons why Ruby is a better choice than PHP for building web applications (from the perspective of a Ruby developer, it seems).

Picking a language for a programming project is never an easy task. [...] This is especially true with web programming projects. Because you are not always in control of the environment where one's application will be run, it is important to pick a language that can adapt to many situations. Ruby is a better language than PHP for the following reasons.

The list of fourteen includes several points that are not the usual "because it's faster" or "because PHP sucks at this" sort of thing. Here's some examples:

• Principle of least surprise
• ActiveRecord design
• Easier to install
• Interactive shell
• Maintainability
• JVM support

According to this recent post to his blog Zack Curl is a big proponent of using web application frameworks for development:

Most all PHP developers have worked off of their own code - they create all their own classes, sometimes borrow a little from previous projects, and basically create whole new frameworks without really knowing it. Even though most developers have the mindset that they have more flexibility, less redundancy in code, and other reasons that usually branch off of the two reasons, a framework actually makes your application load faster, work better, and work more effectively.

His reasons for the recommendation are:

• Classing and OOP Principles
• Model-View-Controller Schema
• Pre-built Libraries
• Built for speed

As far as his choice of a specific framework? He would opt for CodeIgniter, the lightweight and speedy product of Ellis Labs.

On the Zend Developer Zone there's a new article/tutorial posted from Padraic Brady introducing you to the art of unit testing your applications and development.

Testing is an essential aspect of developing in any programming language. If you don't test your source code then how can you verify it works as expected? Manual testing can only be performed irregularly and usually only in limited ways. The answer to testing source code regularly, and in depth, is to write automated tests which can be frequently executed.

He talks about testing frameworks, its filtering in to practices on larger community projects, and a few fallacies that most people have about unit testing (including time involved, difficulty with complex code and that it's just boring). He also includes some examples of what a unit test might look like for some simple code - including explanations.

He rounds it off with some of the "why use unit tests" reasons he's found over the time he's used them like:

• Automated tests can be run as frequently as required
• Unit Testing can improve the design of code especially with Test-Driven Development
• Unit Testing forces you to confront the problem head on
• Unit Testing inspires confidence!

With a comeback from the eight reasons not to write for the PHP manual, Philip Olson has made his own post with a few of his own reasons why you should.

How do we appropriately credit the kind souls who seemingly work anonymously within the php.net CVS repository? Not sure, but here are about 8 reasons why you should write for the official PHP manual.

Among the items on his list (longer than eight reasons) are things like "You'll own a cool @php.net email address", "You'll gain experience using DocBook and the related tools to create documentation", "You'll make new friends" and "You'll help make something better, something you use. It's good to use things that get better, right?"

Check out his full post for the rest of his reasons.

Starting off the week on a light note, Hannes Magnusson has posted a few reasons why *not* to write for the PHP.net manual.

His tongue-in-cheek list includes:

• You get a free pass to conferences by converting your work into presentation
• You get a "trading card" and considered a star
• You can flame the documentations without needing to do anything about it
• You can license your work to forbid any commercial use or further improvements

Hannes also responds in a later comment to the post:

More and more people are thinking about themselves and publish their work on their blog or sell it. There isn't anything wrong with that, but its very annoying that user need to search for information on blogs, commercial websites or magazines rather than the manual.

Krystian Hoffman has posted to his blog today a few reasons (10 to be exact) that he likes and uses PHP. Fortunately, most of them are some of the best reasons for anyone to use the language.

ended up with ten points on why I use PHP and I guess this would be a good post here on my blog, as it seems people like lists in general and maybe I could get some people out there that aren't really sure about whether PHP is good or bad, to get some insight at least.

Here's some of his list:

• The PHP Community
• The (language's) Performance
• Its Portability
• It has strong Object-oriented support

Other things got a mention as well - the low learning curve, low cost, included libraries - but the above few seemed the strongest.