# P++: FAQ

- Thread: https://externals.io/message/106503
- Original archive: https://news-web.php.net/php.internals/106503
- Started by Zeev Suraski on 2019-08-09T19:54:31+00:00
- Messages: 34
- Page 1 of 2: messages 1 to 25 (25 per page, add `?page=N` to the URL)
- Next page: https://externals.io/message/106503.md?page=2
- Reply by email to internals@lists.php.net
- More for agents: search with https://externals.io/search.md?q={query} · RFCs at https://externals.io/rfc.md · JSON API at https://externals.io/api · documentation at https://externals.io/llms.txt

---

## #106503 — Zeev Suraski — 2019-08-09T19:54:31+00:00

URL: https://externals.io/message/106503#106503

During the discussion of the P++ proposal (
https://externals.io/message/106453), it became painfully clear that this
idea did little, so far, to bring peace to the galaxy.

However, based on a lot of the feedback, both on internals@ and elsewhere -
it seems that a lot of people simply didn't really understand what this
idea was actually proposing to do.  I'll take the blame for that - by not
making the idea sufficiently clear.

I went on and create an FAQ, that attempts to address many of the questions
and common misconceptions that repeatedly came up.

It's available here:  https://wiki.php.net/pplusplus/faq

Before you read it, I want to stress that this is an attempt to
provide *everyone
with a good deal, and nobody with a raw deal.  *It doesn't mean it's
successful at that (although I think it is) - but the motivation is clean
and positive.  If & when you read this FAQ, please try to read it without
any preconceived notions.

If there are additional questions that you think are missing, please let me
know - or better yet, if you're up for constructively adding them - go
ahead and do that.

Thanks,

Zeev

---

## #106505 — Mark Randall — 2019-08-09T20:27:21+00:00

URL: https://externals.io/message/106503#106505 · In reply to: #106503

> It's available here:  https://wiki.php.net/pplusplus/faq

I am now even more confused.

How is this drastically different to Nikita's suggestion of setting a 
compiler version via rust-like version declares?

It seems to me that it's just moving the version definition to a tag 
instead of a declare, and having a "Anything and everything new" version.

Is there a major difference I'm not immediately seeing?

Mark Randall

---

## #106506 — Sara Golemon — 2019-08-09T21:02:50+00:00

URL: https://externals.io/message/106503#106506 · In reply to: #106503

> It's available here:  https://wiki.php.net/pplusplus/faq
>
>
It's possible I missed something while on holiday. There are certainly a
lot of messages to page through.  I dig the idea of resolving this
tug-of-war between progress and BC, but I'm not 100% clear on what the
final goals are.  I understand that we're talking about more aggressively
breaking BC in this new mode while preserving BC in "normal" PHP files, but
I think it would help the conversation if we enumerated specific aims.

Some guesses on what we're talking about:

1. Short open tags.  This is probably the ugliest nut to crack since it
can't even be guarded on a declare directive.  Adding a new open tag
doesn't really fix that though, it just changes the specific shape of the
problem.  Unless you add an INI for disabling PHP mode.

2. Strict(er) typing - I'm not sure, on the surface, what future expansions
we'd plan for in this area which couldn't fit into standard PHP in a non
BC-breaking way.

3. Failing closed. Things like `strpos()` being able to return int(0) which
is a falsey value. This has been a long standing "complaint" about PHP
which isn't actually "fixable" without a big BC fail.  We've already shown
we're willing to bite this bullet for security issues
(openssl_random_bytes).

4. Argument order/Naming consistency. I have little respect for this
complaint about PHP, but perhaps this is an assumed goal?  If it is, then
the reusability of the majority of the runtime comes into question since
anything we "fix" in P++ needs to have branching and/or multiple
implementations.

Am I *completely* off base?

-Sara

---

## #106510 — Zeev Suraski — 2019-08-09T21:30:11+00:00

URL: https://externals.io/message/106503#106510

> 
> > […]
>
> I am now even more confused.
>
> How is this drastically different to Nikita's suggestion of setting a
> compiler version via rust-like version declares?
>

In the spirit of my response to Bob, I added a new FAQ:  "How does this
differ from Nikita's Editions idea?"

Zeev

---

## #106509 — Mark Randall — 2019-08-09T21:30:13+00:00

URL: https://externals.io/message/106503#106509 · In reply to: #106506

> 2. Strict(er) typing - I'm not sure, on the surface, what future expansions
> we'd plan for in this area which couldn't fit into standard PHP in a non
> BC-breaking way.

Union types and general reflection do spring to mind on this. I assume 
any APIs using them would need to return more complex objects describing 
them, rather than individual strings from `getType()`.

Typed arrays are also another one which has been in high demand that I 
imagine will present some BC issues if shared between stricter and 
less-strict code.

 From what else I have read on here, the real biggy is probably going to 
be generics (hallowed by thy name).

> 3. Failing closed. Things like `strpos()` being able to return int(0) which
> is a falsey value. This has been a long standing "complaint" about PHP
> which isn't actually "fixable" without a big BC fail.  We've already shown
> we're willing to bite this bullet for security issues
> (openssl_random_bytes).

strpos returning 0 for the start makes perfect sense to me, what doesn't 
make sense is returning false. I think these problems need to be 
murdered-to-death with scalar objects (ideally returning -1 or, at a 
push, null, because at least the return type could be expressed as ?int, 
but IMO -1 is far superior).

I think scalar would be a huge game changer for allowing more sensible 
function names / return types without completely killing backwards 
compatibility on the existing core functions.

The entire argument order issue could potentially be wrote off with SON.

My guess is that whatever happens, it's going to require one version 
that really brings the pain, to set the groundwork for the future.

Mark Randall

---

## #106511 — mtkocak@gmail.com — 2019-08-09T21:55:29+00:00

URL: https://externals.io/message/106503#106511 · In reply to: #106503

I do completely agree with this and would like to be part of it. I am
really frustrated to see old developers shrug every time I talk about php.
I am enthusiastic about our language, the language I started coding with
and the language that evolved in years while I was learning it.

2 years ago, while I was preparing for facebook whiteboard interview for 6
months (I was not hired, I don't know what was the reason is.) I was
shocked to see while learning built in array and string functions naming
and parameter order. While we are advocating using coding standards,
forcing people to use PHP-FIG with different versions and advices, our
language does not have the same consistency, I know that was a must for
backwards compatibility with C, but makes me feel bad about the things I am
advocating for years.

Also, it is almost impossible for a newcomer to get into the internals. I
know that PHP source code is robust, evolved in many years to a position
that powers almost all of the internet but adding a new feature (which I
attempted once) requires a great C skill and familiarity with codebase
because of not having comments or source code documentation other than
internals book. (I also cannot say my attempts were welcomed with
happiness, which resulted me to lose my motivation, thankfully NCAO was
implemented by nikita popov)

I would really would be happy to see P++ to be built with some modern
compiled language like Rust and have nice guidelines and techniques to add
new features including new programming concepts. P++ should be the real
programming language of the future, should welcome newcomers, be easy to
use without bureaucracy of Java, nor encouraging spaghetti like code in
Python. I think PHP's secret is this, highly versatile, similar to a swiss
army knife, while other languages rant about their modernity and
superiority, it allows us to survive in the middle of the winter in a
forest under the storms. Even it is slow sometimes nor it is not perfect,
it's like me, it learns, it evolves, not perfect but it's the most used
language of the internet at the end.

From a humanitarian perspective, we have a huge potential here to create
most diverse, most inclusive, most welcoming language and programming
culture in the times that women and minorities leave the industry because
of the unneeded ego atmosphere.

From a technical perspective, P++ can be the language of the future and
bring peace to the galaxy.

Cheers,
Midori






> During the discussion of the P++ proposal (
> https://externals.io/message/106453), it became painfully clear that this
> idea did little, so far, to bring peace to the galaxy.
>
> However, based on a lot of the feedback, both on internals@ and elsewhere
> -
> it seems that a lot of people simply didn't really understand what this
> idea was actually proposing to do.  I'll take the blame for that - by not
> making the idea sufficiently clear.
>
> I went on and create an FAQ, that attempts to address many of the questions
> and common misconceptions that repeatedly came up.
>
> It's available here:  https://wiki.php.net/pplusplus/faq
>
> Before you read it, I want to stress that this is an attempt to
> provide *everyone
> with a good deal, and nobody with a raw deal.  *It doesn't mean it's
> successful at that (although I think it is) - but the motivation is clean
> and positive.  If & when you read this FAQ, please try to read it without
> any preconceived notions.
>
> If there are additional questions that you think are missing, please let me
> know - or better yet, if you're up for constructively adding them - go
> ahead and do that.
>
> Thanks,
>
> Zeev

---

## #106513 — Zeev Suraski — 2019-08-09T21:58:13+00:00

URL: https://externals.io/message/106503#106513 · In reply to: #106506

> 
>
> > […]
> It's possible I missed something while on holiday. There are certainly a
> lot of messages to page through.  I dig the idea of resolving this
> tug-of-war between progress and BC, but I'm not 100% clear on what the
> final goals are.  I understand that we're talking about more aggressively
> breaking BC in this new mode while preserving BC in "normal" PHP files, but
> I think it would help the conversation if we enumerated specific aims.
>
> Some guesses on what we're talking about:
> [snip]
> Am I *completely* off base?
>

I don't think you are.  In addition to these and those brought up by Mark -
other things could be making the new dialect stricter across the board -
including operators, array indices;  Requiring variable declarations;
Potentially changing some conversion rules (for explicit conversions), and
potentially changing some operator behavior (not just in terms of
strictness).

As Bob pointed out I'm rusty, but I do think that we can solve the short
tags issue in this way.  At the lexer level, if we see the <?p++?> tag, we
set short tags to off for the scope of the file before moving forward.  But
more importantly, this approach can allow us to implement different BC
breaking strategies (and not just for language features, but also for
built-in functions).

Zeev

---

## #106514 — Sara Golemon — 2019-08-09T22:42:56+00:00

URL: https://externals.io/message/106503#106514

> 
> > […]
> expansions
> > […]
>
> Union types and general reflection do spring to mind on this. I assume
> any APIs using them would need to return more complex objects describing
> them, rather than individual strings from `getType()`.
>
> Or maybe a string from `getType()` and an object from getTypeAnnotation() ?


> Typed arrays are also another one which has been in high demand that I
> imagine will present some BC issues if shared between stricter and
> less-strict code.
>
> I don't see these (or Generics which you also mentioned) as being
inherently incompatible between more/less strict codebases.
Say we have an array<string> or ValueObject<int> in "more strict" code, we
could refer to an unspecialized version of that as merely "array" or
"ValueObject" in "less strict" code.  Or even not refer to its type at
all.  Without a formalized proposal for how these are implemented, I'm not
sure we can assume there will be technical challenges which we simply can't
overcome.

My point being, I'm not sure these things necessarily require a schism.  We
should be certain they do before we invest much time in figuring out the
how of it.

-Sara

---

## #106515 — Sara Golemon — 2019-08-09T22:50:42+00:00

URL: https://externals.io/message/106503#106515 · In reply to: #106513

> As Bob pointed out I'm rusty, but I do think that we can solve the short
> tags issue in this way.  At the lexer level, if we see the <?p++?> tag, we
> set short tags to off for the scope of the file before moving forward.  But
> more importantly, this approach can allow us to implement different BC
> breaking strategies (and not just for language features, but also for
> built-in functions).
>
> That approach did occur to me to, but as I said in my earlier reply, I
don't think this actually addresses the goals set by the short tags removal
proposal *as I understand it*.  Maybe it does, but for example one could
still not start a file with "<?xml" as at this point the parser hasn't
encountered a "<?p++" tag yet, so it doesn't know if it should disable the
"<?" or not.

-Sara

---

## #106516 — Zeev Suraski — 2019-08-09T23:01:13+00:00

URL: https://externals.io/message/106503#106516 · In reply to: #106515

As Bob pointed out I'm rusty, but I do think that we can solve the short
tags issue in this way.  At the lexer level, if we see the <?p++?> tag, we
set short tags to off for the scope of the file before moving forward.  But
more importantly, this approach can allow us to implement different BC
breaking strategies (and not just for language features, but also for
built-in functions).

That approach did occur to me to, but as I said in my earlier reply, I
don't think this actually addresses the goals set by the short tags removal
proposal *as I understand it*.  Maybe it does, but for example one could
still not start a file with "<?xml" as at this point the parser hasn't
encountered a "<?p++" tag yet, so it doesn't know if it should disable the
"<?" or not.


Good point, you won’t be able to start a file with an XML tag.  But you could place the P++ tag before it.  And we may be able to come up with other ways to designate P++ files.

Zeev

---

## #106517 — Sara Golemon — 2019-08-09T23:01:24+00:00

URL: https://externals.io/message/106503#106517 · In reply to: #106510

> In the spirit of my response to Bob, I added a new FAQ:  "How does this
> differ from Nikita's Editions idea?"
>
>
"""Related to rollout - the Editions approach doesn't allow for just two
dialects - but any number of dialects. We could have a PHP2020 dialect,
along with a PHP2022 dialect and a PHP2027 dialect. If we keep them all -
this may actually increase our maintenance complexity."""

I don't think we would keep them all.  We could set a sunset cycle for
dialects similar to branch support cycles.   PHP2020 comes out and we
support that along with PHP1996.  Two years later, we introduce PHP2022 and
we continue to support 2020 and 1996.  When PHP2024 comes out, we drop
PHP1996.  When PHP 2026 comes out, we drop PHP2020, etc....

This does introduce a point where legacy apps must fix their code or simply
not upgrade, but it also provides a path to upgrade to latest support
version, then migrate files one at a time to that version's latest,
allowing an update to latest-latest.  This is significantly better than the
current state of syntax BC breaks which requires all updates to occur WITH
the upgrade.

Meanwhile, we have a little more work (work you and Niki are both
suggesting we take on already), but with a bounded cap on how long we carry
complications around.

-Sara

---

## #106518 — Larry Garfield — 2019-08-09T23:08:14+00:00

URL: https://externals.io/message/106503#106518 · In reply to: #106503

> During the discussion of the P++ proposal (
> https://externals.io/message/106453), it became painfully clear that this
> idea did little, so far, to bring peace to the galaxy.
> 
> However, based on a lot of the feedback, both on internals@ and elsewhere -
> it seems that a lot of people simply didn't really understand what this
> idea was actually proposing to do.  I'll take the blame for that - by not
> making the idea sufficiently clear.
> 
> I went on and create an FAQ, that attempts to address many of the questions
> and common misconceptions that repeatedly came up.
> 
> It's available here:  https://wiki.php.net/pplusplus/faq
> 
> Before you read it, I want to stress that this is an attempt to
> provide *everyone
> with a good deal, and nobody with a raw deal.  *It doesn't mean it's
> successful at that (although I think it is) - but the motivation is clean
> and positive.  If & when you read this FAQ, please try to read it without
> any preconceived notions.
> 
> If there are additional questions that you think are missing, please let me
> know - or better yet, if you're up for constructively adding them - go
> ahead and do that.
> 
> Thanks,
> 
> Zeev


Zeev,

First off, I want to be clear that I appreciate your efforts at conciliation here, and firmly believe your intent is benevolent.  

However, I ask you to consider that, intent or not, it's really easy for this proposal and some of your comments to come off as "strict people, go away and have your own corner".  That is likely not helping the discussion.

Arvids Godjuks has already covered in great deal most of my issues with this proposal.  There's a few key additional points I want to bring up, though.

First, as Sara observed I feel like this is conflating a number of different threads into a single binary question.

There are "cleanup" type issues, such as short open tags, `strpos()` return values, strict comparisons, and so forth.  The main concern here is BC.  I suspect that, were we only concerned with greenfield projects and nothing else, these would be entirely uncontroversial and most people would be fine with them.  The main difference of opinion here isn't "how should the language evolve" but "how do we balance BC concerns with fixing design flaws, mostly from PHP's early days"?

I don't think anyone can reasonably argue that `strpos()` returning false for not-found, which == 0,  is a good design; but "it's not bad enough design to justify breaking a billion lines of code" is a strong argument, and one on which reasonable people can reasonably disagree.  (And on which we can, and should, explore creative alternative approaches to "just break it".)

Then there's an entirely different class of question regarding future additions.  Should PHP support union types, for instance.  That change has *no BC implications whatsoever*.  If PHP added union types, existing code would continue to run perfectly fine with no issue whatsoever.  New code that used union types wouldn't run on old PHP versions, naturally, but that's expected and is still not a BC issue.  The argument here is entirely different: "Great, one more thing I have to learn because someone is going to use it and I have to read it" vs. "This saves me so much time writing and debugging code, yay".  Again, reasonable people can reasonably disagree here.

These are two almost entirely separate and orthogonal questions.  There's a few places where they touch -- mostly around bugs that are bugs only because of type juggling logic being non-intuitive at times -- but from a philosophical point of view they have nothing to do with each other.  Your proposal conflates them unnecessarily, and I think that's a crucial flaw in it.

For example, suppose PHP++ mode gets union types, and has `strpos()` changed to return something safer, and has short-tags removed, while PHP-oldschool does not.  If I want to use union types... I still have to make just as many changes to my code, including potentially cleaning up 10000 instances of `strpos()` in my huge legacy codebase just so that I can use a union type in new code.  I have gained... extremely little here.  Coupling those two changes has not created any benefit, just more confusion and annoyance.

What about common packages, or interfaces from FIG?  If FIG puts out an interface spec that makes use of a union type (for reasons that are completely reasonable in context), it's essentially forcing people to use PHP++ in order to use that spec; PHP-oldschool people are SOL.  Conversely, in order to maintain compatibility with PHP-oldschool FIG would have to eschew any features not in both branches; essentially not being able to use language features that are especially valuable for exactly that type of use case!

Second point, suppose such a dual-mode happens.  Fast forward 2 years, and I find someone to bribe to help me revive the comprehensions proposal (which has no type considerations, necessarily).  Does that go into PHP++ or PHP-oldschool or both?

Essentially, every syntax-affected RFC would have an extra fight over which PHP flavors get it.  That doesn't seem like a polite thing to do to future generations of core contributors, including future-us.

The only way to short circuit that would be to declare that PHP-oldschool never gets syntax changes at all, only PHP++ does.  Which would be a very strong signal that, yeah, PHP-oldschool is a dead language and anyone who isn't WordPress should just switch to PHP++ and be done with it.  But since your FAQ specifically mentions async as something that would be included in both modes I assume you're not proposing that PHP-oldschool be frozen in time syntactically, which means this debate would resurface for every RFC.  That's a net loss for all involved.

Finally, Zeev, you mention the "PHP philosophy" of being a dynamic language.  While that may well be your philosophy, and you have every right to have it, that has not been the "PHP philosophy" for years, as seen by all of the type "stuff" that's been successfully added to the language and gone into widespread use.  PHP doesn't have a coherent philosophy.  It is proudly directionless, steered by whoever happens to be writing code this week.  A few years back, Anthony Ferrara proposed developing an actual PHP mission statement to help resolve such debates over direction and was resoundingly rejected.  Rightly or wrongly, to speak of "PHP philosophy" as a thing one can actually reference is simply not possible.

To end on a positive note, while I agree that there is often a tension on such questions I think PHP has been remarkable in how well it's navigated it.  I don't know any other language that has managed to evolve as much as PHP has from 5.3 onward with so little relative BC breakage.  The new-features/breakage ratio for modern-era PHP is, I think, bloody amazing.

And when there has been good-reason breakage, we've rolled with it.  PHP 7.0's change to variable evaluation order was, on paper, a massive parser change... and yet the community rolled with it and upgraded and no one died.  It was a BC break, but a good one, and managed well, and it all worked out.

On the typing front, the course PHP has been going down in practice is to have an increasingly robust type system, all of which is opt-in.  Frankly I think that's *super cool*, and a great way of balancing the prototyping benefits of dynamic languages (which are most seen at small scale codebases) and the robustness/safety of more refined type system (which are most seen in larger code bases) within a single ecosystem.  If a given codebase tends toward one or the other, it does so for a reason.  Most tend toward typed these days, for a reason, but also have places where they don't where it doesn't make sense to.

That's a balancing act, yes.  It's not always an easy balancing act.  But frankly, I'd rather celebrate how well we've been able to pull it off over the years than lament how hard it is or introduce even more complexity and inconsistency in an attempt to not have to bother.

--Larry Garfield

---

## #106519 — Chase Peeler — 2019-08-09T23:28:10+00:00

URL: https://externals.io/message/106503#106519 · In reply to: #106518

On Fri, Aug 9, 2019 at 7:08 PM Larry Garfield <larry@garfieldtech.com>
wrote:

> 
> > […]
> this
> > […]
> elsewhere -
> > […]
> questions
> > […]
> me
> > […]
>
>
> Zeev,
>
> First off, I want to be clear that I appreciate your efforts at
> conciliation here, and firmly believe your intent is benevolent.
>
> However, I ask you to consider that, intent or not, it's really easy for
> this proposal and some of your comments to come off as "strict people, go
> away and have your own corner".  That is likely not helping the discussion.
>
> Arvids Godjuks has already covered in great deal most of my issues with
> this proposal.  There's a few key additional points I want to bring up,
> though.
>
> First, as Sara observed I feel like this is conflating a number of
> different threads into a single binary question.
>
> There are "cleanup" type issues, such as short open tags, `strpos()` return
> values, strict comparisons, and so forth.  The main concern here is BC.  I
> suspect that, were we only concerned with greenfield projects and nothing
> else, these would be entirely uncontroversial and most people would be fine
> with them.  The main difference of opinion here isn't "how should the
> language evolve" but "how do we balance BC concerns with fixing design
> flaws, mostly from PHP's early days"?
>
> I don't think anyone can reasonably argue that `strpos()` returning false
> for not-found, which == 0,  is a good design; but "it's not bad enough
> design to justify breaking a billion lines of code" is a strong argument,
> and one on which reasonable people can reasonably disagree.  (And on which
> we can, and should, explore creative alternative approaches to "just break
> it".)
>
> Then there's an entirely different class of question regarding future
> additions.  Should PHP support union types, for instance.  That change has
> *no BC implications whatsoever*.  If PHP added union types, existing code
> would continue to run perfectly fine with no issue whatsoever.  New code
> that used union types wouldn't run on old PHP versions, naturally, but
> that's expected and is still not a BC issue.  The argument here is entirely
> different: "Great, one more thing I have to learn because someone is going
> to use it and I have to read it" vs. "This saves me so much time writing
> and debugging code, yay".  Again, reasonable people can reasonably disagree
> here.
>
> These are two almost entirely separate and orthogonal questions.  There's
> a few places where they touch -- mostly around bugs that are bugs only
> because of type juggling logic being non-intuitive at times -- but from a
> philosophical point of view they have nothing to do with each other.  Your
> proposal conflates them unnecessarily, and I think that's a crucial flaw in
> it.
>
> For example, suppose PHP++ mode gets union types, and has `strpos()` changed
> to return something safer, and has short-tags removed, while PHP-oldschool
> does not.  If I want to use union types... I still have to make just as
> many changes to my code, including potentially cleaning up 10000 instances
> of `strpos()` in my huge legacy codebase just so that I can use a union type
> in new code.  I have gained... extremely little here.  Coupling those two
> changes has not created any benefit, just more confusion and annoyance.
>
> Exactly. I think this is what I worry about the most with this. I'm
against removing short tags. I don't use type hints myself, but, I have no
problem with the fact they exist. If strict typing were introduced for
declared variables, I would almost definitely never use them - but I don't
mind them getting added. There is SO much that can be added and done to
evolve and improve PHP that doesn't introduce BC breaks. There are also
many things that will cause BC breaks that people will understand and
accept given the positive benefit. I keep feeling like this is all coming
as a result of the people treating the opposition to short tag removal as
being against BC breaks in general.


> What about common packages, or interfaces from FIG?  If FIG puts out an
> interface spec that makes use of a union type (for reasons that are
> completely reasonable in context), it's essentially forcing people to use
> PHP++ in order to use that spec; PHP-oldschool people are SOL.  Conversely,
> in order to maintain compatibility with PHP-oldschool FIG would have to
> eschew any features not in both branches; essentially not being able to use
> language features that are especially valuable for exactly that type of use
> case!
>
> Second point, suppose such a dual-mode happens.  Fast forward 2 years, and
> I find someone to bribe to help me revive the comprehensions proposal
> (which has no type considerations, necessarily).  Does that go into PHP++
> or PHP-oldschool or both?
>
> Essentially, every syntax-affected RFC would have an extra fight over
> which PHP flavors get it.  That doesn't seem like a polite thing to do to
> future generations of core contributors, including future-us.
>
> The only way to short circuit that would be to declare that PHP-oldschool
> never gets syntax changes at all, only PHP++ does.  Which would be a very
> strong signal that, yeah, PHP-oldschool is a dead language and anyone who
> isn't WordPress should just switch to PHP++ and be done with it.  But since
> your FAQ specifically mentions async as something that would be included in
> both modes I assume you're not proposing that PHP-oldschool be frozen in
> time syntactically, which means this debate would resurface for every RFC.
> That's a net loss for all involved.
>
> Finally, Zeev, you mention the "PHP philosophy" of being a dynamic
> language.  While that may well be your philosophy, and you have every right
> to have it, that has not been the "PHP philosophy" for years, as seen by
> all of the type "stuff" that's been successfully added to the language and
> gone into widespread use.  PHP doesn't have a coherent philosophy.  It is
> proudly directionless, steered by whoever happens to be writing code this
> week.  A few years back, Anthony Ferrara proposed developing an actual PHP
> mission statement to help resolve such debates over direction and was
> resoundingly rejected.  Rightly or wrongly, to speak of "PHP philosophy" as
> a thing one can actually reference is simply not possible.
>
> To end on a positive note, while I agree that there is often a tension on
> such questions I think PHP has been remarkable in how well it's navigated
> it.  I don't know any other language that has managed to evolve as much as
> PHP has from 5.3 onward with so little relative BC breakage.  The
> new-features/breakage ratio for modern-era PHP is, I think, bloody amazing.
>
> And when there has been good-reason breakage, we've rolled with it.  PHP
> 7.0's change to variable evaluation order was, on paper, a massive parser
> change... and yet the community rolled with it and upgraded and no one
> died.  It was a BC break, but a good one, and managed well, and it all
> worked out.
>
> On the typing front, the course PHP has been going down in practice is to
> have an increasingly robust type system, all of which is opt-in.  Frankly I
> think that's *super cool*, and a great way of balancing the prototyping
> benefits of dynamic languages (which are most seen at small scale
> codebases) and the robustness/safety of more refined type system (which are
> most seen in larger code bases) within a single ecosystem.  If a given
> codebase tends toward one or the other, it does so for a reason.  Most tend
> toward typed these days, for a reason, but also have places where they
> don't where it doesn't make sense to.
>
> That's a balancing act, yes.  It's not always an easy balancing act.  But
> frankly, I'd rather celebrate how well we've been able to pull it off over
> the years than lament how hard it is or introduce even more complexity and
> inconsistency in an attempt to not have to bother.
>
> --Larry Garfield
>
> --
> 
> 
>
>

-- 
Chase Peeler
chasepeeler@gmail.com

---

## #106520 — Andrea Faulds — 2019-08-10T09:37:18+00:00

URL: https://externals.io/message/106503#106520 · In reply to: #106503

Hi Zeev,

As the person who initially proposed and implemented strict_types, I 
think this is heading in the wrong direction. Perhaps that directive was 
a mistake, if it will lead to so many attempts inspired by it to 
fragment the language, including this one. Personally, I don't actually 
want a language like C++ or Java. PHP's flexibility is great, and I 
think splitting the language means going in a direction where you are 
forced to have everything be strict or nothing be. PHP++ sounds like 
Hack, but in mainline. I think it'll end up a mess in the long term.

Regards,
Andrea

---

## #106521 — Peter Bowyer — 2019-08-10T10:42:14+00:00

URL: https://externals.io/message/106503#106521 · In reply to: #106518

[List etiquette question: is it good form here to change the subject line
when starting a tangential discussion?]



> PHP doesn't have a coherent philosophy.  It is proudly directionless,
> steered by whoever happens to be writing code this week.  A few years back,
> Anthony Ferrara proposed developing an actual PHP mission statement to help
> resolve such debates over direction and was resoundingly rejected.  Rightly
> or wrongly, to speak of "PHP philosophy" as a thing one can actually
> reference is simply not possible.
>

I have been working on a proposal for a PHP manifesto / mission statement.
I did not know it had been proposed before. [I haven't tracked down
Anthony's proposal - if anyone has a link, I'd appreciate it]

I started for the same reason: to help the community pull together and
argue less, by having a codified set of values.

On this list there are many different factions, all with their own vision
for PHP. If everyone is fighting to "win", it's an unpleasant, tiring
environment, turns people off contributing, and those who "win" can be
those who keep going the longest, not those with the best idea.

I saw a manifesto helping like this:

"Consider a proposal to remove a function from PHP. If PHP had a manifesto,
heated discussions could be minimised:
  * Does the manifesto say that maintaining backwards compatibility is more
important than cleaning up the standard library? Removing it is not inline
with PHP’s vision.
  * Does the manifesto say that rarely-used functions should be removed to
make the codebase lean? Removing it is inline with PHP’s vision."


Observing the project, I am not hopeful that anything like this could gain
traction without an overhaul of PHP's governance. Someone or some group
would have to have the deciding vote on what went in the manifesto.

In the last few months I have seen:
  * Core contributors should have more/the final say on RFC votes
  * The PHP user-community should have more say on RFC votes
  * The PHP Group have authority over the project
  * The PHP Group do not have authority over the project
  * A longstanding contributor feels they have a leadership position
  * Others feel the longstanding contributor doesn't

I am stating these neutrally, not judging them. Neither am I aiming to
misrepresent positions. If you feel I have, I'm sorry.

I am highlighting that there is no consensus here. I get this is the way
the project has always run (I think of it as the "Linus Torvalds and the
Linux Kernel" meritocracy approach). But: people don't seem happy.

Is there appetite for change?


> To end on a positive note, while I agree that there is often a tension on
> such questions I think PHP has been remarkable in how well it's navigated
> it.  I don't know any other language that has managed to evolve as much as
> PHP has from 5.3 onward with so little relative BC breakage.  The
> new-features/breakage ratio for modern-era PHP is, I think, bloody amazing.
>

I agree, and want to say a big "Thank you" to everyone who made that
happen. The PHP-userland community is too silent about the good things in
PHP, and you who bring the language about deserve way more praise than you
get.


Finally, I am going to wait at least 6 hours, ideally 12 before replying to
responses, and I encourage you to join me in this. My knee-jerk replies can
be more argumentative than I mean them to be, and by slowing down the
conversation I hope we can have a reflective and thoughtful discussion.

Peter

---

## #106527 — Rasmus Lerdorf — 2019-08-10T15:04:09+00:00

URL: https://externals.io/message/106503#106527

> As the person who initially proposed and implemented strict_types, I
> think this is heading in the wrong direction. Perhaps that directive was
> a mistake, if it will lead to so many attempts inspired by it to
> fragment the language, including this one. Personally, I don't actually
> want a language like C++ or Java. PHP's flexibility is great, and I
> think splitting the language means going in a direction where you are
> forced to have everything be strict or nothing be. PHP++ sounds like
> Hack, but in mainline. I think it'll end up a mess in the long term.
>

Yes, I would suspect it would get a bit weird having a AnythingGoes
vs. NothingGoes barrier in the code like that. Forcing a balance, even
if sometimes the arguments get rather heated (and they were just as
heated, if not more so 20+ years ago), keeps everyone on the same
page and working on the same code-base without the us vs. them
situation that is bound to creep in.

-Rasmus

---

## #106528 — guilhermeblanco@gmail.com — 2019-08-10T15:20:59+00:00

URL: https://externals.io/message/106503#106528 · In reply to: #106527

Hi all,

I tried as much as I could to stay away from this discussion. My
personal take is that breaking the language in two is a *really bad
idea* (shouldn't I have put caps here instead?).
Anyway, people are commenting a lot on features that adds a feature to
the language, but nothing was being spoken about scenarios where
severe internals changes would be required. Zeev, sorry for taking you
as the guinea pig here, but since you were the one that started this
whole thread, I think it's fair to ask you directly.

1- How would you envision a shared runtime between PHP and P++, in the
case that this new evolved solution decides to support objects as keys
in array structure? This fundamentally changes internals, and a
drastic change to both runtime of PHP and P++ would be required.

2- How would you envision injecting an actual namespace structure,
allowing scoping support for namespaces? FYI, this is what blocked me
to finish class visibility in https://github.com/php/php-src/pull/947
It'd require drastic changes in both PHP runtime and P++ too.

I have added 2 small samples (feel free to ask me if you need a few
more) where in order to add a feature in P++, changes to the way PHP
operated would have to change too.

The only I see this to operate is either P++ re-implementing the same
PHP structures in order to evolve, leading to a full fork becoming
more attractive, or compromises in P++ (like unable to support a given
feature) because PHP would make it set back.

Please let me know your thoughts on this.

Cheers,


>
> 
>
> > […]
>
> Yes, I would suspect it would get a bit weird having a AnythingGoes
> vs. NothingGoes barrier in the code like that. Forcing a balance, even
> if sometimes the arguments get rather heated (and they were just as
> heated, if not more so 20+ years ago), keeps everyone on the same
> page and working on the same code-base without the us vs. them
> situation that is bound to creep in.
>
> -Rasmus



-- 
Guilherme Blanco
SVP Technology at Statflo Inc.
Mobile: +1 647 232 5599

---

## #106530 — Christian Schneider — 2019-08-10T16:08:45+00:00

URL: https://externals.io/message/106503#106530 · In reply to: #106527

Am 10.08.2019 um 17:04 schrieb Rasmus Lerdorf <rasmus@lerdorf.com>:
> 
> 
> > […]

I very much agree with this.
I see strict_types as an attempt to cater to both factions but if it is used as a precedent to all kind of language fragmentation proposals then I'm regretting it.

> Yes, I would suspect it would get a bit weird having a AnythingGoes
> vs. NothingGoes barrier in the code like that. Forcing a balance, even
> if sometimes the arguments get rather heated (and they were just as
> heated, if not more so 20+ years ago), keeps everyone on the same
> page and working on the same code-base without the us vs. them
> situation that is bound to creep in.

I do not believe in the language mode/version model but instead agree that trying to get on the same page is worth some discussions.

I'm just a bit surprised and disappointed that the discussions recently got so out of hand.
There is a very vocal minority right now asking for BC breaking language changes who IMHO are a bit too quick dismissing opinions of very distinguished PHP developers. I think there should be some sort of respectful meritocracy (no, I'm not asking to introduce a formal system based on karma or something like that), minimally meaning: Listening to people with years of experience in PHP development and history.

It strikes me as odd that new features are often marketed with "if you don't need it, don't use it" but the same people then ask for deprecation / removal of features they personally don't use. Even if the advantages of the removal is minor.
I'm accepting a lot of complications in the PHP core for features I don't use already, but I'd expect the same respect for different (e.g. more dynamic) coding styles and older code bases.

Language fragmentation is not a sustainable solution, we do not want a Python2 vs. Python3 scenario.

- Chris

---

## #106532 — Mark Randall — 2019-08-10T16:59:54+00:00

URL: https://externals.io/message/106503#106532 · In reply to: #106530

> There is a very vocal minority right now asking for BC breaking language changes who IMHO are a bit too quick dismissing opinions of very distinguished PHP developers.

I would just question the assertion that it's a vocal minority when 
viewed in a wider context. In the realms of internals it may be, but 
this discussion board represents at most a miniscule fraction of those 
using PHP.

Outside of these walls, on the likes of reddit, discord and other 
discussion mediums, it is my take that the majority seem to favour a 
leaner, cleaner, stricter language, even at the cost of some backwards 
compatibility. This is of course anecdotal, but I voted on a survey a 
few days ago and just checked the results again just now, and it shows 
the vast majority of people on that forum were in favour of pushing the 
language at the cost of backwards compatibility. Prioritizing backwards 
compatibility did not receive a strong response.

I seem to remember listening to Nikita on Derick's podcast a while ago 
where he made comment on his observation that newer generation 
programmers were looking for improved typing and strictness.

Mark Randall

---

## #106534 — Stanislav Malyshev — 2019-08-11T03:16:40+00:00

URL: https://externals.io/message/106503#106534 · In reply to: #106518

Hi!

> Finally, Zeev, you mention the "PHP philosophy" of being a dynamic
> language.  While that may well be your philosophy, and you have every
> right to have it, that has not been the "PHP philosophy" for years,
> as seen by all of the type "stuff" that's been successfully added to
> the language and gone into widespread use.  PHP doesn't have a
> coherent philosophy.  It is proudly directionless, steered by whoever
> happens to be writing code this week.  A few years back, Anthony

I don't think that's the case, moreover, I don't think project can exist
and bring coherent results useful to the outside world this way. Of
course, we do not have "mission statement", but those formal
committee-designed ones are a useless baloney in about 99.999% of cases
I've seen. There are, however, certain ideas that underly what is and
what isn't PHP and why people use PHP and not some other language, and
why certain features are done in certain way. Dynamic language has been
one of them, but not only. Pragmatism - preference for solutions that
deliver maximum value for the users to solutions that adhere to one or
another kind of abstract conceptual framework - is another. Low barrier
of entry and embracing users not requiring strong theoretical background
and extensive training to be productive is another. Paving the walkways
and serving the common use case is another. Borrowing concepts proven to
be successful is another. There could be a lot of things, and the list
would probably differ from person to person, but I am pretty sure
"directionless" is not how you properly describe it.

> Rightly or wrongly, to speak of "PHP philosophy" as a thing one can
> actually reference is simply not possible.

I think not only is it possible, it is necessary. I don't think a
project can exist as a hodgepodge of code that people randomly graft on
whatever they happened to like in the moment. Maybe we have no official
Constitution document, but I think we still have some guiding principles
that PHP have been following over the years of its history.
It doesn't mean everything we have done we have to repeat forever again.
Environment changes, people change, community needs change, and
something we rejected 10 years ago we may embrace now. That's ok, but
this is not the same as being directionless.
-- 
Stas Malyshev
smalyshev@gmail.com

---

## #106535 — Stanislav Malyshev — 2019-08-11T03:26:46+00:00

URL: https://externals.io/message/106503#106535 · In reply to: #106521

Hi!

> I started for the same reason: to help the community pull together and
> argue less, by having a codified set of values.

The risk here however is for the document to be seen as a means to
"argue less" by way of excluding certain points of view from discussion.
That would not be a good thing. This is the main concern for codifying
such things - as soon as you have written The Rules, next thing that
happens is rule lawyering and instead of considering arguments on their
merits, people start arguing whether raising this or that proposal
violated the Rules and whether their opponents should be silent because
The Rules say so. This is tempting because arguing rules is usually
easier than arguing merits (The Rules are always the same and the merits
are always new), but winning on the rules is never satisfactory and
rarely healthy, because the other side always feels they have not been
properly heard.

> "Consider a proposal to remove a function from PHP. If PHP had a manifesto,
> heated discussions could be minimised:
>   * Does the manifesto say that maintaining backwards compatibility is more
> important than cleaning up the standard library? Removing it is not inline
> with PHP’s vision.
>   * Does the manifesto say that rarely-used functions should be removed to
> make the codebase lean? Removing it is inline with PHP’s vision."

But do we really want to pre-commit one being always more important than
the other in any case, no matter what? Do we want to pre-commit never
considering specific case on its merits and always be satisfied with
"The Rules say A more important than B, therefore function has to be
removed and you can't argue it's important because The Rules are
supreme, kneel before The Rules!" I certainly wouldn't feel satisfied
with such outcome. We can reflect certain philosophy and premises we
consider preferred, but we shouldn't pre-commit to it excluding discussion.

-- 
Stas Malyshev
smalyshev@gmail.com

---

## #106537 — Andi Gutmans — 2019-08-11T04:31:48+00:00

URL: https://externals.io/message/106503#106537 · In reply to: #106503

I must admit that the first time I read Zeev’s email I got anxious... but it is frustrating that PHP has a WAY better runtime than Python and most other dynamic languages yet is falling out of fashion. It’s strange given how much better it actually runs (really being unbiased here). One reason is security perception (which is BS but perception matters) and the second is arguably some of the historic baggage which makes some folks feel PHP is hard to master without a manual (we have the best manual).

So many times I have thought “is it time to just take an axe and simplify it and do a cleanup?”. I actually don’t think we lack many features but rather lots of stuff I would dump like references, array(), global namespace for functions(?), type juggling in areas where we should be stricter, etc... I actually think that having a p++ is risky but it is an opportunity. I think it’s mostly be an opportunity if we’d be careful about feature bloat and try and be really aggressive about removing things and cleaning up. We potentially would get the significant benefits of our runtime but with a cleaner language. Will non-PHP appreciate it? maybe, maybe not... I actually do think there’s value of a different brand just because of the BS perception issues...

Andi

Get Outlook for iOS<https://aka.ms/o0ukef>

---

## #106538 — mtkocak@gmail.com — 2019-08-11T07:26:15+00:00

URL: https://externals.io/message/106503#106538 · In reply to: #106537

+1



> I must admit that the first time I read Zeev’s email I got anxious... but
> it is frustrating that PHP has a WAY better runtime than Python and most
> other dynamic languages yet is falling out of fashion. It’s strange given
> how much better it actually runs (really being unbiased here). One reason
> is security perception (which is BS but perception matters) and the second
> is arguably some of the historic baggage which makes some folks feel PHP is
> hard to master without a manual (we have the best manual).
>
> So many times I have thought “is it time to just take an axe and simplify
> it and do a cleanup?”. I actually don’t think we lack many features but
> rather lots of stuff I would dump like references, array(), global
> namespace for functions(?), type juggling in areas where we should be
> stricter, etc... I actually think that having a p++ is risky but it is an
> opportunity. I think it’s mostly be an opportunity if we’d be careful about
> feature bloat and try and be really aggressive about removing things and
> cleaning up. We potentially would get the significant benefits of our
> runtime but with a cleaner language. Will non-PHP appreciate it? maybe,
> maybe not... I actually do think there’s value of a different brand just
> because of the BS perception issues...
>
> Andi
>
> Get Outlook for iOS<https://aka.ms/o0ukef>
>
> ________________________________
> From: Zeev Suraski <zeev@php.net>
> Sent: Friday, August 9, 2019 12:54 PM
> To: Internals
> Subject: [PHP-DEV] P++: FAQ
>
> During the discussion of the P++ proposal (
> https://externals.io/message/106453), it became painfully clear that this
> idea did little, so far, to bring peace to the galaxy.
>
> However, based on a lot of the feedback, both on internals@ and elsewhere
> -
> it seems that a lot of people simply didn't really understand what this
> idea was actually proposing to do. I'll take the blame for that - by not
> making the idea sufficiently clear.
>
> I went on and create an FAQ, that attempts to address many of the questions
> and common misconceptions that repeatedly came up.
>
> It's available here: https://wiki.php.net/pplusplus/faq
>
> Before you read it, I want to stress that this is an attempt to
> provide *everyone
> with a good deal, and nobody with a raw deal. *It doesn't mean it's
> successful at that (although I think it is) - but the motivation is clean
> and positive. If & when you read this FAQ, please try to read it without
> any preconceived notions.
>
> If there are additional questions that you think are missing, please let me
> know - or better yet, if you're up for constructively adding them - go
> ahead and do that.
>
> Thanks,
>
> Zeev

---

## #106540 — Zeev Suraski — 2019-08-11T09:41:33+00:00

URL: https://externals.io/message/106503#106540

> Hi Zeev,
>
> As the person who initially proposed and implemented strict_types, I
> think this is heading in the wrong direction. Perhaps that directive was
> a mistake, if it will lead to so many attempts inspired by it to
> fragment the language, including this one. Personally, I don't actually
> want a language like C++ or Java. PHP's flexibility is great, and I
> think splitting the language means going in a direction where you are
> forced to have everything be strict or nothing be. PHP++ sounds like
> Hack, but in mainline. I think it'll end up a mess in the long term.
>

Hi Andrea,

I really appreciate your point of view on this.  I'd love to better
understand what you think we should do when translating this point of view
into action.

Specifically - if we go in the direction of Editions, which - as far as I
can tell - has the potential to split the userbase (de-facto) at least as
much if not more - would you see this as a bad direction?

Nikita pointed out that there are several strategies to introduce
compatibility-breaking elements.  The precedent that we introduced with
strict_types, is to provide granular control at the feature level.
Granted, we only did one of those so far - but it's of course a possibility
to go on adding additional ones (such as strict_variable_declaration,
strict_ops, etc.).
The other option proposed is to have editions - which are collections of
such changes, that come as a unified package - you can't pick and choose
what you like or dislike, it's all or nothing
The 3rd option that I proposed, is to have the equivalent of just two
editions - we could call them 'classic' and 'strict' - that like editions,
users will be able to choose from on a per-file or per-package basis.

I *think* most of us will agree that option #1 isn't a very good one.  It's
by far the most flexible one - but it's also the messiest one.  It's also
arguably more complex to maintain, as you have to make sure each feature is
conceptually consistent with each other feature in both of its mode
(on/off), and also that each feature actually *works* with the other
feature in both of its modes in terms of implementation, if there's any
interaction between the two.

I think most folks would agree that Editions is a superior idea.  You group
several changes together, and you have a new, consistent dialect of the
language that users can opt into.  It's by definition a lot less flexible,
but flexibility isn't always a good thing.  It's easier to maintain, easier
to explain, provides fewer permutations of testing need to happen - and
reduces the cognitive load when reading code.  In terms of what we
sacrifice - we don't sacrifice much - because as we come to evaluate the
wants and needs of the userbase - it seems that the same folks that would
want strict_types, would be the ones that want strict_ops and
strict_variable_declarations.

In my mind, Editions -> per-feature-control is similar to P++ -> Editions:
- It's less flexible, but much like that's not a negative thing with
Editions - it's not a negative thing here either.  We won't have to support
PHP2020 in a version that we'd release in 2023.  Someone committing to P++
will be getting the new features (and compatibility changes) as they
upgrade - precisely as folks who upgrade PHP today do, without having to
(or being able to for that matter) opt-in or out.  The motivation that
everyone has to keep current (for stability/security reasons) will continue
to be a driving force for folks to take the trouble to upgrade.  They'd
have the ~2 years of maintenance time of the previous version to take the
time to upgrade - but over a long enough timescale, we'd have just two
flavors - not N.
- Psychologically, it allows us to introduce more compatibility breaks from
the get-go - instead of rolling them out gradually over time.  That is also
a good thing.  Much like PHP 5 (that introduced a completely different
object model) kickstarted the development of brand new frameworks (Symfony,
Zend Framework, others) - I'd expect there to be P++ frameworks that would
spring to life.  It's a lot more sensible to give them solid grounds upon
which they can build the framework (or app) - and not tell them that them
that if they'd want to keep current in 2025 - they'd be likely to have to
roll out another rewrite.
- Vision-wise, it allows us to lay out a clear, consistent vision for P++,
and say how we think it will differ from PHP.  We don't have to deliver on
it right away - it will still be helpful to users to know what they should
expect from PHP, what they should expect from P++  - and allow them to
choose which one to focus on.  It'll also help us in internals@ discussions
- it'll usually be fairly clear what goes where - making discussions a lot
less contentious.
- Marketing-wise, it has clear advantages, even if many folks here don't
want to evaluate that angle.

P++ is not radically different from the Editions idea.  It's quite similar,
with a different roll-out strategy - and it opts to make a clear statement
on the long term viability of dynamic PHP.

Regarding splitting the userbase - I think we need to face reality.  Our
userbase is already soft-split, and as we introduce more and more
optional-strict elements - this soft-split will grow larger (although I
still think it'll remain soft - I don't think it'll descent into an "us vs.
them" level).  Since we're considering the introduction of more and more
compatibility-breaking ever-stricter changes as a given (so many, in fact,
that the key implementation challenge with P++ appears to be our ability to
deliver all of them in a reasonable 2-3 year timeframe (!)) - we need to
ask ourselves what that would mean in practice.  It's clear that at least
for some folks - that means that the language gradually evolves in that
direction - slowly but surely leaving its dynamic nature behind and
allowing it (or forcing it) to die.  I'm hoping that the vast majority of
folks here understand that this isn't a viable option, and I think we need
to send a clear message to everyone (particularly the pro-dynamic crowd)
that this isn't in store for them.  At the same time, we need to figure out
how we are going to manage the growing distance between dynamic PHP and the
new one that we're working to create.

If we insist on keeping our language unified as we introduce these changes
- do you see a way to do that that is not a zero-sum game?

Thanks again for your feedback,

Zeev

---

## #106541 — Zeev Suraski — 2019-08-11T10:36:20+00:00

URL: https://externals.io/message/106503#106541 · In reply to: #106528

On Sat, Aug 10, 2019 at 6:21 PM guilhermeblanco@gmail.com <
guilhermeblanco@gmail.com> wrote:

> 1- How would you envision a shared runtime between PHP and P++, in the
> case that this new evolved solution decides to support objects as keys
> in array structure? This fundamentally changes internals, and a
> drastic change to both runtime of PHP and P++ would be required.
>

Why would that only make it into P++ and not PHP?  Things which are
sensible to both dialects should go into both dialects.

2- How would you envision injecting an actual namespace structure,
> allowing scoping support for namespaces? FYI, this is what blocked me
> to finish class visibility in https://github.com/php/php-src/pull/947
> It'd require drastic changes in both PHP runtime and P++ too.
>

I don't think we have an answer for that, but I also think it's an
orthogonal question.  It applies at the exact same way to the Editions.

The only I see this to operate is either P++ re-implementing the same
> PHP structures in order to evolve, leading to a full fork becoming
> more attractive, or compromises in P++ (like unable to support a given
> feature) because PHP would make it set back.
>

While I think that the deltas would be a lot smaller than something we
should lose sleep over in terms of maintenance overhead - this will
primarily depend on the substance of what we'd want to change - and not on
how we package it.  Whether we go for feature-specific declare()s,
Editions, or P++ - makes little to no impact on the complexity of the code
base.  In fact, if anything - having an all-or-nothing option is likely to
make the engine code simpler to develop and maintain, as instead of a huge
number (per-feature) or medium number (Editions) of combinations that need
to be designed to work together, supported and tested - we'd have just two.

Do you view this differently?

Thanks for the feedback!

Zeev

---

Next page: https://externals.io/message/106503.md?page=2
