Tony Edwards

User Needs Mapping by Rich Allen

Mon, 20 Jul 2026 00:00:00 +0000

I took some time out of the office today, releshing the opportunity to read a good book in the sunshine.

And it’s almost as good as the view!

User needs are difficult to pin down, whether the individual is internal or external to the business. Sometimes they’re masked by complexity. Sometimes they’re hidden behind user pains. And sometimes. . . just sometimes. . . no one actually knows what they need. . . only what they want.

All combined, they result in unaligned goals across a team/org, ill defined boundaries and responsibilities, and confusion between internal needs and the actual needs of the end user. (Developer experience is important. Honest boss!)

Thankfully, Rich Allen is here to save the day!

In User Needs Mapping, Rich draws from multiple Agile-esque processes to distill the core of User Needs Mapping. It gives you the language to talk about the issues to be solved with clients and the team around you, and breaks down the process step by step with really good illustrations to support the text.

My favourite thing about this book is the examples. They’re as deep as they need to be, exceptionally well written, and not the usual. After reading a few books of this ilk, it’s nice to not see the same examples being regurgitated in an effort to draw new insights.

Highly recommended 👍

If User Needs Mapping is something you’ve been meaning to look deeper at, pick up a copy of this book and learn EVERYTHING you need to know to do the job.

A quick guide to c# expressions in .net MAUI.

Fri, 17 Jul 2026 00:00:00 +0000

I’ve written more Boolean converters than I’d care to admit. Not complicated ones, either. They work, but a convertor is a lot of ceremony for something so small.

C# expressions are coming to .NET MAUI in .NET 11, and they’re designed to remove a bunch of this sort of boilerplate. They let you write small C# expressions directly inside XAML attributes, which means conditions, calculations, formatting and simple event handling can live closer to the controls that use them.

<VerticalStackLayout IsVisible="{!IsLoading}" />

<Button
    Text="Save"
    IsEnabled="{IsValid && !IsSaving}" />

<Label Text="{$'{FirstName} {LastName}'}" />

This is a fairly substantial change to the way we can work with XAML. It doesn’t mean view models, converters, commands or normal bindings are going away, and it certainly doesn’t mean every bit of application logic should now be squeezed into an XML attribute. What it does mean is that a lot of the tiny pieces of supporting code we write around XAML may no longer be necessary.

What are C# expressions?

C# expressions let you use C# syntax inside XAML attributes. That includes property access, Boolean conditions, arithmetic, string interpolation, null-coalescing, ternary expressions, method calls and small event-handler lambdas.

The feature is being introduced as part of .NET MAUI in .NET 11 and is still experimental at the time of writing. Some of the syntax, behaviour and limitations may change before the final release, so this probably isn’t the moment to enthusiastically rewrite half a production application on a Friday afternoon.

The interesting part is that these expressions aren’t simply strings being interpreted at runtime. They’re understood by the .NET MAUI XAML source generator, which can inspect an expression, work out which types and properties it uses, and generate the required C# or binding code at build time.

That makes this more than shorter syntax. It gives the compiler a much better understanding of what the XAML is trying to do. It gives you less code to grep.

Why is this happening?

XAML is very good at describing the structure of a user interface. It becomes less elegant when you need to add a small amount of presentation logic, particularly when that logic is too simple to deserve its own class or view-model property.

Suppose you have an activity indicator that should be visible while data is loading, and some page content that should be visible when it isn’t. A fairly typical approach looks like this:

<ContentPage.Resources>
    <toolkit:InvertedBoolConverter
        x:Key="InvertedBoolConverter" />
</ContentPage.Resources>

<ActivityIndicator
    IsRunning="{Binding IsLoading}"
    IsVisible="{Binding IsLoading}" />

<VerticalStackLayout
    IsVisible="{Binding IsLoading,
        Converter={StaticResource InvertedBoolConverter}}">

    <!-- Page content -->

</VerticalStackLayout>

There’s nothing especially wrong with this. Converters are useful, particularly when transformation logic is shared across several views. In this case, though, we’ve introduced a converter, registered it as a resource and referenced it from the binding simply to invert a Boolean.

With C# expressions, the same thing becomes:

<ActivityIndicator
    IsRunning="{IsLoading}"
    IsVisible="{IsLoading}" />

<VerticalStackLayout IsVisible="{!IsLoading}">

    <!-- Page content -->

</VerticalStackLayout>

The new version is shorter, but that isn’t the only benefit. The condition is right next to the element that uses it, and the intent is obvious without jumping around the project looking for a converter.

A tiny bit of logic stays tiny.

Simple property bindings

The most basic example is binding to a property.

Before

<Label Text="{Binding Username}" />

<Label Text="{Binding User.DisplayName}" />

With C# expressions

<Label Text="{Username}" />

<Label Text="{User.DisplayName}" />

At first glance, this looks like shorthand for removing the word Binding, but the source generator is doing more than that. When the page has an x:DataType, the expression can be checked against the binding context at build time.

<ContentPage
    x:Class="MyApp.ProfilePage"
    x:DataType="viewModels:ProfileViewModel">

    <Label Text="{Username}" />

</ContentPage>

