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 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.
The problem with PHP is that it is a horrible language and there are plenty of better options in its niche. Those two factors combine to make PHP a nonstarter for programmers who are familiar with the other options.
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.
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.
Can you name something that Python can do that PHP can't?
Please do.
$image_urls = [];
foreach ($images as $image) {
$image_urls[] = 'illos/' . $image['url'];
}
image_urls = ['illos/' + x['url'] for x in images]
In PHP 5.3+ you can write:
$image_urls = array_map(function($image) {return 'illos/'. $image['url'];}, $images);
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.
(javascript pun intended)
image_urls = images.map { |img| "illos/#{img}" }
$image_urls = array_map(compose(papply('concat', 'illos/'), papply('lookup', 'url')),
$images);
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()));
};
}
PS: I still much prefer Python to PHP, but straw men aren't going to help ;)
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.14On the other hand, <? ?>.
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?
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 :)
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.