Joe Littlejohn

Event sourcing and BDD scenarios share the same mental model: both capture what has happened, not what hasn't. In event sourcing, we name events in past tense: "OrderPlaced," "PaymentReceived," "InvoiceAged." In Given-When-Then scenarios, the Given section describes past conditions—things that have already occurred. Here's what this means practically: there's no "payment not made" event because nothing happened. But "time passed"? That's an event we can capture if it has meaning in the domain. This shapes how I write Given statements. Instead of "Given I have not paid my invoice," I write "Given seven days have passed and there's no record of payment." Every Given becomes something that actually occurred—making scenarios more testable and mapping better to how (not just automated) systems really work. How do you handle time-based events in your scenarios? https://lnkd.in/gcMZHdph

14

8 Comments

The early 2010's were the golden BDD days, I really enjoyed the projects I worked on back then. An astute article on the rise and fall of BDD tools, and BDD in general. Thought I do wish people would stop talking about things "dying" in tech or being "dead", it's just evolution. " ... we as an industry failed to successfully productize tools for collaboration. The world jumped on BDD because Cucumber-esque frameworks were easy to adopt. The world was less willing to adopt BDD’s collaborative techniques because they were merely processes, not products. Products are sticky; processes are not. Cucumber tests will still be running after we all retire." https://lnkd.in/ezXXbvUE

1

Testing is often an unnecessarily emotive subject in the software industry. I particularly recall a trip to a 'Software Craftsmen' London meetup in the early 2010s - the culture disintegrated into a shark tank when a brave soul dared to even slightly question (respectfully) the received wisdom du jour. As a fresh graduate, was I then going to ask any questions I had? Was I heck! I didn't go back, safe to say. (I instead found the London Clojurians, a much friendlier bunch - my kinda people 😊) Fast forward to today: I wanted to define a more objective language to talk about testing - a recognition that, despite all of the religious fervour, there can be a pragmatic middle ground that adequately mitigates the risks at a reasonable cost. So, rather than vague lamentations around 'we need time to improve our tests', 'we don't have enough tests', etc, the dimensions in this JUXT article give us a more precise, objective language to talk about the value and costs that our tests bring, prioritise certain areas over others, or quantify our improvements. https://lnkd.in/eu8rp8Wa Have I missed any big ones?

13

9 Comments

Are your Operations Directors running strategy, or are they acting as high-paid compliance admins? A new project lands. You need 10 senior contractors for the next 6 months. That means 10 separate IR35 Status Determinations. So, what happens? Your Ops Director stops being a strategist. They scour contracts for substitution clauses, dig through messy email threads for working conditions, and manually click through the government's tax assessment tool. Every time you force leadership into manual data entry, you pay a tax. --> It burns half a day of director-level salary on a spreadsheet exercise. --> It stalls your sales cycle while you chase hiring managers for vague details. --> It introduces human error into a highly sensitive HMRC compliance check. This is the copy-and-paste tax. We're turning our most expensive assets into data entry clerks. In our latest Digital Workforce spotlight, we look at IR35 Determinations. A Digital Employee handles the complex compliance loop autonomously: ☑️ 1. The Intake: The moment a Statement of Work is signed, it reads the deliverables and working conditions perfectly, ignoring the noise. ☑️ 2. The Assessment: It hunts down the exact substitution clauses and populates the status determination tool in milliseconds. ☑️ 3. The Action: It generates the final statement instantly, only alerting your Ops Director if a marginal result requires professional human judgment. The result? Time-to-compliance drops to under 60 seconds. HMRC non-compliance risk is mitigated by design, not by effort. Your Ops Director stops chasing emails and goes back to doing what matters: scaling the business and managing client relationships. It's time to stop paying humans to act like software. Let them do human work. Watch the workflow in action. 👇 #DigitalWorkforce #IR35 #Compliance #Automation #Enbros

9

2 Comments

Some great thoughts for pair programming with agents by Nick Radcliffe: https://lnkd.in/eya7QdqE Best set of quotes: > So it’s tempting to think that Claude’s knowledge is broad but shallow. > But that’s wrong. > So Claude’s knowledge is broad and deep. > But that is wrong too. > A library “contains” knowledge but knows nothing. There is a sense in which Claude might be said to “know” something. > Claude “knows” a lot of things but doesn’t really understand what it knows