If Username doesn’t exist on ProfileViewModel, the tooling has enough information to complain about it. That’s rather more useful than discovering a typo after navigating to the page and wondering why the label is empty.

Writable properties can still be used with controls that support two-way binding:

<Entry Text="{Username}" />

This isn’t throwing away data binding. It’s giving the compiler a more direct and strongly typed way to describe it.

Boolean expressions

Boolean expressions are probably where many developers will see the quickest win. Applications tend to collect converters and calculated properties for conditions such as “invert this value”, “check whether both values are true” or “show this control when a count is greater than zero”.

A view model might currently expose another property:

public bool CanSave => IsValid && !IsSaving;

The XAML then binds to it:

<Button
    Text="Save"
    IsEnabled="{Binding CanSave}" />

This works, but the view model must also raise a property-change notification for CanSave whenever either IsValid or IsSaving changes. That is easy to forget and can produce the sort of bug where the state is correct but the button remains stubbornly disabled.

Another option is a MultiBinding and converter:

<Button Text="Save">
    <Button.IsEnabled>
        <MultiBinding Converter="{StaticResource CanSaveConverter}">
            <Binding Path="IsValid" />
            <Binding Path="IsSaving" />
        </MultiBinding>
    </Button.IsEnabled>
</Button>

That is a lot of XAML for a condition that is perfectly readable in one line.

With C# expressions

<Button
    Text="Save"
    IsEnabled="{IsValid && !IsSaving}" />

Other conditions are equally direct:

<Label IsVisible="{ItemCount > 0}" />

<Button
    IsEnabled="{HasAcceptedTerms && IsFormValid}" />

<VerticalStackLayout
    IsVisible="{IsSignedIn || IsGuestAccessEnabled}" />

This is the sort of thing C# expressions are particularly good at. The logic is small, local to the view and understandable without extra context.

Word-based operators are also being explored to avoid some of the awkwardness caused by XML escaping:

<Button
    IsEnabled="{HasAcceptedTerms AND IsFormValid}" />

The available aliases include forms such as AND, OR, LT, GT, LTE and GTE. Whether you prefer those or the normal C# operators will probably come down to readability and how much XML complains about what you’re trying to type.

Calculated values

Calculated properties are another common piece of view-model furniture. Suppose you have a price and quantity and want to show the total.

Before

public decimal Price { get; set; }

public int Quantity { get; set; }

public decimal Total => Price * Quantity;

<Label Text="{Binding Total}" />

Again, Total needs to raise a change notification whenever Price or Quantity changes. Without that notification, the calculation may be correct in the view model while the UI continues showing an old value.

With a C# expression, the calculation can be written directly in the XAML:

<Label Text="{Price * Quantity}" />

The source generator can inspect the expression and work out which values it depends on. Because Price * Quantity isn’t something that can be assigned back to the view model, the generated binding is one-way, which is exactly what you would expect.

This works well for small presentation calculations. It doesn’t mean your pricing rules, discount logic and tax calculations should now live in a forty-line XAML expression. If the calculation has business meaning, is reused elsewhere or needs proper testing, keep it in C# and give it a useful name.

String interpolation

Formatting text in XAML has always been possible, but it isn’t always pleasant. You might use StringFormat, a calculated property or a FormattedString full of spans.

For example, displaying a full name might involve another property.

Before

public string FullName => $"{FirstName} {LastName}";

<Label Text="{Binding FullName}" />

With C# expressions

<Label Text="{$'{FirstName} {LastName}'}" />

The single quotes are used because the XAML attribute itself is already wrapped in double quotes. You can use the same approach for other bits of display text:

<Label Text="{$'Hello, {FirstName}'}" />

<Label Text="{$'{Quantity} × {ProductName}'}" />

<Label Text="{$'Total: {Price:C2}'}" />

Dates can be formatted in the same way:

<Label
    Text="{$'Arriving {ArrivalDate:dddd, d MMMM}'}" />

This should be particularly useful when the formatted text exists for one specific view. If several pages need the same formatting, or the formatting is part of the application’s behaviour rather than its presentation, a named property or formatter is probably still the better home.

Ternary expressions

Sometimes you need to choose between two values. A common way of doing this is to add another property to the view model.

Before

public string AccountTypeText =>
    IsPremium
        ? "Premium account"
        : "Standard account";

<Label Text="{Binding AccountTypeText}" />

With C# expressions

<Label
    Text="{IsPremium ? 'Premium account' : 'Standard account'}" />

You can also combine a ternary with interpolation:

<Label
    Text="{ItemCount == 1 ? '1 item' : $'{ItemCount} items'}" />

This is useful up to a point. One small ternary expression is easy to understand, but three nested ternaries and a method call will quickly make the XAML harder to follow.

At that point, give the condition a name and move it back into C#.

Null handling

Null fallback values are another good fit for expressions.

Before

public string DisplayName =>
    Name ?? "Unknown user";

<Label Text="{Binding DisplayName}" />

With C# expressions

<Label Text="{Name ?? 'Unknown user'}" />

You can also use null-aware property access:

<Label
    Text="{User?.DisplayName ?? 'Guest'}" />

This is useful when the fallback is specific to a particular element. If the application has a defined rule for how user names should be displayed everywhere, put that rule somewhere reusable rather than copying the same expression across six pages.

