> Nobody mentions how much or little the PHP community thrives. People point out how bad PHP compares against other languages.

I don't actually think that faults in a language matter that much if the people using it are competent. Both Javascript and Perl come close to PHP in terms of negative traits, yet a lot of good software was written with both. The same can be said about PHP, the only difference is that people on HN have very little idea about what contemporary PHP (language and software) looks like.

There are many good PHP web frameworks out there today, yes. These don't somehow erase PHP's core flaws as a language though.

You can make a new project in Symfony or Laravel, sure, but you'll get that same niceness plus way more goodies if you use a popular Python or Ruby framework.

I think you need to qualify that a bit - what are "way more goodies" exactly?

Can you name something that Python can do that PHP can't?

No, but I can name a lot of things that are way easier and cleaner to do in Python than in PHP.

Real production ready servers ,complex scientific calculations, 2d, 3d games , to name a few things. PHP is not general purpose. Python is.

PHP has type hinting and interfaces that makes it "java" like(it's a strength).

Python doesnt have interfaces but allows type hinting through decorators.

    @typecheck
    def gimmeFloat(a:int, b:list, c:tuple=(1,2,3)) -> float:
        return 3.14

And who is talking here about a general purpose lenguage in this context, i only care about the web stuff i don't need things that ain't gonna use.

It's also a far more readable language, which matters more than anything in large-scale projects

On the other hand, <? ?>.

Large scale projects doesn't need "more redeable" languages, it needs good engeneering and type checks.

The single biggest everyday-use thing I miss with PHP is keyword arguments. With PHP the only real equivalent is passing an array of arguments and then checking if each possible key exists, and that's just way clunkier.

> No, but I can name a lot of things that are way easier and cleaner to do in Python than in PHP.

Please do.

I can name two. First, list comprehensions. In PHP, what you might write as this:

    $image_urls = [];
    foreach ($images as $image) {
        $image_urls[] = 'illos/' . $image['url'];
    }

can just be this in Python:

    image_urls = ['illos/' + x['url'] for x in images]

And, closures in Python -- and to be fair, just about any language that isn't PHP -- close over variables in the scope they're defined automatically, without having to use PHP's strange "use ($a, $b, $c)" construct. Yes, that's a small thing, but PHP's way is a little bonkers.

I'd prefer something like this:

    $image_urls = array_map(compose(papply('concat', 'illos/'), papply('lookup', 'url')),
                            $images);

This builds a function via composition: first lookup 'url' then prepend with 'illos/'. This function is then mapped over the array.

Unfortunately relies on a bunch of functions which PHP doesn't include. Unfortunately PHP's stdlib concentrates on incredibly-single-purpose functions for, eg. string manipulation, while ignoring general programming constructs. Also, most of the really useful parts of the language aren't available as functions, for no real reason. In any case, we can define these things ourself like this:

    // Function composition
    function compose($f, $g) {
      return function() use ($f, $g) {
        return $f(call_user_func_array($g, func_get_args()));
      };
    }

    // String concatenation. Unfortunately we can't write "concat = papply('implode', '')"
    function concat() {
      return implode('', func_get_args());
    }

    // Array subscript. I'd prefer to do this the other way around and write an
    // argument-flipping function, but that's unnecessary for this example
    function lookup($x, $y) {
      return $y[$x];
    }

    // Partial application
    function papply() {
      $args = func_get_args();
      return function() use ($args) {
        return call_user_func_array('call_user_func',
                                    array_merge($args, func_get_args()));
      };
    }

Regarding lexical scope, Python has ridiculous gotchas too http://stackoverflow.com/questions/5218895/python-nested-fun...

PS: I still much prefer Python to PHP, but straw men aren't going to help ;)

> can just be this in Python:

In PHP 5.3+ you can write:

    $image_urls = array_map(function($image) {return 'illos/'. $image['url'];}, $images);

Not as concise, but I'd postulate easier to read for people not familiar with list comprehensions.

In PHP 5.5+ there may be another way, but we're stuck with 5.3 in production for most clients, so I'm not up to speed.

> And, closures in Python -- and to be fair, just about any language that isn't PHP -- close over variables in the scope they're defined automatically, without having to use PHP's strange "use ($a, $b, $c)" construct.

Mmm, the debate of explicit or implicit scope? Explicit at least gets round those strange errors (hello Javascript) where you think you're referencing one thing... and actually referencing something else.

You can't write production Python and be unfamiliar with list comprehensions. They're a fundamental part of the language.

this

(javascript pun intended)

> I dispute that there is any good software written in Perl.

Do you even Linux? Have you ever installed anything? If you pay attention you will notice that lots of the libraries you are using for everything are written in Perl.

> Many have been where you are now, and then moved on to other languages to never ever look back. From what I've seen, the reverse is much less common.

I really doubt that. In my experience there haven't been a single time when someone attacking PHP actually knew something about it that wasn't outdated by at least 5 years.

It's funny how difficult it is for people like you to grasp that the language and its ecosystem evolves every day, much faster than other languages. Just look at what you just said. How can someone have been where I am right now? They used a time machine? Or you are assuming that the language stopped evolving at some point, or never evolved at all in the first place?

If you enjoy programming in it, and you can create great code then what's the problem?

That you are too pragmatic for the fashion victims of programming.

because real world people don't program because it's fun, they program because they need to make money.

Oh, come on.

I've probably written about 20x as much code in my life for fun, than I did to make money.

Guess I'm not a "real world people".

Though that ratio changes a bit closer to 3:1 looking at only PHP code I ever wrote. The "for fun" element was good times though, my first steps in server side programming :)

Something needs to pay the bills. If a PHP project takes longer to complete (I'm not saying it does), is harder to maintain, etc than an equivalent project written in another language, then you will simply be less productive in PHP.

This is the case for any language. No matter how much you enjoy something, if a design choice you made (like choosing PHP, or Perl, or C++) means that you spend more of your time on the project, you've made a mistake. The purpose of a language is to remove as much of the incidental complexity of the project as possible, leaving only the (more enjoyable) intrinsic complexity.