3

Platform Engineering Needs a Shared Language As I continue to chat with clients globally, I have seen that one of the hardest parts of platform engineering isn’t the tech, it’s the translation and lack of a shared language. I’ve lost count of how many times we’ve started a client kickoff and heard five different definitions of what “the platform” actually means. CI/CD pipelines, IDPs, Kubernetes, portals, everyone's talking about something slightly different. Those small misalignments slow everything down. Without a shared language and a clear strategy, teams struggle to move. That’s why we always spend time upfront building alignment before a single component gets designed. The Platform Engineering community has been a great reference point for us, giving us shared frameworks, vocabulary and examples that get everyone on the same page. Once that happens, org design, tooling, metrics and governance just flows much more naturally. I am looking for more insights into platforms and would love to hear how your team and organization describes “your platform”?

81

3 Comments

When you’re asked to lead a project in a framework you’ve never used… 🛑 Challenge My first role as a Tech Lead—and I joined a team already two weeks into an Angular project. I was a React developer by training, completely new to Angular, yet I was asked to guide those two engineers and own delivery. 💡 Action • Embraced the learning curve: Dove into Angular docs, tutorials, and sample apps. • Paired programming: Ran daily sessions to onboard my teammates and share emerging best practices. • Translated patterns: Adapted familiar React and TypeScript patterns into Angular’s structure. ⚙️ Results • The client loved our momentum and awarded us a follow‑on project. • Our billable team grew from 3 → 8 engineers in just a few months. • I received a significant appraisal hike for taking on the challenge—and delivering. 🔑 Takeaway Learning new libraries, frameworks, or technologies makes me a stronger, more adaptable engineer—and it invariably earns recognition. 🤔 Your Turn Have you ever stepped into a new technology and come out stronger? #LeadershipInTech #TechLead #CrossSkilling #FullStack #CareerGrowth #Learning

15