Method calls

Expressions can call methods:

<Label Text="{Name.ToUpperInvariant()}" />

They can also call helper methods:

<Label Text="{GetFormattedDate()}" />

Static methods are supported too:

<ProgressBar
    Progress="{Math.Min(Progress, 1)}" />

This comes with an important caveat: not every expression is automatically reactive. An expression generated as a binding can update when its dependencies raise property-change notifications, but a method called directly from the page may be evaluated once when the view is created.

If you write this:

<Label Text="{GetCurrentStatus()}" />

you shouldn’t assume it will rerun whenever some unrelated property changes. The expression needs a clear set of observable dependencies for the generated binding to know when it should update.

This is one of the areas worth testing carefully while the feature is still in preview.

Inline event handlers

C# expressions can also be used to handle events. Imagine a button that increments a counter.

Before

<Button
    Text="Add"
    Clicked="OnAddClicked" />

private void OnAddClicked(object sender, EventArgs e)
{
    Count++;
}

With C# expressions

<Button
    Text="Add"
    Clicked="{(sender, args) => Count++}" />

You can call a method in the same way:

<Button
    Text="Reset"
    Clicked="{(sender, args) => ResetForm()}" />

This is useful for genuinely tiny synchronous actions. It becomes less useful when the event handler contains validation, logging, navigation, cancellation, error handling and three service calls. At that point, give it a name and put it somewhere sensible.

Async lambdas aren’t currently supported, so asynchronous event handlers still need a normal method or command:

<Button
    Text="Save"
    Clicked="OnSaveClicked" />

private async void OnSaveClicked(
    object sender,
    EventArgs e)
{
    await viewModel.SaveAsync();
}

That limitation may feel inconvenient, but it also stops the XAML from becoming a hiding place for sizeable chunks of asynchronous application logic. Probably not a bad thing.

Existing XAML markup still works

C# expressions are being added alongside the XAML features that already exist. Normal bindings, static resources and x:Static all continue to work:

<Label Text="{Binding Name}" />

<Label Text="{StaticResource PageTitle}" />

<Label
    Text="{x:Static local:AppConstants.AppName}" />

The source generator needs to work out whether the contents of the braces are a markup extension or a C# expression. Where something is ambiguous, you can be explicit:

<!-- Explicit expression -->
<Label Text="{= SomeValue}" />

<!-- Resolve against the page -->
<Label Text="{this.Title}" />

<!-- Resolve against the binding context -->
<Label Text="{.Title}" />

The last two are useful when the page and its binding context contain properties with the same name. It’s one of those problems you may not have until you do, at which point you’ll be pleased the explicit syntax exists.

What could this replace?

C# expressions may remove the need for quite a few small pieces of supporting code, including inverted Boolean converters, simple comparison converters, some multi-value converters, presentation-only calculated properties, basic formatting properties, straightforward triggers and tiny synchronous event handlers.

A MultiBinding such as this:

<Label>
    <Label.IsVisible>
        <MultiBinding
            Converter="{StaticResource AllTrueConverter}">

            <Binding Path="IsLoggedIn" />
            <Binding Path="HasSubscription" />

        </MultiBinding>
    </Label.IsVisible>
</Label>

can become:

<Label
    IsVisible="{IsLoggedIn && HasSubscription}" />

That is fewer lines, but the more useful change is that the condition is visible immediately. You don’t need to inspect a converter to discover whether AllTrueConverter really means all values must be true, whether null counts as false or whether it does something surprising because someone changed it four years ago.

What shouldn’t go into an expression?

Just because C# can now be written inside XAML doesn’t mean every bit of application logic should move there. I’d avoid using expressions for business rules, network calls, database operations, complex state changes, reusable calculations, anything that needs focused unit testing or anything that requires a comment to explain what it does.

You could write something like this:

<Label
    IsVisible="{
        CurrentUser != null &&
        CurrentUser.Subscription != null &&
        CurrentUser.Subscription.ExpiresAt > DateTime.Now &&
        !CurrentUser.IsSuspended
    }" />

But a named property is much easier to understand:

<Label
    IsVisible="{CanAccessPremiumFeatures}" />

The second version tells me what the condition means. The first tells me how it is calculated and asks me to work out the meaning myself.

That is the line I’d use when deciding whether an expression belongs in XAML: use an expression when it makes the XAML more obvious, and use a named property or method when it makes the intention more obvious.

A complete example

Here’s a small page using several of the new expression types together:

<ContentPage
    x:Class="ExpressionDemo.MainPage"
    x:DataType="viewModels:MainViewModel">

    <VerticalStackLayout
        Padding="24"
        Spacing="16">

        <Label
            FontSize="24"
            Text="{$'Welcome, {FirstName}'}" />

        <ActivityIndicator
            IsRunning="{IsLoading}"
            IsVisible="{IsLoading}" />

        <VerticalStackLayout
            IsVisible="{!IsLoading}"
            Spacing="12">

            <Label
                Text="{$'{Quantity} × {ProductName}'}" />

            <Label
                Text="{$'Total: {Price * Quantity:C2}'}" />

            <Button
                Text="Place order"
                IsEnabled="{
                    Quantity > 0 &&
                    HasAcceptedTerms &&
                    !IsSubmitting
                }" />

        </VerticalStackLayout>

    </VerticalStackLayout>

