
Programming Community Index for July 2013: PHP is regaining ground - pikexxn
http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html
======
dkhenry
When will we stop pretending TIOBE is even remotely relevant. Do we still
honestly think that there are four times as many python developers then
Javascript developers or twice as many Perl developers as Ruby developers ?
This is absolute rubbish

~~~
deweller
Just because Hacker News is biased toward Javascript and Ruby doesn't mean the
rest of the world is.

~~~
shubhamjain
Just forget the bias, how many alternatives are their to PHP in terms of back-
end? Many : Python (Django), Ruby ( Rails ) and I think almost every major
langauge has some port for Web development. Now what are the alternatives to
Javascript: None. Why do you think PHP would be more popular?

~~~
nbouscal
There are tons of alternatives to JS if you count languages that compile to
JS. Probably just as many as there are alternatives to PHP. Also, the fact
that there are alternatives to PHP does not mean that they are widely used.
We're in an echo chamber here, but in the real world, PHP is still the de
facto language of the back end web. The LAMP stack is still the dominant
setup. It's unfortunate, but it's reality.

------
druiid
PHP never really went away. It's still quietly powering many, many websites
out there (and not just sites running a copy of Wordpress). There are active
developers making loads of projects with it still.

I think it gets a bad rap on HN because there are so many terrible PHP
developers and it lends itself to allowing them to function. I work with
numerous GOOD php developers and it's quite a different story then. I do find
it funny that Matlab is somehow in the top-20. I mean, I've studied
engineering and the curriculum used Matlab for teaching, but how many real
engineering firms out there actually use Matlab??

~~~
nbouscal
It also gets a bad rap on HN because it is just not a very good language.
There are much better alternatives, and those alternatives are now really easy
to use and deploy. Yes, there are good PHP developers, and they can make it
work. I like to think I'm one of them. That said, if you give me the choice, I
will pick almost any other language over PHP, no questions asked. It's not
just warts (though there are plenty of those), the language has deep
fundamental flaws.

Relevant: [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/)

~~~
coldtea
> _It also gets a bad rap on HN because it is just not a very good language._

It's not the language, it's the ecosystem.

All languages have imperfections.

Javascript, which does not have a "bad rap" on HN is even worse.

~~~
nbouscal
Javascript has some really, really bad parts. It also has some very good
parts. PHP has the former, but not really the latter. The most common argument
made for it is that it's drop-in-and-go, so you don't have to worry about
things like application servers or deployment strategies. I would argue that
that's the _worst_ thing about PHP. Languages (and frameworks, etc) are well
characterized by what they make easy. PHP makes it really easy to do things
really wrong.

~~~
coldtea
> _Javascript has some really, really bad parts. It also has some very good
> parts. PHP has the former, but not really the latter._

Not so sure.

PHP is equally dynamic (what with closures et al), with very good reflection
style features.

It has an ACTUAL hash instead of using objects a dict.

It has better arithmetic, not the FP horror of Javascript.

It has a class system -- which is something people seem to like and
desperately try to imitate in Javascript in 200 ways (very few seem to
appreciate prototypical inheritance as is).

It now has generators and traits.

Generally, not that shabby.

It's greatest sin is the hodgepodge that it's standard libraries are. But,
given their shortcomings and arbitrary APIs, there are quite complete, feature
wise.

