
PHP solves problems. Oh, and you can program with it too - nikic
http://nikic.github.com/2012/06/29/PHP-solves-problems-Oh-and-you-can-program-with-it-too.html
======
10098
Let's talk about the conclusions that are drawn in this article. I'll try to
challenge them one-by-one.

> PHP is a great language to start programming!

No. PHP is not a good language to start programming. And I mean programming in
a broad sense, not slapping together websites (which is not really
programming, let's be honest). Let's look at people who know how to program,
you know, the guys who participate and win awards at ACM ICPC and TopCoder.
There are several such people among my friends. Exactly zero of them have
started with PHP. Some have started with Pascal, some with Java, some with
C++. None with PHP, even though it was available and widely used when they
started. I wonder why.

> Once you started, PHP is also good for “real” programming (you know, object
> orientation and stuff).

First of all, "object-orientation and stuff" is not a measure of how good a
programming language is. So you'll have to bring a better argument to explain
why PHP is good for "real" programming (whatever that term means). Saying "but
Facebook and Wikipedia use PHP!" doesn't count :-)

> PHP is not as bad as they say. There are issues, like with every language,
> but they rarely cause problems in practice.

Actually, it is. It has some deeper issues that lack of consistency in
function arguments. Some of them really do cause problems in practice, like
its retarded type system and lack of sane support for multithreading. But I'm
not going to name them here because there are tons of articles on the internet
explaining those issues. You have probably read some of them. If they did not
change your opinion about the language, then I surely won't be able to do it.

~~~
llimllib
I hate PHP too, but this:

> Let's look at people who know how to program, you know, the guys who
> participate and win awards at ACM ICPC and TopCoder.

Is goalpost moving. He's not suggesting that PHP is a great language to start
with if you aim to become a great algorithmic programmer, rather that it's a
great language to start with if you aim to become a competent web developer.

> Saying "but Facebook and Wikipedia use PHP!" doesn't count :-)

But why not? Surely "X and Y outrageously successful projects use Z" is a
valid argument for Z's power as a programming language?

~~~
lusr
It's an invalid argument because not all projects are alike. Facebook and
Wikipedia are indeed very successful projects but they have a massive
advantage over the types of projects I deal with in enterprise environments.
For instance:

\- technical environment: the Facebook/Wikipedia/generally-any-web-startup
architects get to choose their technical environment 100%; in most corporates
you need to integrate with legacy applications and databases in a specific
environment, often enforced by IT policy, and this imposes significant
constraints on which languages will be feasible options

\- interoperability: for large, modular systems developed by disparate teams
over decades with little or no standards or co-ordination, a statically typed
language can be absolutely invaluable for ensuring interoperability and
discovering usage (documentation is typically non-existent in these
environments, as are tests, and the latter is seldom - often impossible - to
retrofit); even for new systems, static typing can save a lot of time when
developing and integrating new work across large teams, in my opinion

\- resistance: business and technical knowledge lives in developers who are
part of an ancient stack, e.g. Microsoft or Oracle or Borland; switching to
PHP or Python or Ruby etc. means convincing these people to learn very
different new technologies (good luck - won't happen), figuring out how to
interface with legacy stuff using a language outside of the stack, introducing
new tool chains, etc.j

\- time & budget: even if the existing developers are keen to learn, it's
tough convincing the project manager you need an extra month to go through the
upskilling process and that you need to spend time researching
interoperability options, and that inevitably you will run into future issues,
etc.; the problem is most projects are run and budgeted for on a local cost
benefit analysis and very rarely would the benefit of switching languages for
one project be worth it (even though, in the big picture across multiple
projects, it may very well be)

An observation: whenever this debate comes up on the HN, the proponents of
modern, dynamic languages are invariably people working in closed environments
where they have the freedom to set standards, do things right from the
beginning (coding standards & reviews, tests, documentation) and the ability
to make technology selections across the board. Often this freedom is not a
characteristic of other environments, and consequently the language used in a
one environment may be unsuitable in another.

------
robomartin
Oh, please. Stop it! Not another fucking PHP vs. the world thread on HN! C'mon
kids, get off it!

Any number of us could name tons of very successful (profitable, popular,
worth tens, hundreds and billions of dollars) companies that rely to a large
extent on PHP.

And the same could be said about a dozen other languages and frameworks.

Be done with this shit, will you? Haven't you had enough?

~~~
j_col
I blame Atwood for trolling PHP yet again with this link bait. I'm deadly
serious: he has a history of posting anti-PHP rants, then sitting back and
watching his blog traffic grow.

------
fleitz
No one is disputing that you can hammer a nail with a brick. Most of the
criticisms around PHP revolve around the idea that it's better idea to use a
hammer (with one claw side, and one hammer side)

Likewise, when you have a real problem that isn't needs to run on a $5 shared
host, or written for $4/hour in China PHP is rarely a good choice unless you
happen to already know it.

If I needed to solve either of the above two problems I'd choose PHP. I write
a lot of PHP (mainly wordpress sites) and it's certainly workable, it's just
annoying once you've used languages like C#, Ruby, F#, Scala, Clojure, or
Python.

None of the problems with PHP are unmanageable it's like driving an old diesel
car, you just remember to plug it in the night before if it's going to be less
than 40 degrees.

~~~
Zak
_$5 shared host_

Modern shared hosting can actually handle long-running processes and complex
frameworks that used to require a VPS. I don't have broad experience with it,
but I did just deploy a client's site to webfaction.com, which supports
Django, Rails, arbitrary long-running processes, JVMs, custom Apache
configurations etc.... Pricing can be as low as $5.50/month there, and there
are probably even cheaper services for those who shop around.

 _you just remember to plug it in the night before if it's going to be less
than 40 degrees_

People in warm climates who have never seen electric engine heaters might not
understand this.

~~~
fleitz
Good point on the block heaters, I guess that's a cultural reference most
likely to be picked up by Canadians.

It's especially bad for diesels as when they age even with new glow plugs it
isn't enough heat to make the diesel ignite with out waiting 5 to 10 minutes
if it isn't a nice summer day.

Yeah I've run a couple rails apps on dreamhost, it's becoming more common but
you know for sure that PHP is going to be installed.

------
mixmax
it's interesting to read the comments here. Most of them go on bashing PHP
because it's a terribly designed language. They're probably right, but they're
totally missing the point, primarily because this is a very technical
community.

I'm not a programmer. Yes, I can solve problems with code, I can whip up a
webpage, I can talk to a database, I can use Jquery. But I don't know what
lambdas are, I don't understand what LISP macros are all about, and I wouldn't
know where to begin writing image recognition software.

But you know what? I get stuff done. And PHP helps me do it. Because I can
make things without worrying about not having a CS degree, not caring how a
compiler works and not having to set up a server from scratch.

If you look at all the sites out there making money and getting views I think
you'll find that an awful lot of them are made by people like me.

~~~
Argorak
But you do know what a function is? Or a class? Or an object? It is not like
those are non-trivial already or that knowing what a lambda is needs years of
studies if you understood these things.

The fatal flaw in the "PHP is simple"-Argument is that its actually not
simpler than other things (I wouldn't say that its harder either). Sure, it
gets stuff done (tm), but so do others, also without any deep knowledge. They
may not be Lisps or Haskells, but Ruby and Python are coming close.

The problem I have with the PHP community is that "its so easy to start" seems
to be their main argument. Wouldn't the world be a better place if we had an
easy to start stack _without_ a shitty language?

~~~
btilly
The problem is that any popular "easy to start" stack attracts people who have
no idea how little they understand. And then they start building things badly
because they don't understand. Some of it proves useful to other people who
don't know what they are doing. And before long the ecosystem built around
that stack becomes a horror to behold.

This has happened with PHP. It happened with Ruby on Rails. (Before
disagreeing with me, think about how much abuse of monkey patching happened,
and how many have been bitten by it.) It happened with Perl back when Perl CGI
scripts were the de facto standard.

So yes, it would be wonderful to have an easy to start stack that is popular
that guides people towards doing the right thing. But human factors guarantee
that any that get popular will go downhill over time.

(I've ignored the obvious argument that the same features that make you
popular also make you worse. See the famous essay _Worse is Better_ about Lisp
vs C for context.)

------
Joeri
I think PHP's problems are actually quite solvable without core language
changes. The OO model is actually pretty good, there's even reflection
functionality that's sufficient to do stuff like auto-generating docs and
self-validating DTO objects. The issue are the "legacy" api's, and the
primitive types. What's missing are object api's wrapping the primitive and
legacy functionalities. Those could be built quite easily though.

You could have something like jQuery's $ function, but for PHP variables, that
gives you an OO api on top of that value (especially now that you can use the
-> operator on return values of functions without intermediate assignment). I
wonder why nobody's built that yet. I suppose because those in the PHP
community are all busy programming instead of meta-programming.

~~~
whichdan
Do you mean something like this?

    
    
      function s($string) {
        return new String($string);
      }
    
      class String
      {
        public $string;
    
        public function __construct($string) {
          $this->string = $string;
        }
    
        public function __toString() {
          return $this->string;
        }
    
        // several helper methods like the following:
    
        public function toLower() {
          $this->string = strtolower($this->string);
          return $this;
        }
        
        // this would create lots of extra objects,
        // but leave the original unchanged
        public function alternateToLower() {
          return new String(strtolower($this->string));
        }
      }
    
      $username = s('ExampleUser');
      echo $username->toLower();
    

My concern would be the memory used to create several dozen extra objects. If
this is indeed what you're talking about, is there any strong benefit besides
convenience?

~~~
Joeri
Yes, lots of memory, much worse performance, but it doesn't really matter. If
you care that much about those, you're not using any interpreted language.

Besides, most PHP code is linear without much looping other than iterating
database records. The overhead of such an approach wouldn't matter that much,
and when it does you can always use the old way of doing things.

But you wouldn't need to create an object per call, you could reuse a
singleton that gets initialized by a wrapper function to work on your current
variable (using references). Fix($str)->replace("foo", "bar") is a syntax that
doesn't require object instantiation or string copying. And the singleton
could use the mb functions internally to be multibyte aware.

------
Ralith
As C++ has taught us, the solution to the errors made in a badly misdesigned
language is not to continue cramming every feature you can think of into it.

~~~
josegonzalez
Right, and in recent years, PHP has been really cautious as to how it adds
certain features, but more importantly, has been cleaning up old edge cases.

~~~
Ralith
TFA seems to argue that people's complaints don't apply to PHP5 because it
added a random assortment of features.

------
CodeMage
I guess it's irrational, but the fact that there are some good points nestled
inside this post only makes me more irritated about the post as a whole. You
see, it's easier to just shrug and say "meh" if the whole thing is crap.

Te problem with the main premise is the same thing PHP apologists have been
harping about all the time:

 _some poor soul wants to create an online encyclopaedia, or some teacher
needs an online teaching platform, or someone wants to write a blog. Those
people do not want to learn to program, they want to solve problems._

Newsflash: solving those kinds of problems is called programming. That's what
programming is. You want to make the computer do something that it can't do
with the existing programs, so you create a new program.

If a programming language is easy to use by _everyone_ , it's because it
doesn't require you to think like a programmer. It's part of the language
design. If you start fixing those design decisions, you'll most likely end up
with a decent language that simply isn't easy to use by _everyone_ anymore.

This idea that you don't need to be a programmer to write programs has already
failed on several occasions in history of programming: dBase, Visual Basic and
Access are notable examples. Not repeating the history is too much to ask for,
but let's at least try to avoid making it look like it's a good thing.

~~~
rprasad
You do not need to be a writer to write, a driver to drive, a cook to cook, a
runner to run, or a businessperson to conduct business...and you don't need to
be a programmer to program.

~~~
CodeMage
And yet you need to be a dentist to work on someone's teeth, a doctor to
prescribe medical treatment or a pilot to fly a plane.

Yes, you can program without being a programmer, just as you can drive a city
car to your office and back, but you won't take that same city car to Monza
and expect to beat Ferrari's Formula One team in a race.

So let's dispense with the sophistry and admit that you need to learn a
specific skill set to do a skilled job and that you need adequate tools for
that job.

~~~
rprasad
A race car driver is a very different thing from a driver. There are also
restrictions placed on who can be a race car driver. It sounds like what you
are really saying is that programmers need to be certified by a professional
trade organization, following a period of 2-6 years of education and
apprenticeship, enforced by law. After all, that is what separates doctors,
dentists, lawyers, and accountants from other professions. (Race car drivers
have contracts and other measures to enforce exclusivity, as racing is
generally illegal except on dedicated courses or in licensed races.)

Programming is a skill/trade. It is not a profession. _That is a good thing._
If programming were a profession, it would not be open to everyone to learn
and do.

------
whichdan
This is offtopic, but I just wanted to say that I really enjoyed your "PHP's
Source Code for PHP Developers" posts. Please keep writing!

------
banana_bread
The fact that people have to constantly defend PHP says something in itself.

~~~
jimminy
That people constantly attack PHP?

In all seriousness, it just works when your building for the web (unless it
doesn't.)

Is it often messy? Absolutely. Is it sometimes a bit verbose? Sure. Can it
sometimes be like laying a snare, only to accidentally step back into it? Yes,
but it's not alone, just seems to make it a little easier to occur.

It doesn't have to be that way, it just tends to be like that.

I prefer Python and Scheme, but I don't enjoy them when it comes to working
with web development. There are frameworks that help with this, but it's still
a pain. PHP is quick and easy, in that area and works 95% of the time in about
99% places you stick it.

I've been trying for years to embrace Python in web development, but it just
annoys me during the setup. PHP gets out of the way, in that area, and let's
me go.

------
zenogais
Coming from someone who didn't start with PHP. Has used a variety of other
programming languages. And programs in PHP daily I will say that it fails in
many important respects and will for some time to come. The first things that
come to mind are functional programming (it has some abilities but is fairly
quirky and harder to read than other languages). Being able to use array_map
or array_reduce is useful in many places but certainly not elegant in PHP.
Code reuse is also not that easy with PHP (though traits may fix it, but we
don't use PHP 5.4 yet because it's seemed fairly problematic for us in
production) and the need for autoloaders is somewhat insane once you've used a
language with an actual package system. It doesn't have a mature dependency
management system (though Composer is currently an up and comer). It's great
for small projects but horrible to maintain at large scale - and this is from
someone who has written 100K+ line programs in PHP.

------
zobzu
That's what i like about PHP:

\- low maintenance. That's true.

\- straight forward coding. Yes you can shot yourself in the foot. But it's
easy.

\- controlled file descriptors, functions, etc:

Tell me, how can you restrict the baseopen dir, certain functions such as
exec'ing, how can you log all mails going out from.. python's wsgi, or ror,
etc?

That's right. You can't. Well PHP can.

So, I dislike PHP for all the reasons everyone are going to write for the
umpteen time too, but it does have several unique strengths too.

------
stevencorona
Wrong! Nope!

PHP OO is screwed up and hacked together. Look at crappy support for late
static binding, being unable to bind $this in closures, and all of the hack-
glue that is get_class(), get_class($this), get_called_class(), self:: vs
static::, the list goes on.

The thing is that, with PHP, the "new, modern" features are only surface
deep... once you do anything slightly advanced, you can always tell that they
were hacked on to a language that was never meant for anything more than
'include counter.php', and maybe that's okay, but stop saying it's a real
programming language because it's NOT.

~~~
vectorpush
_but stop saying it's a real programming language because it's NOT._

Any definition of "real programming language" that can inexplicably exclude
the Facebook stack is just meaningless. Saying that another stack could do it
better is pointless since _PHP is what does it_. And just to preempt any
"HipHop is the stack, not PHP", just remember that front-end Facebook
engineers don't write C++, they build Facebook in PHP, inconsistent parameter
orders and all.

~~~
sandfox
Does everyone think the facebook stack is just built from PHP, there is a
boatload of C etc too. Don't forget they have HipHop which makes thier PHP a
little non-standard. Also they have a MASSIVE legacy codebase I presume so
just swapping out to something might not be justifiable despite how much they
wish they could.

------
calinet6
There's nothing particularly wrong with this article. It describes some
aspects of PHP.

It's just that Atwood's article describes PHP _much_ better.
([http://www.codinghorror.com/blog/2012/06/the-php-
singularity...](http://www.codinghorror.com/blog/2012/06/the-php-
singularity.html))

I think the latter view is spot-on, and nikic's view here just serves as a
perfect example of why certain people are still addicted to their awkward
toolset.

