PHP 8.6 First Look What’s Coming and What’s Leaving

PHP 8.6 First Look: What’s Coming and What’s Leaving ![rw-book-cover](https://img.youtube.com/vi/vmSiuI2tVQ4/maxresdefault.jpg) 🔗 **Source:** [PHP 8.6 First Look: What’s Coming and What’s Leaving](https://www.youtube.com/watch?v=vmSiuI2tVQ4#transcript) > [!note]+ Document Notes > tags: [php-8-6, partial-function-application, readonly-properties, polling-api, session-security, deprecations] > author: Brent Roose > source: PHP Annotated (YouTube) / stitcher.io > reference: https://www.youtube.com/watch?v=vmSiuI2tVQ4 > date created: 2026-08-11 > > > [!info] Generated analysis — not the author's words. Sections below are machine-written > > from the captured source. Only text inside `> [!quote]` blocks is verbatim from the author. > > Do not quote or attribute any other line to the named author. > > # 🏷️ Title: PHP 8.6 First Look: What's Coming and What's Leaving >  ## 🧭 Table of Contents - [📝 Summary](#-summary) - [📖 Main Content](#-main-content) - [🗒️ Notes](#️-notes) - [📚 References](#-references) - [🗣️ Paraphrase](#️-paraphrase) - [📰 Newsletter](#-newsletter) - [✅ Action Items](#-action-items) - [🧪 Hypotheses](#-hypotheses) - [📊 Methodology](#-methodology) - [❓ Questions](#-questions) - [🔮 Future Research](#-future-research) - [💡 Implications](#-implications) - [🧠 Learning Styles Assessment](#-learning-styles-assessment) - [📊 Accessibility Assessment](#-accessibility-assessment) - [🌍 DEIB Assessment](#-deib-assessment) - [✅ Logical Validity](#-logical-validity) - [🛡️ DARVO Analysis](#-darvo-analysis) - [🎯 Conclusion](#-conclusion) ### 🔗 References - [What's new in PHP 8.6 | stitcher.io](https://stitcher.io/blog/new-in-php-86) - [Partial function application in PHP 8.6 | stitcher.io](https://stitcher.io/blog/php-86-partial-function-application) - [PHP 8.6 kicks off with partial function application | The PHP Foundation](https://thephp.foundation/blog/2025/12/08/partial-application/) - [PHP 8.6: What's New and Changed | PHP.Watch](https://php.watch/versions/8.6) ## 📝 Summary - PHP 8.6 (targeting GA around November 19, 2026) is nearing feature freeze; the video is a "first look" roundup of confirmed features and deprecations. - Headline feature is partial function application (PFA) — creating a reference to a function with some parameters pre-filled — which the presenter frames as the fix that finally makes the pipe operator (added a prior release) practical without wrapper closures. - Other confirmed additions: readonly property defaults (unlocked by PHP 8.4's property hooks), a built-in `clamp()` function, function-parameter-level doc comments, and more secure session defaults (strict mode on, cookies `HttpOnly`, `SameSite=Lax`). - The polling API is explicitly downplayed — the presenter warns viewers not to expect it to enable "better async code"; it's mainly a lower-level primitive for frameworks like Amp and ReactPHP. - Roughly 20 deprecations ship in this cycle; the presenter expects community pushback but argues deprecations are healthy language evolution, made low-friction by tools like Rector and Mago. - Stakeholders: PHP core/RFC voters, framework maintainers (Amp, ReactPHP, and pipe-operator consumers), hosting providers (session default changes), and WordPress/plugin ecosystems that eventually inherit PHP's minimum-version floor. - Risks/tradeoffs: deprecation fatigue and backlash vs. long-term maintainability; new session defaults could silently change behavior for legacy code depending on loose session handling. - Bottom line: an incremental but ergonomics-focused release — PFA is the standout, everything else is quality-of-life or security-hardening. ## 📖 Main Content - **Partial function application (PFA):** lets a developer create a reference to a function with some parameters already filled in, without hand-writing a wrapper closure. Its main payoff is with the pipe operator, which requires a single-parameter closure at each stage — previously forcing awkward wrapper functions. ```php // Illustrative, not from the transcript — one fenced block per document policy $result = $value |> str_replace(' ', '-', ...); // PFA pre-fills two of three params ``` - **Readonly property defaults:** previously nonsensical (a readonly property with a default is functionally a constant). PHP 8.4's property hooks changed that — hooks can now be declared on interfaces, so a single readonly property can resolve differently per implementation, making a default value meaningful again. - **Polling API:** explicitly *not* a new concurrency model — it's positioned as a lower-level replacement for existing mechanisms, mainly useful to frameworks like Amp/ReactPHP, with possible (not guaranteed) performance gains. - **`clamp()`:** bounds a value to a min/max range, snapping to the nearest edge if out of bounds; notable for working across ints, floats, strings, and dates, not just numerics. - **Function parameter doc comments:** lets docblocks attach directly to individual parameters instead of one block of `@param` tags on the function. Presenter is ambivalent — expects an adjustment period. - **Session hardening:** `session.use_strict_mode` and equivalent cookie flags default to more secure values (`HttpOnly` on, `SameSite=Lax`) — an opinionated, security-by-default change rather than a new API. - **Deprecations:** ~20 in this cycle. Presenter's stance: deprecations are a healthy evolution mechanism, and tooling (Rector, Mago) has largely solved the historical pain of migrating a codebase off them. - **Uncertainty/contested claims:** the presenter self-flags two open questions rather than asserting confidence — whether function-parameter doc comments will feel ergonomic once adopted, and whether PFA will be as transformative in practice ("time will have to tell"). ## 🗒️ Notes Source has no embedded timestamps (plain narration transcript, not a captioned VTT/SRT), so notes are organized by feature topic rather than timecode. #### Partial function application - Framed as "the missing feature that should have been added ... a year ago" — implies the presenter sees it as overdue relative to the pipe operator's original release. - Dedicated follow-up video promised — treat this note as provisional pending that deeper coverage. #### Readonly property defaults - Causal chain worth preserving: property hooks (8.4) → hooks definable on interfaces → multiple implementations can vary a "readonly" value → defaults become meaningful again (8.6). This is a genuine cross-version dependency, not a standalone feature. #### Polling API - Presenter explicitly counters likely audience over-expectation ("I want you to not overhype it") — a deliberate expectation-management framing, useful to preserve verbatim-adjacent for anyone citing this video. #### clamp() function - Framed as filling a gap userland/frameworks had already patched — signals PHP core absorbing a common convenience pattern rather than inventing new capability. #### Sessions and deprecations - Security defaults change is presented as uncontroversial; deprecations are pre-emptively defended, suggesting the presenter anticipates the deprecation list to be the most contested part of this release cycle. ## 📚 References - [PHP 8.6 kicks off with partial function application | The PHP Foundation](https://thephp.foundation/blog/2025/12/08/partial-application/) - [What's new in PHP 8.6 | stitcher.io](https://stitcher.io/blog/new-in-php-86) - [Partial function application in PHP 8.6 | stitcher.io](https://stitcher.io/blog/php-86-partial-function-application) - [PHP 8.6: What's New and Changed | PHP.Watch](https://php.watch/versions/8.6) ## 🗣️ Paraphrase - PHP 8.6 is close enough to feature freeze that its shape is now known: partial function application headlines the release, finally making the pipe operator practical by letting developers pre-fill some of a function's parameters instead of writing throwaway wrapper closures. Readonly property defaults round out a change started in 8.4 — property hooks made interface-level readonly properties meaningfully variable across implementations, so a default value stopped being a contradiction in terms. - The polling API is real but modest — a lower-level primitive mostly useful to async framework authors, not a new way to write concurrent PHP. `clamp()` and per-parameter doc comments are smaller ergonomic wins, and session handling gets more secure defaults out of the box. The presenter's biggest editorial point is about the ~20 deprecations: expects backlash, argues it's unwarranted given how mature deprecation tooling (Rector, Mago) has become. ## 📰 Newsletter PHP 8.6 is shaping up nicely, and if you've been waiting for the pipe operator to stop requiring wrapper-closure gymnastics, partial function application is your answer. Brent Roose's first-look walkthrough also covers readonly property defaults (thank property hooks for that one), a long-overdue built-in `clamp()`, and more secure session cookie defaults — worth a skim before your hosts start shipping 8.6 betas. Bookmark it for the WordPress-compatibility angle: session default changes and the deprecation list are exactly the kind of thing that quietly breaks a plugin nobody's touched in three years. [Watch the video](https://www.youtube.com/watch?v=vmSiuI2tVQ4) · [Read the companion post on stitcher.io](https://stitcher.io/blog/new-in-php-86). ## ✅ Action Items #### DevRel - Education: the video's "first look + dedicated deep-dive follow-ups" structure (separate videos already exist/planned for PFA and the polling API) is a reusable content pattern for WP major-release education. - Developer experience, developer marketing, community management, cross-project: not applicable — source is upstream PHP language content with no WordPress-specific developer-experience surface to act on yet. #### OSPO - Security Management: session default hardening (strict mode, `HttpOnly`, `SameSite`) is worth a note in any org-level PHP-upgrade security checklist once 8.6 reaches RC. - Policy & Governance, License Compliance, Software Inventory, Developer Support, Community Engagement, Strategic Alignment: not applicable — no governance or compliance content in this source. #### Community - Not applicable to this source — no community program, contributor, or sponsor content; this is a solo language-feature explainer. #### WordPress - Core: track PHP 8.6 compatibility (readonly defaults, session ini flips, ~20 deprecations) ahead of core's PHP support-matrix update; run core's test suite against 8.6 alpha/beta once available. - Core Performance: evaluate `clamp()`/PFA as replacements for existing userland helpers once 8.6 becomes a viable minimum floor (years out — tracking ticket only). - Core AI: not applicable. - Core Program Team: add an 8.6 deprecation-and-security-defaults briefing to the next cross-team compatibility sync. - Mobile: not applicable. - Playground: add a PHP 8.6 WASM build once upstream ships one, to demo PFA/`clamp()`/session-default changes in-browser. - Community: not applicable — covered under the top-level Community section above. - Training: update PHP-fundamentals lesson plans to cover PFA + the pipe operator once WP's minimum PHP catches up. - Marketing: not applicable. - Support: pre-stage a KB note on the new session cookie defaults (`HttpOnly`/`SameSite`) before hosts ship 8.6 — login/cookie behavior changes are a predictable support spike. - Design: not applicable. - Documentation: flag for a future DevHub PHP-compatibility note; nothing actionable until 8.6 reaches GA. - Photos: not applicable. - TV: not applicable. - Polyglots: not applicable. - Accessibility: not applicable. - Meta: not applicable. - CLI: confirm WP-CLI's PHP-version detection handles 8.6 correctly once RCs are out. - Hosting: flag the `session.use_strict_mode` / `cookie_httponly` / `SameSite` default flips for hosting partners — could change behavior for legacy plugins relying on loose session handling. - Tide: not applicable. - Openverse: not applicable. - Themes: not applicable. - Plugins: add PHP 8.6 to the plugin-review deprecation-scan checklist once RCs land, mirroring prior major-version prep. #### The WPOCC - Not applicable to this source — no WPOCC program, funding, or governance content. ### FAIR - Not applicable to this source — no AT Protocol, provenance, or funding-covenant content. ## 🧪 Hypotheses - H1: Codebases already using the pipe operator will show a measurable drop in single-use wrapper-closure declarations after adopting PFA. - H2: Readonly-property-default adoption will correlate with prior property-hook usage in the same codebase, since the feature is only meaningful in that context. - H3: The default-secure session settings (strict mode, `HttpOnly`, `SameSite=Lax`) will reduce a measurable share of session-fixation/cookie-theft findings in PHP security scans post-8.6 adoption, independent of any application-level code change. - H4: Community backlash to this cycle's ~20 deprecations will be measurably lower than PHP 7→8-era deprecation backlash, correlating with Rector/Mago adoption rates. - H5: `clamp()` adoption will reduce the number of duplicate userland clamp implementations across the top PHP frameworks within 12 months of GA. ### 📊 Methodology - Static-analysis diff (e.g., via Rector custom rules) on public GitHub PHP repos, comparing wrapper-closure and userland-clamp density before/after an 8.6 upgrade commit. - Framework-maintainer survey (Amp, ReactPHP, Laravel, Symfony) on property-hook and PFA adoption timelines. - Longitudinal CVE/security-advisory tracking for PHP session-related vulnerabilities, segmented by PHP version. - Sentiment analysis of PHP RFC threads and social discussion (r/PHP, PHP Slack/Discord) comparing this cycle's deprecation reception to PHP 8.0/8.1 cycles. ### ❓ Questions - How much of the pipe operator's real-world friction does PFA actually remove once frameworks build idiomatic patterns around it, versus how much is addressed by other language features? - Will `SameSite=Lax` becoming the default break any common cross-site embed/redirect patterns still in production use? - Does the "tooling has solved deprecation pain" claim hold for smaller, unmaintained plugins that never adopted Rector/Mago in the first place? ### 🔮 Future Research - Real-world adoption telemetry for PFA once 8.6 ships (Packagist composer.json `require` version bumps as a proxy). - Hosting-provider rollout timing for PHP 8.6 defaults, and how quickly the new session settings propagate to shared hosting. - IDE/static-analysis tooling support for function-parameter doc comments — adoption may hinge entirely on tooling catching up. ### 💡 Implications - **Practice:** PFA plus the pipe operator is a genuine ergonomics shift for functional-style PHP; expect style-guide and linter-rule updates in frameworks that lean functional. - **Security:** secure-by-default session settings reduce the "forgot to harden session config" class of misconfiguration, shifting risk toward legacy apps that explicitly override the new defaults. - **Education:** existing PHP fundamentals content teaching the pipe operator is now incomplete without PFA; training material needs a refresh once 8.6 is broadly available. - **Policy/funding:** not directly implicated by this source. ### 🧠 Learning Styles Assessment - Reading level estimate: Flesch-Kincaid Grade Level ≈ 8–9 (approximate, based on the conversational sentence structure and largely non-technical vocabulary of the spoken transcript — not run through a scoring tool). #### 👀 Visual learners - Present: none — audio-only narration transcript, no diagrams, code, or on-screen text described. - Improve: add code snippets for PFA/`clamp()` syntax and a before/after diagram of pipe-operator usage. #### 🔊 Aural learners - Present: this *is* a narrated video — well served by default. - Improve: none needed; format already matches this learning style. #### 🗣️ Verbal learners - Present: plain-language definitions for PFA, property hooks, and `clamp()` are given inline. - Improve: a short glossary of PHP-specific terms (RFC, readonly, property hook) for newer developers. #### 🧩 Kinesthetic learners - Present: none — no hands-on exercise or sandbox referenced. - Improve: link to a runnable PHP 8.6 RC sandbox (e.g., 3v4l.org or Playground) so viewers can try PFA/`clamp()` directly. #### 🧠 Logical learners - Present: causal chain from property hooks (8.4) to readonly defaults (8.6) is explained. - Improve: a version-dependency timeline diagram (8.0→8.6) would make cross-release causality clearer. #### 🧑‍🤝‍🧑 Social learners - Present: presenter invites comments ("let me know what you're looking forward to"). - Improve: link to the actual RFC discussion threads for readers who want to follow community debate. #### 🧘‍♀️ Solitary learners - Present: content is consumable solo with no required interaction. - Improve: add a self-check ("could you rewrite this closure using PFA?") prompt. #### 🌿 Naturalistic learners - Present: not applicable — no ecosystem/sustainability framing in this source. - Improve: not applicable. ### 📊 Accessibility Assessment #### Screen reader semantics - Present: not assessable from a transcript alone (no page/DOM to evaluate). - Improve: N/A to this source type. #### Keyboard navigation - Not applicable — video content, not an interactive interface. #### Contrast and readability - Not applicable — no on-screen text/graphics described in the source transcript. #### Text resizing and reflow - Not applicable. #### Media and captions - Present: transcript exists (this document's source), implying captions/subtitles are available on the platform. - Improve: verify auto-captions are accurate for technical terms (PFA, `clamp()`) which ASR commonly mangles — this transcript itself shows a likely mis-transcription of "SameSite=Lax" as "same site is set to less." #### Forms and interactions - Not applicable. #### Standards reference - Insufficient source material (transcript only, no page markup) to map to specific WCAG 2.2 AA success criteria beyond the captions note above (1.2.2 Captions). ### 🌍 DEIB Assessment #### Cultural breadth - Present: single presenter, single-language (English) content; no regional/multilingual examples. - Improve: not required for a technical release-notes format, but a translated companion post would broaden reach. #### Inclusive language - Present: technical, gender-neutral, no exclusionary language observed. - Improve: none needed. #### Neurodiversity support - Present: consistent topic-by-topic structure (PFA → readonly → polling → clamp → doc comments → sessions → deprecations) is predictable and easy to follow. - Improve: chapter markers/timestamps on the original video would help chunk consumption. #### Representation - Not applicable — single narrator, no represented identities/roles to assess. #### Psychological safety - Present: respectful, low-stakes framing even when discussing a contentious topic (deprecations); presenter explicitly invites disagreement in comments. - Improve: none needed. ### ✅ Logical Validity #### Strong reasoning - Causal reasoning: the readonly-property-defaults explanation correctly chains PHP 8.4's property hooks (interface-definable) to why 8.6 can now permit meaningful defaults — a sound, verifiable technical claim, not just an assertion. - Inductive framing: the argument for `clamp()` ("it came with all the major frameworks but never built into PHP") uses convergent independent implementations as evidence of genuine need — a reasonable inductive case for the feature's value. #### Fallacies - **Hasty generalization / unsupported prediction:** "I think partial function application will be a gamechanger" is asserted with only the pipe-operator argument as support, then immediately hedged ("time will have to tell") — the hedge is honest, but the headline claim outruns the evidence given. Fix: qualify the claim explicitly as a prediction rather than stating it before the hedge. - **Appeal to inevitability (mild):** deprecation opposition is framed as something that "shouldn't" happen given modern tooling, which sidesteps that tooling maturity doesn't address every real-world case (e.g., abandoned plugins). Fix: acknowledge the edge case explicitly rather than treating tooling as a complete solution. #### Tone of voice - Enthusiastic, informal, first-person opinion-forward ("I would call it," "I don't know how I feel about this one"), consistent with a YouTube dev-advocate explainer rather than formal release documentation. ### 🛡️ DARVO Analysis Not applicable to this source — a technical feature walkthrough with no interpersonal conflict, accusation, or defensive framing; DARVO's deny/attack/reverse-victim-offender pattern has no content to map to here. ## 🎯 Conclusion PHP 8.6 is shaping up as an ergonomics-and-security release rather than a paradigm shift: partial function application is the standout for finally making the pipe operator practical, readonly property defaults close a gap opened by 8.4's property hooks, and session handling gets more secure defaults out of the box. The polling API and ~20 deprecations are the parts most likely to be misunderstood or contested, respectively. Practical next step: revisit this note once the presenter's promised PFA deep-dive lands, and track the session-default and deprecation list against WordPress's PHP compatibility work as 8.6 approaches its November 2026 GA. ## 🔄 Refactor Appendix — PHP 8.6 First Look: What's Coming and What's Leaving ### 📚 Literature Atoms (H3) #### PFA lets you pre-fill a function's parameters > [!quote] ID:transcript_pfa > partial function application allows you to create a reference to a function with some of its parameters pre-filled. **Context & use**: - Presented early as the definition of PFA, immediately tied to the pipe operator's ergonomics problem. - Matters because it's the mechanism that eliminates wrapper-closure boilerplate — the concrete "why this feature" answer, not just a definition. **Tags**: #xref **Highlight**: transcript (no timestamp data in source)  #### Property hooks unlock readonly property defaults > [!quote] ID:transcript_readonly > we can now set default values on readonly properties because of this and I think that's really good. **Context & use**: - "This" refers to property hooks (PHP 8.4) becoming interface-definable, letting a readonly property vary meaningfully by implementation. - Matters as a cross-version dependency: this feature is inert without understanding 8.4's property hooks first. **Tags**: #xref **Highlight**: transcript (no timestamp data in source)  #### Sessions get secure-by-default settings > [!quote] ID:transcript_sessions > Session strict mode is enabled by default. Cookies are now marked as HTTP only by default and same site is set to less as well. **Context & use**: - Note: "same site is set to less" is a likely ASR mis-transcription of "SameSite=Lax" — flagged in the Accessibility section above, preserved verbatim per quote policy. - Matters for WordPress hosting compatibility — flagged in Action Items → Hosting. **Tags**: #xref **Highlight**: transcript (no timestamp data in source)  ### 🧠 Permanent Candidates (H4) #### Partial function application removes the wrapper-closure tax on pipe-style PHP **Claim** (Courtney's voice): Partial function application makes a pipe-operator-style call chain viable without hand-written single-purpose wrapper closures. **Evidence pointer**: [[#H1]] (PFA lets you pre-fill a function's parameters) **Scope & conditions**: - Holds when: composing multi-step transformations where each step needs only 1–2 of a function's parameters fixed. - Breaks when: the function's remaining "open" parameter isn't the one the pipe operator expects to pass, forcing a closure anyway. **Links**: - [[Function composition]] — because extends (PFA is a language-level primitive in service of the same goal composition patterns solve in userland) - [[Pipe operator ergonomics]] — because applies-in the specific pain point this claim resolves  ### ✏️ Fleeting Queue - [F1] Verify whether the ASR error "same site is set to less" (likely `SameSite=Lax`) is corrected in the video's official captions — https://www.youtube.com/watch?v=vmSiuI2tVQ4 #xref - [F2] Revisit once Brent Roose's dedicated PFA follow-up video ships — check stitcher.io for the post version — https://stitcher.io/blog/php-86-partial-function-application #xref ### → Things 3 - [ ] Watch Brent Roose's dedicated partial-function-application follow-up video when published — WordPress PHP-compatibility research #things - [ ] Check WP-CLI and core test suite status against PHP 8.6 RC once available — hosting/compatibility prep #things --- ## Full Transcript [00:00] partial function application, read only [00:02] property defaults, a new clamp function, [00:05] and also one or two um or 20 [00:09] deprecations. PHP 8.6 is coming in [00:12] November. There's still quite some time [00:14] before it's here, but we're nearing [00:16] feature freeze, so we already know [00:19] what's coming, um but also what's going. [00:22] Let's take a look. [00:31] First up is partial function [00:33] application, PFA for short. Uh I would [00:36] call it the missing feature that should [00:39] have been added in PHP a year ago. Uh [00:42] because it makes the pipe operator [00:44] finally usable. In short, partial [00:47] function application allows you to [00:48] create a reference to a function with [00:51] some of its parameters pre-filled. And [00:53] it's especially useful combined with a [00:55] pipe operator because that one always [00:57] needs a closure with exactly one [01:00] parameter. So instead of having to wrap [01:02] a function with another function, you [01:04] can now write much cleaner code. There's [01:07] much more to tell about PFA. I'll be [01:09] making a follow-up video in the coming [01:11] weeks about it. So make sure to [01:12] subscribe if you haven't yet to uh be [01:15] kept in the loop about that one. Next [01:17] are readonly property defaults. And you [01:19] know it didn't make much sense to have [01:21] default values for readonly properties [01:23] before uh because that would essentially [01:26] make them constants you know uh a [01:27] hard-coded value that cannot change. [01:30] However, uh PHP 84 introduced property [01:32] hooks and made it so that they could be [01:35] defined on interfaces and that kind of [01:38] changed the situation because now a [01:41] readonly property from within the [01:42] context of an interface can have [01:44] different values because there can be [01:46] multiple implementations of that same [01:49] interface. Long story short, we can now [01:52] set default values on readonly [01:54] properties because of this and I think [01:56] that's really good. Next is the polling [01:58] API, and I want you to not overhype it. [02:01] You might think that PHP's new polling [02:04] API allows you to write more or better [02:06] async code, but in reality, it was [02:09] mostly designed to be a replacement for [02:12] something that was already possible. The [02:13] polling API uh will likely be useful to [02:16] lower level frameworks like AMP or React [02:19] PHP. Um, and it may even lead to better [02:22] performance in some cases, but nothing [02:24] more than that. I've already made a [02:27] dedicated video about the polling API. [02:29] Uh so make sure to check that one out [02:31] after this one. Uh I'll leave a link in [02:33] the description. Then there's a new [02:35] clamp function and it's one of these [02:37] things that makes you wonder, wasn't [02:39] this in PHP before? It actually came [02:41] with all of the major frameworks um but [02:43] never built into PHP. And so that's [02:46] changed now. Now the clamp function [02:48] ensures that a given value is within a [02:51] given bound. And if not, the nearest [02:53] edge value is returned. What's [02:55] especially cool is that it doesn't just [02:56] work with integers and floats, but also [02:58] with strings and dates. Next is function [03:02] parameter doc comments. Uh, I don't know [03:05] how I feel about this one. It will [03:07] probably take some time to get used to, [03:09] but essentially it allows you to add doc [03:11] comments to function parameters directly [03:13] instead of adding one giant block on the [03:16] function with add param tags. Again, [03:19] it'll probably take some time to get [03:20] used to. We'll see. Then there are some [03:23] changes to sessions. More specifically, [03:25] uh some in setting defaults have been [03:28] changed uh to make them more secure. [03:30] Session strict mode is enabled by [03:31] default. Cookies are now marked as HTTP [03:34] only by default and same site is set to [03:36] less as well. I also leave a link in the [03:39] description uh to my blog post where I [03:42] have a bit more info about these changes [03:45] um if you want to check them out. So [03:46] finally, deprecations. Um, full [03:50] disclosure, I like deprecations. Uh, I [03:52] think they are a good way of evolving [03:55] any language or library. You know, with [03:57] modern PHP, I also feel it's pretty easy [04:00] to to deal with them thanks to tools [04:02] like Recctor and Mago that will [04:04] basically upgrade your codebase for you. [04:06] Despite all of that, uh, deprecations [04:08] always tend to cause some backlash. Um, [04:11] I don't think they should, but I I am [04:14] expecting many developers to be vocally [04:16] against them. I think especially in this [04:18] day and age, it's so important to keep [04:21] your software up to date and [04:24] deprecations really shouldn't be a [04:26] blocker to you. So, PHP 8.6 uh there are [04:30] some small features and changes uh that [04:32] you'll find in the blog as well. Um but [04:35] these are definitely the most important [04:36] ones. I think partial function [04:38] application will be a gamecher. Um, time [04:42] will have to tell, but you let me know [04:44] what you're looking forward to the most [04:46] uh in the comments and also share your [04:48] thoughts about deprecations. And while [04:50] you're writing your comments down there, [04:52] also leave a like and don't forget to [04:54] subscribe. And then I'll see you in the [04:56] next one. Bye-bye.  📄 **Full text:** [[Full Document Contents/Articles/PHP 8.6 First Look What’s Coming and What’s Leaving.md|PHP 8.6 First Look: What’s Coming and What’s Leaving by YouTube]] ## Highlights - call it the missing feature that should have been added in PHP a year ago. Uh because it makes the pipe operator finally usable. In short, partial function application allows you to create a reference to a function with some of its parameters pre-filled. And it's especially useful combined with a pipe operator because that one always needs a closure with exactly one ([View Highlight](https://read.readwise.io/read/01kzrhm7csnvz768xahfeqaey1)) - Note: Partial function application pre-fills arguments and makes the pipe operator cleaner. - Tags: atom/literature/h1, partial-function-application, php-8-6 - different values because there can be multiple implementations of that same interface. Long story short, we can now set default values on readonly properties because of this and I think that's really good. Next is the polling API, and I want you to not overhype it. You might think that PHP's new polling API allows you to write more or better async code, but in reality, it was ([View Highlight](https://read.readwise.io/read/01kzrhm8dk92tv172svm1wnf25)) - Note: Readonly property defaults become meaningful because property hooks allow interface implementations to vary values. - Tags: atom/literature/h2, readonly-properties - mostly designed to be a replacement for something that was already possible. The polling API uh will likely be useful to lower level frameworks like AMP or React PHP. Um, and it may even lead to better performance in some cases, but nothing more than that. I've already made a dedicated video about the polling API. Uh so make sure to check that one out ([View Highlight](https://read.readwise.io/read/01kzrhm9e5n0xf41y755p4a7nz)) - Note: The polling API is a lower-level primitive for frameworks, not a general async model. - Tags: polling-api, atom/literature/h2 - description uh to my blog post where I have a bit more info about these changes um if you want to check them out. So finally, deprecations. Um, full disclosure, I like deprecations. Uh, I think they are a good way of evolving any language or library. You know, with modern PHP, I also feel it's pretty easy to to deal with them thanks to tools like Recctor and Mago that will ([View Highlight](https://read.readwise.io/read/01kzrhmacwgs1hrnsr04t7azfk)) - Note: PHP 8.6 shifts session handling toward secure defaults and frames deprecations as language maintenance. - Tags: session-security, atom/literature/h2 ## Links - [[WordPress's Compatibility-First Culture Is Now Its Binding Security Constraint]] — applies-in: secure PHP defaults and deprecations become ecosystem work where legacy compatibility delays adoption. - [[Pin Composer Platform PHP for Portable CI Lockfiles]] — applies-in: explicit PHP targets keep dependency resolution reproducible while runtimes move toward 8.6.