~~~
nbouscal
It has a class system that was bolted on after the fact, leading to tons of
inconsistencies. It has "closures", but they're not proper lexical closures
since you have to explicitly declare what part of the lexical scope you want
your anonymous functions to have access to (rather than the interpreter
figuring out the free variables like a sane implementation). Named functions
can't even do that much (the fact that they're separate implementations being
an indicator that they're designed poorly. Unsurprising, given anonymous
functions were added post hoc). If by "good reflection style features" you
mean the god-awful isset-on-every-line-of-code garbage, I'll pass, thank you.
It's Turing complete and can get the job done, yes, but there's absolutely no
part of it that I would call "very good". The best it ever reaches, in my
experience (several years, for what little that's worth), is "doesn't quite
make me want to vomit".

(Yes, I'm a bit bigoted towards PHP. I recognize that. Having to write it
every day can do that to a person.)

------
venomsnake
It just won't go away and always comes back - just like herpes but not as
pleasant.

disclaimer - PHP developer with 3 years of experience.

~~~
Shish2k
I'd consider even mentioning them in the same sentence to be an insult to
herpes

(PHP developer with 9 years experience. Now thankfully using Python for new
projects, but still supporting PHP legacy D: )

------
nutmeg
Please link to the actual TIOBE article:
[http://www.tiobe.com/index.php/content/paperinfo/tpci/index....](http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html)

------
quchen
Here's an index that is based on GitHub/StackOverflow instead of random search
strings.

[http://langpop.corger.nl/](http://langpop.corger.nl/)

(Fun fact: according to Google, there are ten times as many "C developer" than
"C programming". TIOBE is somewhere between FUD and trash, stop using it.)

------
n1ghtm4n
The RedMonk programming language rankings seem much more plausible to me.
They're based on 1) questions on StackOverflow and 2) projects on GitHub.

[http://redmonk.com/sogrady/2013/02/28/language-
rankings-1-13...](http://redmonk.com/sogrady/2013/02/28/language-
rankings-1-13/)

~~~
nbouscal
Those are great rankings for the parts of the software development community
that use Stack Overflow and GitHub. Here's a hint: those parts of the
community are not representative of the community as a whole. Not even close.

~~~
dkhenry
I would claim the opposite. People who live in a vaccume can't very well be
said to be part of a community.

~~~
nbouscal
I actually felt a bit weird using the word community and considered changing
it to something else. Really though, just because they aren't part of SO or
GitHub doesn't mean they live in a vacuum. There are tons of other focal
points for developers on the web, and that's not even considering local user
groups and meetups, etc.

------
shire
There is a reason why php is climbing the list, because how anyone can learn
this language and for a beginner because they will learn server-side scripting
from the get go with MySQL and this is great for transitioning to other
languages that do magical wonders like Ruby ( on Rails ) but it would be
cumbersome to understand how this works without really understanding under the
hood which PHP will show you and when you move on to an elegant language you
will appreciate pythons beauty if you have done PHP.

------
lkrubner
I find it humbling to look at these lists and see what most people do. At work
we have had the occasional debate about Scala versus Clojure. I was for
Clojure and I mostly lost (I didn't convince anyone).

Perhaps mistakenly, I thought we were arguing about one of the big issues
facing the tech world right now. What is the correct way to move forward in
our new, functional, multi-core world?

Then I look TIOBE. Scala is in 33rd place with a 0.326% share.

Clojure is not even listed -- it might as well not exist.

Lists like this remind me how easy it is to think that the thing you are
excited about also has other people excited. But that is not necessarily the
case.

I've been using PHP since early 2000, when PHP 4.0 was still in beta. For
awhile I loved PHP. It was my main language for most of 10 years. But the
world has changed. I find it amazing that anyone would still use PHP for a
project, given the wealth of great alternatives that have sprung up.

Let's go back in time. Here is what the world looked like in the spring of
2000: I want to build a dynamic website. What should I use? I wanted to use
open source so that ruled out Microsoft and ASP. I could use Perl, but Perl
took assembly -- every module I could want was in CPAN but you had to know
them and understand them and it was a bit of a hassle to assemble them (there
was nothing quite as easy as modern package managers). Java seemed like
overkill. The people who loved Java were, at that time, very focused on the
enterprise and they were loudly promoting the benefits of the Struts framework
(which in the end turned out to be overkill for every single type of
application that anyone could ever actually want to build). And Java needed to
be compiled, and there were none of the tools then that make life so much
easier now. And when debugging the stack traces were fearsome. Then there was
PHP. It was simple and it was all in one. No assembly required -- a huge built
in library. No need to compile, just edit a text file and then hit "reload" in
your browser to see the change. When debugging, the error messages were
crystal clear and always told you what line, in which file, needed to be
fixed.

PHP was an obvious choice then.

But things changed.

In 2004, Basecamp was launched, and the world noticed Ruby On Rails. (Bruce
Eckel wrote a great essay at the time about how this effected the thinking of
a certain portion of elite programmers:
[http://www.artima.com/weblogs/viewpost.jsp?thread=141312](http://www.artima.com/weblogs/viewpost.jsp?thread=141312)
)

Starting around 2005 there was a revolution happening in the land of the Java
Virtual Machine. Dozens of innovative new languages sprang up (among the ones
I worked with and admire: Groovy, Scala, Clojure). The tools improved
dramatically: for debugging and profiling, Java had long had the edge, and now
you could use those same tools with dynamic languages that were fun to work
with. Modern package managers arrived, which made it easy to assemble
libraries, and greatly reduced the benefit of PHP's all-in-one approach.

Many of the new languages offer a REPL to make it easy to play with the
language and assemble the code in a live environment -- this is even more
interactive than the fast edit/reload cycle that made PHP seem so special in
2000.

Meanwhile, PHP was going the other direction, towards more complexity. There
was clearly a desire on the part of the core PHP team to imitate aspects of
Java. I now work at a company that has a large CMS built with Symfony -- this
is a very large code base full of classes that have what I would think of as
"classic" OOP features such as variables with limited visibility outside of
the class. This is not a bad thing, but please note, PHP is now, in 2013, the
only language that I work with that gives me no way to automatically create
getters and setters for class variables. (Some of you will say Symfony has
tools that will auto-generate these classes for me, which is true, and if you
like having your code auto-generated from other sources, like YAML files, then
of course this is a fine approach.)

What drew me to PHP, in 2000, was its flexibility, ease of debugging, ease of
assembly (all-in-one philosophy) and the fast edit/reload cycle. It's
important to note that PHP is no longer the leader of the pack in any of these
dimensions. All of the same considerations that drew me to PHP in 2000 now
draw me to Clojure -- its a dynamic language that does not get in my way,
debugging is easy thanks to many debugging tools, assembly of parts is easy
thanks to Leiningen, which is an amazing build tool, and the fast edit/reload
cycle is replaced by the even better REPL experience.

What draws people to PHP now? I loved it once but I can not imagine choosing
it now.

~~~
Udo
> _What draws people to PHP now? I loved it once but I can not imagine
> choosing it now._

I choose it regularly, although to be fair I also do web projects in Ruby on
Rails or Node.js. To me there is no inherent reason not to choose PHP if the
nature of the project fits it, it often allows me to get stuff done very
quickly, with very little code, and (this might be surprising to some)
elegantly.

PHP's per-request execution model is a strength that is often overlooked by
people who are mostly using persistent application servers. Starting with a
clean environment at every request can be a huge advantage, especially in
large projects where PHP allows you to selectively load only what you need.
This can be used to severely limit code complexity and unexpected runtime
behavior (in addition to the more obvious points such as better resource
management).

Language-wise I wouldn't say PHP syntax is pretty, and the standard library is
very uneven. There's also some weirdness with the parser that should be fixed.
I hope there'll be a reboot that addresses these, but sadly this would
probably not come from the PHP core devs. At the same time, "recent" language
features have made developing in PHP fun again. For example, I couldn't
imagine doing PHP without anonymous functions.

On the flip side, some OO features are superfluous to the point of being a
liability. Also, and this is me departing from the party line even further
here, framework envy has bogged down PHP by zapping its strengths and
unreasonably emphasizing its weaknesses. With the exception of light-weight
MVC frameworks, more heavy-handed RoR "clones" and object-relational silliness
tends to kill performance and severely hinders developer flexibility. Of
course, some newbie developers probably _should_ be prevented from exercising
flexibility, but I'd argue that PHP isn't suitable for them in the first
place.

You said that PHP is going toward increasing complexity, but I'd argue that
this is more due to the proliferation of complexity in its ecosystem - which
ultimately comes from importing unsound ideas from other languages just for
the sake of making PHP development seem hip and legit by (badly) emulating
counterproductive features. Again, this might be unpopular, but for example:
why should a PHP app use a templating engine when PHP itself is one? I can see
this is justified when unprivileged users are editing the templates, but this
case can't possibly account for all the Smarty (and worse) misuse that is
happening all over.

People like to switch between languages and frameworks as if nothing changed,
but I'd say they're wrong. Building stuff in Node.js is fundamentally
different from Rails, which is fundamentally different from PHP. Use the right
tool for the job, don't bend runtimes to do something they're unsuited for.

~~~
krapp
_why should a PHP app use a templating engine when PHP itself is one?_

It's just cleaner, and makes it easier, visually, to separate layout from
code. Wordpress seems to be a good example of the opposite case -- it switches
directly between PHP and html and there are no 'templates' to speak of, in the
way Smarty/Twig etc. people would think of them. It is 'closer to the metal' I
guess but also for anyone who's had to edit a theme, really ugly.

Personally I find just not having to worry about context with opening and
closing PHP tags and echoing variables (and manually escaping everything)
worth the extra bit of abstraction involved with a templating system, which
will do the work for me.

~~~
Udo
_> It's just cleaner, and makes it easier, visually, to separate layout from
code._

That's true, and I think PHP would be better for it if there were three kinds
of files by convention: pure code, layout, and entry points that are actually
callable (the other two shouldn't be invokable by typing in their URL). It's
trivial to configure a webserver to handle them differently, but it's
impossible if you're writing code that needs to run everywhere.

However, I would not say that {$blah} is _that_ much more readable than <?=
$blah ?>, not to the extent that the complexity and cost of running a separate
engine is justified.

~~~
krapp
Depending on how the code is structured, it might not matter much either way
in terms of legibility (assuming the sight of something like

    
    
        if($foo){ 
        ?>
        <b> <?php echo $bar; ?></b>
        <?php 
        }
    

doesn't set your teeth on edge to begin with), but I do think the former is
easier to _type_ and maintain which in PHP to me counts for a lot.

Then again I never use the short tags so i'm adding at least those three
characters of overhead per variable anyway. Also, having the views inline
couples them to whatever logic they happen to be in, so the templates are less
portable. A lot of templating engines will meet you halfway and compile down
to classes so they don't reinterpret the templates each time. YMMV I guess.

~~~
Udo
Yes, but _if_ you're using short tags, things can be better ;)

    
    
      <? if($foo) { ?>
        <b><?= $bar ?></b>
      <? } ?>
    

True, it's not as nice as a templating language, but then again, it doesn't
have the aforementioned limitations either. Inlining views is a choice, it
tend to avoid this. Just because templating engines prevent this pattern
doesn't mean you'll be forced to use it in plain PHP.

Re-interpreting templates is also an interesting case. Of course, native
templates will pretty much always be faster so the need to cache isn't as
pressing. But still, with the built-in output buffer functions it's easy to do
something like

    
    
      do_some_caching(function() {
        include('sometemplate');
      });

~~~
krapp
I was playing around with Slim framework recently and I 'discovered' the
option in the PDO driver to fetch into a class. Add a parent class to the data
classes (with magic setters and getters, having the getter wrap everything in
htmlspecialchars)[1] and you really can, probably, accomplish most of what a
lot of templating systems do (and a good chunk of MVC with the serial numbers
filed off) with a fraction of the code in most frameworks and, say, Twig.

Even static caching probably, using output buffering.

[1][http://stackoverflow.com/questions/8898794/using-pdofetch-
cl...](http://stackoverflow.com/questions/8898794/using-pdofetch-class-with-
magic-methods)

------
arxpoetica
Node.js is notably absent.

~~~
throwaway420
JavaScript is listed there, though I don't understand it's relatively low
ranking given that virtually every website uses it.

~~~
petepete
A puzzling list in general; there are surely more Ruby and JavaScript
developers than there are Perl and Visual Basic.

Github's trends offer a different viewpoint:
[https://github.com/languages/](https://github.com/languages/)

~~~
degroat
Github's numbers are going to be biased towards programmers who use languages
that are more progressive. .NET developers aren't using Github and neither are
many older companies that are still using self-hosted SVN and CVS repos.

~~~
earlz
".NET developers aren't using Github" says who? I find about 80% of open
source projects for .Net on Github. With the other 20% being split between
codeplex, sourceforge, Google Code, and self-hosting/publishing

~~~
pjmlp
Open source is the keyword.

Most corporations would faint just with the idea of hosting their code outside
premises.

------
joebeetee
C'mon Actionscript!

