Ron Jeffries

No article about TDD, particularly one that shouts out to the respected Ron Jeffries http://ronjeffries.com/, is complete without mentioning the TDD Sudoku Fiasco :) Ravi has a nice summary: http://ravimohan.blogspot.se/2007/04/learning-from-sudoku-solvers.html Peter Norvig's old-fashioned approach is excellent counterbalance: http://norvig.com/sudoku.html

I always love to compare Peter Norvig’s sudoku solver implementation [1] versus Ron Jeffries TDD approach [2]. Norvig starts with the theory building and creates a constraint solver in about 50 lines of code. Jeffries starts with TDD, assumes an implementation, has to change that implementation, therefore has to change the tests, and after a series of five blog posts kind of fizzles out on it. To me it just highlights that defining the problem is with so much more than defining the tests, as you can’t write a test for a problem you haven’t defined yet. In this way the tests are an imposition. In short to me it shows that TDD only really works if you already knew how to buold the project to begin with. [1] https://norvig.com/sudoku.html [2] https://ronjeffries.com/xprog/articles/oksudoku/

One of the original signatories of the Agile Manifesto, Ron Jeffries, suggests developers abandon the word Agile [1]. Instead, we should recommend and practice "Manifesto Agile". 1. https://ronjeffries.com/articles/018-01ff/abandon-1/

Do you mean the series of posts linked to from the one you give, beginning with [1]? They are an excellent demonstration of two of the pitfalls of naive TDD: 1) The things you can test first (before you have figured out the central problem) are not necessarily the things that matter most. The author should have addressed the algorithm for solving the puzzle first; everything else is secondary. 2) This is an example of those cases where having tests for what you are going to write does not provide much guidance into how to solve the problem. [1] https://ronjeffries.com/xprog/articles/oksudoku/

I came here to post a link to Ron Jeffries' "we tried baseball" article [1] but that's already linked at the bottom of OP. Since it's a good read, but slightly tucked away, here it is anyway. [1] http://ronjeffries.com/xprog/articles/jatbaseball/

Technical debt is an explicit choice to optimise for speed of delivery at the cost of having to do more work later to bring the delivered code up to the usual expectations of code/features in the system. Ideally the choice to take on that technical debt comes with an agreement of when the debt will be paid down and an understanding of the additional work that will be required because of the shortcut being taken now. It is not technical debt if there is no explicit decision, or it is the gradual and continuous bitrot that all codebases suffer. I usually refer to this as cruft and while good design and writing code to optimise for readability / understandability reduce the rate that cruft accumulates, it cannot be stopped due to the nature of software. The best practice I have found to fight cruft is many small refactorings and cleanups as part of every piece of work I deliver. This strategy is outlined in https://ronjeffries.com/xprog/articles/refactoring-not-on-the-backlog/…

The hardware engineering world (oil and gas, aerospace, civil) is less about ego and more about well established processes, practices and rules. These are much more mature industries than the software industry. In my experience intellectual posturing is much more a software industry thing than a hardware industry thing. Software developers are still struggling to figure out what's the best way to do things. SOLID, YAGNI, Agile, RUP, RAD, Clean Code, OOP/FP - they're all just the start of a maturing process. They will no doubt be superseded in time by other, better practices, just as they have superseded others. In mature engineering industries, the engineering rules and practices are well establishes. Much of this has come about because of accidents (and death - planes crashing, bridges collapsing, oil rigs exploding) and the court cases that follow. In the early oil industry health and safety mattered little. Same goes for the aerospace industry. These are hard lessons to learn and practices had to change. The cost of not changing was uneconomical. The software industry is still growing up and best practices still have to be formally established. All the articles and books written about best practices in software - they're just the beginning - and most are probably wrong to some extent. Where does the intellectual posturing come from in the software industry? It's largely because of a lack of provably reliable practices and processes. The ones we have, are sold to us as…

Norvig mentions it in the article linked in the post to which you are replying. The game was Sudoku. The person was Ron Jeffries. https://ronjeffries.com/articles/-z022/01121/sudoku-again/

Yes, but remember the much more important rules of programming: You aren't gonna to need it[1] Do the simplest thing that can possibly work[2] 1. https://en.wikipedia.org/wiki/You_aren%27t_gonna_need_it 2. https://www.ronjeffries.com/xprog/articles/practices/pracsimplest/

Bullshit. That's like claiming no one can play good football because the Cleveland Browns suck. https://ronjeffries.com/xprog/articles/jatbaseball/