"Software architecture for developers" ... my 2-day introduction to software architecture, aimed at developers/engineers looking to move into tech lead/software architecture roles. We cover: - what software architecture is about - architectural drivers (requirements, quality attributes, constraints, principles) - the software architecture role - architecture diagramming (an architect's superpower) - architecture documentation - "how much up front design should we do?" Workshops are available to run privately in-person at your office, and I'm also running two more public workshops in 2026 in conjunction with the lovely folks at Trifork: - May 12-13; Amsterdam, Netherlands - September 28-29; Copenhagen, Denmark Links in the comments.

36

1 Comment

Currently halfway through The Pragmatic Programmer 2nd Edition, and two principles that really stood out to me are orthogonal design and DRY. Both ideas focus on reducing coupling and duplication so changes in one part of the code don’t cause issues elsewhere. It’s made me more aware of how repeated logic and connected parts can make projects harder to maintain than they need to be. I’m starting to look at my own projects and asking myself, If I change this, how many places will break? If the answer is more than one, there’s probably a better design. I definitely recommend this book to other students who want to work on their basics in software design and write more maintainable code!

5

Clearing System Design interviews at the Staff+ level remains a mystery. Even if you go for best-in-class courses, like HelloInterview by my colleague Stefan, you're often left on your own to show your experience. Sys Design is hard - you need to master foundations, manage time and comms, make solution future-proof, etc. Common prep materials make it worse with overly complex examples like social platform ranking systems or Dropbox-style sync protocols. The truth is: on Staff+ interviews they ask relatively simple questions to test depth, not speed. You won't waste time drawing 20 components - they want to see how deeply you think instead. I don't know the full formula to clear Sys Design rounds at this level, but can share what was working for me personally: 1/ Learn the fundamentals: things like GFS/Dynamo/RocksDB papers, behavior of distributed systems under high load, data locality, over-provisioning, clocks, replication lag, consistency models, use scientific notation, etc. Example from Anthropic Sr Staff interview: - Me: "I don't remember the exact metric name, but we trigger provisioning when we detect this resource utilization pattern." - Interviewer: "Oh, we call it metric X, and pattern Y, and the way you're describing it is how it works in our system." Pro tip: share some anecdotes, e.g., "we don't need persisted state from the get-go, but it was a nightmare to revoke stateless sessions on my previous project". 2/ Become good at sizing the problem. Know the population of key countries/markets, understand seasonal usage patterns across days/weeks, distributed systems fundamentals - like maximum dataset size for RDBMS, DB index overhead, key latency numbers, etc. Example from Google L7 interview: - Me: "Let me quickly quantify the system. For this problem, I'm estimating the population size to be in the mid-hundreds of millions, let's say it's 500M, but I will round it up to 1B." - Interviewer: "Actually, in my reference notes I have 500M, so let's keep it like this, so it's easier for me to compare the final numbers." - In the end, the final numbers checked. Pro tip: casually drop some fundamental reference, e.g. "By Little's Law, RAM won't bottleneck this cluster given our latency and throughput targets". 3/ Start and finish simple. Most real systems avoid expensive services like Kafka, complex client/server protocols, or real-time UI updates. Example from my current role's interview: - Me: "I'd just hash the input and denormalize the schema to avoid excessive DB upserts. Not the fanciest approach, but it works". - Interviewer: "Oh, this is exactly how our system actually works". Pro tip: research the company's tech stack, and don't be shy if you're not familiar with it: "I haven't used GCP, but we solved similar problems with AWS service X".

110

5 Comments

Watch and learn how technical coaching can enhance code quality and flexibility with Emily Bache’s Devoxx UK talk "Software Excellence in Large Orgs through Technical Coaching." Discover practical skills like TDD and refactoring to build a quality culture. Talk @ https://lnkd.in/gsntttW5

13

1 Comment

In this new video tutorial, Global Payment's Senior Software Developer Tony Smedal covers the complete configuration process including: 🔵 Extension activation 🔵 API key integration 🔵 Test transaction setup 🔵 Production deployment. This tutorial skips the installation basics and jumps straight into the configuration workflow (perfect for devs who need to get payment processing live quickly). Whether working on client sites or internal projects, this video covers the core setup process from development to go-live: https://bit.ly/3Gp9VgO

5

TDD finally pays off, just not the way we expected. For years I’ve balanced the pragmatism of time to market with TDD and test coverage for long-term maintenance. It’s a constant tradeoff. Every team I’ve led heard me say: we ship fast, but we don’t skip tests. Now, with AI-assisted development, that discipline matters more than ever. When you ask an AI model to refactor a module or implement a feature, it doesn’t know your business rules. It doesn’t know that changing a payment flow breaks a downstream reconciliation. It doesn’t know your edge cases. But your test suite does. A codebase with high test coverage becomes the safety net that lets AI move fast without breaking things. AI generates code, tests catch regressions faster, you iterate with confidence. You spend your time reviewing intent and architecture, not manually tracing side effects. TDD was always about fast feedback loops. We just didn’t have a consumer fast enough to benefit from them at this scale. Now we do. The discipline didn’t change. The context around it did. #TDD #AI #SoftwareEngineering #DeveloperExperience

48

1 Comment

I think this captures the situation well. Many of the people running this race are software engineers (aka interoperability developers). There’s plenty of coaching available—mainly in the form of NHS England interoperability and data-standards guidance—but much of it focuses on the third hurdle. That’s also where informatics clinicians tend to focus their requests, and so where national-level engineering and management attention often ends up. In reality, many software engineers have already burned out by the time they reach the second hurdle, or the project stalls there because the immediate business requirement—getting reports from the LIMS into the EPR—has been met. But as we shift from NHS Trust–level work to ICS and Regional Diagnostics models, we’ll need to come back to those first and second hurdles, scale them up into enterprise-level data models, and only then tackle the third. This needs to be an agile, iterative process—starting at hurdle one and working through each challenge together?

6

2 Comments

Technical debt, often a website or platform's greatest enemy, doesn't always have to be a problem. Not know what debt matters most does - unranked debt if you will. Most engineering teams already know what is wrong with their stack. The issue is that they do not agree on what matters most. Everything feels risky. Everything feels slow. So the backlog grows, and nothing fundamental changes because touching it feels, well, dangerous. I have seen this pattern repeat. Debt becomes a guilt list rather than a plan. A simple prioritisation lens helps: Stability; Speed; Control. Stability is anything that could break production or compromise compliance. Speed is what makes change expensive or painful. Control is what limits visibility, testing, and safe releases. Once issues are grouped this way, the conversation changes. You stop debating every item in the backlog and start asking where risk actually lives. Then do the hardest thing - choose. Pick how ever many fixes works for your team for the next 90 days that reduce risk the most. Not the loudest issues or the ones with the biggest architectural consequences. The ones that meaningfully improve stability, speed, or control. This is how technical debt stops feeling paralysing and starts feeling manageable.

1

Is your BDD suite a "tax" or a "tool"? Most teams struggle with the "Indirection Tax" of traditional BDD frameworks, the separate layer of glue code that sits between a specification and its execution. It often becomes harder to maintain than the application itself. I’ve been working on an architectural shift for choreo to eliminate this, and I recently put it through a real-world stress test: building a complete BDD suite for my other project, tbdflow. Dogfooding from the Trenches I wrote 40 real-world tests across 5 .chor files, covering everything from branch naming conventions to data-driven commit validation, but I realised that technical "Direct Execution" wasn't enough. I needed to move up the stack and separate Business Intent from Technical Protocol. Inspired by Dave Farley’s "Four-Layer Model" and a masterclass in feedback from Valentina Jemuović, I’ve introduced Composite Tasks to the Choreo DSL. As shown in the visual below, this allows you to define a "Domain Vocabulary" directly in your spec: 1️⃣ The Policy Layer: Scenarios that read exactly like your Acceptance Criteria. 2️⃣ The DSL Layer: Named tasks (e.g., create_branch or verify_commit_succeeded) that describe the "What." 3️⃣ The Driver Layer: Task implementations using Choreo's native actors that handle the "How." 4️⃣ The Execution Layer: Zero-glue interaction with your CLI, APIs, and System. The tbdflow suite proved that you can have high-level business specifications that are easy for stakeholders to read, without the maintenance penalty of external step definitions. Special thanks to Valentina for the invaluable insights on separating intent from protocol. 🙏 If you’re looking for a way to make your tests a true "Model Client" of your system, check out the updated choreo here: https://lnkd.in/dSdrcHrz #BDD #ATDD #SoftwareArchitecture #ContinuousDelivery #Rust #DevOps #PlatformEngineering

10

5 Comments

Thanks for listening at droidcon London #dcldn25 💀🎃 If you missed it, I can sum it up quick! Technical debt is not bad code, technical debt is the system you put in place that prevents your developers from doing their best work. Developers are not at the bottom of some hierarchy, they are the foundation of your company! Find ways to empower them, not shackle them, and you will find that "technical debt" stops being a talking point at every retro you have. And if you are a developer, know your value 💪 Stand up for the technical decisions you have to make, and take responsibility for your codebase. With the right mindset, everyone wins, all the way from end users to leadership 😊

39

1 Comment

The wonderful Oliver Whitwam has written a short blog about how we're practicing type-driven development and domain-modelling to create software that is both correct and is communicable via ubiquitous language. We're really making good usage of the Rust newtype and Haskell-esque smart-constructor patterns to leverage types to encode business rules and invariants (until Rust adds refinement types via pattern-types!). If you love #types, #correctness, #domainmodelling, you'll like this blog I'm sure! https://lnkd.in/eqKWXtqS

14

1 Comment

There's polarisation in how senior technical folks treat LLM coding assistants. And it seems to fall into two camps. When you're a senior technical person you typically have to branch at some point into either a people leader (Engineering Manager, CTO etc) or a technical leader (Principal Engineer, Architect). My sense is that people in the former camp are currently far more comfortable with LLM coding tools and get way more out of them. People in the latter camp can be more reluctant to use them, find them frustrating, and are even threatened by them. That may be because a lot of the skills involved in using LLM coding assistants well are the same as managing people: - Have a good plan. - Set expectations well. - Understand the technical aspect of what you're building, but be comfortable with delegating that. - Know what matters and what doesn't, and be OK with letting the unimportant things slide in pursuit of the bigger goal. Curious if anyone else is seeing this?

14

7 Comments