Posted on by

Workplace toxicity and trigger words

Every organization has its own culture and its own internal jargon, including trigger words that can lead to friction if we’re not careful how we say things. A case in point.

A few weeks ago I facilitated a couple of short training courses with the title, “Advanced Lean Development: A Feature-Centric Approach.”

When a training company approached me to do this, I was intrigued by the title because I offer a workshop on process improvement based on Lean thinking, described here: https://neopragma.com. The course title they presented sounded like a perfect match.

Continue reading Workplace toxicity and trigger words
Posted on by

AI and me

This post was written without the assistance of AI. Spelling and grammatical errors are my own. Failures of understanding or nuance may be my own as well, or they may result from a joint effort between you and me. In that case, neither of us can be entirely sure where the blame falls.

Social media activity in the recent past has been preoccupied with artificial intelligence (AI) and variations on that theme, such as Large Language Models (LLMs), small language models (SLMs), Agentic AI, Artificial General Intelligence (AGI), and Artificial Superintelligence (ASI). I’m not an expert in that field, so I’m going to follow a longstanding Internet tradition and express opinions about it anyway.

It seems to me several distinct lines of thought about AI are evident in the social media discussions.

Continue reading AI and me
Posted on by

A Broad and Shallow Introduction to Unit Testing

Many software teams struggle with testing and verification of their code. There seems to be general confusion or misunderstanding around topics like unit testing, integration testing, functional testing, exploratory testing, test-driven development, test automation, and refactoring. When technical coaches introduce concepts like “levels” of executable checks, “testing strategies,” and the distinction between testing and checking, I notice many team members’ eyes glaze over. When the coaches show people how to write executable unit tests or how to do test-driven development, it seems as if they learn the mechanics in a rote way yet still aren’t sure where the various pieces fit into the bigger picture of effective software delivery. And they can’t easily judge which of the numerous topics may apply to their own workflow.

Continue reading A Broad and Shallow Introduction to Unit Testing
Posted on by

Things To Come(?)

I’m seeing a lot of talk online about agile software development – what it is, what it used to be, what it’s supposed to be, whether it’s dead or alive, how we can design better agile frameworks, etc. Maybe the subject isn’t being discussed broadly, but I’m connected with so many “agile” people that it gets a lot of play in my feeds. I get the feeling people are beating up a rag doll, or flogging a dead horse, if you like old sayings.

I think there are three converging trends that are quickly making the whole subject moot.

Continue reading Things To Come(?)
Posted on by

Template-Based Development Then and Now

There’s an old saying: There’s nothing new under the sun. Maybe there’s something to it. Details change, but the general patterns of things remain consistent. The wheel keeps turning, and if you live long enough you see the same spokes come around again and again.

James Shore, a well-respected figure in the software development field and the author of the highly-regarded book, The Art of Agile Development, has developed an approach to software development he has called a pattern language for testing without mocks.

I struggled to get started using James’ pattern language. Initially, I was trying to write code in two different ways in parallel – one using mocks and the other using the pattern language. I thought it would be interesting to apply the patterns to different types of languages and different programming problems. It was extremely frustrating. It seemed no matter what I did, I was breaking one of more of the “rules.”

Fortunately, James was willing to help me quite a lot, pointing out where I had gone astray and suggesting reference material to help me learn. He mentioned that people who have internalized testing with mocks often have similar difficulties picking up this approach, and that it requires a mindset shift.

That’s exactly what I was doing. I was approaching it from the perspective of testing with mocks and then seeing what would have to change to build the same solution using the pattern language. It proved to be a fool’s errand.

I paused and took a couple of days off from it. Then I read through all the material describing the various patterns and so forth. It struck me that what he was describing was very similar to the way we used to apply common application patterns in the 1970s-80s. By focusing on the comparison between “using mocks” and “not using mocks” I was missing the point.

Continue reading Template-Based Development Then and Now
Posted on by

A conversation with my rubber duck concerning the linearity of time and other impossible things, plus a little about test-driven development and refactoring

Sometimes talking through a problem with a rubber duck can yield surprising insights.

With increasing frequency, I’ve been hearing comments to the effect that when people refactor code, they break existing test cases that were passing before they refactored.

When I ask whether the test cases “know” about underlying implementation details in the code under test, they look puzzled. Well, of course. How else would you know the code was working?

Hmm.

So, when I ask them whether they test-drive the refactorings, they look puzzled. Well, of course. We always test drive code changes.

Hmm.

So, when I ask them whether the tests break due to refactoring, even when the refactorings are test-driven, they look puzzled. Well, of course. That’s what we said, isn’t it?

Hmm.

I didn’t see how the last two statements could be true at the same time. I needed advice from my rubber duck.

Continue reading A conversation with my rubber duck concerning the linearity of time and other impossible things, plus a little about test-driven development and refactoring

Posted on by

Random musings on the Agile Manifesto

As of February, 2001 the authors of the Agile Manifesto were all advanced in their careers and were already well known as top-tier software professionals. The individuals are quite different from each other; different experiences, different perspectives, different political views, different levels of formal education, different ways of approaching problems, very different personalities.

Notwithstanding their differences, they have one thing in common, and I think it may have a bearing on the tone of the Manifesto, as well as on a peculiar incongruity that I’ll mention later. The common factor: They are middle-class white males raised in a West European or North American cultural context.

Continue reading Random musings on the Agile Manifesto
Posted on by

Induced Work

People say there are certain things that are hard to unsee once you’ve seen them. When you start to see software development and delivery processes through the lens of lean thinking, it seems you can never unsee it again. You can’t fail to notice opportunities for improvement. Sometimes it’s puzzling that others don’t see the same things, but it may be they’re looking at the situation through a different lens.

Continue reading Induced Work
Posted on by

A sidelong view of organizational transformation failure

Looking at the corporate landscape of the 2020s, I’m compelled to wonder why large organizations today seem no different from those of 150 years ago, despite the work of people like W. Edwards Deming, Peter Senge, Taiichi Ohno, and others; and well-thought-out improvement programs/frameworks/methods like Kaizen, Business Process Reengineering, Operational Excellence, Total Quality Management, Agile- and Lean-derived frameworks, and others, all diligently applied year after year.

There’s been speculation about why all this time, money, and effort has yielded no fruit.

Continue reading A sidelong view of organizational transformation failure
Posted on by

Mastering the keyboard

You’ve probably heard advice from certain quarters that a software developer doesn’t need a pointing device. Everything they need to do can be done with the keyboard, and the work is much faster that way.

The advice seems succinct until you unpack some of the underlying assumptions. Besides that, I think we should think about the effect on novice developers when highly-experienced trainers and coaches tell them to throw away their mouse. They often end up spouting off on their blogs about how anyone who ever reaches for a mouse for any reason is unprofessional.

They have been told by mentors they respect that they don’t need a mouse. All they need is a keyboard. And they’ve practiced working that way through code katas and other exercises. They can navigate their favorite text editor flawlessly using the keyboard alone.

Continue reading Mastering the keyboard