Moien Tajik

💻 Why Test-Driven Development (TDD) Should Be in Every Developer’s Toolkit 💻 In the fast-paced world of software development, Test-Driven Development (TDD) stands out as a disciplined and powerful approach to building reliable, maintainable, and scalable software. 🔍 What is TDD? TDD flips the traditional development process on its head. Instead of writing code first and tests later, you: Write a failing test for a new feature or function. Write the minimum code necessary to make the test pass. Refactor the code while keeping all tests green. This cycle—Red ➡ Green ➡ Refactor—is the heartbeat of TDD. How TDD works: The Red-Green-Refactor cycle TDD follows a cyclical process, commonly known as the "Red-Green-Refactor" cycle. 🟥Red (Write a failing test): The developer starts by writing an automated test case for a small, specific piece of functionality that needs to be added or changed. This test is expected to fail initially because the code it's testing doesn't yet exist. This failing test serves as a concrete definition of the desired behavior and drives the next steps. 🟩 Green (Write minimal code to make the test pass): Next, the developer writes just enough code to make the previously failing test pass. The focus here is on simplicity and functionality, not necessarily on writing perfectly optimized or complete code. ♻️Refactor (Improve the code while keeping the tests green): Once the test passes, the developer can refactor the new code to improve its design, readability, and efficiency. This process involves simplifying the code, removing redundancy, and ensuring it adheres to best practices, while consistently running the tests to ensure no existing functionality is broken. Why It Matters •.Improved Code Quality: Writing tests first forces you to think through requirements and edge cases early. • Faster Debugging: Bugs are caught early, often before they hit production. • Better Design: TDD encourages modular, loosely coupled code. • Confidence to Refactor: With a robust test suite, developers can refactor without fear. ⚖️ Pros and Cons Pros: • Reduces regression bugs • Enhances documentation (tests explain what the code is supposed to do) • Encourages better architecture and design Cons: • Steeper learning curve for beginners • Can slow down initial development • Requires discipline and consistency Final Thoughts TDD isn’t a silver bullet, but when used wisely, it can transform the way teams build software. It’s not just about testing—it’s about designing with the right approach. Have you tried TDD in your projects? What’s been your experience? #SoftwareDevelopment #TDD #CleanCode #Agile #DevOps #AIEngineering #TestDrivenDevelopment #CodingBestPractices

11

Continuing my dive into Angular’s lesser-known internals and old API 👨‍💻 Have you heard of the EventManagerPlugin? It’s the secret behind every (click) event — and you can extend it to create your own modifiers! In my latest article, I show how to build a .stop event modifier that automatically calls stopPropagation(). 👉 Do you want to learn how? https://lnkd.in/d-8X2rTj

28

1 Comment

TL;DR I did something that might save you time and money (lots of it). Last week I had a very expensive code refactoring session together with Cursor as you might already know from my previous post https://lnkd.in/dBtjUMx8 During the refactoring session one thing I noticed and got really frustrated about was renames. As "naming" is one of the most challenging problems in swe renaming happens all the time, during refactors, while implementing a new feature... Other people might overlook to the naming problem but every swe knows it in heart. Before AI agent era your IDE was your best friend, you could rename a class and viola 100 files changed even without a compile error. After AI agents it has become a pain. Since agents need grep/set/replace ... to to find the correct locations to change in the code... sometimes it takes several minutes + tens of agent actions to change a single class name. Long story short, renaming has become a costly and time consuming operation in the era of AI agents; it used to be very easy and fast. I know you've already smelled what's coming next :) I and Claude 've developed a renamer (only for Kotlin for now); it is a bash command named 'kr' check it out here -> https://lnkd.in/dEjgrnM7 I benchmarked it in my mid-sized product catalog project. Prompt : "rename the term Combo with Bundle as it is more accurate, using kr bash command" first it tried to dry run and then got happy with the result then started using it. Then I did the same without kr, and the results; 12x less AI agent actions 10x faster and the shocking part is; I used cursor composer-1 FREE model with kr, however without it composer couldn't event complete the task, I switched to Opus 4.6. so the cost is infinitely less :) If you enjoyed the tool leave a star in my repo If you enjoyed the post leave a comment, spread the word and let everyone save the planet :P -- Update -- I’ve released a significant update to the Kotlin Renamer. In this version, I introduced skills files and everything outside of the core rename functionality is new. Alongside the existing rename and move capabilities, the skill now includes a full suite of project analysis commands — outline, find, dependencies, hierarchy, unused symbols, and Spring bean scanning — all with structured output support. The skill’s activation, triggering logic, documentation, and examples have also been added or expanded. These improvements make the tool far more useful for understanding Kotlin project structure and preparing safe renames.

42

4 Comments

Stories the way I want them told (in code) TL;DR: I wrote a small PHP library that keeps human-readable stories and PHPUnit tests in sync. It’s called Verteller — Dutch for Storyteller. I’m a big fan of TDD and BDD. Describing system behaviour as a story is a powerful way to understand a problem space and agree on outcomes — especially with non-technical stakeholders. In practice, those stories often get distilled into scenarios using the familiar Given → When → Then structure. Working mainly with PHP and JavaScript, the usual way to translate that human-readable text into executable tests is through step definitions: one function for “Given”, one for “When”, one for “Then”. That approach has never sat well with me. Even though step definitions look neat on the surface, I find them hard to reason about when you’re actually working in test code. You constantly have to jump between: - the story file - the step definitions (often scattered) - the test runner And then mentally reconstruct what the test really does. What I wanted instead was: - human-readable, stakeholder-friendly stories - single-function PHPUnit tests that implement those stories - and a way to prevent story- and test-rot over time In other words: stories and tests should stay explicitly in sync. If a story changes or is removed, the engineer should be warned that action is required. So I built "Verteller" The core idea is simple: a PHP attribute called #[CoversStory]. It links a PHPUnit test method directly to: - the story file - the scenario name - a hash of the scenario body If the scenario body changes, the hash changes, and the test is flagged. Sometimes that change is just a typo. Sometimes it’s a real behavioural change. Either way, the engineer makes an explicit decision and re-syncs when appropriate. Verteller doesn’t care what’s inside the scenario body. You can use Gherkin, plain text, or something else entirely. There is no step translation at runtime — only explicit traceability. The scenario name is the contract. The test is the implementation. If this sounds interesting, the repository explains the architecture and workflow in more detail: 👉 https://lnkd.in/eeeAci9f

9

1 Comment