
In many ways PHP is just now starting to come into its own - guillaumepotier
https://gist.github.com/Blackshawk/5327505
======
mgkimsal
"Jeff Atwood has stated publicly that one of his ulterior motives with the
Discourse project is get people to stop using PHP and start using Ruby."

This just won't ever happen. The people that wanted to drop PHP for something
else (Ruby, etc) largely did so years ago. The hosting/running situation for
PHP is just too basic and easy for people to get in to vs having to 'run a
server' (Rails, etc).

PHP is still the only language that assumes HTML output by default. Put a file
on a web server, hit it via a URL, and get HTML output. It's that simple. You
can start at 'simple' then graduate up to complex stuff like Symfony if/when
you want to. Every other language or platform forces a lot of extraneous
concepts on you on day one, which is _always_ going to be a turn-off for a
not-insignificant portion of the people coming in to the field.

~~~
Joeboy
> PHP is still the only language that assumes HTML output by default.

For me, that's not a feature, it's an oddity that I have to work around. I
guess it's a feature if you're using PHP as the HTML template language it was
designed to be, but I suspect that's a minority use case these days.

~~~
sbarre
I would actually argue that using PHP as the templating language in a PHP MVC
application has become the _majority_ use case.

Why layer an additional templating language (Smarty, etc) on top of PHP -
incurring extra processing and parsing - when PHP is a perfectly capable
templating language itself?

There are cases where you may need to do this (if you can't "trust" the
templates for example and you need to enforce some kind of validations or
restrictions on them) but otherwise you just need to follow/enforce business
rules about what can go in your views, and just use plain ol' PHP..

~~~
Kudos
> Why layer an additional templating language (Smarty, etc) on top of PHP -
> incurring extra processing and parsing - when PHP is a perfectly capable
> templating language itself?

From past experience: to stop shittier developers at your company putting
controller logic in the templates. Using something that does nothing but
templating ensures that your templates do nothing but present data.

~~~
sbarre
I addressed that in my post actually. If you have shitty developers in your
company who can't follow business rules, PHP isn't your problem.

------
mjburgess
I'm as cutting edge in the PHP community as any is going to be (having used
the latest betas & community-best-practices since 2004).

I still have serious doubts about PHP, and always insist to new developers
should learn a (ruby/python/... clojure/...) too.

The main problem with PHP is the language itself. There is no paradigm it does
well. If you're into class-ical OO, then the language's type system is a joke
(esp. with the lack of co/contra-variance in type hinting).

If you're into dynamic OO, PHP's java leg-humping perpetually gets in the way.
There is no meta-classes, monkey patching, etc. everything that should be
dynamic is static.

If you wanting functional programming... you have nothing. Literally. The best
they've been able to do is a half-baked closure system. Half the library uses
references (rather than returning meaningful data) so you cannot compose
functions and there is no hope for any kind of collections system (lists,
arrays, etc.) that support a typical functional manipulation.

All you're left with is a "dynamic C".

Add to this that PHP is designed to terminate immediately... and you're modern
"daemonic" web requirements (concurrency, queuing, etc.) are completely out of
the window.

From the point-of-view of "web-scale" application development PHP is a broken
toy: both in the sense that talented developers are hampered by it, and in the
sense that its execution model is ill suited to the problem.

~~~
hrvbr
Plus there is PHP's aesthetics. I can't help but see all PHP code visually
unpleasing. Programming isn't just a technical task. It's also an art like
writing novels. I'm not satisfied when the code I produce doesn't look pretty,
independently from the algorithm. In the article here, the Ruby code looks
much cleaner to me than the PHP version, even though it's technically the
same. Aesthetics is the main reason why I switched from PHP (that I learned in
class) to C# (that I learned on my own).

~~~
memla
That really depends on what you're writing and how you are doing it. How is
this php[1] code uglier than this python[2] code?

