🧐 Curious about Test Driven Development (TDD) and its impact on code quality? Join us in the workshop "Test Driven Development For Everyone" by Daniel Raniz Raneland. 👩‍💻 📢 Explore more: https://cz.pycon.org/2023/program/workshops/18/
#TDD #CodeQuality #PyConCZ23

We just shipped new prerelease versions of the core framework and the Visual Studio adapter.

- We've added new overloads of Assert.RaisesAny and Assert.RaisesAnyAsync
- We've made SerializationHelper public
- We've fixed potential analyzer errors for users of xunit.assert.source
- We've fixed a bug in the Visual Studio adapter that affected runner authors.

Release notes:

https://xunit.net/releases/v2/2.5.1-pre.33
https://xunit.net/releases/visualstudio/2.5.1-pre.15

#dotnet #csharp #fsharp #unittest #tdd

ei! I forgot to announce it, next Tuesday I will be sharing a session about, yes, you have guessed, around #TDD with #Java 😉
It will be interesting to see how #India's 🇮🇳 developers receive the session.
Here you can register for free: http://bit.ly/3RbKX7N

⏰ Ping-Pong and Timing – In a pairing session, ever tried Ping-Pong? Swap roles based on time or when a test fails. Keeps both parties engaged, and you get to experience both sides of the TDD cycle. #TDD #SoftwareEngineering #Engagement

🧠 Struggling with complex input scenarios? Use the 'Triangulation' technique to test one variable at a time. Say goodbye to missed and over-tested scenarios. #TestingStrategies #TDD

@todd_a_jacobs @berkes

#TDD is a great tool for surfacing design issues, but if you can't see what it's showing you, or ignore it, then you might create "bad" designs.

At least you'll have tests for the code you have? But if you ignore coupling, then they may be overly tied to implementation, which will make refactoring difficult.

@todd_a_jacobs @berkes

Absolutely #TDD supports good design!

I still see people saying TDD "forces" good design, or bad design (depending on their agenda), and I'm trying to push back against that.

It's a tool, that I find extremely helpful for adaptive and emergent design, but it's a tool that still requires some sense of what "good design" is.

I've done "good design" before I went 100% TDD, though I wouldn't do that again if I had a choice.

@jitterted I'm not sure I fully agree. I think #TDD lends itself to #emergentDesign by deferring design decisions to the last responsible moment.

#TDD doesn't produce designs, good or bad.

If you see statements like:

"TDD produces a design based on indirections. Much more complex than what could be otherwise."

Without some kind of examples, e.g., video of the process that demonstrates it, it's a meaningless and useless statement.

Humans design code, and in TDD they can use the feedback from Red-Green-Refactor to make decisions. The decisions are design, not the mechanism (TDD).

Test-Driven Development is a bit like daily exercise. We know it's good for us, but putting it in practice requires so much damn willpower. In his talk at RubyHACK 2018, David Brady outlines a helpful way to think about TDD by locating it within the quadrants of "Behaviour known/unknown" and "Implementation known/unknown". (Spoiler: It's quadrant 2.)

https://www.opsitive.com/development/test-driven/

#Ruby #Coding #SoftwareEngineering #TestDrivenDevelopment #TDD

Hi everyone,

I'm Fred, 35ish father of two sons living in Bordeaux, France. 🇫🇷

I am a software developper and a teacher.
I develop mainly in #angular #NestJs ( #nodejs ) and #dotnet Planning to learn #godot soon!
I teach mostly about #softwarearchitecture #softwaretesting #Tdd

Hoping to learn new things here! #Introduction

Welcome to the new home for xUnit.net on Mastodon! We thank you for joining us. 😀

Home page: https://xunit.net/

Source code: https://github.com/xunit

If you'd prefer to follow via RSS, you can find that feed here: https://dotnet.social/@xunit.rss

#introduction #dotnet #csharp #fsharp #unittest #tdd

I'm curious if anyone has written about a strategy for fixing bugs in a way that retains the integrity and usability of the code base beyond #TDD and #CI? As my role sunsets, I'm thinking about how I can set the next maintainers of my packages up for success so that patches can be made in a way that does not break workflows ten iterations in the future due to patches piled upon patches.

Relevant XKCD: https://xkcd.com/1172/

#RStats

I've appeared on more Podcasts than I thought! Check 'em out:

https://ted.dev/podcasts/podcast-guest-appearances.html

And if you host a #podcast that talks about refactoring, #Java, design, #TDD, Ensembles (mob programming), hexagonal architecture, etc., I'd love to come on and share what I've learned!

Learned about attaching debuggers to running processes early on, but understood its real value when dealing with a project's tangled startup scripts.

🔗 Read about it here:

https://medium.com/@_init_/how-to-attach-a-debugger-to-a-running-fastapi-server-in-vs-code-ecd679f5426a

Ever encountered a similar situation? Let's chat!

#tdd #fastapi #python #softwareengineering #codingtips

📊 Refactoring isn't just for production code. Your test suite also needs refactoring. Otherwise, you're accumulating 'test debt,' and that's a no-go. #TDD #TestQuality

@kingrat Sure, but when you're writing code, you have _some_ requirement in mind, even if it's not what's needed or wanted.

I still don't see this as a reason to not do #TDD. My experience is that TDD will get you faster feedback so you can adjust more quickly.

I never understood the request for "empirical studies" to prove this or that in software development, e.g.:

"Show me an unbiased experiment with measurable outcomes that proves that TDD makes a dev team more productive. Until then, I'll continue doing what I do now."

Let's flip that around:

"Show me an unbiased experiment with measurable outcomes that proves NOT doing [whatever your current process is] makes a dev team more productive than doing TDD."

Unless you can do those experiments (which are extremely difficult to do), you can't use the claim that since there is no "TDD works better" study, that means that it _must_ be worse than what you're currently doing. That's what philosophers call an "appeal to ignorance".

TDD might be worse; you might have a great process! (In which case, I'd love to try it out!) On the other hand, TDD might be better, and you're missing out on improving. Without the (possibly impossible) empirical evidence, you have to try it and see.

#Experience #TDD

The 3 Laws of #TDD: A 10-minute #Swift demo https://qualitycoding.org/3-laws-tdd/

We just shipped new prerelease versions of the core framework, the Visual Studio adapter, and analyzers.

There is one new analyzer, and two bug fixes in the core framework. There are no changes in the Visual Studio adapter other than picking up the new framework dependencies.

Please test these as they are likely to become the RTM versions.

Release notes:

https://xunit.net/releases/v2/2.5.1-pre.26
https://xunit.net/releases/analyzers/1.3.0-pre.19
https://xunit.net/releases/visualstudio/2.5.1-pre.11

#dotnet #csharp #fsharp #unittest #tdd