Taking PHP Seriously | Hacker News Reader

Taking PHP Seriously

infoq.com

59 pointsArabGeek40 comments

With an optimizing compiler to boost its performance, I think PHP would still benefit from two things:

1) A resource like "PHP - The Good Parts", that guided developers through the dos and don'ts of the language at an early stage.

2) An overlay language (like Coffeescript over Javascript) that effectively hides the bad parts, but that might also be extended to bring some consistency to the library APIs (even a bunch of aliases that used consistent naming rules would help).

I'll admit that I have written anything serious in PHP since the late '90s but those are the issues we had bring new developers up to speed.

1) sort of exists in http://phptherightway.com/

2) There's been a couple of these, most recently Mammouth[0], but personally I don't think that's useful - the syntax is more or less OK. I do think that renaming the core functions and then providing an alias/compatibility library would be beneficial however.

Personally, the most inviting part of HHVM for me isn't the performance, it's the alternative team that seem willing to develop the language more in-line with what users want.

[0]: https://github.com/btwael/mammouth

>>> I do think that renaming the core functions and then providing an alias/compatibility library would be beneficial however.

Totally agree with that. In the real world, one is normally using some sort of framework which hides most of the language quirks (inconsistent naming, order of parameters, etc). And the cases, when you need to use quirky native functions, are rear enough so that introducing additional layer where bugs might occur is not beneficial enough. So I'd focus more on picking the right framework (both philosophically and technically) rather than on focusing on a new language.

Why I mention frameworks that much? Because in the of majority cases, applications are just some CRUD with a bit of logic and going with flat php + some home made libraries is just waste of time.

Also about 2), haxe: http://haxe.org/doc/start/php

For 2) there is https://github.com/runekaagaard/snowscript

I also wrote one for fun at http://cretz.github.io/pratphall, but I have come to the conclusion that cross compiling to PHP isn't practical. The whole point is that it's easy to write and see the results right away.

why an overlay ? PHP is a server-side language, it doesnt need an overlays, it needs fixing.

It's not like javascript where you dont control the client, you control everything that is running on your servers.

HHVM is good for Facebook,though i fail to understand how they could not migrate to any other serverside language given the number of developpers they hire, unless the legacy code is an unmaintainable,unreadble mess. Twitter did it(rails to jvm).

Giant rewrites don't have the best track record of success. Other than language aesthetics, what would be the justification for undertaking that enormous cost and risk? I despise PHP but I wouldn't make that call.

Why can't something like PHP to Java be done? It's been done for everything to Javascript.

That way they could simple move PHP to the other language, and write whatever new in the other language?

I'm sure it could be done, but if it's working this way (and it does seem to be working), why bother?

> 1) A resource like "PHP - The Good Parts"

Not exactly the same, but "PHP - The Right Way" [1] is a good starting point.

[1]: http://www.phptherightway.com/

Why are we so masochistic?

We invent bad languages, they spread everywhere like plague and then we're like "hey, let's create an overlay language to hide the hideousness". It's insane.

Bodging up old crap is part of the industry. We now use HTTP mostly for asynchronous RPC, TCP streams for reliable datagram protocols that suffer from head-of-line blocking as a result, and a scripting language thrown together for basic form validation as the focus of intense JIT development and back-end work. Oh, and let's not forget NAT and bodging HTTP/2 (which fixes HOL blocking) to, likely, only exist over TLS on TCP port 443.

Facebook were forced down the road of supporting PHP because, just like everyone else everywhere else, they found it is several orders of magnitude more expensive to bring good features and lessons learned to a completely new language, stack or framework.

Its kind of awful that new projects will see this as a new lease of life for PHP, rather than life support, but that's just inevitable. I guess it's both.

In many cases, PHP very definitely being one of them, what we ended up with wasn't invented at all: it grew organically for a while from something much smaller (or sometimes even something quite different). People use it because it is good enough and additions keep being made with little call for standards until you have a huge pile of stuff that many people are relying on. At this point a proper redesign from the ground up is impractical, you have to make step changes, so fixing the mess takes a long time.

PHP was not initially intended to become what it has: it wasn't invented to be what it has turned out to be. But don't complain too much: dealing with that sort of legacy is what keeps some of us in active employment! (not them I'm implying anyone causes these issues on purpose, you'd have to be both a special sort of evil and a special sort of intelligent to create PHP4 (I've not used it since then, things may have improved massively recent years (they were certainly promising to) and I'd be non the wiser) with all its problems on purpose)

