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.

It's always interesting to get an outsider's perspective on the language that we all work with and love (or hate, just depends on how debugging's going). In his latest blog post, Chris Justis does just that with some of his comments from an interview with IEEE magazine about why Java will outlive PHP.

I had the good fortune to be interviewed by an IEEE magazine in February to comment on the demise of Java (vs. PHP). A 45-minute interview turned into a paragraph in the article, but I thought that I might put all of my thoughts up on my blog.

There's some interesting ideas here, but I'm not sure that most of them mean the "victory" of Java over PHP. In fact, most of them seem to reinforce the thought that PHP and Java will coexist happily for a good long while.

Chris Shiflett mentions in this new post today Theo Schlossnagle's Lightning Talk from this years OSCON. The topic? "Six Reasons PHP Sucks".

Theo has posted the slides of his PHP lightning talk in PDF format. The topic? Why PHP sucks.

I've never disputed the fact that PHP has problems, but for some reason, everyone who tries to explain why PHP sucks misses most of the actual reasons it does. It's astonishing.

Chris also makes the comment that he doesn't actually give six reasons, but the first three of the ones he gives are solid ("No lexical scoping", "No namespacing", and "World's worst configure system").