</ContentPage>

There are no converters here, no calculated Total property and no CanPlaceOrder property that needs change notifications whenever three other values change.

The important question isn’t whether this version contains fewer lines. It’s whether someone opening the page can understand what it does.

In this case, I think they probably can.

When can I try it?

C# expressions are being developed for .NET MAUI in .NET 11. .NET 11 is scheduled for release in November 2026, but the feature can be tried using the .NET 11 preview SDK and the matching .NET MAUI workload.

It’s still experimental, so expect rough edges, incomplete tooling and behaviour that may shift between preview releases. I wouldn’t start converting a production application wholesale yet.

A better approach is to create a small test project or pick one isolated page containing a few obvious candidates: an inverted Boolean converter, a basic MultiBinding, a display-only calculated property, a formatted string or a one-line synchronous event handler.

Replace them one at a time and see what the resulting XAML feels like. Check whether it becomes easier to read, whether the expression updates when you expect it to, whether Hot Reload behaves and whether the compiler errors point you towards the problem when something goes wrong.

Those are the useful questions during a preview.

Give it a try

C# expressions won’t replace MVVM, converters, commands, view models or code-behind, and they shouldn’t. What they offer is a way to remove some of the faff around small bits of presentation logic.

That could mean fewer converters, fewer properties that exist purely for one label and less hopping between files to understand a simple condition.

Try them in a small page and see which bits of boilerplate disappear. More importantly, notice which bits are still clearer with a proper name in the view model.

Then tell the .NET MAUI team what worked, what didn’t and where the tooling got confused. Preview features improve when people use them for real things rather than admiring them from a release note.

Read the spec

Entertainment is consumed. Fun is created.

Sat, 20 Jun 2026 00:00:00 +0000

One day. . . I'll go straight there.

Tue, 14 Apr 2026 00:00:00 +0000

See you soon-ish City JS!

MAUI Day and the stowaway ladybird

Fri, 06 Feb 2026 00:00:00 +0000

7 Talks + 2 nights away + a stowaway ladybird = another successful MAUI Day!

With almost 100 attendees in the room, how could it not be?

The gaggle of .NET MAUI developers had descended from around the globe on central London for a day of cross-platform knowledge sharing. Not only did we learn a whole bunch, but we also got to meet and mingle with the faces behind the avatars that we chat with day in and out.

Between Syncfusion providing the food, NewDay providing the venue, and the community providing the conversations, the room was in exceptionally high spirits.

Was it fun?

It sure was.

Did it run on time?

Hell no!

Will we do it again?

For sure!

Where?

Everywhere!

For as long as another group of speakers are willing to assemble to provide an excuse to get together, then we’ve got no excuse not to. Massive thanks to David, Stéphane, Mark, Matt, Shriram, and Clifford for giving the days conversations a focal point, plus allowing the conf to ✅ the 5 continents box.

Not sure how we’ll reach six!

In a distributed sector, within a distributed world, opportunities to connect in person and deepen the rapport built on top of hundreds of online chats is important. Both to the individual and the whole. Communities thrive based on the value of conversations, and judging by the buzz in the room last week the hashtag#dotnetMAUI community has never been so alive.

Just like the ladybird.

She’s part of the colony hibernating in the bedroom back home, although one of the family decided to come on the 580 mile round train trip.

Thankfully, Premier Inn rooms are hermetically sealed. . . meaning she could fly around the room in the evening without me having to worry about her escaping. Countryside bugs don’t deserve city life, although I’m sure she has some stories to tell the others!

We both have to be fair.

Overall, it was another successful trip to the UK capital for the hashtag#MAUIDay crew.

But multiple attendees on the day gave me feedback that there should be more focus on performance amongst the sessions.

Hopefully we’ll be able to arrange that for London 2027, and maybe even add a little performance to the panel 🤞

3 minutes to go. Stuck in the toilet 🤦‍♂️

Thu, 05 Feb 2026 00:00:00 +0000

3 mins left and I was stuck in the toilet

It was broadcast time.

Eat a Banana. Drink some water. Go to the bathroom.

Gran always said to never miss an opportunity, and this wasn’t the moment to defy such hefty wisdom.

Hearing the click of the door behind me, it didn’t cross my mind that this is the high security HQ of Microsoft. Doors have locks. A few minutes later I soon realised the consequences of this lapse in concentration.

The call was made.

I was rescued.

Everything worked out in the end. But it wasn’t the warm-up I’d imagined for my guest appearance on the dotnet YouTube channel.

I wouldn’t worry about watching.

My appearance amounts to just babbling about chocolate salty balls.

They are tasty tho.

Life - All about the bounce back

Wed, 28 Jan 2026 00:00:00 +0000

.NET MAUI - Toggle fullscreen for MacCatalyst desktop app

Fri, 23 Jan 2026 00:00:00 +0000

.NET MAUI Mac Catalyst apps run on macOS, but use UIKit (iOS frameworks) rather than AppKit (native macOS frameworks). To toggle full screen, the same behavior as clicking the green ”zoom” button in the window chrome, we need to bridge into AppKit’s NSApplication and NSWindow using the Objective-C runtime.