2) In "Taking PHP Seriously" (http://www.infoq.com/presentations/php-history) it's discussed a language called "Hack" that seems to be exactly what you are talking about. But the link (http://hacklang.org) is redirecting to hhvm page now...

Going JIT seems to be the common way of the scripting/bytecode-compiled languages.

Java -> HotSpot, Python -> PyPy, Javascript -> V8 and friends, PHP -> HHVM

Lisp and Smalltalk were the first ones.

McCarthy is mentioned for that, but I guess more work on that was done in the Smalltalk and Self context.

Since quite some time most Lisp systems don't use a JIT. They compile the code ahead of time or explicitly incrementally.

> Since quite some time most Lisp systems don't use a JIT. They compile the code ahead of time or explicitly incrementally.

I am aware of type hints, but given Lisp's dynamic nature, wouldn't a JIT provide more optimized code than AOT?

It would be nice if they just reinvented PHP. Get the top 20 major frameworks behind them and fork it.

They're proposing essentially that: start at the 24th slide http://www.slideshare.net/zerutreck/taking-php-seriously-kei...

The smart part is that it's opt-in so you could gradually migrate a large project in-place. The only question would be whether they've broken compatibility with standard PHP or if it's simply stricter — it'd be really easy to get major projects to switch if it was like JavaScript's "use strict" where you can develop in strict mode but run on a legacy runtime.

I'll have to take a look at the Hack language. I've always wanted to try PHP, but I've always been deterred by the cruft (same reason I avoid Java).

That would probably result in the same situation as what we have with Python 2 and 3.

Previous discussion:

https://news.ycombinator.com/item?id=7054294

Is there a "how to" in using this with PHP framework X?

Perhaps HHVM just need to be installed and then a change to your Nginx/Apache config needs to happen?

Serious kudos to FB and the developers who are making this happen!

if you are discounting this discussion on account of not being interested in the VM consider it's also quite interesting for the way they changed the language.

E.g. gradual typing with type inference, generics, closures, nullable types, generators and a lot of static checks and removals of "arguably dumb" php features.

What is different from the intermediate code HHVM generates and the code that OPcache/apc stores? Is HHVM always faster compared to code that is cached in OPcache/APC?

An opcache code just stores the bytecode so you just avoid the parsing step in each request. It does not inherently optimizes anything, although it has been tried with APC in the past (but finally abandoned). I don't know what's the status with the new official opcache and optimization.

tl;dr what is HHVM and why should I care as a PHP developer?

It's an alternative PHP runtime. It no longer compiles PHP to C++ (it's predecessor hphpc), instead it uses a JIT compiler which gives it better performance over standard PHP, without requiring a compilation step. It's mostly compatible with the standard PHP syntax/stdlib.

It offers an alternative syntax that allows you to give return types of functions, which can give you further speed improvements. There's also a few additional features (for example, it supports similar hinting to the recent ArrayOf RFC).

It's worth checking out, but probably not worth using in production yet - they're working on getting the top 20 frameworks to pass their unit tests in HHVM[0], so there's a good chance your existing apps will run.

[0]: http://www.hhvm.com/blog/2813/we-are-the-98-5-and-the-16

Phalcon is noticeably absent from that list. Do they have any intention of supporting that, too?

Unless you are running something custom/unsupported, if you are using nginx/php-fpm you can just replace it with the HHVM FastCGI and get it to run your code really really fast.

It's great as it makes everything run a lot quicker for clients who use PHP, especially if you have code that needs to be run in PHP on the command line.

Just run it and see :).

Well, it doesn't support mysqli_, which is a very common family of functions, especially since mysql_ is being deprecated. But a lot of stuff does run, as long as it doesn't need mysqli_.

HipHop Virtual Machine, it "compiles" PHP into C++. Though it needs to be written in a certain way to work correctly as I understand it.

You're mistaking HHVM with HPHPc.

They're both Facebook projects and one grew inspired by another, but they use different approaches.

It doesn't need to be written in a certain way, there may be new features in recent releases of PHP that don't work on HHVM but the HHVM folks are pretty quick to add in support for those features. Here is a little library[0] I wrote in PHP and this is tested on HHVM using Travis (see .travis.yml). I haven't had to write the PHP any differently, it just works (although it's an incredibly small library).

Edit: The speaker in the video also mentions that they have taken the test suites from the top twenty PHP projects and they test them against new releases of HHVM, further confirming that the syntax requires no special attention except for new language constructs.

[0] https://github.com/unfunco/bijective

It`s a jit-compiler for PHP. Code is compiled once to an intermediate representation (like Java) which makes execution faster on subsequent request.

Code does not have to be written in a certain way most of the time because hhvm is 98% compatible to all major PHP-Frameworks[1]. It also features a built-in webserver alltough static performance is lower than nginx.

[1] http://www.hhvm.com/blog/2813/we-are-the-98-5-and-the-16

No, it does not compile to C++, but to bytecode. HHVM's predecessor converted PHP to C++, though.

What's the difference between that and APC? The performance, or is there something else?

Confession: I haven't listened to the OP yet.

Somehow an asm.php

Reply on news.ycombinator.com