Posts Tagged ‘NDCConferences’
[NDCMelbourne2025] TDD & DDD from the Ground Up – Chris Simon
Chris Simon, a seasoned developer and co-organizer of Domain-Driven Design Australia, presents a compelling live-coding session at NDC Melbourne 2025, demonstrating how Test-Driven Development (TDD) and Domain-Driven Design (DDD) can create maintainable, scalable software. Through a university enrollment system example, Chris illustrates how TDD’s iterative red-green-refactor cycle and DDD’s focus on ubiquitous language and domain modeling can evolve a simple CRUD application into a robust solution. His approach highlights the power of combining these methodologies to adapt to changing requirements without compromising code quality.
Starting with TDD: The Red-Green-Refactor Cycle
Chris kicks off by introducing TDD’s core phases: writing a failing test (red), making it pass with minimal code (green), and refactoring to improve structure. Using a .NET-based university enrollment system, he begins with a basic test to register a student, ensuring a created status response. Each step is deliberately small, balancing test and implementation to minimize risk. This disciplined approach, Chris explains, builds a safety net of tests, allowing confident code evolution as complexity increases.
Incorporating DDD: Ubiquitous Language and Domain Logic
As the system grows, Chris introduces DDD principles, particularly the concept of ubiquitous language. He renames methods to reflect business intent, such as “register” instead of “create” for students, and uses a static factory method to encapsulate logic. His IDE extension, Contextive, further supports this by providing domain term definitions across languages, ensuring consistency. By moving validation logic, like checking room availability, into domain models, Chris ensures business rules are encapsulated, reducing controller complexity and enhancing maintainability.
Handling Complexity: Refactoring for Scalability
As requirements evolve, such as preventing course over-enrollment, Chris encounters a race condition in the initial implementation. He demonstrates how TDD’s tests catch this issue, allowing safe refactoring. Through event storming, he rethinks the domain model, delaying room allocation until course popularity is known. This shift, informed by domain expert collaboration, optimizes resource utilization and eliminates unnecessary constraints, showcasing DDD’s ability to align code with business needs.
Balancing Testing Strategies
Chris explores the trade-offs between API-level and unit-level testing. While API tests protect the public contract, unit tests for complex scheduling algorithms allow faster, more efficient test setup. By testing a scheduler that matches courses to rooms based on enrollment counts, he ensures robust logic without overcomplicating API tests. This strategic balance, he argues, maintains refactorability while addressing intricate business rules, a key takeaway for developers navigating complex domains.
Adapting to Change with Confidence
The session culminates in a significant refactor, removing the over-enrollment check after realizing it’s applied at the wrong stage. Chris’s tests provide the confidence to make this change, ensuring no unintended regressions. By making domain model setters private, he confirms the system adheres to DDD principles, encapsulating business logic effectively. This adaptability, driven by TDD and DDD, underscores the value of iterative development and domain collaboration in building resilient software.
Links:
[NDCOslo2024] Choosing The Best AWS Service For Your Website + API – Brandon Minnick
In the sprawling spectrum of cloud solutions, where a plethora of platforms perplex even the seasoned, Brandon Minnick, an AWS architect and mobile maestro, navigates the nebulous nebula of Amazon’s offerings. As a developer advocate with a penchant for demystifying deployment, Brandon dissects the dizzying array of AWS services—Lambda, Elastic Beanstalk, Lightsail, Amplify, S3—distilling their distinct domains to guide builders toward bespoke backends. His exploration, enriched with empirical evaluations, empowers enterprises to align ambition with architecture, balancing cost, celerity, and scalability.
Brandon begins with a confession: his own odyssey, as a mobile maestro thrust into AWS’s vast vault, was overwhelmed by options—acronyms and aliases abounding. His mission: map the maze, matching motives to mechanisms, ensuring websites and APIs ascend with alacrity.
Decoding the Domain: AWS’s Hosting Horizons
AWS’s arsenal is abundant: S3 stores static simplicities, buckets brimming with bits; Amplify augments apps, knitting frontends to functions. Brandon breaks down the basics: Elastic Beanstalk builds bridges, automating infrastructure; Lightsail lightens loads, offering preconfigured planes; Lambda launches lean, serverless scripts scaling seamlessly.
Each excels in its enclave: S3’s simplicity suits static sites, Amplify’s agility aids authenticated apps, Lambda’s litheness loves lightweight logic. Brandon’s benchmark: cost—S3’s cents versus Lambda’s low levies; speed—CloudFront’s celerity; scale—Fargate’s fluidity.
Cost and Celerity: Calculating the Calculus
Price predicates priority: S3’s storage starts at sub-dollar sums, Lambda’s invocations linger at $0.20 per million, Amplify’s adaptability aligns at $0.023 per GB. Brandon’s breakdown: static sites savor S3’s thrift, dynamic domains demand Amplify’s depth—authentication via Cognito, APIs via API Gateway.
Performance pulses: CloudFront’s CDN cuts latency to 300ms, Lambda’s cold starts cede to containers’ constancy. Brandon advises: weigh user whims—300ms matters for markets, less for leisurely loads.
Scalability and Simplicity: Structuring for Surge
Scalability shapes success: Lambda’s limitless leaps, Fargate’s fleet-footed fleets, Beanstalk’s balanced ballast. Brandon illustrates: API Gateway guards gates, throttling torrents; Amplify’s auto-scaling absolves administrative aches.
Simplicity seals the deal: Lightsail’s one-click launches lure lone developers; Amplify’s abstractions attract architects. Brandon’s beacon: start small—S3 for static, scale to Amplify for ambition.
Strategic Selection: Synthesizing Solutions
Brandon’s synthesis: match mission to mechanism—S3 for static starters, Amplify for authenticated ascents, Lambda for lean logic. His counsel: consult AWS’s compendium—getting-started guides, web app wisdom—curated for clarity.
His clarion: choose consciously, calibrating cost, celerity, scalability—AWS’s arsenal awaits.
Links:
[NDCOslo2024] Hub-Spoke Virtual Networks in Azure – Bastiaan Wassenaar
In the labyrinthine landscape of Azure’s azure architecture, where connectivity contends with compliance, Bastiaan Wassenaar, a cloud custodian and connectivity connoisseur, clarifies the conundrum of hub-spoke virtual networks. As a Dutch devops dynamo, Bastiaan blueprints the bedrock—endpoints, peering, policies—propelling practitioners past perplexities in private provisioning. His session, a symphony of safeguards and setups, spotlights the saga from service sentinels to spoke sanctuaries, ensuring egress elegance and ingress integrity.
Bastiaan banters on boredom’s behalf: vnet vexations vex veterans, yet victory vaults with vigilance. He heralds history: vnet’s 2014 genesis, endpoints’ evolution, private peers’ precision—pivoting from public perils to partitioned paradises.
Foundations of Fortification: Endpoints and Evolutions
Service endpoints erect ramparts: subnet sentries shielding storage, SQL sans sprawl. Bastiaan bewails bandwidth burdens—10Gbps ceilings—yet blesses them as basics, bridging to private endpoints’ purity: dedicated daisy-chains, DNS delegations demystified.
Hub-spoke’s heartbeat: central hub harboring firewalls, spokes siphoning spokes—peering propagates prefixes, UDRs usher unicast. Bastiaan blueprints: Azure Firewall’s fabric, forced tunneling fortifying flows.
Orchestrating the Orbit: Peering, Policies, and Proxies
Peering’s pact: global gateways, transitive taboos—spokes supplicate hubs for harmony. Bastiaan bemoans BGP’s burdens—bidirectional broadcasts—yet bows to basics: static routes suffice for simplicity.
Policies propel protection: NSGs nestle at NICs, FW’s finesse filters flows. Bastiaan broadcasts best bets: hub’s hegemony, spokes’ seclusion—egress egressing exclusively, ingress inspecting intently.
DNS’s Dominion: Delegations and Dilemmas
DNS dances delicately: private endpoints’ FQDNs, hub’s handlers hijacking queries. Bastiaan bemoans blunders—external IPs eclipsing internals—yet extols overrides: custom configurations, conditional forwarding.
His hack: hosts’ hacks for haste, yet hub’s hegemony harmonizes hordes. Bastiaan broadcasts: reboot realms for resolution—vnet’s vicissitudes vanquished.
Victory’s Vista: Vigilance in Vastness
Bastiaan’s benediction: hub-spoke as haven, harmonizing hazards—history heeded, hurdles hurdled. His hurrah: harness helpers, heed heuristics—Azure’s arsenal awaits.
Links:
[NDCMelbourne2025] DIY Usability Testing When You Have No Time and No Budget – Bekah Rice
In an insightful presentation at NDC Melbourne 2025, Bekah Rice, a UX consultant from True Matter, delivers a practical guide to conducting usability testing without the luxury of extensive time or financial resources. Drawing from her experience at a South Carolina-based UX consultancy, Bekah outlines an eight-step process to gather meaningful qualitative data, enabling developers and designers to refine digital products effectively. Her approach, demonstrated through a live usability test, underscores the importance of observing real user interactions to uncover design flaws and enhance user experience, even with minimal resources.
Step One: Preparing the Test Material
Bekah begins by emphasizing the need for a testable artifact, which need not be a fully developed product. A simple sketch, paper prototype, or a digital mockup created in tools like Figma can suffice. The key is to ensure the prototype provides enough context to mimic real-world usage. For instance, Bekah shares her plan to test a 12-year-old hospital website, currently undergoing a redesign, to identify usability issues. This approach allows teams to evaluate user interactions early, even before development begins, ensuring the product aligns with user needs from the outset.
Crafting Effective Tasks
The second step involves designing realistic tasks that reflect the user’s typical interactions with the product. Bekah illustrates this with a scenario for the hospital website, where users are asked to make an appointment with a doctor for regular care after moving to a new town. By phrasing tasks as open-ended questions and avoiding UI-specific terminology, she ensures users are not inadvertently guided toward specific actions. This method, she explains, reveals genuine user behavior, including potential failures, which are critical for identifying design shortcomings.
Recruiting the Right Participants
Finding suitable testers is crucial, and Bekah advocates for a pragmatic approach when resources are scarce. Instead of recruiting strangers, she suggests leveraging colleagues from unrelated departments, friends, or family members who are unfamiliar with the product. For the hospital website test, she selects Adam, a 39-year-old artist and warehouse tech, as a representative user. Bekah warns against testing with stakeholders or developers, as their biases can skew results. Offering small incentives, like coffee or lunch, can encourage participation, making the process feasible even on a tight budget.
Setting Up and Conducting the Test
Creating a comfortable testing environment and using minimal equipment are central to Bekah’s DIY approach. A quiet space, such as a conference room or a coffee shop, can replicate the user’s typical context. During the live demo, Bekah uses Adam’s iPhone to conduct the test, highlighting that borrowed devices can work if they allow observation. She also stresses the importance of a note-taking “sidekick” to record patterns and insights, which proved invaluable when Adam repeatedly missed critical UI elements, revealing design flaws like unclear button labels and missing appointment options.
Analyzing and Reporting Findings
The final step involves translating observations into actionable insights. Bekah emphasizes documenting both successes and failures, as seen when Adam struggled with the hospital website’s navigation but eventually found a phone number as a fallback. Immediate reporting to the team ensures fresh insights drive improvements, such as adding a map to the interface or renaming buttons for clarity. By presenting findings in simple bullet lists or visually appealing reports, teams can effectively communicate changes to stakeholders, ensuring the product evolves to meet user needs.
Links:
[NDCOslo2024] Building a Robot Arm with .NET 8, Raspberry Pi, Blazor and SignalR – Peter Gallagher
Amid the mesmerizing merger of microcontrollers and modern markup, Peter Gallagher, a prolific .NET pioneer and podcast personality, prototypes a pivotal plaything: a prehensile prosthesis powered by Pi, .NET 8, Blazor’s bounty, and SignalR’s synergy. As the mind behind “The .NET Core Podcast” and a maestro of minimal viable marvels, Peter parades the panoply—from GPIO gymnastics to VR vistas—proving platform potency in playful pursuits. His hands-on homage, humming with hardware harmony, heralds hobbyists to harness high-level harmony for haptic happenings.
Peter polls the populace: Raspberry aficionados abound, yet arm artisans are scarce—his spur to share schematics, sans soldering sermons. .NET 8’s native nod to ARM architectures animates accessibility, eclipsing esoteric embeds.
Wiring the Wonder: GPIO and Servo Symphonies
Genesis germinates in GPIO groundwork: Pi’s pins, PWM-proficient, pulse servos to swivel shoulders, elbows, wrists. Peter parades the paraphernalia: SG90 servos, jumper joys, breadboard bastions—budget below 50 quid.
Code commandeers: Iot.Device.Bindings beckon, Servo class summoning sweeps—angle aspirations from 0 to 180. Peter’s prototype: console commands calibrating claws, clutching candies in cinematic clips.
Blazor’s Bridge: Browser-Borne Brawn
Blazor bridges the breach: WebAssembly wielding webcams, SignalR streaming signals—real-time relays routing remote reaches. Peter’s portal: Razor renders ranges, sliders summoning servo shifts; hubs herald hubbub, harmonizing host and handler.
He highlights hitches: CORS courtesies, container conundrums—Pi’s paucity of ports prompting proxies. Yet, yields yield yawns: yawns of yawp, where web wielders wrench wrenches wirelessly.
VR’s Vanguard: Questing for Quarters
Quest 3 quests quaternary: Unity unleashes OpenXR, hand-tracking hailing haptics—gestures grasping grippers. Peter’s phantasm: VR viewport voyaging Pi’s panorama, passthrough peering at prehensile prowess.
Integration ignites: SignalR surges selections, servos saluting salutes—synthetic senses simulating seizures. Peter’s plea: print, procure, partake—his GitHub grotto granting guides.
Horizons of Hardware: Harmonizing Hopes
Peter’s panegyric: .NET’s ubiquity unlocks universes—embedded epics, VR ventures—vitalizing visions. His valediction: venture ventures, validate validations—birthday bonuses beckon bold builders.
Links:
[NDCOslo2024] Being Staff Plus – Ian Cooper
In the intricate hierarchy of technical hierarchies, where progression once propelled practitioners toward managerial mantles, Ian Cooper, a venerable voice in software strategy and Brighter’s beacon, illuminates the ascent of alternative avenues: Staff Plus echelons. As London’s .NET sage and a proponent of polyglot pursuits, Ian interrogates the imperatives of individual influence, delineating the divergence from senior stewardship to strategic stewardship. His discourse, drawn from decades of deliberation, deciphers the demands of distinction—archetypes, advocacy, allocation—equipping aspirants to amplify impact sans administrative ascent.
Ian introduces the inflection: long the lone ladder, management lured luminaries from lines of code; now, Staff Plus—staff, principal, distinguished—sustains savants in the saddle. He hails the shift: organizations, awakened to autonomy’s allure, afford avenues for authority absent oversight, fostering focus on foundational fortification.
Archetypes and Ascendance: Navigating the New Normal
Staff Plus manifests manifold: the Tech Lead, tactical troubleshooter; the Architect, abstraction artisan; the Solver, systemic surgeon. Ian itemizes: Tech Leads temper teams, Architects abstract ambitions, Solvers salve sores—each emblematic of expertise elevated.
Ascendance demands discernment: beyond badges, it’s breadth—breadth in blueprints, benevolence in bestowal. Ian invokes virtues: visibility’s valor, where veiled virtuosity vanishes; versatility’s vista, spanning silos to synthesize.
Transcending Transactions: Technical Tenets and Team Triumphs
Code’s cradle yields to counsel’s chamber: Ian implores evolution—from crafting commits to curating cultures. Technical leadership thrives on tenets: temperance in toil, where intervention invites inertia; illumination in incidents, dissecting dilemmas to distill doctrines.
He heralds help: hire heroes, not hirelings; hoist horizons, mentoring multitudes. Ian’s insight: authority accrues through altruism—alleviating ailments, amplifying allies—sans the scepter of supervision.
Prioritizing the Paramount: Allocating Ambition Wisely
What warrants weight? Ian interrogates: eschew ephemera—glue code’s grime, granular gripes—for grand gestures: systemic shifts, strategic scaffolding. His heuristic: harvest high-leverage horizons—cross-cutting concerns, cultural catalysts—yielding yields that endure.
Influence, Ian insists, inheres in independence: innovate itineraries, improvise if imperatives falter; insulate initiatives with insurance—contingencies crafted, compensations contemplated. Visibility vaults value: chronicle conquests, convene coalitions—virtue voiced, not veiled.
Pathways to Prominence: Propelling the Pursuit
Ian’s itinerary: introspect imperatives—align ambitions with archetypes; illuminate insufficiencies—influence inventories, iterate incrementally. Resources resonate: Riley’s “Staff Engineer,” Larson’s “An Elegant Puzzle”—lanterns lighting the leap.
His homily: Staff Plus as summit sans servitude, where sagacity shapes spheres, sustaining the soul of software.
Links:
[NDCOslo2024] Lessons Learned Building a GenAI Powered App – Marc Cohen & Mete Atamel
In the exhilarating epicenter of emergent engineering, where generative grammars graft onto granular goals, Marc Cohen and Mete Atamel, a dynamic duo of developer advocates, dissect the delights and dilemmas of deploying a GenAI quiz quest. Marc, a Google Cloud sage, and Mete, a London-based luminary, limn their labyrinthine launch: an interactive trivia titan, turbocharged by text-to-quiz transformers, traversing from ideation to iteration. Their tale, tempered by trials and triumphs, tempers enthusiasm with empiricism, extracting edicts for ensembles eyeing AI augmentation.
Marc and Mete meander from mundane meetings—Gemini-fueled frivolities birthing brain-teasers—to blueprinting a bespoke bot: prompts pioneering puzzles, Vertex AI vending variety. Their venture: a web wizard weaving whimsy, where users umpire uniqueness, quizzes quizzing quaestions quarterly.
Ideation to Implementation: Igniting the Interactive
Genesis gleamed in a Google gabfest: Gemini’s garrulous games germinated a gadget for GDD—Google Developer Days—gamifying gaps in grasp. Marc’s maiden foray: manual mocks, mired in monotony, morphed via Vertex AI’s verve—prompts pulsing personalities, quizzes questing quandaries.
Mete’s mastery: modularize might—microservices marshalling models, Cloud Run cradling containers. Their synergy: separation of synthesis and scrutiny, safeguards staving spurious spiels via safety settings.
Pitfalls and Panaceas: Prompting Precision
Prompts proved pivotal: personas personifying pizzazz—”pirate patter”—yet perils prowled: profanities percolating, inaccuracies amassing. Marc’s mitigation: modular mandates—system strictures scripting safeguards, few-shot finesses finagling fidelity.
Costs crept: characters cashed credits, caching curbed cascades. Their calculus: quotas quelled quiescence, quotas quashing queues.
Live Labyrinths: Latency and Learner Loops
Latency loomed large: live quizzes languished, learners lagging. Marc’s maneuver: asynchronous artistry—prefab puzzles poised, personalization post-facto. Feedback’s finesse: thumbs-up tallies tailoring topics, Vertex’s vectors vectoring variety.
Their tableau: a Twitch-streamed spectacle, spectators selecting spheres, quizzes quizzing quaestions—engagement eclipsing expectations.
Edicts Extracted: Engineering Enlightenment
Lessons luminated: prompts as poetry—precise, persistent; modularity’s merit—micro over monolith; costs as calculus—cache, cull. Marc and Mete’s missive: GenAI gamifies growth, yet guardrails guide greatness.
Links:
[NDCMelbourne2025] How to Work with Generative AI in JavaScript – Phil Nash
Phil Nash, a developer relations engineer at DataStax, delivers a comprehensive guide to leveraging generative AI in JavaScript at NDC Melbourne 2025. His talk demystifies the process of building AI-powered applications, emphasizing that JavaScript developers can harness existing skills to create sophisticated solutions without needing deep machine learning expertise. Through practical examples and insights into tools like Gemini and retrieval-augmented generation (RAG), Phil empowers developers to explore this rapidly evolving field.
Understanding Generative AI Fundamentals
Phil begins by addressing the excitement surrounding generative AI, noting its accessibility since the release of the GPT-3.5 API two years ago. He emphasizes that JavaScript developers are well-positioned to engage with AI due to robust tooling and APIs, despite the field’s Python-centric origins. Using Google’s Gemini model as an example, Phil demonstrates how to generate content with minimal code, highlighting the importance of understanding core concepts like token generation and model behavior.
He explains tokenization, using OpenAI’s byte pair encoding as an example, where text is broken into probabilistic tokens. Parameters like top-k, top-p, and temperature allow developers to control output randomness, with Phil cautioning against overly high settings that produce nonsensical results, humorously illustrated by a chaotic AI-generated story about a gnome.
Enhancing AI with Prompt Engineering
Prompt engineering emerges as a critical skill for refining AI outputs. Phil contrasts zero-shot prompting, which offers minimal context, with techniques like providing examples or system prompts to guide model behavior. For instance, a system prompt defining a “capital city assistant” ensures concise, accurate responses. He also explores chain-of-thought prompting, where instructing the model to think step-by-step improves its ability to solve complex problems, such as a modified river-crossing riddle.
Phil underscores the need for evaluation to ensure prompt reliability, as slight changes can significantly alter outcomes. This structured approach transforms prompt engineering from guesswork into a disciplined practice, enabling developers to tailor AI responses effectively.
Retrieval-Augmented Generation for Contextual Awareness
To address AI models’ limitations, such as outdated or private data, Phil introduces retrieval-augmented generation (RAG). RAG enhances models by integrating external data, like conference talk descriptions, into prompts. He explains how vector embeddings—multidimensional representations of text—enable semantic searches, using cosine similarity to find relevant content. With DataStax’s Astra DB, developers can store and query vectorized data efficiently, as demonstrated in a demo where Phil’s bot retrieves details about NDC Melbourne talks.
This approach allows AI to provide contextually relevant answers, such as identifying AI-related talks or conference events, making it a powerful tool for building intelligent applications.
Streaming Responses and Building Agents
Phil highlights the importance of user experience, noting that AI responses can be slow. Streaming, supported by APIs like Gemini’s generateContentStream, delivers tokens incrementally, improving perceived performance. He demonstrates streaming results to a webpage using JavaScript’s fetch and text decoder streams, showcasing how to create responsive front-end experiences.
The talk culminates with AI agents, which Phil describes as systems that perceive, reason, plan, and act using tools. By defining functions in JSON schema, developers can enable models to perform tasks like arithmetic or fetching web content. A demo bot uses tools to troubleshoot a keyboard issue and query GitHub, illustrating agents’ potential to solve complex problems dynamically.
Conclusion: Empowering JavaScript Developers
Phil concludes by encouraging developers to experiment with generative AI, leveraging tools like Langflow for visual prototyping and exploring browser-based models like Gemini Nano. His talk is a call to action, urging JavaScript developers to build innovative applications by combining AI capabilities with their existing expertise. By mastering prompt engineering, RAG, streaming, and agents, developers can create powerful, user-centric solutions.
Links:
[NDCOslo2024] The History of Computer Art – Anders Norås
In the incandescent interstice of innovation and imagination, where algorithms awaken aesthetics, Anders Norås, a Norwegian designer and digital dreamer, traces the tantalizing trajectory of computer-generated creativity. From 1960s Silicon Valley’s psychedelic pixels to 2020s generative galleries, Anders animates an anthology of artistic audacity, where hackers harnessed harmonics and hobbyists honed holograms. His odyssey, opulent with optical illusions and ontological inquiries, unveils code as canvas, querying: when does datum dance into divinity?
Anders ambles from Bay Area’s beatnik bytes—LSD-laced labs birthing bitmap beauties—to 1970s fine artists’ foray into fractals. Vera Molnar’s algorithmic abstractions, Molnar’s mechanical marks, meld math with muse, manifesting minimalism’s machine-made magic.
Psychedelic Pixels: 1960s’ Subcultural Sparks
San Francisco’s hacker havens hummed with hallucinatory hacks: Ken Knowlton’s BEFLIX begat filmic fractals, A. Michael Noll’s noisy nudes nodded to neo-classics. Anders accentuates the alchemy: computers as collaborators, conjuring compositions that captivated cognoscenti.
Algorithmic Abstractions: 1970s’ Fine Art Fusion
Fine artists forayed into flux: Frieder Nake’s generative geometries, Georg Nees’s nested nests—exhibitions eclipsed elites, etching electronics into etudes. Harold Cohen’s AARON, an autonomous auteur, authored arabesques, blurring brushes and binaries.
Rebellious Renderings: 1980s’ Demoscene Dynamism
Demoscene’s defiant demos dazzled: Future Crew’s trance tunnels, Razor 1911’s ray-traced reveries—amateurs authored epics on 8-bits, echoing graffiti’s guerrilla glee. Anders applauds the anarchy: code as contraband, creativity’s clandestine cabal.
Digital Diaspora: Internet’s Infinite Installations
Web’s weave widened worlds: JODI’s jetset glitches, Rafael Lozano-Hemmer’s responsive realms—browsers birthed boundless biennales. Printouts prized: AARON auctions at astronomic asks, affirming artifacts’ allure.
Generative Galas: GenAI’s Grand Gesture
Anders assays AI’s ascent: Midjourney’s mirages, DALL-E’s dreams—yet decries detachment, Dolly’s depthless depictions devoid of dialogue. Jeff Wall’s “A Sudden Gust of Wind” juxtaposed: human heft versus heuristic haze, where context conceals critique.
Anders’s axiom: art awakens awareness—ideas ignite, irrespective of instrument. His entreaty: etch eternally, hand hewn, honoring humanity’s hallowed hue.
Links:
[NDCMelbourne2025] Preventing Emu Wars with Domain-Driven Design – Lee Dunkley
In an engaging and humorous presentation at NDC Melbourne 2025, Lee Dunkley explores how Domain-Driven Design (DDD) can prevent software projects from spiraling into chaotic, unmaintainable codebases—likening such failures to Australia’s infamous Emu War. By drawing parallels between historical missteps and common software development pitfalls, Lee illustrates how DDD practices, such as event storming and ubiquitous language, can steer teams toward solving the right problems, thereby enhancing maintainability and extensibility.
The Emu War: A Cautionary Tale for Coders
Lee begins with a whimsical analogy, recounting Australia’s 1930s Emu War, where soldiers armed with machine guns failed to curb an overwhelming emu population devastating crops. The emus’ agility and sheer numbers outmatched the military’s efforts, leading to a humbling defeat. Lee cleverly translates this to software development, where throwing endless code at a problem—akin to deploying infinite soldiers—often results in a complex, bug-ridden system. This sets the stage for his argument: without proper problem definition, developers risk creating their own unmanageable “emu wars.”
He illustrates this with a hypothetical coding scenario where a client demands a solution to “kill all the pesky emus.” Developers might churn out classes and methods, only to face mounting complexity and bugs, such as emus “upgrading to T-Rexes.” The lesson? Simply writing more code doesn’t address the root issue, much like the Emu War’s flawed strategy failed to protect farmers’ crops.
Modeling Smells in E-Commerce
Transitioning to a more practical domain, Lee applies the Emu War analogy to an e-commerce platform tasked with implementing an “update order” feature. Initially, the solution seems straightforward: create an endpoint to modify orders. However, as Lee demonstrates, this leads to bugs like customers receiving too many items, being undercharged, or getting empty boxes. These issues arise because the vague “update order” requirement invites a cascade of edge cases and race conditions.
By examining the system’s event timeline, Lee highlights how an “order updated” event disrupts critical processes like payment capture and stock reservation. This modeling smell—where a generic action undermines system integrity—mirrors the Emu War’s misaligned objectives. The real problem, Lee argues, lies in failing to define the business’s true needs, resulting in a codebase that’s hard to test and extend.
Refining with Domain-Driven Design
Here, Lee introduces DDD as a remedy, emphasizing techniques like event storming and the five whys to uncover the true problem space. Revisiting the Emu War, he applies the five whys to reveal that the goal wasn’t to kill emus but to secure employment for returning soldiers. Similarly, in the e-commerce case, the “update order” request masks specific needs: ensuring shoppers receive only desired items, adding forgotten items, and canceling orders.
By reframing these needs, Lee proposes targeted solutions, such as a “supplementary order” endpoint for adding items and a time-bound “order received” event to allow cancellations without disrupting the system. These solutions, rooted in DDD’s ubiquitous language, reduce complexity by aligning the code with business intent, avoiding the pitfalls of generic actions like “update.”
Simplicity Through Abstraction
Lee challenges the notion that complex problems demand complex solutions. Through DDD, he shows how elevating the level of abstraction—by focusing on precise business goals—eliminates unnecessary complexity. In the e-commerce example, replacing the problematic “update order” endpoint with simpler, purpose-specific endpoints demonstrates how DDD fosters maintainable, extensible code.
He acknowledges the challenges of implementing such changes in live systems, where breaking changes can be daunting. However, Lee argues that aligning solutions with the problem space is worth the effort, as it prevents the codebase from becoming a “Frankenstein’s monster” burdened by accidental complexity.
Conclusion: Avoiding Your Own Emu War
Lee wraps up by urging developers to wield their coding “superpower” wisely. Instead of burying problems under an avalanche of code, he advocates for DDD practices to ensure solutions reflect the business’s true needs. By employing event storming, refining ubiquitous language, and questioning requirements with the five whys, developers can avoid fighting futile, unmaintainable battles.
This talk serves as a compelling reminder that thoughtful problem definition is the cornerstone of effective software development. Lee’s blend of humor and practical insights makes a strong case for embracing DDD to create robust, adaptable systems.