#if MACCATALYST

    var nsAppClass = ObjCRuntime.Class.GetHandle("NSApplication");
    var nsApp = ObjCRuntime.Runtime.GetNSObject(nsAppClass);
    var sharedApp = nsApp?.PerformSelector(new ObjCRuntime.Selector("sharedApplication"));
    var keyWindow = sharedApp?.PerformSelector(new ObjCRuntime.Selector("keyWindow"));
    keyWindow?.PerformSelector(new ObjCRuntime.Selector("toggleFullScreen:"), keyWindow);

#endif

If you want to see it in action, check out this demo project containing a Mac App.

Here’s how it works.

var nsAppClass = ObjCRuntime.Class.GetHandle("NSApplication");

Gets a handle (pointer) to the Objective-C class NSApplication. This is AppKit’s application singleton class that manages the macOS app lifecycle. Since Mac Catalyst doesn’t directly expose AppKit types to C#, we access it dynamically through the Objective-C runtime.

var nsApp = ObjCRuntime.Runtime.GetNSObject(nsAppClass);

Wraps the raw class handle in an NSObject that we can interact with from C#. This gives us a managed object representing the NSApplication class itself, which we get with the next line.

var sharedApp = nsApp?.PerformSelector(new ObjCRuntime.Selector("sharedApplication"));

This calls the sharedApplication class method on NSApplication, which returns the singleton instance of the running application.

var keyWindow = sharedApp?.PerformSelector(new ObjCRuntime.Selector("keyWindow"));

This retrieves the keyWindow property from the shared application, i.e. the window that will receive any keypresses. This returns an NSWindow instance. Then. . . finally. . .

keyWindow?.PerformSelector(new ObjCRuntime.Selector("toggleFullScreen:"), keyWindow);

Calls toggleFullScreen: on the NSWindow. This is the same method macOS invokes when you click the green full screen button. The method takes a sender parameter (we pass the window itself), and toggles between full screen and windowed mode. This mean you can call it again to revert the full screen.

And with that, you now have a fullscreen Mac app using .NET MAUI.

What about Windows?

If you want to implement the same functionality within MAUI for Windows, I highly recommend this blog post.

A MAUI example starter project

Wed, 17 Dec 2025 00:00:00 +0000

Setting a project up in the right way from day one is key to long term success. But with a myriad of different ways to achieve the same goal, it’s fairly easy to go down the wrong path. Especially as a learner. This is even more true with MAUI, given how much it’s changed in recent years.

Quite often example projects are created by experts in software engineering, who’ve internalised abstractions and know the APIs inside out. These abstractions and helper libraries might make complete sense to someone with years of experience in a field, but to a learner, they’re can be plain confusing.

To AI as well.

By setting up the basics of a project, and then handing off to AI to fill in the gaps, the end result is much better and quicker to get to. With a little prompting, an AI coding assistant will scan a project and pattern match what exists already, making the right setup even more foundational and key.

At the outset of a recent vibe Mac app, I created a boilerplate project to act as an example of a good starting point for a .NET MAUI app to grow from. It:

Uses view models via the community toolkit to allow for a clean separation of UI and business logic
Sets up dependency injection for services, and consumes them in the view models
Uses app settings to pull config from

It achieves these things in the simplest way possible, without abstracting the reader of the code from how it fits together. It also offers a great starting point to experiment with using something more fancy to achieve the same goals, and will work on any platform if you alter the platform identifiers.

Hopefully you’ll find it useful on your MAUI journey.

https://github.com/tonyedwardspz/maui-di-vm-settings-example

Festive friday at Sapphire House

Mon, 15 Dec 2025 00:00:00 +0000

34 people, 23 dishes, (only) 4 bottles of Prosecco, and 1 happy chef *.

That’s a festive Friday at Sapphire House.

To bring the team together before we start disappearing ahead of Christmas, the Sapphire Holidays IT team, joined up with parts of the Aspects Holidays and Classic Cottages teams to craft the ultimate office roast. Of course, this came shortly after giving out the presents.

The meal itself was both a success and tasty!

Honey glazed parsnips met crispy roast potatoes. Succulent beef collided with terrific turkey. Cute little piggies nestled in their blankets, with a trio of gravies smothering them all. It’s was one of those moments that having multiple full kitchens in the building became a major highlight of office life.

Unfortunately, expectations for 2026 are now super high.

I suspect we’ll only top 2025 by getting a visit from Santa himself. . . although Dan was a adequate stand-in come time for secret Santa.

Ok. There were actually two chefs. . . but only one of them regularly makes me bacon sandwiches so he’s getting all the credit

10 years of Digital Plymouth

Thu, 04 Dec 2025 00:00:00 +0000

10 year of bringing Plymouth’s digital community together!

Getting to come along for the journey has been an honor.

We’re too quick to say that something is life changing nowadays. So much so that its become a cliché. But for this meetup, the people around it, and those that attend, it is often true in the truest sense of the word.

Whenever I’m doing something amazingly fun professionally, in the farthest corners of Europe, I can ALWAYS trace the origin back to the encouragement and support that came from being a part of the Digital Plymouth / Plymouth Web / PlymouthJS communities 🙏

