P++ idea: FAQ

https://wiki.php.net/pplusplus/faq

by tnorthcutt • 7 years ago

167 91 7 years ago

wiki.php.net

qwerty4561272• 7 years ago

dynamic, with strong BC bias it could be more daring with BC

What is BC?

no_wizard8• 7 years ago

Backward compatibility in this context.

qwerty4561272• 7 years ago

Thanks. I have used the "backward compatibility" term many times but never abbreviated it nor seen it abbreviated. The only idea that comes into my mind when I see "BC" is "Before Christ" which actually feels pretty much relevant :-)

Indeed they should really have spelled it out first and only used the uncommon abbreviation for subsequent occurrences.

hn_throwaway_99• 7 years ago

I upvoted you, because I had the exact same question, but I also wanted to comment. It seems SOOO common, especially for technical writers, to overuse, or invent, acronyms and to expect that people automatically know what they are talking about. I've been in software for about 20 years, I'm very familiar with the concepts around backwards compatibility, but I have never seen it abbreviated 'BC' before.

If you want to use uncommon acronyms, please be sure to spell it out (e.g. "backwards compatibility (BC)") the first time you mention it.

mjburgess3• 7 years ago

I really struggle to see what the case is for PHP anymore.

I maxed out '04 to '14.

After working in a dozen other languages, the only motivation left seems to be sunk-costs and job-market openings.

It's so domain-specific that you're hamstringing yourself in the future.

That you'd create a new language out of PHP just seems mad.

Who's the audience?

The pragmatic (market) motivations don't exist.

no_wizard8• 7 years ago

I agree with this. I'm struggling to get out of my current role/job right now, because I want to move away from PHP (I'm really growing to dislike it as a whole, and in my personal experience have some very negative connotations around the development practices of the PHP developers I deal with on a day in day out basis)

I been looking at C#, what did you find was easy to translate to quickly?

mjburgess3• 7 years ago

Might seem cliche (?) but Python.

Ignore all the java lipstick that went on after PHP5; PHP doesnt work like a static language and C#/Java really quite different.

Python fits the mental model of PHP far more closely, in that everything you expect to be able to do easily (dynamic dispatch, OO, closures, etc.) are easy. And everything hard (mixins, metaprogramming, etc.) is about as hard.

Most things are easier.

C# may seem more "grown up". From a PHP-culture perspective "Java OO" is grown up, and "procedural C" is babyish. That has more to do with PHP3 vs PHP5 than either Java or C. The latter of which, as with python, includes the best programmers in the world.

From a web job-market perspective I can't say. I got into data science a few years ago, and haven't much contact since. C# may make more sense; it would have back when I was in the area.

lainproliant• 7 years ago

Back in 2008, I chose PHP for my first forays into web programming because of how easy it was to setup and use compared to other solutions I was aware of. The last time I touched it was back in 2011. Python has pretty much completely replaced PHP for me. Get a good basic web framework like CherryPy or Bottle and couple it with a templating engine like Jinja2 or Mako and you can do anything you could do in PHP, but in a better ecosystem.

oraknabo• 7 years ago

I switched from PERL & ColdFusion to PHP back in 2000 and stuck through every version up to 7 for web app development. I've built apps in both Python and C# (mostly game projects) but never got comfortable with either as a web development language.

It was only when I started working in Go a few years back that I was able to completely walk away from PHP. There is literally nothing I was doing with PHP that I can't do in a more satisfying way with Go and I like compiling everything into a single binary when I'm ready to deploy.

nicoburns• 7 years ago

