Modern PHP Features You're Probably Not Using (But Should Be)

You’ve read the release notes. You’ve seen the blog posts. But how many of PHP’s modern features have actually made it into your day-to-day code? Sure, you’ve heard about enums. You might’ve even dabbled with match expressions or readonly properties. But chances are, you might still be writing modern PHP with a very 7.x mindset.

This talk is your invitation to ditch the boilerplate and embrace the features modern PHP has given us. We’ll walk through a set of underused gems - from union types and readonly classes, to cleaner control flow, and smarter typing.

Expect before/after code, real-world scenarios, and the occasional “wait, you can do that now?” moment. Whether you're modernising a legacy app or just looking to write less code that does more, this session will leave you with a better understanding of how these features combine to make your code safer, more expressive, and easier to maintain.

Transcript

1. Modern PHP Features You're Probably Not Using (But Should Be) Paul Conroy / @conroyp 30th October, 2025
2. From Dublin, Ireland Started playing with the web 30+ years ago (Notepad, Frontpage & Geocities!) CTO at Square1 conroyp.com / @conroyp Paul Conroy 👴 🌍 🇮🇪
4. Latest & Greatest PHP Features
5. Latest & Greatest PHP Features • Bugfixes
6. Latest & Greatest PHP Features • Bugfixes • Deadlines
7. Latest & Greatest PHP Features • Bugfixes • Deadlines • The Day Job
8. Latest & Greatest PHP Features • Bugfixes • Deadlines • The Day Job • Getting Paid!
9. https://stitcher.io/blog/php-version-stats-june-2025
10. https://stitcher.io/blog/php-version-stats-june-2025
11. We’re All Busy, and Habits Run Deep • Most developers learn a few ways to do things early in their careers, and stick with them. • We’re focused on shipping, fixing bugs, hitting deadlines. • It’s easier (sometimes safer!) to copy a familiar pattern from elsewhere in the codebase. • That consistency is good, but it can also keep us from taking advantage of new language features.
12. Strong & Stable Core
14. 😱
15. 😱
20. What Exactly Is an Enum? Enum == “Enumerated Type” A special kind of class that: • Defines a fixed set of possible values. • Gives each value a name and (optionally) data. • Lets you compare, validate, and extend safely. • A type understood by PHP!
24. 🤔 ⁉⁉⁉
25. 🤔 ⁉⁉⁉
33. Input Validation
34. Input Validation
40. • Move the logic closer to what it represents. • Single place to check role-related logic.
42. Enums: Cementing the Foundation • Replace fragile strings with structured, type-safe values. • Keep logic where it belongs - in the enum itself. • Validate input once, use confidently everywhere. • Generate labels and actions consistently. • Fewer bugs, less boilerplate, clearer intent.
46. ?? ⁇ • Function starts out obvious.
 • Params added over time - flags!
 • Readability isn’t great.
47. ?? ⁇ • Function starts out obvious.
 • Params added over time - flags!
 • Readability isn’t great.
48. Named Arguments
49. Named Arguments
50. Named Arguments • Makes the code obvious.
 • Refactor-safe.
 • Impossible to misorder.
 • Suitable for long parameter lists.
52. // Don’t care about this!
53. // Don’t care about this!
60. ❌ Easy to accidentally mutate after instantiation ❌ No enforcement of immutability ❌ Bugs creep in when state is shared across layers
66. Readonly properties • Properties are initialised once, in the constructor. • Whole class can be readonly.
 • No reassignment allowed - even from inside the class.
 • 🚨🚨 Objects within readonly properties can still be mutated 🚨🚨 
 (unless they are also immutable!)
67. Readonly properties • Properties are initialised once, in the constructor. • Whole class can be readonly.
 • No reassignment allowed - even from inside the class.
 • 🚨🚨 Objects within readonly properties can still be mutated 🚨🚨 
 (unless they are also immutable!)
79. The Robots will figure it out…
80. The Robots will figure it out…
81. The Robots will figure it out…
82. The Robots will figure it out…
83. The Robots will figure it out…
87. Strong & Stable Core • Data that behaves itself - predictable and self-describing. • Less duplication, fewer side effects. • Strong typing from start to finish. • Boilerplate replaced by intention. • Safer, cleaner, faster to read.
88. Framing the Structure
89. Switch it up
90. Switch it up
91. Switch it up
92. Switch it up
93. Switch it up 🔵 🔵
94. Switch it up 🔵 🔵 🟡 🟡
95. Switch it up 🔵 🔵 🟡 🟡 ⚪ ⚪
96. Switch it up
97. Switch it up
98. Match Expression
99. Match Expression
100. Match Expression • Closer to if/else functionality • No fallthrough • Strict comparisons (===) • Must return a value!
101. (De)faulty switch
102. (De)faulty switch
103. (De)faulty switch
104. (De)faulty switch
105. (De)faulty switch
106. (De)faulty switch • default is easy to miss. • Silent failure in switch case. • Very loud failure with match!
107. Strongly typed
108. Strongly typed
109. Strongly typed
110. Strongly typed
115. • Checking what condition matches “true”
 • First match wins!