It been great to watch it grow over the past decade into something bigger, more diverse, and even more impactful to the city.

Here’s to 10 more years of the same 🥂

A response to https://www.linkedin.com/feed/update/urn:li:activity:7402436542780305408/.

Hanging up the wigs

Fri, 28 Nov 2025 00:00:00 +0000

I’ve hung up the wigs for 2025.

But be warned. . . they’ll be back on occasion in 2026.

In recent years, the two talks I’ve delivered the most have both had a gimmick. Something to create a photo opportunity as part of an event, and hopefully to put a smile on the audiences face.

It worked!

Well. . . most of the time.

Without giving away the moment, the wigs and hats were both an integral part of the talks. But you (or even the organiser) can only play the fool so often, and it’s time to be a little more serious with the content I deliver. So whilst they’ll both be back, they’ll be used mainly for meetups where things are a little more informal and expectations on takeaway learnings are a little lower.

But one of the projects behind the talk has changed a huge amount over the years. Plus it’s super fun to work on.

Back then it was little more that a clone of a platform demo with a changed h1 tag, a ton of showmanship, and a dash of hot bars. Today, it’s grown into a multi API backend encompassing locally hosted speech recognition, LLMs, and image recognition paired with either a website or .NET tMAUI desktop app as the interface. It’s even binging in the hot newness that is Aspire to both the web and .NET stacks.

Naturally, the software is a bit shaky. That’s part of the fun. However the learnings are solid and it keeps a mechanism for growing my hat collection a little more.

The trickiest part?

Fitting the details into a paragraph or two so I can submit to conferences!

Wish me luck 🤞

The value of user testing

Wed, 26 Nov 2025 00:00:00 +0000

At work, the project I head up is entering its final phase of development before release. To make sure that we’re making guests life easier, I’ve hosted a user testing session in recent days. The results are surprisingly unsurprising. Bugs have been flagged up, paths through the app were broken, and features were not used as expected.

It was enlightening!

Whilst we’re well past the prototyping phase, the Designing UX: Prototyping book by Dan Goodwin and Ben has been super useful in setting up this activity. It pushed me into the right mindset for testing in a high fidelity context, giving a great framework for asking the right questions and setting the right tasks for users to work though. Although some of the tooling in the book in out dated, the concepts are solid and will never not be relevant. It’s also a super easy read, and pairs up well with lessons withing ‘The Mum Test’. Both are highly recommended if you’re about to perform this type of task.

On the day, test users were provided with four groups of related tasks, the kind of things that guests will over the lifecycle of their stay. Feedback was gathered via both a form and conversation, plus observational notes to pair with screen and audio recordings. The perspective afforded by looking over a shoulder instead of testing yourself allows different elements of the product to jump out. E.g,

I never miss the hit box to open the account edit screen, but every single tester did.
Users consistently look for X as part of the search interface.
I think feature X is complete, but the people from within the brand think Y and Z are missing from it.

Talking with frontline staff, those on the end of the phone during both the booking process and during the stay, uncovered a bunch of easy wins for the product.

“20% of our calls are about X”
“Our life would be easier if guests had Y when they called up”
“99% of guests only have one booking at a time”

The process also threw me back to a conversation at the Product Task meetup in Köln. I was talking about testing with a fellow attendee, with the conversation continuing afterwards digitally. I highlighted that my test group will come from within the company. It was suggested that they’d use the product differently to actual guests due to institutional knowledge, whilst I exibited an undeserved level of hubris that they wouldn’t.

Surprise surprise. . . they did.

One of the tasks was to navigate to a booked property, effectivly the stay starting tomorrow. Everyone within the business checked to see if the textual directions were present in the app. Everyone outside of the business simply clicked the map to start navigation within their maps app. This really highlighted how institutional knowledge affects the was a user performs a task. Martin. You were right. . . but only one of us knew that at the time! To paraphrase Tim Herberg, the speaker on the night:

Gut feeling has a place in the discovery process. It can inform the direction in the early days, but should quickly be backed up or discarded due to data.

Unfortunatly, I’d forgotten that point in the sime since and neglected to get the data to back up my assumptions.

Overall this was an enlightening process, and one that reminded me of the value that the rapid feedback loop that often comes with an agile-esque development process. Whilst some of the things that were flagged up are solid suggestions, there’s not really enough time to both polish what exists and introduce the refined features before launch day.

Lesson learned.

This was a fun and very useful process to go through as a product developer. I’m now sitting on a pile of actionable feedback, insights from different levels of the business, and even a few ideas that can help make the wider teams life easier via minimal changes to existing products or a quickly vibed prototype.

Oh. . . and biscuits. We ate a lot of biscuits.

Looking around @ HalfStack London

Fri, 21 Nov 2025 00:00:00 +0000

Rings - Aesop Rock

Tue, 18 Nov 2025 00:00:00 +0000

Used to draw
Hard to admit that I used to draw
Portraiture and the human form
Doodle of a two-headed unicorn
It was soothin’, movin’ his arm in a fusion
Of man-made tools and a muse from beyond
Even if it went beautifully wrong
It was tangible truth for a youth who refused to belong
No name nuisance, stews in a bedroom
Oozing a brand new cuneiform
Barely commune with the horde
Got a whole gray scale ungluing his world

