Simon Martinelli

✨ First open source PR in years. First blog post ever. First time adding Cassandra support to Testcontainers-dotnet? Yep, Gavin de Kock just did all three. And it was smooth sailing. 🚢 From spotting a missing module to contributing it with ease, Gavin shares how friendly the Testcontainers OSS community is—and how simple it is to spin up Apache Cassandra for .NET integration testing using Docker. A fun read and a great reminder that open source is open for everyone. 🙌 Check out the post and try it yourself: http://spklr.io/6048APQn #Docker #Testcontainers #OpenSource #DotNet #ApacheCassandra #IntegrationTesting #DeveloperExperience

40

2 Kommentare

When working with associations in Rails, managing referential integrity is quite important. Often we need to ensure that records with dependent associations cannot be deleted without first handling those dependencies properly, at the same time giving helpful errors to the end users. In this post, we'll explore how Rails provides a simple solution for this problem and when to use it over the other alternatives. I recently discovered it while working on a new feature, and wanted to share a summary of my understanding. As always, I hope you find this post helpful and you learn something new.

34

📢 Slides Now Available: 20 Years of Domain-Driven Design - What I’ve Learned 📢 For over two decades, Eric Evans' Domain-Driven Design (DDD) has been a cornerstone of effective software development. But what really works in practice? 🤔 I recently shared key lessons from applying DDD across real-world projects at #JAX conference – the wins, the challenges, and how to navigate its complexities. In this talk, we explored: ✅ The power of close collaboration with domain experts ✅ Techniques for effective modeling (including Event Storming!) ✅ Rethinking Bounded Contexts & their role in system architecture ✅ Comparing DDD’s strategic design principles with modern approaches like Team Topologies Whether you're a DDD veteran or just starting out, I hope these insights help you focus on delivering real value to your customers. 🚀 ➡️ You can find the slides here: https://lnkd.in/ehjqPsSy

31

If you're working on a complex software project, having good architecture diagrams really helps. And in this guide Alex explains what the C4 model is & how it works. You'll go through each level - context, containers, components, & code - in detail. https://lnkd.in/ef34fiwF

259

5 Kommentare

And yet another native component quite underused... RenameButton() Can be used in many scenarios, this one was on top of my head where I'd use it in my projects... :) A few advantages of using it - Automatically uses the correct system icon and localized "Rename" label - The "Rename" text is automatically translated to the user's language - Follows Apple's Human Interface Guidelines automatically - VoiceOver labels and hints are included - Supports all accessibility features without extra code - The button automatically disables if no .renameAction() is defined - Adapts to platform specific behavior (iOS, macOS, iPadOS) etc... - Works spotless inside contextMenu, Menu and Swipe Actions - Less code to maintain, Apple does the hard job - Saves some lines of code :) - iOS 16+ Ref: https://lnkd.in/eJwDFr3U #iOS

70

8 Kommentare

“The only real documentation is well-written code.” That’s the reply I received from a senior dev I used to work with when I asked for documentation. When I insisted, he dismissively replied: “If understanding the code is too difficult for you, at least try looking at the unit tests.” Many engineers find writing documentation so useless and boring that they will do anything to avoid it. They consider docs the very last thing they should care about. And I get it, writing docs means more work. But the truth is, writing good documentation has never been more important than it is today. Why? Humans and AI thrive on explicit, up-to-date docs, clear abstractions, and unambiguous rules. Skip docs, and you throttle onboarding, code reviews, and your AI leverage. Document what code can’t say: - Why we chose this approach (trade-offs, ADRs) - Boundaries and contracts (inputs, outputs, errors) - How to operate it (runbooks, examples, expected behaviors) Keep docs short, versioned, and well maintained. With docs, I think engineers have come full circle. We used to run from them. Now, without documentation, our AI strategy turns into a dumpster fire. You know… garbage in, garbage out. What’s your relationship with documentation? -- #Documentation #SoftwareEngineering #AI #Productivity #EngineeringManagement

20

11 Kommentare

🚀 Just published my first technical article with ML Con Magazine by entwickler.de – and it’s all about AI-powered coding environments! 🧠 In “Vergleich KI-unterstützter Coding-IDEs”, I compare three of the most promising tools in the market: Cursor Windsurf (formerly Codeium) VS Code with GitHub Copilot These tools don’t just autocomplete code — they offer intelligent agents, contextual chat, and deep integration into your coding workflows. But how do they really perform in daily dev life? 📊 My article takes a deep dive into: AI capabilities & integration depth Practical UX & developer productivity Architecture and everyday usability Whether you’re already using Copilot or exploring agentic IDEs like Cursor, this comparison might help you choose the right setup for your needs. 📝 The article is currently available in German only, but an English version is on the way! 🔗 Read it here: https://lnkd.in/eG5NwWDG #AIDevelopment #CursorIDE #GitHubCopilot #Windsurf #AIWorkflow #AgenticCoding #DeveloperTools #MLCon #AIIDE #ProductivityTools

14

AI and Test-Driven Development: A New Perspective The common misunderstanding about TDD: many believe it simply means you first write the tests, then write the code to make them green (passing test). But that misses the essence of TDD. TDD's Red-Green-Refactor cycle delivers its real value in the refactor step: improving design with tests as a safety net. You write code and tests rapidly to get the tests green, then refine: refactor the code while keeping tests green, then refactor the tests while keeping the code stable. With agentic coding tools, we can generate code and tests quickly - effectively handling TDD's first two steps. But here's the problem: the generated output often needs significant refactoring. I've seen the same function duplicated three times in a single generation. I've watched agents hardcode values repeatedly instead of using defined constants. I've observed test generation that ignores existing test utilities, even when explicitly instructed to reuse them. This reality suggests we need to rediscover TDD, adapted for the AI era: 1. Generate code with AI 2. Generate tests with AI 3. Fix both until tests pass with AI 4. Refactor the code while keeping tests frozen (AI and human collaboration) 5. Refactor the tests while keeping code frozen (AI and human collaboration) Steps 1-3 of this workflow can be mostly automated with AI, but refactoring (steps 4-5) requires human oversight. AI excels at mechanical changes—renaming, extracting functions, removing duplication—but struggles with design decisions and lacks the broader project context needed for effective refactoring: architectural patterns, codebase conventions, and cross-module dependencies that extend beyond its context window. Humans guide; AI executes.

31

15 Kommentare

#ADRs (Architecture decision record) are like event sourcing. ADRs are written down decisions about architecture. Why did you chose React? Why not Angular? What were the Pro and Cons and why was that solution the winner? They make it easy for developers new to the company or new to the team to understand the decisions BEHIND the current tech stack and architecture. So they can make better decisions themselves. A side effect of ADRs is that you do not have the same discussion over and over again. How are they like Event Sourcing? ADRs have not the downside of normal documentation. Normal documentation is hard to keep in sync with reality. It's a tedious process, and nearly impossible if you did not find the right level of documentation (deep enough, but not too deep). ADRs do not change. They are write-one-read-often, they are read only. They don't need to be maintained, they are always correct. In this way they are like events in Event Sourcing. Those also do not change. And ADRs can be seen as an event, and to get an understanding of the current state of your architecture, you need to read and aggregate those ADRs, just like events in event sourcing. https://adr.github.io/

28

2 Kommentare