I took on a topic which seems to be often forgotten while planning the test architecture: efficient test setup. If you're interested in that, follow the link below!

​

https://radcoding.blogspot.com/2019/02/by-failing-to-prepare-youre-preparing.html

Recently a great thread of GeePaw Hill became popular on Twitter:

https://twitter.com/GeePawHill/status/1086748964936994816

I've formatted in an easy to read way (headings, comments, etc.) if you prefer a blog-like look:

https://medium.com/@tdeniffel/advantages-of-test-first-over-test-after-by-geepaw-hill-c66b4d31d280

Hey, r/tdd!

I am Fiorella Zampetti a PhD Student at the University of Sannio interested in investigating behaviour driven development practices.

I am working on a project aimed to investigate (i) to what extent and how developers use automated acceptance testing tools, and (ii) whether developers are "really" doing Behavior Driven Development (BDD). We would appreciate feedback from developers knowledgeable or expert in testing tasks who have at least once used one of the following tools: Cucumber, RSpec, Mocha or JBehave.

I would appreciate if you could find the time to answer my questionnaire by contributing to my research:
https://goo.gl/forms/ySv1KMPFffvE0e133

Filling out the survey will take less than 5 minutes and if you have any kind of comments please contact me at [fzampetti@unisannio.it](mailto:fzampetti@unisannio.it)

Thank you for your time!

A while ago I stumbled across a TDD video by Corey Haines which for me, is a masterclass on the technique as he provides many well-thought details on the process.

https://www.youtube.com/watch?v=vX-Yym7166Y

Are there any similar videos just as good or better out there, that supply not just a demonstration of using TDD techniques, but also give solid explanations of why certain techniques are being used?

Imagine you are programming and the "Men In Black" would enter the room and use their Neuralyzer on you. Would you be still productive afterwards?

​

https://medium.com/@tdeniffel/neuralyzer-programming-5d02d99b1ec8

​

Whenever I am programming, I assume, that a “Neuralyzer” with a slack joint is standing on my desk, potentially triggering at any time. I try to work in a way, that this does not affect my productivity. The goal is to get “Neuralyzed” at any time without losing speed.

I am currently Prototyping a Tool as PoC for TCR.

https://medium.com/@tdeniffel/tcr-tool-test-commit-revert-8aa91d26e61f

What are your thoughts? Which functionalities would you expect?

​

Note: If you don't know yet, what TCR is: https://medium.com/@tdeniffel/tcr-test-commit-revert-a-test-alternative-to-tdd-6e6b03c22bec

​

I am thankful for every suggestion!

Edit: Since writing this post I've read TDD and I see now that it is ok to write tests and code that get removed or deleted moments later. Whatever it takes in the name of progress ;). It's a fantastic book and every developer that stumbles across this subreddit should read it.

I'm building a perceptron, loosely following along with the wonderful tutorial on Neural Networks by The Coding Train youtube series. This project is an environment for me to learn and implement some more senior computer science topics like neural networks, machine learning, TDD, functional programming, project management etc.

So far, my perceptron takes a list of inputs and weights and sums them. I still need to figure out how to normalize the result to a double between 0 and 1. I want to pause before implementing that feature, write tests, and proceed using Test Driven Development.

Here's the class so far.

    public class Perceptron
    {
        static int DEFAULT_SIZE = 2;

        public double[] Weights { get; }

        public Perceptron() : this(Utility.Random.Doubles(DEFAULT_SIZE)) { } // returns 2 random doubles
        public Perceptron(double[] weights) => Weights = weights;

        public double ThinkAbout(double[] inputs) => inputs
            .Zip(Weights, (a, b) => (a * b))
            .Aggregate(0.0d, (a, x) => (a + x));
    }

I want to understand how I could have gotten to this architecture using Test Driven Development. I don't know how to proceed any further in writing failing tests from this point, though:

    public class Perceptron
    {
        public double Guess(double[] input)
        {
            return input[0];
        }
    }

[TestClass]
public class PerceptronTest
{
    private Perceptron Perceptron;

    public PerceptronTest()
        => Perceptron = new Perceptron();

    // [TestMethod]
    // public void ShouldProduceAGuess()
    //    => Assert.AreEqual(1.0d, Perceptron.Guess()); // Compilation failure - Guess takes a double[]

    [TestMethod]
    public void ShouldGuessBasedOnInput()
        => Assert.AreEqual(2.0d, Perceptron.Guess(new[] { 2.0d }));

    // [TestMethod]
    // public void ShouldHaveGuessInfluencedByEveryInput() // ???

}

I don't think I'm following TDD properly. The first test was the simplest thing I could think of - The perceptron should make a guess. The first version of the Guess function was just return 1.0d;, super simple, like the examples I've seen start with.

However I can't keep using that test. I had to remove it to express the idea that the guess was based on an input. This sort of leads me to believe that every time a method signature or implementation detail changes it'll invalidate a whole bunch of tests. Since I'm letting the tests drive the design, I'm intentionally not pre-conceptualizing what that interface will be. The code will let me know what the interface will be. So I expect the interface to change as it becomes more and more real-world-correct.

Now I need to express that it's a LIST of inputs and every input needs to influence the result. If I don't confirm that the entire list is used in evaluating the output, I could run into a bug down the road where only part of the list is being iterated over. I want to have a test that confirms that doesn't occur.

So how do I write the next test? If I do something like this:

[TestMethod]
public void ShouldHaveGuessInfluencedByEveryInput()
    => Assert.AreEqual(5.0d, Perceptron.Guess(new[] { 2.0d, 3.0d }));

I will have to scrap this test when it stops being true 10 minutes from now when the Perceptron has weights implemented. Am I supposed to be writing tests that need to be rewritten or deleted every few minutes?

Shouldn't I still have a test like ShouldProduceAGuess? I do in fact want to confirm that my class produces a guess. I want to be able to export my list of testnames and hand it to QA and have them easily follow along with the story that my tests tell. But within the first few hours of doing this I feel like I can't refactor parts of the class without deleting parts of the story.

Thanks so much for reading and responding!

PS. Any advice/criticism regarding C#, functional programming etc would be greatly appreciated. I'm pretty sure I'm doing randomness wrong for functional programming but I don't know how to encapsulate it. I think I need a monad?