Ron Jeffries

In some ways at least, you can look at data science / ML work as an extreme form of TDD and closer to it in spirit than most proselytizing I've come across. In another great example, Peter Norvig does way more TDD for his Sudoku solver [1] than a "textbook" attempt at it [2] ..like many orders of magnitude more testing when counting cases. The spirit is better if we try to answer the questions of "what do you know about your program" and "how do you know it" through code. [1] http://norvig.com/sudoku.html [2] https://xprogramming.com/articles/oksudoku/

OP here, I learned a lot from asking this question. Specifically that the Deadlines I have seen fail, were not due to Agile, but failure to implement Agile. Agile takes buy in both from the Customer, managers and dev team. This also takes education on roles and expectations. Without buy-in, you lose the check's and balances and end up with dev teams on a death march, or product deliveries not providing value for the Customer. Ron Jeffries has a great post on this topic that I highly recommend http://xprogramming.com/articles/jatmakingthedate/

An often touted "benefit" of TDD is that "addictive" feeling when you write tests and see them pass. "you feel like you have done a lot because you have a lot of code"; "you feel a great deal of accomplishment". Quite a few pages talk about it when you search for "tdd addictive". The canonical example is the master of XP solving Sudoku in the TDD way: http://xprogramming.com/articles/oksudoku/ (part 1 out of 5) -vs- Peter Norvig: http://norvig.com/sudoku.html

This isn't really a new thing though, is it. There is the (in)famous example of Ron Jeffries trying to solve Sudoku through TDD (and failing miserably). http://xprogramming.com/articles/oksudoku/ Compare and contrast his impotent flailing with Peter Norvig's masterful approach. http://norvig.com/sudoku.html Of course for the lulz you had people like Spolsky and Martin all use it to set out their view of software engineering with essays like Duct Tape Programming and Echoes from the Stone Age. Anyway ... The conclusion from it all was that TDD works best as a design tool for interface discovery. That you get a regression suite, of sorts, is a side effect. It doesn't work as a specific optimization tool or algorithm discovery tool. Which isn't really surprising as these are two of the few remaining 'non-mechanical' aspects of programming.

One is also supposed to never change the test after it has been etched in stone, especially in BDD, but good luck getting people to follow that rule, especially in this modern age of Agileish development cycles. TDD, if practiced exactly as originally described, ends up being a drain on resources. You care more about the tests than about the code being tested. As a now-classic example, observe a TDD master struggling with Sudoku: http://xprogramming.com/articles/oksudoku/

Another avenue for learning is to start from hard problems. A hard problem is a problem that is very hard without using a known technique or solution. Somebody who's unfamiliar with it has no clue on how to even start solving it. Solving such a problem will add new techniques to your tool-belt for solving a whole class of problems. Problems that I've found worth studying: - Parsing. This is hard if you don't know the standard techniques: mostly recursive descent parsing with precedence -- or a parser generator, but that won't teach you much unless you write the generator yourself. Moreover I've found that you quickly run into limitations with parser generators and they don't make parsing easier in the long run, that's probably why most real world parsers are hand written (e.g. gcc, llvm). You can probably hack something together that sorta works, but knowing the right techniques makes writing an efficient parser that you have high confidence in a breeze. I've seen many ad-hoc parsers that would have benefited greatly from proper parsing. - Constraint solving. Examples are solving sudoku, the zebra puzzle, SAT solving, optimal register allocation and many others. The three most important techniques are backtracking, constraint propagation and conflict learning. Even professional programmers can't do this if they don't know these techniques (e.g. http://xprogramming.com/articles/oksudoku/). - Interpretation/Compilation. In addition to being a hard problem, writing an…

" I know there are people who build incredible things out of monads, or inventing monadic metatypes I'm unable to grasp, and generally doing stuff never done before. But that is merely a sign of great cleverness of these people; One could, I suppose, say that it's like a treadmill with wheels that are connected to the running belt but slightly downgeared: you can use it to move on a street by exercising walking with your legs but most people choose to just.. you know, walk directly." This is the flakiest analogy (not to say a condescending one) I've seen here in a while. The exact same argument could be made for writing a macro in Clojure vs just writing out the code in java. "yes you could write a clever macro and there are clever people doing it but other people just, you know, walk" Some programmers have trouble grasping monads. Others have trouble grasping macros. Others (believe it or not,) recursion (Ron Jeffries, an agile "guru" said "Recursive methods tend to be confusing, in my opinion." http://xprogramming.com/xpmag/dbchaskellbowling/), Others TCO (see Tim Bray's recent rant for e.g). When some programmers look at powerful languages they see, "merely weird languages. He probably considers them about equivalent in power to Blub, but with all this other hairy stuff thrown in as well.". - PG on the blub paradox. Insert clojure and haskell appropriately and this sums up your argument. People who don't "get" monads and/or or how powerful type systems…

Required reading: “We tried Baseball and it didn’t work.” http://xprogramming.com/articles/jatbaseball/

They need to come up with a new metric. LOC is so wrong for so many reasons. Running tested features seems like a good way to measure project progress but I don't know how it would relate to overall project complexity. http://www.xprogramming.com/Blog/Page.aspx?display=RunningTestedFeatur…

This is certainly a good counterpoint to the highly visible silicon valley status quo, but it's risky. Deep thinking might be the solution to a given problem, on the other hand it might give you insight a lot slower than iterating on a prototype. One of the benefits of computers is that experimentation is easier and cheaper than most other technical disciplines, so it's good to be able to whip up some experiments to glean practical information. Arriving at optimal solutions to difficult problems is not an endeavour that is well served by a monolithic approach. In a way it's the contrapositive of one of my annoyances with TDD. Sometimes TDD advocates (along with anyone selling a methodology I suppose) get overzealous and start making ridiculous claims like "TDD ensures program correctness". When pressed they may backpedal and acknowledge that unit tests are no substitute for mathematical proof. But yet there remains a dogged obsession with one particular technique. Take the experiment of writing a Sudoku solver via strict TDD (http://xprogramming.com/xpmag/OkSudoku). It's obvious that TDD doesn't help you write better algorithms. It's a good discipline for ensuring test coverage, it gives good sanity checks, and it can even help the modularity of your program, but it sure as hell doesn't inherently lead to better code. So whether you spend years thinking things through before writing a line of code, or most of your time is spent writing and rewriting tests to…

Discussions about TDD always make me think of Ron Jeffries' attempt to develop a sudoku-solver using TDD. That attempt is discussed in Ravi's article: http://ravimohan.blogspot.com/2007/04/learning-from-sudoku-solvers.htm… Peter Norvig wrote a sudoku solver, not by using TDD, but using old-fashioned engineering: http://norvig.com/sudoku.html Ron Jeffries' attempts: http://xprogramming.com/articles/sudokumusings/ http://xprogramming.com/articles/oksudoku/ http://xprogramming.com/articles/sudoku2 http://xprogramming.com/articles/sudoku4 http://xprogramming.com/articles/sudoku5 And, as dessert (Ron is very frank about his failures): http://xprogramming.com/articles/roroncemore/ "This is surely the most ignominious debacle of a project listed on my site, even though others have also not shipped. (Sudoku did not ship and will not. [...])"