Well, it's about story points rather than estimation per-se. The alleged inventor of story points says their invention was probably a mistake: https://ronjeffries.com/articles/019-01ff/story-points/Index.html But most people ultimately want estimates to determine whether or not a project is going to be late or over budget (often the same thing). What's worked for me is to ensure the stories are of the same sort of size (ie they mostly sort of look like they could be done in a few hours/days/week/months) - count them up and divide by remaining time. You'll then get an idea of whether you'll need to deliver 2 things a week or 50 - and you'll have a gut feel on whether that's achievable.

Huh? Ron Jeffries is a champion of TDD (see for instance https://ronjeffries.com/articles/019-01ff/tdd-one-word/). He most certainly wasn't deliberately implementing Sudoku in a stupid way to make TDD look bad!

Well that's pretty naive. I've worked with some pretty good teams that wouldn't work any other way. I suspect you've only worked at places that abused agile as described here... https://ronjeffries.com/articles/language-of-hatred/

For a proper discussion I'm surprised no one has mentioned this principle from Extreme Programming possibly predates Google as a company. https://ronjeffries.com/xprog/articles/practices/pracnotneed/

Article seems to identify main reasons as either poor implementation, or poor change management. Funny how much this reminds me of capital-A-gile, and Jeffries "we've tried baseball"[0] - we've implemented some simple changes that make things better! - everyone, let's all do this thing! - there! We've tried! It doesn't work - but you've bastardized the original idea beyond recognition - doesn't work! [0] https://ronjeffries.com/xprog/articles/jatbaseball/ edit: formatting

Similar musings under the "Dark Scrum" heading by Ron Jeffries: > Every day, the team is supposed to get together and organize the day’s work. [... The ScrumMaster ...] knows his job. His job is to stay on top of what everyone is doing, make sure they’re doing the right things, and redirect them if they’re not. How convenient that there’s a mandatory meeting where he can do that, every single day! > In practice the Dark Sprint Review begins by someone reminding everyone what the team “promised” to do. (That is, what was demanded right before the team said “We’ll try”. That’s a promise, isn’t it?) Then we look at the pitiful failure the team brings us. https://ronjeffries.com/articles/016-09ff/defense/

I always knew that Scrum wasn't as agile as some people want to tell you, but this was the first time I read about 'Dark Scrum' [1]. In my opinion, Scrum is a good tool to kickstart the process of becoming an agile organization, but too often the process languishes there and generates a lot of frustration. [1]: https://ronjeffries.com/articles/016-09ff/defense/

Don't think, just set the halt. https://ronjeffries.com/xprog/articles/practices/pracjustsetthehalt/

Ron Jeffries' original article can be found here. https://ronjeffries.com/articles/018-01ff/abandon-1/

Developers should abandon agile: https://ronjeffries.com/articles/018-01ff/abandon-1/

Or "do the simplest thing which could possibly work": https://ronjeffries.com/xprog/articles/practices/pracsimplest/

> Unmanaged Complexity This comes back to the XP practice[1] of simple design[2] or "code that can change" which Fred George says has 4 properties: 1. Works 2. Communicates 3. No Duplicate Code 4. Least classes and methods see GOTO 2015 • The Secret Assumption of Agile • Fred George [3][4] [1] https://ronjeffries.com/xprog/what-is-extreme-programming/circles.jpg [2] https://ronjeffries.com/xprog/what-is-extreme-programming/#simple [3] https://www.youtube.com/watch?v=l1Efy4RB_kw [4] https://gotocon.com/dl/goto-amsterdam-2015/slides/FredGeorge_TheSecret…

NoEstimates: http://ronjeffries.com/xprog/articles/the-noestimates-movement/

Before you start trying to draw conclusions about the general state of development, consider that Mr. Jeffries... "Some further very simple tweak, which I no longer remember, and the test ran … and did nothing. That’s not too surprising, I guess, because there’s no if __name__ == '__main__': "which, I believe, means that no one calls the testrunner. "You’re supposed to know that!" ...is also the fellow who had some trouble with Sudoku[1]. I say this not as an attack on Mr. Jeffries, but as a way of pointing out that shaving yaks is easier if you know to start with shears and not a hatchet. [1] http://ronjeffries.com/xprog/articles/oksudoku/

I've noticed that solving a sudoku is something of a rosetta stone for how people program. Norvig's solution is very straightforward in hindsight, but I think that code was either the result of many iterations or of a career of making progressively more readable code. Here are some other sudoku solvers that give more insight into the coder than the problem: Sudoku in APL: https://www.youtube.com/watch?v=DmT80OseAGs Test driven sudoku: http://ronjeffries.com/xprog/articles/sudokumusings/

A better title would be "Dark Agile is a scourge on the planet". There are plenty of people who've written about this, but Ron Jeffries' posts "Dark Scrum" (https://ronjeffries.com/articles/016-09ff/defense/) and "We Tried Baseball and It Didn't Work" (https://ronjeffries.com/xprog/articles/jatbaseball/) cover this well. Retros: Retros are about being more effective. That usually means talking about and solving problems. If too many problems are beyond the team's control, that's indicative of a "faux agile" or "dark agile" environment. If your "CEO being a dickhead" is the biggest problem in anything but the smallest organizations, your CEO is not pushing decisions down to the lowest possible level where they can be made and isn't trusting and respecting the people with the knowledge and skills to get the work done. This is the kind of cultural shift needed to make agility work. If most decisions are made two or three (or more) levels above the team, then agility falls apart. When it comes to successes, it's not about patting yourselves on the back, but about finding ways to repeat those successes again and again in the future. Standups: Even a "quick morning briefing'" isn't the intent of a standup. It's a planning session. If you have a bunch of people who barely work together, you won't get value from a daily standup. But when you have highly collaborative teams and are planning things like who is going to pair or mob today, what work will be integrated and would be…

Ah, yes. The famous Sudoku solver controversy. In 2006 Ron Jeffries wrote four blogs about solving Sudoku in Ruby with TDD. His blogging effort ended before he completed the solution. I think he got interested in something else and left the whole thing hanging. That same year Peter Norvig wrote a Sudoku solver in Python using a constraint based approach. You can see their respective documents here. https://ronjeffries.com/categories/sudoku/… https://norvig.com/sudoku.html The anti-TDD lobby, at the time, hailed the two documents as proof that TDD didn't work. Ha Ha, Nya Nya Boo Boo. I was aware of this silliness, but never bothered to study it. I had better things to do. Until March of 2020. Then I thought I'd use Sudoku as a case study for Episode 62 in http://cleancoders.com. I had not read either of the previous documents and decided to maintain that ignorance while writing the solver in Clojure using TDD. It turned out to be a rather trivial problem to solve. You can see my solution in http://github.com/unclebob/sudoku I don't know why Ron stopped blogging his Sudoku solver in 2006; but he picked it up again in 2024 and has written much more about it. The trick I used to solve Sudoku with TDD was to consider the degenerate cases. Sudoku is usually a 3x3x3x3 grid. Let's call this a rank-3 problem. I started with a rank 1 problem which is trivial to solve. Then I moved on to a rank 2 problem which was relatively simple to solve; but was also very…

Another linguistic confusion here. The author doesn't seem to clarify what exactly he thinks "agile" even means, which is not really surprising given that the original formulation [0] of "individuals and interactions over processing and tools" has somehow been co-opted and appropriated by the Scrum certified managerial class into an enterprise-scale methodology. There is Scrum(tm), and then there is kanban, and eXtreme Programming/XP, and your own homespun variant of "agile" that your team honed after a couple of years of working together and evolving your own working agreements... which one is under discussion here, and what are your definitions? The equivocation deepens once the author starts bringing devops into the picture, widening the already frighteningly large umbrella term "agile" into a diffuse, ill-defined mess: All the sins Marlinspike ascribes to Agile - siloing, big picture blindness, suppression of skills acquisition - are explicitly addressed by devops, which is entirely compatible with Agile. That being said, Moxie doesn't seem to clarify what _he_ means by "agile," either: Anybody who is managing an engineering organization will have some kind of management philosophy that is in some way downstream of, derivative of, in the zone of, or somehow related to agile [...] [1] - but given that both his remarks and TFA's recapitulation of those remarks tend to revolve around technical practices, and abstraction in particular, let's try…

If you do Scrum like that, you're doing it wrong (I know, no true Sctosman [1], and I know, there are actually dark patterns [2]). I wrote a whole book about "Agile Anti-Patterns" [3]. Most of the book's content is about things that many companies get wrong when they start with agile or lean software development. Because it is very easy to get those things wrong. Yes, those problems are extremely common. Not only with Scrum - Organizations also face those problems when they try Kanban or SAFe or whatever. Because, change in a traditional organization is hard. And to really implement Scrum, you'd probably need to change more about the organization than the org was willing to change. But those problems are not Scrum's fault. If the team has no power, it is also not truly self-organized. And the Scrum Master is not doing their job. You could start to improve by creating awareness about the problems. Blaming Scrum may or may not be a good idea to do that - Because, some people in your org may be invested in Scrum. Some mentoring or coaching for your Scrum Masters, Product Owners and developers and managers might be a better start. [1] https://www.davidtanzer.net/david%27s%20blog/2014/03/26/no-true-scotsm… [2] https://ronjeffries.com/articles/018-01ff/hills-to-die-on/ [3] https://www.quickglance.at/agile_antipatterns.html