<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Lloyd Moore on Medium]]></title>
        <description><![CDATA[Stories by Lloyd Moore on Medium]]></description>
        <link>https://medium.com/@iolloyd?source=rss-6b4bca04d30a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*ESztxmjEEHb4LeLRzkw3gg.jpeg</url>
            <title>Stories by Lloyd Moore on Medium</title>
            <link>https://medium.com/@iolloyd?source=rss-6b4bca04d30a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 02:08:33 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@iolloyd/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Your Entire Project Lifecycle in a Single Taskfile]]></title>
            <link>https://medium.com/@iolloyd/your-entire-project-lifecycle-in-a-single-taskfile-9469108ab080?source=rss-6b4bca04d30a------2</link>
            <guid isPermaLink="false">https://medium.com/p/9469108ab080</guid>
            <dc:creator><![CDATA[Lloyd Moore]]></dc:creator>
            <pubDate>Sun, 08 Mar 2026 14:20:40 GMT</pubDate>
            <atom:updated>2026-03-08T14:23:35.518Z</atom:updated>
            <content:encoded><![CDATA[<p>Open a typical project repository and count the places where lifecycle logic lives.</p><p>Build commands in `package.json` scripts. Git hooks managed by husky or lefthook. File watching through nodemon or chokidar. Linting configuration that also defines when linting runs. CI pipelines in YAML that duplicate half of what the build scripts already do. Maybe a Makefile too, because someone once needed a shorthand for `docker compose up`.</p><p>Each of these works. None of them know about each other.</p><p>A new engineer joins the team, and asks “How do I run the tests?” The answer is: it depends. If you mean locally, `npm test`. If you want linting first, check the Makefile. If you want to know what runs on commit, look in `.husky/pre-commit`. If you want to know what CI does, open `.github/workflows/test.yml`. The lifecycle of the project is scattered across five or six files in three different syntaxes.</p><p>This is not a tooling problem, but more of an architecture problem. And it has a straightforward solution.</p><p><strong>Why it got this way</strong></p><p>Each tool solved its own problem well. npm needed a way to run scripts alongside package management. Git needed extensible hooks for repository events. CI systems needed declarative pipelines. File watchers needed configuration for what to watch.</p><p>The trouble is that every ecosystem assumed it owned the lifecycle. npm thinks it owns your build. Git thinks it owns your commit workflow. Your CI provider thinks it owns your test pipeline. None of them intended to create fragmentation. They each solved their piece without considering the whole.</p><p>The result is accidental architecture. Your project’s lifecycle is the sequence of checks, builds, tests, and deploys that turn source code into running software, but it often has no single definition. It is implied by the collection of config files, and the only person who knows how they all fit together is the one who set them up.</p><p><strong>The pattern underneath</strong></p><p>When you strip away the tool-specific syntax, all lifecycle automation reduces to three primitives.</p><p><strong>A dependency graph</strong>. Some things must happen before other things. Tests run before deploys. Linting runs before tests. The database schema exists before the integration tests start.</p><p><strong>Event triggers</strong>. Something happened. This could mean a file was committed, a branch was pushed, or a deploy completed, and now other things should run in response.</p><p><strong>File-change detection.</strong> A source file changed, so the build output is stale and needs regenerating. If nothing changed, do not rebuild.</p><p>Unix figured these out decades ago. Make handles dependency graphs and file-change detection. Directories of executable scripts handle event triggers — put a script in `/etc/init.d/` or `.git/hooks/` and it runs when the event fires. `inotify` and `fswatch` handle file watching.</p><p>These are solved problems. The modern tooling landscape has not improved on them. It has scattered them across more files.</p><p><strong>Enter task</strong></p><p><a href="https://taskfile.dev/">Task</a> (go-task) is a task runner written in Go that absorbs all three primitives into a single YAML file.</p><p>It is not revolutionary. It does not introduce new concepts. What it does is consolidate. The dependency graph, the event triggers, the file-change detection, and the cleanup logic all live in one `Taskfile.yml` at the root of your project.</p><p>Here is what that gets you.</p><p><strong>Dependencies</strong> replace ad-hoc ordering. Instead of hoping your CI pipeline runs lint before test, you declare it: `deps: [lint]` on your test task. Task resolves the graph.</p><p><strong>Sources and generates</strong> replace Make’s timestamp logic. If the source files have not changed since the last run, Task skips the work. You get Make’s best feature without Make’s archaic syntax.</p><p><strong>Watch mode</strong> replaces nodemon, chokidar, and similar tools. Add `watch: true` to any task and Task monitors its source files, re-running when they change.</p><p><strong>Defer</strong> replaces cleanup scripts and trap handlers. Need to stop a service after tests finish, regardless of whether they pass or fail? `defer` handles it.</p><p><strong>Cross-platform</strong> by default. Task is a single Go binary. No Python runtime, no Node dependency, no GNU-vs-BSD Make incompatibilities. It works the same on macOS, Linux, and Windows.</p><p>The advantage over Make is not any single feature. It is that a Taskfile is readable. A new engineer can open it, scan the task names, and understand the project lifecycle in thirty seconds. Think how more challenging that can be with a Makefile that uses implicit rules and recursive variables.</p><p>And the advantage over npm scripts, husky, and the rest is scope. Task does not just handle builds. It handles the entire lifecycle, from repository setup to deployment, in just one place.</p><p><strong><em>The complete working example</em></strong></p><p>Here is a Taskfile.yml you can drop into a project. It covers initialisation, dependency management, linting, type checking, testing, building, deployment, file watching, and git hooks.</p><p>```yaml<br>version: ‘3’</p><p>vars:<br> APP_NAME: myapp<br> BUILD_DIR: dist</p><p>tasks:<br> init:<br> desc: Set up the project for first use<br> cmds:<br> — mkdir -p .git/hooks<br> — |<br> for hook in pre-commit pre-push; do<br> printf ‘#!/bin/sh\ntask %s\n’ “$hook” &gt; “.git/hooks/$hook”<br> chmod +x “.git/hooks/$hook”<br> done<br> — task: deps<br> status:<br> — test -x .git/hooks/pre-commit<br> — test -x .git/hooks/pre-push</p><p>deps:<br> desc: Install dependencies<br> cmds:<br> — npm ci<br> sources:<br> — package-lock.json<br> generates:<br> — node_modules/.package-lock.json</p><p>lint:<br> desc: Run linters<br> deps: [deps]<br> cmds:<br> — eslint src/<br> sources:<br> — src/**/*.ts<br> — .eslintrc.*</p><p>typecheck:<br> desc: Check types<br> deps: [deps]<br> cmds:<br> — tsc — noEmit<br> sources:<br> — src/**/*.ts<br> — tsconfig.json</p><p>test:<br> desc: Run tests<br> deps: [lint, typecheck]<br> cmds:<br> — jest — coverage<br> sources:<br> — src/**/*.ts<br> — tests/**/*.ts</p><p>build:<br> desc: Build for production<br> deps: [test]<br> cmds:<br> — esbuild src/index.ts — bundle — outdir={{.BUILD_DIR}}<br> sources:<br> — src/**/*.ts<br> generates:<br> — “{{.BUILD_DIR}}/**/*.js”</p><p>deploy:<br> desc: Deploy to production<br> deps: [build]<br> cmds:<br> — kubectl apply -f k8s/<br> defer: { task: healthcheck }</p><p>healthcheck:<br> desc: Verify deployment health<br> cmds:<br> — curl -sf <a href="https://{{.app_name}}.example.com/health">https://{{.APP_NAME}}.example.com/health</a></p><p>dev:<br> desc: Start development with file watching<br> deps: [deps]<br> watch: true<br> sources:<br> — src/**/*.ts<br> cmds:<br> — esbuild src/index.ts — bundle — outdir={{.BUILD_DIR}} — sourcemap</p><p>pre-commit:<br> desc: Git pre-commit checks<br> deps: [lint, typecheck]</p><p>pre-push:<br> desc: Git pre-push checks<br> deps: [test]<br>```</p><p>Every lifecycle event lives here. `task init` wires the git hooks. `task dev` watches for changes. `task deploy` runs the full chain — install, lint, typecheck, test, build, deploy, healthcheck. A new engineer reads this file and knows exactly how the project works.</p><p>The `sources` and `generates` fields mean Task skips work that does not need doing. If you have already linted and no source files have changed, `task test` skips linting and goes straight to the tests. This is Make’s file-timestamp intelligence with none of its syntax quirks.</p><p>The `status` field on `init` means it only runs setup once. Calling `task init` on a project that is already configured does nothing.</p><p>## The one thing it cannot do</p><p>Task cannot register itself as a git hook. Git will only execute files in `.git/hooks/`, and that directory is not committed to the repository. You need a one-time bootstrap step — `task init` — that writes the shims.</p><p>Each shim is a single line:</p><p>```bash<br>#!/bin/sh<br>task pre-commit<br>```</p><p>This is the irreducible minimum. Git controls its own hook mechanism, and no task runner can change that. But the logic — what actually runs on commit — lives in the Taskfile, not in the hook script.</p><p><strong>The principle outlasts the tool</strong></p><p>The recommendation here is `task`. It is the best current expression of a pattern that has worked for decades: define your lifecycle in one place, make dependencies explicit, skip work that does not need doing, and keep the syntax readable.</p><p>If `task` disappeared tomorrow, the pattern would survive. You could rebuild this with Make and a handful of shell scripts. You could do it with `just` and accept the missing file watching. The underlying ideas are older than most of the tools that fragment them.</p><p>But right now, `task` is the one tool that unifies all three in a single file that any engineer can read and understand in under a minute. That is worth something.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9469108ab080" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Economic Intervention That Stops Engineer Attrition: Pa]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">This is Part 2 of a series on engineer retention. Part 1 examined why senior engineers leave&#x200A;&#x2014;&#x200A;information asymmetry prevents executives&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@iolloyd/the-economic-intervention-that-stops-engineer-attrition-pa-2cc841ae30f5?source=rss-6b4bca04d30a------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@iolloyd/the-economic-intervention-that-stops-engineer-attrition-pa-2cc841ae30f5?source=rss-6b4bca04d30a------2</link>
            <guid isPermaLink="false">https://medium.com/p/2cc841ae30f5</guid>
            <dc:creator><![CDATA[Lloyd Moore]]></dc:creator>
            <pubDate>Mon, 01 Dec 2025 10:01:31 GMT</pubDate>
            <atom:updated>2025-12-01T10:02:56.456Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Why Your Best Engineers Are Interviewing Elsewhere]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">In 2018, a senior engineer at a $40M ARR SaaS company spent six months arguing that the proposed database architecture would not scale&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@iolloyd/why-your-best-engineers-are-interviewing-elsewhere-0794f3f90ae7?source=rss-6b4bca04d30a------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@iolloyd/why-your-best-engineers-are-interviewing-elsewhere-0794f3f90ae7?source=rss-6b4bca04d30a------2</link>
            <guid isPermaLink="false">https://medium.com/p/0794f3f90ae7</guid>
            <dc:creator><![CDATA[Lloyd Moore]]></dc:creator>
            <pubDate>Mon, 01 Dec 2025 09:55:36 GMT</pubDate>
            <atom:updated>2025-12-01T09:55:36.264Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[96% Retention in Hypergrowth: How We Beat the Industry Average by 28 Percentage Points]]></title>
            <link>https://medium.com/@iolloyd/96-retention-in-hypergrowth-how-we-beat-the-industry-average-by-28-percentage-points-98adfc4a3b74?source=rss-6b4bca04d30a------2</link>
            <guid isPermaLink="false">https://medium.com/p/98adfc4a3b74</guid>
            <dc:creator><![CDATA[Lloyd Moore]]></dc:creator>
            <pubDate>Tue, 08 Jul 2025 00:00:02 GMT</pubDate>
            <atom:updated>2025-10-27T14:27:12.894Z</atom:updated>
            <content:encoded><![CDATA[<p>When I told our CEO I wanted our best blockchain engineers to work part-time for Ethereum Foundation and Solana, he didn’t blink. Konstantin trusted me. But I understood why it sounded mad.</p><p>We were scaling Blockdaemon from 10 to 187 engineers. We’d just closed a funding round. Everyone knows you’re supposed to lock down your best people during hypergrowth, not let them moonlight with the competition.</p><p>But here’s what I’d learned: certain engineers need challenging work more than they need loyalty speeches. If Blockdaemon couldn’t provide that challenge every single day, they’d leave anyway. Better to let them scratch that itch with Ethereum Foundation while bringing back knowledge that would benefit us for years.</p><p>We ended up with 96% retention. Industry average is 68%.</p><p>That’s a 28 percentage point advantage during the exact period when most companies haemorrhage talent.</p><h3>Why Series A retention matters more than you think</h3><p>Series A is when the knowledge problem starts to kill you.</p><p>You’ve gained momentum. You’ve got paying customers. You’re hiring fast because the next funding round depends on hitting aggressive targets. And then someone leaves.</p><p>They take with them all the reasons why the codebase looks like it does. Why you made that architectural decision in March. Why the team culturally rejected that framework everyone else uses. The new person comes in and immediately creates work — explaining context, justifying decisions, re-litigating debates you thought were settled.</p><p>Lose three people in quick succession and you’ve lost your institutional memory. The team stops moving forward because they’re constantly explaining the past.</p><p>2025 data shows 38% of engineering leaders report less motivated teams than a year ago. Only 21% describe their teams as healthy. If you’re a Series A founder reading this and thinking “my team seems fine,” you might be six months behind the curve.</p><h3>What actually worked</h3><p>I’m not going to give you a generic retention framework. You’ve read those. They don’t work because they’re not specific enough.</p><p>Here’s what we actually did, and why it mattered.</p><h3>Let your best people work elsewhere</h3><p>I mentioned the Ethereum Foundation arrangement. This wasn’t charity. It was strategic.</p><p>Top engineers with niche blockchain knowledge were hard to keep challenged. Blockdaemon’s work was demanding but sometimes not cutting-edge enough for people who’d rather be solving novel cryptographic problems.</p><p>So we let them work part-time on Ethereum and Solana projects. They stayed engaged. We got early visibility into where the ecosystem was heading. They brought back knowledge that kept us ahead of the market.</p><p>The mistake most companies make is thinking they need to own 100% of someone’s time to get 100% of their value. Wrong. Give your best people the freedom to stay intellectually stimulated and they’ll give you their best work.</p><h3>Build systematic onboarding that scales</h3><p>When you’re growing fast, the temptation is to throw new people at problems immediately. We built Blockdaemon University instead.</p><p>Four-week rotation system. New engineers spent their first month learning from different teams, understanding our architecture, absorbing why we’d made key decisions. Crucially, this meant existing teams didn’t lose productivity every time someone new joined.</p><p>Most companies treat onboarding as a checklist. We treated it as a system. The difference: our teams stayed productive even while we were hiring aggressively.</p><h3>Design teams that don’t need help</h3><p>Cross-team dependencies kill velocity. Every time Team A needs something from Team B, you’ve introduced delay, coordination overhead, and frustration.</p><p>We structured teams so they could complete their work independently. Not perfectly — some dependencies are unavoidable — but we minimised them ruthlessly.</p><p>This mattered for retention because engineers hate being blocked. They hate waiting for other teams. They hate feeling like they can’t ship because someone else is the bottleneck. Give people autonomy to complete their work and they stay engaged.</p><h3>Pay globally competitive rates everywhere</h3><p>We paid salaries based on the highest paying regions, regardless of where someone lived.</p><p>This wasn’t altruism. It was pragmatism. If you want to hire the best people from anywhere, you can’t pay them based on local markets. You pay them what they’re worth globally.</p><p>Most companies try to arbitrage talent by paying local rates. They save money in the short term and lose people in the medium term. We chose to compete globally from day one.</p><h3>Evaluate fairly with SPACE</h3><p>Performance reviews are where retention dies quietly. People leave when they feel evaluations are subjective, political, or unfair.</p><p>We used the SPACE framework — Satisfaction, Performance, Activity, Communication, Efficiency. It’s not perfect but it’s systematic. More importantly, it gave us a common language for evaluating people that felt less arbitrary than “culture fit” or “leadership potential.”</p><p>Engineers respect systems. They don’t respect vibes-based management.</p><h3>Over-communicate the mission</h3><p>At any stage of onboarding — week one or month six — anyone on the team could tell you what Blockdaemon was trying to achieve and why it mattered.</p><p>That’s not an accident. I over-communicated constantly. Mission, strategy, priorities, trade-offs. Again and again until it felt repetitive to me but was finally landing with the team.</p><p>People don’t leave companies with clear missions. They leave when they don’t understand why their work matters.</p><h3>What this actually means for you</h3><p>If you’re running a Series A company, here’s what you should be thinking about:</p><p><strong>Who are your retention risks right now?</strong> Not the people who are obviously unhappy — you already know about them. The high performers who seem fine but haven’t been challenged in three months. They’re the ones who’ll get a LinkedIn message next week and actually reply.</p><p><strong>What knowledge lives only in people’s heads?</strong> If your best engineer left tomorrow, what decisions would the team struggle to understand? That’s your documentation gap. Fix it before you need it.</p><p><strong>Are your teams designed for autonomy?</strong> Map out the dependencies. Every time Team A waits for Team B, you’ve found a retention risk. Engineers who can’t ship get frustrated fast.</p><p><strong>How do people learn your “why”?</strong> New joiners need to understand not just what you’ve built, but why you built it that way. If that’s not systematic, you’re creating work every time you hire.</p><p><strong>Who’s being challenged enough?</strong> Your best people need hard problems. If you can’t provide them, they’ll find them elsewhere. Better to make that arrangement explicit than lose them entirely.</p><p>The 96% retention rate wasn’t luck. It was deliberate systems, built over time, that removed the friction that makes people leave.</p><p>Most companies lose their best people not because they’re bad places to work, but because they haven’t thought systematically about what makes people stay.</p><p>You’re scaling fast. You’re hiring aggressively. You’re under pressure to hit targets that unlock the next round.</p><p>But if you lose your best people in the middle of that, you’re not moving forward. You’re explaining the past to newcomers who don’t have the context to understand it.</p><p>That’s the retention problem at Series A. And it’s fixable if you’re willing to build systems instead of relying on hope.</p><p>Want this framework as a one-page reference? Download it here: <a href="https://lloydmoore.com/downloads/retention-framework.pdf">https://lloydmoore.com/downloads/retention-framework.pdf</a></p><p><em>Originally published at </em><a href="https://lloydmoore.com/posts/2025-07-08-retention-hypergrowth/"><em>https://lloydmoore.com</em></a><em> on July 8, 2025.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=98adfc4a3b74" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Less things for more]]></title>
            <link>https://medium.com/@iolloyd/less-things-for-more-b2edc48ace17?source=rss-6b4bca04d30a------2</link>
            <guid isPermaLink="false">https://medium.com/p/b2edc48ace17</guid>
            <dc:creator><![CDATA[Lloyd Moore]]></dc:creator>
            <pubDate>Fri, 28 Feb 2025 14:21:03 GMT</pubDate>
            <atom:updated>2025-02-28T14:21:03.039Z</atom:updated>
            <content:encoded><![CDATA[<p>Lloyd drummed his fingers on the conference room table as the team filed in for another architecture review. Four months into building Quantum, a promising new fintech app, and they were already drowning in complexity.</p><p>“Let’s start with the current state,” he said, approaching the whiteboard. His marker squeaked as he fleshed out their system: React frontend, seven microservices, PostgreSQL clusters, Redis caching layer, Kafka streams, K8s orchestration.</p><p>“And here,” he circled some arrows in red, “is where we’re seeing the timeout issues between the transaction service and the notification pipeline.”</p><p>Nods around the table. Eyes glazed with that fatigue of chasing phantom bugs through distributed systems.</p><p>“We could add another layer of retry logic,” suggested Gavin, their newest engineer. “Or maybe a circuit breaker pattern?”</p><p>“What about splitting the transaction service further?” offered Stefano. “One for processing, one for verification.”</p><p>More boxes. More arrows. More complexity to solve the problems created by complexity.</p><p>As Lloyd sketched out these proposed solutions, his hand slowed. He stepped back from the board, surveying what they’d created. What began as a simple idea to help people save money, had now morphed into a topology map that would make NASA engineers cry.</p><p>“Actually,” he said, putting the top back on his pen. “Let’s try something different.”</p><p>He wiped the whiteboard.</p><p>“What if we started over?”</p><p>“Three months in, and we have exactly zero users because we’re too busy untangling our own infrastructure,” Michael said. “So let’s rethink this with one rule: minimum complexity.”</p><p>They spent the morning building a prototype. One server. One SQLite database. Vue.js for the frontend. By lunchtime, they had a working version handling the core user flows.</p><p>“But it won’t scale,” Dukey protested, though his objection lacked conviction as he watched the app smoothly process test transactions.</p><p>“It doesn’t need to yet,” Lloyd replied. “First, let’s see if anyone wants what we’re building.”</p><p>Three weeks later, they launched with their embarrassingly simple architecture. Two hundred users in the first week. Five hundred by the end of the month.</p><p>“The notification delivery rate is 99.8%,” Jenny reported during their standup. “And the entire system fits in my head now. I fixed that balance calculation bug in twenty minutes yesterday because I could trace it end-to-end.”</p><p>Leo nodded. “And server costs?”</p><p>“Ninety-seven pound last month,” Gavin replied. “Down from five thousand, which is what we thought it would be.”</p><p>They did eventually add complexity. Six months in, with ten thousand active users, they migrated from SQLite to PostgreSQL. At fifty thousand users, they split out the analytics processing into a separate service. But each addition came only when they had proven they needed it. Only when simplicity alone no longer served.</p><p>A year later, Lloyd stood at a different whiteboard in a much larger office. A potential acquirer was doing technical due diligence on Quantum, now valued at eight figures.</p><p>“I don’t understand,” said the lead engineer from the acquiring company, studying their architecture diagram. “How are you handling two hundred thousand users with so few moving parts?”</p><p>Lloyd smiled. “We only add complexity when simplicity fails us. Not before.”</p><p>The acquiring company’s CTO leaned forward. “And your uptime?”</p><p>“99.97% over the past six months,” he replied. “Turns out, fewer things means fewer things break.”</p><p>As they filed out after the meeting, Gavin caught up with Lloyd in the hallway.</p><p>“Remember when we almost built that monstrosity last year?” he asked. “All those services and caches and queues?”</p><p>Lloyd nodded. “We’d have run out of money debugging it before we ever found product-market fit.”</p><p>“What made you change direction that day in the conference room?”</p><p>Lloyd thought for a moment. “I realized we were building an architecture by default and not to serve our requirements. Sometimes the most sophisticated solution is the one simple enough to actually work.”</p><p>The beauty of simplicity isn’t just aesthetic. In our rush to build systems that showcase our technical prowess, we often create complexity that becomes our master rather than our servant. We forget that technology exists to solve problems, not to create them.</p><p>The most powerful architectures aren’t the ones with the most impressive diagrams or the latest buzzwords. They’re the ones that deliver value with the minimum necessary complexity.</p><p>They’re the ones that leave room for humans to understand, maintain, and evolve them.</p><p>In both software and life, we can find wisdom in the courage to do less.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b2edc48ace17" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Engineering Strategy: Do’s and Don’ts for Effective Leadership]]></title>
            <link>https://medium.com/@iolloyd/engineering-strategy-dos-and-don-ts-for-effective-leadership-39424b9d7398?source=rss-6b4bca04d30a------2</link>
            <guid isPermaLink="false">https://medium.com/p/39424b9d7398</guid>
            <dc:creator><![CDATA[Lloyd Moore]]></dc:creator>
            <pubDate>Wed, 02 Oct 2024 13:58:04 GMT</pubDate>
            <atom:updated>2024-10-02T13:58:04.444Z</atom:updated>
            <content:encoded><![CDATA[<h3>Engineering Strategy: Do&#39;s and Don&#39;ts for Effective Leadership</h3><p>As engineering leaders, we often face the question: &quot;What&#39;s our engineering strategy?&quot;</p><p>Having a decent strategy is vital for a successful team. It&#39;s the roadmap guiding technical direction, resource allocation, and decision-making. Here&#39;s a comprehensive guide I follow to crafting an effective engineering strategy:</p><ol><li>Write Your Strategy Like an Argument</li></ol><ul><li>Present clear reasoning, not buzzwords</li><li>Structure: diagnosis of challenges → guiding policies → coherent actions</li><li>Skip the deck and write a one-page prose document</li></ul><p>Buzzwords may sound clever, but they can serve as boilerplate and are useless. Your strategy documents aren&#39;t meant to be as long as possible, so make each word count. The structure should start with a diagnosis of the challenges. This serves as context for the strategy and subsequent plan you&#39;ll put together. Writing well takes practice, so the proverbial &#39;deck&#39; is popular. If you put the work in to write well, it will also pay dividends in other areas.</p><p>2. Ground Your Strategy in Reality</p><ul><li>Be honest about what&#39;s working and what&#39;s not</li><li>Use data and feedback from your team</li><li>Focus on solving real problems, not aspirational goals</li></ul><p>People tend to follow narratives that align with their beliefs. Mindlessly relying on your echo chamber makes it all too easy to sell strategies that are not based on reality. If something isn&#39;t working, you can work to fix it now and reap the rewards later. Use any data or information that you have to your advantage. If you know there is data out there that you could use but don&#39;t have, I recommend including a goal to measure that missing information as part of your strategy.</p><p>3. Involve the Right People</p><ul><li>Align with business goals</li><li>Get input from senior engineers, product leaders, and executives</li><li>Engage early with a small working group for reviews</li></ul><p>Although producing the strategy document may be your responsibility, it should be a team effort. It never surprises me how the best ideas and insights can come from the most unlikely places.</p><p>4. Focus on Leverage</p><ul><li>Create efficiency across the organization</li><li>Standardize where it matters most</li><li>Think about where significant gains can come from</li></ul><p>Some people talk about operational efficiency as separate from strategy. I like to think of operational efficiency as a prerequisite to strategy.</p><p>5. Start Writing Today</p><ul><li>An imperfect strategy is better than none</li><li>Document implicit strategies first, then refine</li><li>Remember: Strategy is a living document</li></ul><p>Your first attempt at writing a strategy will most likely suck. So, when starting, keep it as simple as possible. Let&#39;s start with one thing that must change from the status quo. Once you explain why the change is required and share how you think you can make that change happen, you have your minimal strategy document written.</p><ol><li>Keep it simple</li></ol><ul><li>Avoid technical jargon and overly theoretical concepts</li><li>Focus on what truly matters</li><li>Keep it simple for effective execution</li></ul><p>Use language that everyone understands. There are no prizes for elaboration. Writing out a strategy allows you and others to understand a common goal and not to extend anyone&#39;s vocabulary.</p><p>2. Enforce It</p><ul><li>Establish precise accountability mechanisms</li><li>Set up regular check-ins and reviews</li><li>Be consistent in enforcing core guiding policies</li></ul><p>Now that you have a strategy, you must ensure it is acted upon. Ensure your team is as effective as possible by constantly working towards the same approach.</p><p>3. Strategy is where top-down is better than bottom-up, but:</p><ul><li>Allow flexibility at the team level</li><li>Encourage escalations when something feels off</li><li>Balance organizational goals with team autonomy</li></ul><p>Treat the strategy as rigid but malleable. As the marketplace and business requirements change, ensure the engineering strategy is updated accordingly.</p><p>4. Write Your Strategy Now</p><ul><li>Don&#39;t wait for perfect data or conditions</li><li>Start small and iterate</li><li>A strategy you can action is always better than an ideal draft</li></ul><p>Some say that writing is clear thinking. I cannot count the times I&#39;ve thought of an idea and then realized how much it needed reviewing whilst trying to put pen to paper. As you write your strategy, you&#39;ll often discover that some other dependency needs to be prioritized, or it may even trigger another idea. If you are waiting for the right time to do your strategy, now is the right time.</p><p>A practical engineering strategy should be simple, clear, and actionable. It should be grounded in reality, enforceable, and create leverage. Most importantly, it should align your organization and enable informed decision-making.</p><p>If you have any questions, reach out publicly or DM me. I&#39;m happy to discuss this further with anyone who needs help.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=39424b9d7398" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scrum is not web friendly]]></title>
            <link>https://medium.com/@iolloyd/scrum-is-not-web-friendly-b00354e17573?source=rss-6b4bca04d30a------2</link>
            <guid isPermaLink="false">https://medium.com/p/b00354e17573</guid>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[scrum]]></category>
            <category><![CDATA[continuous-delivery]]></category>
            <dc:creator><![CDATA[Lloyd Moore]]></dc:creator>
            <pubDate>Thu, 12 Apr 2018 15:37:58 GMT</pubDate>
            <atom:updated>2018-04-12T15:56:18.527Z</atom:updated>
            <content:encoded><![CDATA[<p>Scrum is not web friendly</p><p>tl;dr Do it properly, or get rid of it.</p><p>Ask different developers how long a scrum should be and you’ll get lots of different answers. That’s because there isn’t an ideal answer, but, there isn’t really a solid set of guidelines to discover what that answer should be. The only way to do that would be to be able to accurately predict how long each ticket will take in any given sprint. Anyone who has spent enough time doing estimations for tickets will know it’s more akin to art and guesswork than science. When somebody uses methods, such as gut instinct times two plus some percentage, it’s safe to say that it’s the wild wild west of planning. So if we can’t rely on our ability to provide accurate planning, we can at least make it easier by chopping up bigger jobs into smaller, more manageable tasks. This gets us some way there, yet only the most positive-thinking person would believe that this would lend itself to allowing the same amount of work, for the same amount of man-hours, from one sprint to the next.</p><p>The web is an ever-changing playing field, with updates taking place every minute, and yet, somebody introduced the idea that it’s better to wait anywhere between two and four weeks for an update. There are a couple of things wrong with this; why wait more time when you have a single new update or feature that’s complete and ready to go live? It’s crazy to have that hidden from the end user making zero impact. Also, the more changes that you release at any one time, the more things that can go wrong at any one time. By releasing a new feature or update as soon as it’s ready, it’s much easier to manage any problems that come along with that, and by adding value at a much more incremental pace, your application feels more organic, and is easier to manage and reason about. The other elephant in the room is bugs. I’m not aware of any environment where it’s better to wait for a bug-fix to be released at the end of some pre-determined time span.</p><p>Sprints are a good idea for managers and paper pushers, but they are not good for a modern web application that lives and dies from one day to the next. The original idea behind scrum was to provide an environment where teams could stick to a plan over a typical two week or more period. But two weeks for a web application is an eternity. Some people will argue that scrum and continuous deployment can co-exist, but it’s not a natural fit at best. Others will argue that one week scrums can be a thing, negating the retrospective and planning for the next sprint. Planning and prioritisation are moving targets, even without bugs in the wild, so, continuously plan, and continuously deploy.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b00354e17573" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Programmers are the problem’s solution]]></title>
            <link>https://medium.com/@iolloyd/programmers-are-the-problems-solution-31116f726fb4?source=rss-6b4bca04d30a------2</link>
            <guid isPermaLink="false">https://medium.com/p/31116f726fb4</guid>
            <category><![CDATA[business-strategy]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Lloyd Moore]]></dc:creator>
            <pubDate>Tue, 07 Nov 2017 22:51:48 GMT</pubDate>
            <atom:updated>2017-11-07T23:06:19.342Z</atom:updated>
            <content:encoded><![CDATA[<p>The problem with programming</p><p>The quality of software ranges from the highest quality, to abysmal. The type of quality software that exists, and indeed, has existed for a long time, has allowed us to land on the moon, make payments online, search for things with a browser; Google is now a house-hold word, and we know things about the human genome that would have been considered impossible not even twenty years ago.</p><p>A lot of programmers consider themselves ‘engineers’ which by most engineering standards, if not all, is laughable. Most software that I’ve seen, not all, is ridiculously low grade. That is not to say that the blame lies on the shoulders of the programmer. In most disciplines where accuracy and correctness are paramount, time is allocated accordingly. I find it hard to imagine a surgeon being rushed because of budget and time constraints to perform an operation, or an architect being told that suddenly that sky scraper needs to be completed in a month instead of a year, and yet these are the mainstays of the business of building software.</p><p>Amazingly, people that employ teams to build software to solve a business need, tend to undervalue the work involved by that team to complete it. So, even before the project has started, corners have already been cut, and the rest is history, and quite probably the future.</p><p>The solution is simple, although this is one of those cases where logic and reality don’t mix. Imagine that suddenly a business saw the light and decide to allocate more time and money to a software solution. This would reveal the other problem; that developers will tend to use as much time that has been allowed. Any software developer that is reading this and shaking their head is fooling themselves. Even if they themselves are not guilty of this, which I find hard to believe, I propose that they will know more developers than not that are.</p><p>So, with all that said, is there a solution? Yes, emphatically there is. Here is my three-line manifesto:</p><p>1. Stand on the shoulder of giants <br>2. Know which giants are worth standing on.<br>3. Know when to stand on their shoulders.</p><p>None of these points are valid without the other two, so my manifesto couldn’t be simpler than that. There are a multitude of people that have brought forth ideas, ideologies, best practices, languages and tools, and most of them are ignored by the programming masses. How many programmers have honestly compared methodologies of software architecture, the merits of OOP and Functional style problem solving through theory and practice, why closures matter, where continuation style programming makes sense, when it does matter to write unit tests and when in most cases it doesn’t. Am I right?</p><p>Is there one programming language that is better for most things? Of course not, although popular digital watering holes would lead you to believe that isn’t so. Kanban vs Scrum? they can be used together, and sometimes one is better than the other; it depends. What I’m trying to show with just a few examples is that the engineering is missing from software engineering in the main.</p><p>In physics, there is a lot of experimentation and theory. I’m not going to guess the ratio, but there’s a lot of both. The modern development team is fairly lacking in both. It’s mostly a combination of past experience and brute force. I’m not referring to the well-known facebook-google-netflix-cloudflare-soundcloud-twitter-github-esque teams of this world, but the working-for-money business-constraint-shadowed developers putting food on the table. In the main, business is hurting itself by hurting the development process, and developers need to stop being the frog that doesn’t see itself boiling in the slowly heating death-bath.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=31116f726fb4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Music and work]]></title>
            <link>https://medium.com/@iolloyd/music-and-work-709c5240e410?source=rss-6b4bca04d30a------2</link>
            <guid isPermaLink="false">https://medium.com/p/709c5240e410</guid>
            <category><![CDATA[music]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[work]]></category>
            <dc:creator><![CDATA[Lloyd Moore]]></dc:creator>
            <pubDate>Sun, 26 Feb 2017 14:31:57 GMT</pubDate>
            <atom:updated>2017-02-27T08:35:26.337Z</atom:updated>
            <content:encoded><![CDATA[<p>Music and work</p><p>“One good thing about music, when it hits you, you feel no pain” — Bob Marley.</p><p>Reggae music is something that I’ve loved since early childhood, where it was all around me in the not-so-leafy Manchester suburbs of Hulme and Moss Side. Amongst all the troubled labels associated with those places, music was a chance to forget reality, and step into a state of joy. Of course, as a pre-teen, one would never describe it as that, but there it was, an escape from unrest and a coming together of community.</p><p>Such is the power of music, that it’s ability to change the way we feel, the very essence of our conscious thoughts, is awe-inspiring at least and magical at best. Go into most industrial factories and you are likely to hear some form of music playing throughout the main halls of production. Enter the mechanic’s shop floor, the front cab of a lorry driver, and you won’t be surprised to listen to a local radio station, or a chosen playlist. But in these environments and others, such as the surgeon’s room when an operation is being performed, music plays an important role; sometimes a distraction from the task in hand, or a calming influence during stressful exertion. Go into any commercial gym and witness the countless trainees tuned into to their headsets, to get them through their workouts, or to help them break their previous workouts’ best efforts.</p><p>Music serves the purpose in each of these cases to alter the mood of the individual in some way. But is music always a good thing when we are working? Anything that requires you to accomplish something, regardless of how you feel about it, is work, regardless of the need to do it, and it can be joyful, or not. What is music? Music is described as a form of art. It’s also described as a form of entertainment through the practice of putting sounds together in a way that people like or find interesting. But this description masks the true power of music and how it affects our perception, the very thing that causes us to like something or find it interesting.</p><p>Our ability to consciously apply our minds is what allows us to focus. When we need to focus, we try to shut out all those things not related to the task in hand. In some instances, music can help us do just that, but it’s not always the case.</p><p>Let’s dissect the nature of music. It’s mostly repetitive across the broad range of genres. It has characteristics that cause our cognitive pathways to experience a higher degree of pleasure.Some music is experienced as being much more repetitive than others, and it’s this type of music that doesn’t distract the brain as much, making it more suited to those times when we need to focus. However, when music has lyrics, the sounds of the words turns on certain parts of our brain that cause a cognitive loading, which in turn distracts us from the job in hand when we need to concentrate.</p><p>Another important aspect of music is familiarity. When we hear something new, our brains pay even more attention to what we hear, again, distracting us from focusing on the current unit of work.</p><p>Certain styles of music tend to have those characteristics conducive to aiding concentration. Classical music, especially with baroque timing, has a measurable positive impact on productivity and increased concentration. Ambient electronica is another style that has pronounced layers of repetition and sits easily in the background of our consciousness, aiding in better focus. Video game tracks are especially designed to not distract the game player and for that reason provide a great audio backdrop for improved concentration and focus. A great example amongst many is the Eve Valkyrie VR soundtrack.</p><p>Some noise, although not technically a style of music, can block out audible distractions, helping the listener to zone in and achieve a state of ‘flow’.</p><p>The best way to listen to music or noise is with headphones. This produces a more tailored experience and allows the listener more control over their sonic environment.</p><p>There is one exception to the benefit of music when we are focusing and that is when we are learning something. Since any music or noise causes some cognitive loading, it’s better to have total silence when trying to learn new material. Although people may experience a lift in mood whilst studying, there isn’t a direct link between the mood experience and the ability to absorb new information. For those individuals who cannot stand the experience of silence, it may help to play something to detract from the feeling of anxiety, although for everyone else, silence is key when learning.</p><p>In summary, if you want to increase your attention to the work in hand, playing certain types of music can increase productivity and positively alter your mood. However the effect is much more enhanced when listening with headphones. If you need to learn, no music whatsoever is best.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=709c5240e410" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Testing, the truth]]></title>
            <link>https://medium.com/@iolloyd/testing-the-truth-cfddd8b6974a?source=rss-6b4bca04d30a------2</link>
            <guid isPermaLink="false">https://medium.com/p/cfddd8b6974a</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[testing]]></category>
            <dc:creator><![CDATA[Lloyd Moore]]></dc:creator>
            <pubDate>Tue, 07 Jun 2016 20:27:55 GMT</pubDate>
            <atom:updated>2016-06-07T20:27:55.938Z</atom:updated>
            <content:encoded><![CDATA[<p>Most unit testing is a waste of time. If you are not using integration tests, just give up already. An application is a solution to a problem, as a whole. If the individual pieces work on their own, but they don’t work together, do you really think that the unit tests have any business value when they tell you that they work?</p><p>Please take note that when I say most unit testing, I mean explicitly that, which is different from all unit testing. Unit testing alongside integration testing can be extremely useful. If all the unit tests pass, but the integration tests fail, it’s child’s play to eliminate the units of code themselves, and look at the parts of the application that glue the units together for the culprit.</p><p>However, it’s an isolated case, and in the realm of all the things that can go possibly wrong, not a huge help. Writing unit tests takes time, and the benefits of spending that same time to prove a much larger part of the code-base works will get my vote, and the vote of the person paying for development, every time.</p><p>Another downside to the culture of unit testing is using unit tests as a means to code architecture. It’s embarrassingly common for developers to write some code that passes a unit test and move on. That’s so common it’s scary. If you are wondering what the next step should be then hang your head in shame. The next step should be to refactor the code so that it’s designed well following good code practices. Just because the code passes a unit test, it doesn’t mean it’s ready for production, it just means it passes a unit test.</p><p>Integration tests (or any tests) should provide decent informative comments about why something failed. If this is difficult to do, then it’s time to look at the code base, run ‘git blame’ and get whoever is responsible for not providing decent error checking to rectify their glaring faux pas. It’s pointless writing tests for code that’s not ready. If it’s not easy to provide informative error messages in the tests, you have a deeper issue that’s begging to be solved.</p><p>Automated tests are under-used. If you have the luxury of a QA team, and all their tests are manual, then you clearly have money to burn. Automate all the things. Invest the time to be able to do this and increase the quality and depth of your testing.</p><p>Tests, whether automated smoke tests, integration tests, or unit tests, all have their place, and time, just in varying degrees. Happy coding.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cfddd8b6974a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>