Might zone out to the yap of the magpie
Unseen hand dragging his graphite
Cross contour, little bit of backlight
Black ink after a Bristol to baptize
You can’t imagine the rush that ensue
When you get three dimensions stuffed into two
Then it’s off to a school where it’s all that you do
Being trained and observed by a capable few
Back in New York, five peeps and a dog
In a two-bedroom doing menial jobs
Plus, rhymin’ and stealin’ and being a clod
Distractions free to maraud

I left some years a deer in the light
I left some will to spirit away
I let my fears materialize
I let my skills deteriorate
Haunted by the thought of what I should have been continuing
A mission that was rooted in a 20-year affinity
In rickety condition with an ID crisis
Nap on the front lawn, look up in the sky, it’s…

Shapes falling out of the fringe
All heart, though we would’ve made cowardly kings
They will chop you down just to count your rings
Just to count your rings, just to count your rings
And there were colors pouring out of the fringe
All heart, though we would’ve made cowardly kings
They will chop you down just to count your rings
Just to count your rings, just to count your rings

Used to paint
Hard to admit that I used to paint
Natural light on a human face
Stenciled fire on his roommate’s bass
It was blooming addiction
Amiss in the pushing of pigment
Book like a tattooed pigskin, look
Pinhead kids of the minute
Drank Kool-Aid from a tube of acrylic
And it grew up into linseed oil over linen
Joy to the poison, voice of the resin
Capture a map of the gesture
Back up, add a little accurate fat to the figure

Redo that, move that inward
Zinc white lightning shoots from his fingers
Studio strewn with illusion and tinctures
Stay tuned for the spooky adventures
You can’t imagine the stars that align
When a forearm starts foreshortening right
Or a torso hung on a warping spine
In proportion reads as warm and alive
Routine day with a dirt cheap brush
Then a week goes by and it goes untouched
Then two, then three, then a month
And the rest of your life, you beat yourself up

I left some seasons eager to fall
I left some work to bury alive
I let my means of being dissolve
I let my person curl up and die
Eating up his innards, an unfeasible anxiety
Has brutally committed to relinquishing his privacy
Aligning with the trials of the anti-Midas
Nap on the back lawn, look up in the sky, it’s…

Environment dictates performance

Mon, 17 Nov 2025 00:00:00 +0000

A recent conversation with a mentee who is stepping out of education into the world reminded me of this well known phrase. It’s one that makes logical sense.

If you’re in a high performing environment, your much more likely to perform to a high level.

If you’re in a creative environment, you’re much more likely to be creative.

If you’re surrounded by people who are learning, incrementing skills upwards, and pushing boundaries. . . you will as well.

The world around us is a normalising factor.

My advice to them at the outset of their career. . . be eternally careful about the world you choose to inhabit.

Tech Mids community conference

Fri, 14 Nov 2025 00:00:00 +0000

Woah.

That’s how you bring a community together!

230 of the Midlands best and brightest descended on the Mailbox in Birmingham for the TechMids conference.

Did we have fun? We sure did 😎

The sessions across the day covered an extremely broad range of topics. Whilst every single one deserves a mention, there are a few highlights that provided value that is being taken back to the Sapphire Holidays dev team.

Becki Floyd dropped a UX bomb, showing the audience the inner awesomeness of the Voxpopme, a tool to validate ideas and garner feedback at a humungous scale.

Guy Barker shared a11y insights drawn from his dotnetMAUI Accessible Solitaire app, backed by a lifetime of experience in the field. What the talk lacked in chanting (this time), it made up for in actionable insights 🙌

Si Jobling dispensed psychological safety from the stage, thanks to the PETALS framework. It’s a simple framework for continuously improve a tech team’s health. Don’t worry Si. . . I refused to do the exercise with Toby as suggested. . . instead having a useful topic adjacent conversation during that part of the proceedings 💬

Wrapping up the day was a wonderful talk from Shaun Lawrence which perfectly walked the tightrope of informative, fun, and inspirational. I’ve not yet managed to convince the team to set up a IoT brewing operation in the corner of the office, but I suspect it won’t take much more persuasion.

Overall, this is tied with WhatTheStack Conference as my favourite community led event to be a part of in 2025.

Why?

As a speaker, you know you’re part of a great line-up when you don’t want to be in your own talk!
You also know you’re in safe hands when the track host, conf team, and audience join forces to fix show stopping problems in the moments before your talk starts (thanks Bruce 🙏)
You know your witnessing a thriving community when the conversations carry on LAAAAATE into the night.

With TechMids over, my speaking engagements for 2025 are complete. There is no other conference on the earth that would have provided a juicier cherry to top this years conf cake.

It. Was. Perfect.

Let’s make this a tradition and do it again next year.

It’s lovely to finish the year with a short-long trip home 🚗

P.S - If anyone knows how to take good a selfie whilst facing the camera into a cinema projector. . . please let me know. It’s turning into a recurring problem 😂

The end of the HalfStack era

Wed, 12 Nov 2025 00:00:00 +0000

I’ve never been so sad to have a day watching fun talks, have conversations with friends, all whilst munching tasty pizza and late night bagels.

Why???