[1]:
[https://github.com/laravel/framework/blob/master/src/Illumin...](https://github.com/laravel/framework/blob/master/src/Illuminate/Config/Repository.php)
[2]:
[https://github.com/reddit/reddit/blob/master/r2/r2/controlle...](https://github.com/reddit/reddit/blob/master/r2/r2/controllers/wiki.py)

~~~
mehwoot
I'm not saying it really matters, but the PHP just looks ugly to me. I think
it's all the dollar signs and braces.

~~~
jacquesm
That's a mirror image of 'Lisp just looks ugly to me. I think it's all the
parentheses.'.

There is a lot more to a language than its syntax.

~~~
PommeDeTerre
Syntax is highly important, however. A poor syntax can make an otherwise
decent language quite unbearable. A nice syntax doesn't make an otherwise poor
language good, either.

------
PLejeck
While it's certainly true that PHP is better than it was 7 years ago, that is
primarily in the ecosystem and not the language.

The language remains as bad as it was 7 years ago, and they seem to be
woefully unwilling to actually fix it.

~~~
dasil003
How would they fix it anyway? It was never really designed, it just evolved as
a slow accretion of features using whatever syntax was convenient in the
parser codebase over a couple of decades.

The author makes a good point that people like me who ditched PHP in the
mid-2000s should probably stop complaining about it since we don't really know
the current state of affairs.

The problem is when we have languages like Ruby, Clojure, Scala, Haskell, or
even plain old Javascript ala Node, why would I waste another thought on PHP?
PHP was created to make very simple dynamic web pages, and I would still use
it for that in the way that I still write bash scripts for simple shell
operations to avoid a higher level dependency like Ruby or Perl. I'll use PHP
for small stuff, but I see no benefit towards putting any real engineering
effort into a PHP project.

~~~
philipp-de
(can't reply to your reply so here goes)

I'd argue that PHP came out of the gate with some pretty powerful properties,
too.

They hit a sweet spot of

* Being there at the right time (none of the "good" languages in your book was around or usable for web dev at the time of PHP4 and PHP5 came out)

* Being easy to learn - giving beginners quick rewards.

* Being powerful enough to do quite a bit more than "simple web pages", as you say. This enabled people to "graduate" from "simple web pages" to "web apps". In fact, most of the web was built in PHP (Wikipedia, Facebook, Wordpress runs on 50% of all webpages or so, Drupal is incredibly popular, Magento runs loads of webshops, and on and on). This has not happened merely by accident. I feel it's a bit wrongheaded to suggest otherwise.

* Being dead easy to deploy on almost any webhost (Drop files, hit them with their url, be done - almost no other language delivers this even today)

In all i feel PHP has moved the web forward tremendously. In time, itself has
evolved as well. It may not have evolved as fast as one would want.

It's the C++ of the web era, really.

~~~
boomlinde
"Being there at the right time" is pretty much the only redeeming quality it
has, and it's not so much a quality of the language, is it?

"Easy to learn" is not the same as giving beginners quick rewards. Being easy
to learn, in reality, would probably result in things like Wordpress not
having more holes than a swiss cheese.

"Powerful enough" \-- most web frameworks are. Saying that it didn't happen by
accident of course depends on how you define accident. Personally I think the
only thing PHP has got going for it is the timing and next point:

"Dead easy to deploy" again isn't a property of the language. Saying that
"almost no language delivers this" about something that's really up to the
service you're using to host your website isn't fair, in that it actually has
nothing to do with the language.

I must say that I wholeheartedly agree with your closing statements, though.

------
aidos
I spent a couple of years with php recently. I was using Codeigniter as a
framework. Php frameworks now compete with the rest and the language is as
complete as most others. Setup couldn't be much easier and it's probably the
most ubiquitous web language.

It does, however, have some bad behaviours of out the box that promote bad app
development. I was startled at the default error handling when I had to start
using it again recently. It was a fight to get it to display errors - and stop
executing - whenever something was wrong in the code. This is madness. If your
code is broken, it should notify you. I tried doing the same thing to existing
well known php apps. They wouldn't even load. That, for me, is the core issue.
You have an ecosystem devoloped by people who seemingly don't even care if
there are bugs in their code.

~~~
jtreminio
Your framework may have been catching exceptions and continuing execution.

If you want _all_ errors displayed, you should tell PHP about it. In fact, it
is recommended you display everything possible and code to strict standard
while in dev. Doesn't sound like you were doing that.

------
kayoone
Ive been working with the Symfony PHP Framework since 2007 and to me it has
transformed PHP completely. Many people left PHP when Rails came along and
never looked at it again, and the biggest misconception is that many of those
still look at PHP like it was in 2005/2006\. But alot has happened!

Symfony2, my framework of choice, has a very mature and solid architecture and
offers anything you could imagine from other frameworks. The code is clean and
maintainable if done right and still its extremely flexible and extensible. It
also depends on PHP 5.3 which has Namespaces, closures, lambdas etc. So id
argue its up there with any of the other top Frameworks, it might even be the
best. While its true that there are languages that are more beautiful to work
in, i dont think its all that bad. For me, the biggest flaws of PHP are
present in any dynamic-typing language. The syntax is just stuff to get used
to once and be done with it.

~~~
thejosh
symfony2 is a beautiful framework.

I have been using symfony1 since january 1st, 2008 and then migrated across to
2 for other projects.

symfony2 is a solid framework for php, and very quick to get started and
maintain. With composer it is even easier, and git repositories are pretty
small as well.

------
yulaow
I was one of the php haters for a long time, then i discovered Laravel and it
was mindblow.

Maybe php stock is not that cool, but using a good framework (and now there
are many) it becomes really awesome.

------
pillock
I wish people would stop trying to defend PHP against "the haters" \- firstly
because no amount of reasoned argument is going to change the views of
fundamentalists, and secondly because they are a minority group whose opinions
are unlikely to inhibit the rise of the PHP ecosystem.

~~~
simonw
I would argue that the "rise of the PHP ecosystem" has been massively damaged
by the amount that has been written about PHP's flaws. An ecosystem needs
talented programmers working on open source libraries for that ecosystem, or
helping spread best practices.

You don't see much fresh innovation in the PHP community these days - instead,
you see developers who work with PHP having to recreate libraries and
techniques developed by other languages.

Meanwhile, the Node.js, Python, Rails etc communities are overflowing with
talented developers who used to work with PHP and are now busily inventing the
future on top of different languages.

~~~
orang55
I'd take issue with arguing that there isn't much innovation in the PHP
community.

It might not be the best language for every application (I find myself using
it less and less these days), but there have been a whole ton of recent
developments that have made it much nicer to work with.

PHP 5.4 made some pretty significant improvements, and Laravel is one of the
nicest full-stack frameworks I've ever worked with. PHP now has good/sane
dependency management via Composer, and many of Laravel and Symfony's
components can now be used outside of the main framework. Microframeworks are
a pleasure to work with in PHP, which is especially nice for smaller one-off
webapps.

Many of the recent improvements have been (very) late to the game, but they're
nevertheless welcome. I could do without the Java-esque levels of verbosity
that PSR-0 encourages, but it does seem to result in highly-maintainable code.

"New PHP" projects (written from scratch, targeting 5.3 and above) tend to be
of surprisingly high quality. As I've mentioned before, Laravel emerged from
nowhere as a lightweight and very high-quality framework, long after the PHP
community had been declared moribund.

------
mojuba
I'm just wondering, why should it take 15 years to get operators [] and -> to
work with _any_ subexpression (and to my knowledge it's still not 100% there)?
Shouldn't it be implied and kind of automatic in a programming language?

Or why should it take 15 years to adopt [...] as an array constructor in a
language where arrays are one of the central data structures?

Here is opinion No. 823,664,783 about PHP from a long time PHP developer: it
sucks (for me) because somehow I don't have a sense that the language itself
is in good hands. I'm not sure if, say, they introduce a new basic operator in
expressions and that it will not take another 15 years until it makes full
_programming_ sense.

~~~
rizalp
It is indeed in bad hands. No language designer / guru ever that I know ever
come close to exploring its Good parts. I'm talking Anders Hejlsberg / James
Gosling / Douglas Crockford level here...

~~~
PommeDeTerre
I wouldn't say that Crockford really "explored JavaScript's good parts".

Rather, he just covered parts of JavaScript that shouldn't be used, and
whatever wasn't completely broken was considered to be "good". It isn't truly
good, however. It's just not "severely bad" like the rest of JavaScript is.

------
rartichoke
I started with php and never used a framework quite some time ago. Every web
site/app I've built had different file structures and my own little twists on
how to abstract away certain things. I rarely used any third party php code
too but my code slowly improved on its own.

Now a days I use rails and prior to that I used node/express for a year or so.
I think working with php made me a better developer because you need to learn
from your mistakes and using bare bones php is the best way to ensure you make
mistakes.

You don't really understand why things are done a certain way until you've
experienced first hand at how horrible it is to maintain a 6,500 line php file
that's mixed with sql, php, html and a ton of inline css in a project that has
about 500kb of mixed php/html/css files and like 30 different dynamic pages.

~~~
krapp
_You don 't really understand why things are done a certain way until you've
experienced first hand at how horrible it is to maintain a 6,500 line php file
that's mixed with sql, php, html and a ton of inline css in a project that has
about 500kb of mixed php/html/css files and like 30 different dynamic pages._

It's quite possible to write PHP applications which aren't that terrible,
tightly coupled or unmaintainable. Perhaps you can blame PHP's low bar for
entry for making those kind of bad practices possible, but it's not as if the
language requires you to work that way.

Although I do see that kind of thing a lot in Wordpress, still.

~~~
rartichoke
Yes I know but if you want to pickup "web development" as a beginner then
chances are you're going to start with PHP unless you are getting trained by
someone who happens to be using a different technology.

At least that's how it was back in 2006ish when I started. Its low barrier of
entry is exactly why it's easy to make mistakes. You are given 5000 functions
and no guidelines other than the ones you make yourself.

~~~
krapp
It's still bad, and there's a _lot_ of bad legacy PHP code out there, but I
don't believe it's as bad as it was. Although most new developers working with
PHP will probably be hacking wordpress themes and plugins (which don't really
have much in the way of best practices other than WP's sometimes infuriating
API and mixins as a feature) but others will still end up using a framework
like Symfony or Laravel, or Composer to manage dependencies and autoloading.

I don't know if it's even as common as it was to start in PHP without at least
touching some kind of framework... although that's just an assumption on my
part. At the very least there's a lot more good PHP code out there and better
practices to be found, even if education seems like a dauntless task.

------
throwaway420
I think many developers on here evaluate programming languages solely based on
technical merits without considering business needs. PHP's sweet spot
currently makes it the wisest choice for many small business projects.

When you're talking about any project that's less than a thousand lines of
code or so, PHP's weaknesses don't really present a major problem and its
strengths (ease of deployment, ease and ubiquity of hosting, having a bunch of
necessary features for websites from DB access to email built into the
language) are ideal for smaller organizations, particularly those without a
full-time technical staff.

Think about how many small businesses out there (restaurants, real estate
agents, a simple online store) just need 1 or 2 basic dynamic elements (simple
DB access, a contact form, some validation on an order form, maybe sending a
confirmation email on a sale) on their website to work to enhance their
business. PHP is a great choice for these types of projects - a good portion
of non-technical small businesses don't need anything more elaborate than
this.

I wouldn't recommend PHP for large or ambitious projects, as other
alternatives like Node and Rails are likely better fits. But when you have a
very simple small business project, PHP is by far the best choice for a lot of
these types of projects.

------
usamec
Ok, PHP got package manager and MVC frameworks, but half of problems mentioned
here [http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-
de...](http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design/) are
still not fixed. It's shitty language and package manager and MVC will not
help.

~~~
rizalp
PHP as a language is broken. I don't want to speak in broken language. It
hurts my brain as human..

Unlike other popular language which has language designer around it, PHP
'copy' other language feature without even serious consideration around it.
Even more, there are no language guru who want to research the Good parts of
it, like Javascript who has Douglas Crockford who tels us the good parts...

------
inthewind
The thing that irritates me the most with Php, is not being able to quickly
jump around the code from class to class without some hack. While magic
autoloaders are great my IDE/text editor isn't smart enough to know how to do
this. You could probably write some code to help in this respect for your
editor or use some other tools. It ultimately ends up that I want to hold too
much of the project in my head, which is a brain muck.

I personally recommend Python over Php to newcomers because I think it's an
easier language to understand and get going with.

~~~
krapp
I would suggest that this in particular is a problem with your workflow and
IDE/editor and not PHP. I've usually just kept everything open as a project in
Sublime Text, works just fine. As far as the code itself goes, using PSR-0
and/or Composer makes most of the headaches with class loading just go away.

~~~
inthewind
I agree about that PSR-0 and using Composer helps. But sadly not all code is
written that way.

------
sergiotapia
PHP is like that old phillips screwdriver you have in your toolbox. You know,
the one with a crack going down the side of the handle. Wrapped in masking
tape to keep the thing together. You bought it when you moved into your first
house and you need to screw a lighting fixture that was about to fall off the
wall. It's been with you for years, always there in case something needed a
little tightening.

Sure you have better, more streamlined tools in your shed, but sometimes you
just need a little elbow grease and your old pal the screwdriver.

~~~
toupeira
Reminds me of this glorious quote from
[http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-
de...](http://me.veekun.com/blog/2012/04/09/php-a-fractal-of-bad-design/):

"I can’t even say what’s wrong with PHP, because— okay. Imagine you have uh, a
toolbox. A set of tools. Looks okay, standard stuff in there.

You pull out a screwdriver, and you see it’s one of those weird tri-headed
things. Okay, well, that’s not very useful to you, but you guess it comes in
handy sometimes.

You pull out the hammer, but to your dismay, it has the claw part on both
sides. Still serviceable though, I mean, you can hit nails with the middle of
the head holding it sideways.

You pull out the pliers, but they don’t have those serrated surfaces; it’s
flat and smooth. That’s less useful, but it still turns bolts well enough, so
whatever.

And on you go. Everything in the box is kind of weird and quirky, but maybe
not enough to make it completely worthless. And there’s no clear problem with
the set as a whole; it still has all the tools.

Now imagine you meet millions of carpenters using this toolbox who tell you
“well hey what’s the problem with these tools? They’re all I’ve ever used and
they work fine!” And the carpenters show you the houses they’ve built, where
every room is a pentagon and the roof is upside-down. And you knock on the
front door and it just collapses inwards and they all yell at you for breaking
their door.

That’s what’s wrong with PHP."

------
tzaman
I'd say one of PHP's biggest flaws is that it's just too easy to get started.
One might argue that's not a flaw, but it is - it allows junior developers to
dig right into the code without knowing the basics of how web works, in turn
producing extreme technical debt and waste years on bad practices.

I've been there too, and I must say I agree with Jeff on this matter - if I
was _forced_ to use Ruby instead of PHP when starting my career, I'd be a
better developer today. But I'm catching up :)

------
apinstein
Prepare yourself for gross generalizations, but I have a point :)

In 1997, people moved from perl to PHP in the same way that in 2004+ people
moved from PHP to Ruby.

At the time, the hard part of web programming was deployment, easy access to
libraries of functions relevant for web programming, digesting forms, and
emitting HTML. PHP suddenly made that trivial. PHP was basically a new
language with a stdlib for web programming. It was enjoyable to work with, and
it took off.

Circa 2004, the hardest part of web programming was managing the DB from the
app code (migrations,ORM), quickly accessing the prolific output of the OSS
community (RubyGems), and having some sane organizing principles around
building apps (opinionated MVC).

In 2004 I had the same problems in my PHP apps. I had just come off of 2 years
of Cocoa development and couldn't stand doing PHP the "old" way. It was too
painful. I ended up porting the Cocoa framework to PHP so that I'd have a sane
way of building apps. I later discovered ruby/rails, but frankly at that time
it was less mature than my framework so I didn't jump.

As someone stuck in PHP land, I was frustrated by the relative lack of
progress in the PHP community vs Ruby, but I was never really enamored with
Ruby the language. It's powerful, and easy to read, but frankly I felt that
power would eventually work against it. As the less-savvy developers moved to
it, the quality of the code would greatly diminish. I feel that this has
happened.

I do use a lot of Ruby projects as well, and it's rare that I don't run into
critical bugs almost immediately. For as many nice things as there are about
ruby, I find it very difficult to debug, and the broad application of
metaprogramming, mixins, and other language tricks ends up delivering apps
that have highly coupled state that fail in unpredictable, hard to debug ways.
Javascript has the same problem. Frankly I don't think the ruby community is
producing code of better quality than the php community at this point. There
is great stuff that we can finally easily share thanks to composer.

Metaprogramming & dynamism are neat ideas but I just don't think it scales
well with the constructs that those languages have. PHP 5.4 has traits which
are really nice for this type of thing, and Scala's traits are even nicer. The
point being that other languages can deliver that flexibility without becoming
unmanageable, and I don't think there's a path to that with Ruby or
Javascript.

IMO, I think languages like Ruby and Javascript will actually WANE in the far
future as new languages come along with better constructs for empowering
developers with dynamism that can be better managed and have faster runtime
performance. I think Ruby will end up as a frowned-upon language with crap
libraries and Javascript will more and more just be used as a build target.

~~~
pcunite
Quote: "I think languages like Ruby and JavaScript will actually WANE in the
far future as new languages come along".

Correction: if it compiles everywhere ... it's not waning. C, C++, and
JavaScript are with us for a _long_ time. But, you're right about Ruby. :-)

------
joeblau
One of my main challenges with PHP is that it has no package manager with
large community support. With npm and gem, and the community supporting them -
developers get so much help in building robust products. Every developer that
I've known for a few years and successfully switched from PHP to Node has said
"Why didn't you tell Me about this before?!"

~~~
memla
Composer/Packagist[1] is exactly like npm. It's even mentioned in the article.

[1]: [https://packagist.org/](https://packagist.org/)

------
cies
> If PHP hadn't evolved [...]

> But it has.

Honestly, how can languages (what PHP in the end boils down to) possibly
evolve?

Example: you cannot bolt OO to it later on, PHP, Perl and to some lesser
extend even Python are a testimony to that. It just does not feel right, leads
to syntactic horrors and is usually not very performant.

Neither can you modify the syntax. You can add to it. But not much modify
existing syntax. For tiny changes all hell breaks loose.

> [...] and feel like they're doing the wider community a service by making
> declaring a religious war against PHP.

I think the religious-war card is clearly overused. This is not a religious-
war, it is an effort by programmers who rather use the best tool for the job
then the bizniz/customer dictating them a languages/framework/CMS. PHP will
not be fixed, mission impossible, they know it and therefor advocate a
retreat-strategy.

The article describes that the community has (be it very late) finally
developed some tool, a package manager, that make it slightly more bearable.
But the language and its community still suffer the exact same unfixable
problems.

An analogy: even in COBOL-land some problems get fixed up until today, but not
fundamental language issues, nor community issues.

Yes, I compare COBOL with PHP. Many, or most, languages will someday be
'legacy' languages. Some just a little sooner then others. :)

~~~
Demiurge
I'm not sure why you're getting modded down, I think you make a very obvious
point. There is a programming language (syntax) and there are libraries. PHP
syntax is not informed by much of Computer Science of the 30 past years, and
it can't be fixed, that would be a new language. Frameworks can evolve and as
long as the syntax allows enough, can be as amazing as anyone bothers to
engineer them. This has nothing to do with how good a language actually is.

------
kailuowang
The code example he gave in ruby and PHP demonstrate perfectly that the PHP
version is verbose (not to mention that the ruby code isn't the most concise
one). It could be just me, who, as a develop, is sensitive to every single
unnecessary characters in the code, which happens a lot in that couple lines
of php code.

~~~
memla
That example is framework specific. Change the php framework to laravel and
this:

    
    
        $topic = $this->get('model.Topic')->find($topic_id);
        $this->get('guardian')->ensureVisible($topic);
    

becomes this:

    
    
        $topic = Topic::find($topicId);
        Guardian::ensureVisible($topic);

------
tux
I don't see anything good about Disclosure project. All it takes is disabling
javascript and nothing works :-)

~~~
eksith
It's not fair that you can't see _anything_ good about Discourse just because
of the JS requirement. That's just one handicap.

It has its good points and all of its current features can be implemented (and
already has in other projects) with HTML fallback in PHP. But I feel the
biggest problems Discourse is attempting to solve is sociological, not
software based. Whether software can fix human nature is another topic
altogether.

Full disclosure: I don't use Discourse and don't plan to any time soon. I
still believe any site/forum worth it's salt should be available via wget so
that rules out most web apps (I don't believe a forum should be a web app).

------
10098
New frameworks != improvement of the language.

PHP was shit then and it's shit now. I earned my first money by writing things
in that language and I'm very glad that I moved away from that particular
technology and web development in general.

~~~
jmcgough
When is "then"? I'm a rubyist, but I worked with PHP for a year and was
impressed with how far the language has come in the last decade. Before PHP5
(2004ish), the language wasn't really even object oriented. In the last few
years, PHP has gotten garbage collection, namespacing, native JSON support and
others.

I really dislike PHP as a language, but it's not fair to call it shit. The
language is maturing.

------
vijayr
Can anyone recommend a good PHP framework? I've used Zend and Yii - they are
okay, but I'd like to try something new. So, other than these two, which ones
are good?

~~~
krapp
Laravel 4 [http://laravel.io](http://laravel.io) for large dependency heavy
projects,

Slim Framework [http://slimframework.com](http://slimframework.com) as a
microframework.

~~~
orang55
Many of Laravel's components can also be stripped out and used as
microframeworks. Their database ORM is particularly nice, and I use it
alongside Slim on a few projects.

From my experience using it, Laravel also feels a lot "lighter" than the other
big frameworks of the past. It's a bit less opinionated, and it's much easier
to get set up and running.

------
billpg
(snarky comment about equality operators goes here)

~~~
PommeDeTerre
There's nothing "snarky" about pointing out stupidly and inexcusably broken
programming language features.

------
unz
The best web platform is haskell and postgres, or ocaml-java/yeti and mysql on
appengine. Phpers and rubyers are missing out on the most delightful and least
error-prone ways to use functional and relational programming.