116. • Checking what condition matches “true”
 • First match wins!
117. FizzBuzz https://www.php.net/manual/en/control-structures.match.php#125987
118. FizzBuzz https://www.php.net/manual/en/control-structures.match.php#125987
122. Union Types
123. Union Types • Comment isn’t a contract!
124. Union Types • Comment isn’t a contract! • Pass in precise types. • Not relying on docblocks.
125. Intersection Types
126. Intersection Types
127. Intersection Types
128. Intersection Types
129. Intersection Types
130. Intersection Types “I don’t care what type is, but it needs to be able to do X and Y” Make function signatures honest about what you depend on!
131. Framing the Structure • Replace fragile switch statements with clear, expressive match. • Build precision into contracts with union and intersection types. • Eliminate ambiguity - make every branch and type explicit. • Let PHP’s type system catch structural errors early
132. Making It A Home
134. Property Hooks
135. Property Hooks
136. Property Hooks
137. Property Hooks • Define get and set behavior inline with the property itself
 • Removes need for verbose getters/setters
 • Keeps logic close to where it’s used • Like computed properties in Swift/C#
138. Property Hooks
139. Property Hooks - Interfaces
140. • Pragmatic, not dogmatic. • Still uniquely PHP. • Evolves & matures by learning.
141. • Pragmatic, not dogmatic. • Still uniquely PHP. • Evolves & matures by learning.
145. Pipe Operator
146. Pipe Operator
147. Pipe Operator
148. Pipe Operator
149. Arrays
150. Arrays
153. ❌ No syntax error ❌ Wrong function is running ❌ Silent failure!
154. #[Override] Attribute
155. #[Override] Attribute 🚨 Previously was a warning ❌ Fatal error in 8.5
156. #[Override] Attribute
157. #[Override] Attribute
158. #[Override] Attribute
159. #[Override] Attribute
160. #[Override] Attribute Refactor-safe!
161. https://stitcher.io/blog/php-version-stats-june-2025
162. https://stitcher.io/blog/php-version-stats-june-2025
163. https://stitcher.io/blog/php-version-stats-june-2025
164. Symfony Polyfills https://github.com/symfony/polyfill • Brings newer PHP functions and classes to older versions. • Seamless drop-in: no code changes needed in most cases. • A lifesaver when your prod still says “7.4”!
165. Making It A Home • #[Override] turns quiet mistakes into loud ones. • New array helpers and pipelines make transformations flow naturally. • Property hooks remove boilerplate from everyday code. • Polyfills let you bring modern PHP to older runtimes. • Small upgrades, big quality-of-life wins for real projects!
166. Build With Better Materials • Clearer intent • Safer defaults • Expressive data • Predictable behaviour
167. Build With Better Materials • Clearer intent • Safer defaults • Expressive data • Predictable behaviour
168. Build With Better Materials • Clearer intent • Safer defaults • Expressive data • Predictable behaviour
169. Small Changes, Big Wins Feature PHP Version Why It Matters Action Enums 8.1 Replace string constants with real, type-safe values Use for statuses, roles, categories Readonly Properties / Classes 8.2 Make data immutable & predictable Use for DTOs and value objects Promoted Constructor Props 8.0 Remove repetitive property assignments Simplify data objects and models Named Arguments 8.0 Clearer, refactor-safe calls Use for constructors & config- heavy APIs
170. Small Changes, Big Wins Feature PHP Version Why It Matters Action Union & Intersection Types 8.0 / 8.1 Replace PHPDoc guesses with true contracts Declare what’s really allowed Match Expressions 8.0 Eliminate fall-through & loose checks Replace switch statements Property Hooks (+ Interfaces) 8.4 Co-locate get/set logic with data contracts Replace verbose accessors #[Override] Attribute 8.3 / 8.5 Turns silent override bugs into compile-time errors Add to subclass methods
171. Small Changes, Big Wins Feature PHP Version Why It Matters Action Pipe Operator (>) 8.5 Read transformations left to right Streamline code appearance Array Helpers 8.4 / 8.5 Expressive collection operations Use array_first(), array_last(), array_find(), array_any() Symfony Polyfills All Back-port modern features to older runtimes Add for legacy projects (7.4 → 8.x)
172. How to Start Modernising Your Code Today • Start small - replace constants with enums in new code. • Use readonly for DTOs and value objects you don’t want to mutate. • Add #[Override] gradually - catch hidden inheritance bugs early. • Refactor conditionals with match expressions for cleaner intent. • Try the pipe operator and array helpers where transformations stack.
173. Enjoy a better app, and an easier life!
175. Conroyp.com @conroyp paul@conroyp.com 🌍 🌐 Thank you! 📧