Just a few short weeks ago, for a 24 Days in December post, I wrote about remembering all of the Open Source Maintainers that create and support the tools that we all use as developer in our daily work. It isn’t always the obvious tools and frameworks (PHP itself, PHPStorm, Symfony, Laravel, Composer, XDebug, PHPUnit) that make a difference; there are so many unsung heroes that work in the background making our work so much easier.
Reflections on Thought and Expression
For me, it’s been a particularly difficult and traumatic last few months of 2021. Not simply because of the whole covid situation, or the usual stresses of work; but because I started taking therapy over the Summer. I know that I’m a mess of hang-ups and inhibitions, and have a lot of difficulty expressing myself emotionally: I’ve spent over two years trying to address those issues with a variety of self-help techniques; but with very limited success. So I finally realised that I needed professional help if I was going to make myself more open.
I found a therapist here in Amsterdam that takes on English-speaking clients; and feel like I’ve been making progress with her. It’s been a painful experience, she seems to have an instinct for homing in on the things that I don’t say; and perhaps it’s the traditional Dutch bluntness, but she’s exposed a few memories that my mind has preferred that I forget, and made me explore them and the effects that they’ve had on me. One in particular going back to my teenage years; another from the mid-90’s when I was living in Manchester; and most recently a third incident in my life from about 25 years ago, which is germane to this post.
I’d just had a particularly difficult week, and received some news that I was dreading; and my mind simply couldn’t focus or concentrate on anything; so I decided to treat myself to a spa day to help clear my mind. I booked in for a full day at Spa Zuiver near Amsterdamse Bos, complete with meals and a relaxation massage; and found that they had a regular schedule of löyly (or aufguss) sessions in the Finnish sauna, which I particularly enjoy. The smell of the scented oils, the blasts of heat: it’s a wonderful, invigorating experience. It was also fun trying to identify the aromas; and amusing that I was identifying the individual smells (cinnamon, nutmeg, cloves, ginger, almonds) aloud in English; and the guy on the bench next to me was putting the ingredients together to get speculaas. The last oil was the trigger for me: I identified anise and liquorice, and when I realised it was sambuca, I had to leave the sauna early to get some cool, fresh air. I don’t drink alcohol, I haven’t done so in over 30 years; but that wasn’t the issue: my mind was just swamped by memories of that incident from 25 years ago.
I’d spoken with my therapist about my intent to visit the spa in my previous session; so naturally in my next therapy session she asked how it had gone: my telling her about walking out of the aufguss is where things got particularly interesting.
Therapist > But you said that you always enjoy the aufguss; so why did you leave the sauna early?
Me > It’s hard to explain; but it triggered a wave of memories that just overwhelmed me, and I needed to escape.
Therapist > Try to put it into words for me. What was your Inner Monologue saying to you?
Me > My Inner what?!?
That’s when she had to explain to me what an Inner Monologue was. And it took some explaining; because I’ve never experienced an Inner Monologue, so the whole concept of the mind giving a verbal commentary on its thought processes was very difficult for me to understand.
The Wonderful World of Callbacks
Anybody that has read any of my previous blog posts or looked at my code samples before should know that I’m a big fan of using callbacks. Whether it’s simply using callbacks with those standard functions that accept them as an argument (such as the functional tripos of array_map(), array_filter() and array_reduce()) or customisable array sorting through usort() and its relatives, building classes with methods that accept callbacks, or the darker magic of binding closures to a class or instance to give it new functionality. I always find that callbacks allow me to build applications with a great deal of flexibility.
Where the logic of the callback is simple (such as filtering an array or iterable), I typically used inline functions; although since the introduction of arrow functions in PHP 7.4, I have been replacing many of my one-liner functions using them instead. If I need something more complex, I might use an anonymous function rather than defining it inline; or if it’s a function that will be called more regularly, or that incorporates business logic that should be maintained separately, then I’ll create it as a named function or method rather than defining it anonymously, so that it’s a separate entity in the codebase, maintained with all the other business logic, and can still be called as a callback.
Posted in PHP
Tagged Anonymous Function, Arrow Function, Callback, Closure, PHP, PHP 8
Leave a comment
ReadOnly Gotchas – A few more limitations with PHP 8.1 ReadOnly Properties
Last month I wrote about the new readonly properties in PHP 8.1, and the difficulties if you want to clone an object that uses them (together with a couple of potential solutions to that problem). The inability to clone an object with readonly properties isn’t the only limitation that you might encounter though; and while the other limitations are mentioned in the PHP documentation, they could easily be overlooked.
Constant Constants. Finally! (On the inconstancy of constants)
One of the many new features of PHP 8.1 is the ability to declare class constants as final, so that they can no longer be overridden in child classes. The same applies when constants are defined as final in an abstract classes, or interface; they can’t be overridden by classes extending that abstract or implementing that interface. So class and interface constants can now truly become constant.
You could be forgiven for believing that a constant will always retain the same value throughout, it’s in the name, right? And technically that’s correct. But it all comes down to context, to the class (or interface) where that constant is defined, and its visibility; and when it comes to class inheritance, all bets are off. The value of a constant can be defined at one level within the inheritance tree; but overridden at another level. Technically, it’s a different constant; but having constants with the same name yet different values within a class inheritance tree can certainly create confusion, and potentially lead to awkward bugs. The PHP documentation does note that this can be the case; but perhaps it really should be a warning instead.
The Tears of a Clone
On the face of it, the new readonly properties in PHP 8.1 seem really useful for Value Objects and Data Transfer Objects: both should be immutable; setting property values should always be handled in the constructor, so no setters; and with readonly properties, we no longer need to code boilerplate getter methods; so we only need to code a comparison method for value objects. Between constructor property promotion introduced in PHP 8, and readonly properties introduced in PHP 8.1, we can reduce the code (skipping the comparison for brevity) for defining a Money class from
class Money {
protected int $value;
protected Currency $currency;
public function __construct(int $value, Currency $currency)
{
$this->value = $value;
$this->currency = $currency;
}
public function getValue(): int {
return $this->value;
}
public function getCurrency(): Currency {
return $this->currency;
}
}
to a much more simplistic
class Money {
public function __construct(
public readonly int $value,
public readonly Currency $currency
) {}
}
and then we directly access the value and currency of the object externally as object properties, rather than needing to use the getter methods of the original version.
The new version of our Money class looks so much cleaner: we’ve reduced the cognitive overhead, and we’ve eliminated a lot of boilerplate code – readonly properties FTW, right?
Closure Binding for Unit testing of Private and Protected Methods
Some years ago, I wrote about using closure binding to access protected and private properties when unit testing an object, to verify internal state; and I created the SpyMaster library to simplify that task. One feature that I didn’t include in the version of SpyMaster that I released publicly on github was the ability to execute protected and private methods within an object.
I know that a lot of developers will declare internal methods as public if they want to make them testable; but defining methods that are supposed to be internal to a class as public is rarely a good idea, because it is then a part of the public API for the class, and can be accessed from external code.
Other developers might use Reflection in their unit tests to make private or protected methods executable. That’s a better approach, because the class under test retains its internal methods as protected or private.
An alternative approach is to use closure binding to execute those methods without needing to change their accessibility at all, similar to the way that the original SpyMaster library accesses internal properties without changing their visibility.
Spreading the News – An Exploration of PHP’s Spread Operator
A few days ago, I wrote about array unpacking and variadic arguments in PHP8. I’m a big fan of these features, and use them extensively, and the changes in PHP8 make them even more useful.
Named Arguments and Variadics in PHP 8
One of the new features of PHP 8 is named arguments. It’s one of those features that I love as an end user developer; although it can be a nightmare for library and framework developers, because argument names are now part of the API for public methods, not simply the argument types, and any change to an argument name becomes a backward-compatible break.
Loving you wasn’t easy.
Loving you wasn’t easy.
Mark Baker's Blog 