HalfStack London is fin. . . but it went out with the creative flair that I’ve come to love about Londons Tech Community. Over the past nine years, this conference has been a highlight of each and every year for a multitude of reasons.

Every talk added something to the event, with a few highlights coming via Jo Francetti, Eduardo Cardenes, Leo Rivera, Carly Richmond and Steve Goodwin. Combined, they served up sessions based around LLM assisted procedural generation, cutting edge APIs, Star Wars themed vector databases, advice on progressing through a company, with a dash of midi madness thrown in for good luck.

In all honesty, these were the standout sessions because they were the ones I caught. Every other talk would have made the list, but with so many interesting attendees to chat with, the hallway track was as popular as ever. Plans for 2026 were hatched, ideas for talks bounced around, and musical collaborations planned.

So why is this conference so special to me?

As a student, it was the first one I attended outside of the southwest and got to meet the people whose tutorials I was following. It was the conference that really sparked my love of tech events. It was a place where I got to meet future friends, collaborators, and speakers for my events. It’s the gathering that I wrote my most popular talk for, one which is still paying dividends all these years later.

It’s the event that opened my eyes to the broader tech industry beyond bashing out code.

Whilst the London outing of the conference is coming to a close. . . for now at least. . . the things it’s added to my life will remain until the end of time.

A massive thank you to Dylan for putting on the jewel in the conf crown, and for the support with various adventures over the years.

WhatTheStack Community Conference, Skopje

Sat, 20 Sep 2025 00:00:00 +0000

WTF was that WTS!?!

To call WhatTheStack a conference would be doing it a disservice.

Community conference comes closer. But still not quite right. Even amongst the best grassroots tech events in Europe(ish) , this one stood out amongst them all. And not just for the conference itself.

Skopje offered the perfect location for a late summer tech event. Clear blue skies provided the backdrop for a architecturally interesting city. Vienna-esque grandeur blended with Soviet style buildings to offer one of the most interesting walks to an event venue ever, with the venue itself offering a peek inside a great example of the brutalist style.

But 30+ speakers didn’t descend on Macedonia from around the globe to take in the buildings, weather, and the THOUSANDS of statues. We were there to share our love of the web through our talks.

We certainly did that!

The big event on Saturday was preceded by a week of smaller events at Base42, a hackerspace in the heart of the city. As part of it, I dropped some Beats, Rhymes, and Neural Nets on the audience. Thankfully, the audience were right into it. I’m always hesitant with this talk in far flung places, as not all cultures appreciate talks at the fun end of the spectrum. This lot. . . they appreciated it more than most 💪

For the main conference, the speakers brought their A++ game. Despite the demo-gods not being on the side of everyone, the sessions were clearly a hit with audience. Whether you wanted to deep dive into React, Angular, (software) architecture, hear case studies, or be made to think, there was something for everyone. Whilst I didn’t get to see a whole host of the sessions, one of the ones I did really shone a light on how useful Supabase would be when prototyping software. Thanks Fanis!

Once the audience had filtered away after the event, the awesomeness of the gathering really shone through. After comparing notes amongst the speaker group, the consensus is that attendees were proactive in seeking out speakers to talk to. Whilst this might not sound like much, typically you’d get a couple of “thanks, that was great” comments and maybe a question or two.

Not at What the Stack.

The community were keen to talk. Very keen in fact. And this is a great sign of a thriving, safe, and engaged community that you don’t get at many events, and one of the things a community conferences should be. Rough around the edges, but polished in the places that matter. Informal, but without becoming a collection of cliques. Honest to what it is, whilst trying to grow into something greater.

This is a direct reflection of the team behind the event, and the communities in the city. To say the speakers were given a personal touch is an understatement. It was more of a concierge service. Want a table at a restaurant booked? Sure. Need a taxi? No problem. Want a day trip to Kosovo? Be ready at 9am. EVERY single tech event organiser, regardless of the scale of the gathering, could learn a thing or two from the team here.

Overall, this has been my favorite conference in a very long time, with Skopje rocketing to the top three of my favorite cities. If you are a speaker in the web world, follow the conf page and keep an eye out for next years CFP. You won’t regret it.

If you are lucky enough to be selected, and you ask nicely, Faris might even buy you a post-event ice cream as well 🙏

Hope to see you there in 2026!

Putting it to the test

Tue, 08 Jul 2025 00:00:00 +0000

For the past few years I’ve been learning German on and off. Today the is the day my approach is to be put to the test.

Instead of spending an extortionate amount of time with apps, books, and AI tools the method has essentially been to overwhelm my brain with the language without worrying what is being said. Almost without exception, every audio book, podcast, book, TV show, song, and Formula 1 race has been purposely undecipherable. The theory. . . no German word will ever take me by surprise.

It’s been a weird experience.

Whilst I only know the very basics of the language off by heart, I can recognise and say hundreds of words without knowing what they mean. Reading basic text out loud is no problem. And, hopefully, being a host of Europe’s largest software development conference in Berlin won’t present too many linguistic challenges.

If all else fails, they’ll be treated to a few raps to fill the time.

Whilst I might struggle to order a meal in German, I’m fully prepped to rock the karaoke stage 🎤

Gotta have your priorities right 😎