Modern PHP is one of the fastest dynamic languages, has one of the best gradual typing systems (IMO almost competitive with TypeScript - TypeScript type system is better at static typing, but doesn't catch runtime errors), and a fantastic community around Laravel/Symphony.

mjburgess3• 7 years ago

Those are upsides.

For a dynamic language, i'd want:

* A REPL

* A language-browsable std lib or trivial reflection

* A consistent API where expectations are reusable

* eg., polymorphic operators "do the right thing"

* Optional typing

* Typing, when present, facilitates polymorphism

* Data processing handed off to fast VM plugins

* Target of major trans-lang libraries (eg., Spark, et al.)

* Good long-running performance

* Community preference for minimalism and clarity

* Easy package management

* Modern functional primitives (eg., comprehensions)

* Modern OO primitives (eg., extension methods)

* Modern metaprogramming primitivates (eg., reified classes)

And probably others. Each poorly provided feels like taking a big step back; and just an injury to my productivity.

I'm not sure I'd get over how manically procedural PHP is; how sequential by nature. Every OO or functional addition runs against its grain and feels random and accidental.

open-source-ux• 7 years ago

"I really struggle to see what the case is for PHP anymore."

PHP started as a language for creating dynamic websites and that's still it's forte. I'm not a fan of the language, but it still retains advantages over it close rivals Python and Ruby when it comes to creating dynamic websites. It's faster than those languages, and its popularity means you can find web development libraries for just about anything.

It's also the only language with almost universal support amongst web hosts. It can run on basic shared hosting plans and on nearly every server. It can be deployed by simply uploading your code to a directory on your web host. Many developers (especially of other languages) vastly underestimate how important this is or the opportunities it unlocks.

It's 2019 and if you want a simple [1] way for your non-technical users or customers to self-install your software on a web server, you are simply out of luck.

Having a ridiculously easy web app installation process for servers would unlock countless opportunities for developers to reach more users or customers. But developers simply can't see it.

Isn't it kind-of crazy that web-friendly languages like Python and Ruby are anything but simple if you want to bundle and distribute your web app for easy server deployment?

By the way, here's an excerpt from a blog post by programmer Jeff Attwood:

"If you want to produce free-as-in-whatever code that runs on virtually every server in the world with zero friction or configuration hassles, PHP is damn near your only option. If that doesn't scare you, then check your pulse, because you might be dead."

To broaden choice, Attwood argues we should

"build compelling alternatives and make sure these alternatives are equally pervasive, as easy to set up and use as possible."

That was written in 2012 (https://blog.codinghorror.com/the-php-singularity/).

[1] Docker images / Cloudtron / Sandstrom / list of command line instructions - sorry, these don't count as simple.

no_wizard8• 7 years ago

It's faster than those languages, and its popularity means you can find web development libraries for just about anything.

In reference to Python:

Faster how? For non-trivial workloads, I have consistently found that pure Python is faster with async/await than PHP

I have not tested django/flask but I imagine that holds up, especially when using gunicorn.

For reference, these benchmarks seem to support my experience: https://github.com/the-benchmarker/web-frameworks

maxk42• 7 years ago

The people who wanted strong static typing have already left PHP. I don't think they're catering to their userbase.

probablybroken• 7 years ago

The PHP base is huge, I've known many good PHP developers who prefer stricter implementations, but work with PHP because they get paid to, and because they know the language and libraries end up using it for new projects. This proposal provides a gradual migration path for those users, and makes adoption a lot more likely.

muglug6• 7 years ago

A lot of people can't easily leave PHP, because they work at companies that use it. Tools like [Psalm](https://psalm.dev), [Phan](https://github.com/phan/phan) and [PHPStan](https://github.com/phpstan/phpstan) have cropped up to help users deal with PHP's slight type system.

paulddraper2• 7 years ago

Maybe not their current userbase.

But things are always changing.

atdt• 7 years ago

It's a little galling that the proposal makes no mention of Hack (https://hacklang.org/), which is also an evolved PHP with static typing that is designed to coexist with PHP 5/7 code on top of a single runtime (HHVM).

Edit: as noted below, since I made this comment, a new section has been added to the doc about this topic.

no_wizard8• 7 years ago

It does make a reference to it further down from the synopsis.

The difference here I think is that most of the PHP community seems to abandon support for Hack, so Hack (as far as I can see. I am happy to be corrected) in the wild is more or less contained to Facebook and its properties. I think a couple of large companies like Slack use it in some places too, but its mainly been disregarded by the broader community (none of the largest frameworks support Hack anymore, for instance).

Which makes sense why Hack is no longer developing with PHP compatibility in mind.

spullara• 7 years ago

Slack is also a large scale user of Hack:

https://slack.engineering/streamlining-your-workflow-debuggi...

Jwarder• 7 years ago

Perhaps they updated the file. I see a "This is Hack all over again, isn't it? Why would it fair any better?" section about 3/4 down.

Was Hack a pain to setup? Getting P++ "for free" with PHP 8 seems convenient.

bryanlarsen• 7 years ago

https://wiki.php.net/pplusplus/faq#this_is_hack_all_over_aga...

skrebbel3• 7 years ago

If they pull this off I just might return to PHP for a lot of work.

I love PHP's pragmatism, I love that it's batteries included, and most of all I love the deployment story. It's basically zero-config AWS Lambda without vendor lockin. If they manage to split off a better language without splitting up the community like Python 2/3 or Perl 5/6 did, then that's a spectacular win in my book. Having a little header on top of each file is real nice (and it also opens the door for mixed PHP/P++ projects, another thing Perl and Python failed at).

I find it telling that the PHP community keeps getting this sort of stuff right (they also got the php4->5 migration right back in the days, through collective community action; they fixed the error that was PHP 6 before it was too late, and so on). Pragmatism to the max, things have to not just keep working, but also stay convenient (like Hack wasn't).

codesushi4213• 7 years ago

How is PHP pragmatic compared to other languages? Do tell.

whatshisface• 7 years ago

Instead of having a trillion build steps, you write PHP right in the HTML.

72deluxe2• 7 years ago

I do not mean to be rude or offensive but are there plans to fix the half-baked type system?

I am using PHP7 at work and the ability to annotate functions with types is a good idea until you get arrays which can take anything (so you can have an array of who-knows-what) so you can't assume further down the call stack that you're dealing with a known type so have to test what you're dealing with, or objects.

It's a bit of a mess to me and makes reading the code very difficult without running it in a debugger to step through what you're dealing with. Generics or some form of strong typing (which seemed to be what the type annotations and return value types hinted at) would really help, particularly with large projects. I am coming from a C++ background.

Any pointers or tips or documentation for me would be welcome.

If P++ pushes some of this strictness further onto the language then great. It saves me having to do it in code.

muglug6• 7 years ago

until you get arrays which can take anything

There's a widely-used PHPDoc standard for annotating arrays: `Foo[]`, and there are at least three PHP static analysis tools that can correctly interpret those annotations: Psalm (https://psalm.dev), Phan (https://github.com/phan/phan) and PHPStan (https://github.com/phpstan/phpstan).

Phan and Psalm also support a docblock syntax for generics - I wrote about it here: https://medium.com/vimeo-engineering-blog/uncovering-php-bug...

stcredzero3• 7 years ago

The first likes PHP roughly the way it is - dynamic, with strong BC bias and emphasis on simplicity

Personally, I have a strong AD bias. Seriously, though, what does this term mean?

EdwinHoksberg• 7 years ago

BC = backwards compatibility

skrebbel3• 7 years ago

Backward compat - something that's been pretty holy in PHP land for ages and hence got abbreviated in the internals community. Pretty fair IMO to abbreviate something that's so core to a language's vision. Don't forget that HN isn't the target audience of this post: it's people who are involved with PHP internals.

stcredzero3• 7 years ago

Pretty fair IMO to abbreviate something that's so core to a language's vision.

When talking to the faithful, sure. Language communities need to constantly fight against a tendency towards navel-gazing and only wanting to talk to the faithful.

muglug6• 7 years ago

There's a long discussion of the FAQ in the internals mailing list: https://externals.io/message/106503

It's important to understand that this is just a proposal from a core PHP developer - at the moment it seems that most other prominent core developers aren't enthusiastic about this particular approach.

codesushi4213• 7 years ago

There's already a statically typed version of PHP, it's called Hack.

Why anyone would use any variation of PHP for a new project in 2019 is simply inconceivable.

alexhutcheson3• 7 years ago

Somewhat surprisingly, the main PHP implementation has made huge performance improvements since Hack was released in 2014, and has actually become one of the fastest mainstream scripting languages.

Speed + ubiquity in shared hosting environments + a huge corpus of existing frameworks and code make it pretty attractive for web applications, especially of the CRUD/CMS variety.

echelon2• 7 years ago

shared hosting environments

I see shared hosting and VPS eventually going the way of the dodo now that cloud hosting is mainstream. Has the market seen any growth recently?

codesushi4213• 7 years ago

Speed is irrelevant because Hack is compiled.

Shared hosting environments are also irrelevant in 2019.

alexhutcheson3• 7 years ago

I think proponents of this change are dramatically underestimating how difficult and limiting it will be to maintain seamless interop between two dialects of a language. Interop between languages is hard, and many of the features and changes that you might like to add to a "P++" would make it either expensive or verbose to call or be called by "legacy" PHP. Ultimately I think this could go one of two ways:

A. The "P++" effort ends up hamstrung by the need to maintain seamless interop with "legacy" PHP, and is therefore only able to implement a small subset of the clean-ups and enhancements they envision. It's not clear that this is better than continuing to improve PHP in a backwards-compatible way.

B. Changes to P++ make it so that interop with "legacy" PHP is either very verbose (specifying types, casting, etc.) or incurs a heavy runtime cost. To avoid this, most significant PHP libraries get a P++ clone, and the language effectively forks into two separate communities.

It would be awesome if it's possible to avoid this, but I haven't seen a specific technical proposal for a significantly improved language that maintains seamless interop.

tottenhm• 7 years ago

The same concern definitely crossed my mind as a reader, but I think the coloring of the critique should be less #000000 and more #888888. A lot depends on the technical goals of the "P++" variant - and on the culture among the language maintainers.

* If everyone generally views both language frontends as equal and shared responsibilities with valid technical rationales and only some specific/reasoned differences, then it's probably sustainable.

* If the team becomes polarized, or if one subteam wants to substantially reinvent their language ("Let's make it purely functional too! Bring on the monads!"), then yes... they'll feel hamstrung.

It might be interesting for them to consider comparisons with other systems that support multiple language frontends, e.g.

* GCC supports C and C++ (not to mention C++11, C++14, ad nauseum).

* HHVM support(ed) PHP and Hack

* JVM and CLR both support a range of language frontends.

My guess is that GCC is a more favorable analog (it feels normal+realistic to support C99 alongside C++11 and C++14). JVM/CLR seems like an unfavorable analog (they've supported many very different languages... but involve many large teams and diverse technical specs).

HHVM is probably the most pointed analog. It's just... mixed. On one hand, HHVM succeeded in supporting two similar languages for a long time (in spite of significant idiosyncrasies of PHP). On the other hand, HHVM eventually gave up on PHP and went pure-Hack. But (as an outsider) I'm not really sure the reason. It could be that they got boxed-in on a technical issue of language-interop, or it could be they got boxed-in organizationally (being a separate team maintaining a secondary implementation amid a continuous drip-drip of external changes - not a great position).

I interpret the original link above as basically an assertion (crude paraphrase): "The HHVM folks were broadly right about PHP and Hack and technology and all that; but their implementation hasn't succeeded on organizational grounds, and we-here can do those organizational things better."

muglug6• 7 years ago

By providing PHP-backwards compatibility HHVM, Facebook provided an off-ramp for themselves and other existing PHP users at a time when HHVM was much faster than the PHP interpreter.

But then PHP sped up, and once it became clear that people had stopped using that off-ramp, Facebook demolished it. The off-ramp was infeasible to maintain, and of no benefit to anyone.

paulddraper2• 7 years ago

Libraries come to mind as a point of concern.

While one do library authors target? Does it split the ecosystem?

As long as one is a subset of the other, this works. If it's a Venn diagram, it hurts.

burk962• 7 years ago

I'm very interested in this and will be watching to see where this goes. I've just started PHP this summer as an intern at a company that uses it. At first I was really put off by the language, I had never seriously worked with either web languages or languages that used dynamic typing. So many things seemed strange, dated, or even just plain wrong. On top of that, the official documentation is often confusing as far as best practices go and the ~20 year old comments can only add to confusion (though it is neat when one helps out).

All that said, I've come to enjoy the language for what it is. It works seamlessly with HTML/CSS and can provide so much function with little effort put into configuration. Nearly everything I need to be done can be accomplished without frameworks or libraries, maybe just Bootstrap's CSS to make things pretty enough for the end user.

I could see P++ being useful for PHP as a chance at rebranding. PHP horror stories had made me believe it just had to be bad language. If P++ brings all of the good of PHP along with typing and better syntax in general, I believe it would be a much easier sell to devs in a situation like my own.

porker2• 7 years ago

At first I was really put off by the language, I had never seriously worked with either web languages or languages that used dynamic typing. So many things seemed strange, dated, or even just plain wrong.

Did you keep a list of these things? That would be really useful to have, because the discussions on the internal mailing list end up saying "We need to talk to users and find out how they found it" and never do...

burk962• 7 years ago

No I did not make a formal list, but I probably have some gists from when I started that could jog my memory a bit. Where would be the best place to provide feedback?

goatlover2• 7 years ago

I don't get the push to add static typing to dynamic languages. If you don't want to use a dynamic language, then use one of the statically typed ones, like Java, Typescript or Go. If it's a case of dynamic languages not scaling well beyond a certain point because of the lack of static typing, then right tool for the job should apply. Don't scale a dynamic language to that size.

_hardwaregeek• 7 years ago

It's mostly from companies with existing codebases built using dynamic languages. Plus everybody's standards for tooling are going up and one of the best ways to improve tooling is through types.

goatlover2• 7 years ago

It's the same argument for continuing to manage Excel applications as they scale up to complicated messes.

eitland• 7 years ago

Try Typescript and see.

Pushing for static typing in dynamic languages means you can have the best of both worlds.

Example: Any valid js file can also be a valid ts file, but now you can also introduce types, vastly reducing mental load since you always have a polite unpaid pair programmer (the type checker + language server) to help you.

throwawaysixthg• 7 years ago

I see a lot of comments defending PHP with arguments about how fast it is.

They may be right about the PHP7 implementation generally executing faster than most popular Python or Ruby implementations, but they're really missing the point when we're talking about languages and language design, which is what these conversations are really about.

Languages aren't fast or slow, implementations are fast or slow (and all to varying degrees in various contexts).

Implementations are also limited in how much they can impact speed, because the speed of execution is primarily a function of the code, how it's written, and sometimes input size (not how it's executed). In other words, speed improvements derived from implementation optimizations are generally constant-time improvements, not improvements that scale with code complexity or input size.

That means speed of implementation is mostly a concern of certain specific domains where milliseconds really matter. A few of them are HFT, computer graphics, UI rendering, systems programming, etc. Outside of that, code and system design optimizations will be far more fruitful than implementation optimizations.

PHP's design is so intertwined with the HTTP request-response lifecycle that it has been (pretty much) completely and permanently relegated to a very narrowly defined set of use cases, mostly template rendering (or more organized code in the same vein as template rendering, WP, most Laravel projects, etc) and HTTP APIs.

Nearly all PHP use cases involve network latency for every user interaction that makes it past caching layers (to where it's actually executed by the PHP7 interpreter). Allowing network latency to impact user experience for every user interaction (which is practically the only thing PHP knows how to do) isn't acceptable anymore in 2019, and the solution is client-side rendering (JS/V8/webkit/blink/etc). PHP cannot (could not) solve that, because no matter how much you optimize it, it will still take 500ms of network latency to reach the user's browser.

So there's really no use case or domain where PHP is the correct choice if speed of execution is a primary concern, and that would continue to be true even if you made PHP's interpreter run as fast or even faster than V8. The language's design is inherently incompatible with use cases that care about speed, because of how deeply in bed it is with HTTP request-response lifecycle.

What this leaves us with is a language that is only functional in environments and use cases where implementation speed does not matter.

PHP's marriage to HTTP request-response lifecycle has also had the effect of enabling bad coding practices at the interpreter level, because when no process lives longer than a few seconds, a lot of things that should matter just stop mattering. This is why very few people have ever tried to use PHP outside the context of HTTP, and those who have returned with the worst kinds of horror stories.

What that leaves us with is a language that can't even reasonably be called a general-purpose programming language.

And through all the efforts to save PHP from these problems, what are we trying to save? The most inconsistent, cluttered, disorganized and ugly syntax and standard library of any prevalent modern language.

I understand that a lot of people have to work with PHP, that good communities can form and be sustained around that, and that some people can even like it. But if there's going to be any semblance of objectivity in any conversation about language design, it has to be agreed that PHP is a terrible language.

A language that served a great purpose and arguably accelerated the success of the web to a historical degree, but not a language that still needs to be here in 10 years.

theodorejb• 7 years ago

The language's design is inherently incompatible with use cases that care about speed, because of how deeply in bed it is with HTTP request-response lifecycle.

Maybe I'm misunderstanding you, but it sounds like you're saying that speed doesn't matter when responding to HTTP requests. This couldn't be further from the truth. The less time a response takes, the more requests can be handled per second, which is critical for scaling Web services. PHP 7.x handles 2-3 times as many requests per second on the same hardware compared to PHP 5.

Also, I don't agree that PHP is only suitable for responding to network requests. I've also found it ideal for writing CLI programs which can run on a schedule and share logic with HTTP APIs.

xiaodai• 7 years ago

Sounds like python 3 saga all over again, but in php land.

toxik• 7 years ago

I disagree, Python 3.x was always meant to be the next version of the language. This seems to intentionally not take that position because the dev team can't settle on which way to go. Python 3.x was difficult to pull off, but it happened, and I actually think it was a bit too conservative with its changes. This would be a parallel language built-in to the same tool.

It'd be kinda like if there was a way to declare your Python code's major version, and then having Python being able to run either.

foobar_• 7 years ago

Rewrite is always a terrible idea. Doing it inside out is an awesome idea.

P++ idea: FAQ

Related Stories