Earlier quoted context omitted.
I like daily syncs if they are done quickly (<15m), and if people are working on different-enough things that they don't really know what their teammates are working on. Because that way you can unblock each other and actually use agile the way it was meant to be done in the face of underestimated tasks or changing requirements
In my experience anything more than 10 minutes is a smell. It typically means you've got stories that are too big, have unaired problems, that you dive into implementation instead of just syncing briefly, or the team has too many people.
The art of interrupting software engineers
61–70 of 255 posts
Re: The art of interrupting software engineers
#62Earlier quoted context omitted.
Pivotal doesn't use sprints. Stories are pointed by engineers and ordered by the PM, but they're done when they are done , to the satisfaction of both. Tracker is able to give short-term forecasts of what will be done by when by averaging the last 3 weeks of deliveries (ie, velocity). Personally I think the idea of sprints is a menace. It creates an artificial deadline that leads to either waste or stress. Deadlines…
I think that artificial deadlines and stress exist because the team and management allow it to exist. A story should fit into a sprint, but it may spill into the following sprint, but you shouldn't sacrifice quality just because you tried to finish it within the sprint. And a team should stand up for themselves in this regard, as a team, because a team succeeds and fails together. If you sacrifice quality because of…
It's just that I've seen the evil twin version of sprints far more than the official version.
Re: The art of interrupting software engineers
#63As a PM of about 4-years of experience, I understand the author's concerns and at the same time believe that he has solved for the wrong problem; his own anxiety rather than team cohesiveness and trust. The issues he solves for can be solved in different ways without such a negative impact on the team, actually in a very positive manner that increases trust, cohesiveness, and user context.
I'd first like to point out that I've made the mistakes of micromanagement that he mentions in the first section. I also quickly learned how detrimental that behavior is to team relationships, productivity, and outcomes. I'm certainly not perfect!
The way the author solves the problem of pace is by creating regular check-ins every half day. He then goes on to identify, how these check-ins can be used as open to monitor common slow-downs: engineering struggle and product context (he calls is product debt).
I'd first like to make the point that some other engineers have commented here, estimates are estimates, we are agile, you learn things along the way and need to adapt. I believe your job as a PM is not to hold the team to estimates, it is to come up with creative solution and serve as a master facilitator on your team.
So when the author says the following I can't help but notice the irony. I'd explore us all to practice what we preach. Instead care about iterations (sprints) not task micromanagement:
"As a product manager (PM), I often make assumptions as to when a particular user story will be delivered. This is painful because I don’t believe in time estimates and don’t think I should be involved in estimating the relative complexity of a story since I don’t own its implementation.
I know I shouldn’t but I can’t help doing it anyway…"
So how do you solve the problems that the author points to "struggle" and "context" without adding interruptions?
• For struggle, that is what standup is for. Not only standup, but if you create a culture of trust engineers will naturally reach out if they hit road blocks, make a slack channel for your team. It's even better if you can teach your team about red flags, things that the article says which are true to look out for: complexity is rapidly increasing, not feeling confident in the stack/codebase. For any of this to work you MUST create a culture of questions and answers. Yes, all want to look competent, but what's also great is being able to depend on your team.
• Adding to the previous point, this is why small tasks are soo important, [read this book on product flow](https://www.amazon.com/dp/B007TKU0O0/ref=dp-kindle-redirect?...) if complexity is small to begin with you can avoid that issue AND you get the added benefit of smaller iterations, meaning faster red flags. The author points this out too, this is critically important.
• For context, context is king. Want to avoid "Product debt", get your team/tech lead involved from Day 0 of your quarterly/yearly roadmap, they should know everything about the user that the PM does minus the RAW research effort. Run a Kickoff/Inception/IPM that truly integrates your entire team, every engineer should have product context. Devs will then see tricky edge cases, radiate them up to the PM and you can make a call together if the work is necessary.
All of this is to say that there are some good parts of this article, but I think that adding one more check-in is not necessary when there are other ways to solve the problems identified.
Re: The art of interrupting software engineers
#64Is it really common for software engineers to work under these conditions? As an electrical Engineers I have plenty of deadlines and do plenty of work with PMs, but none of this daily standup and thankfully Jira was recently dropped as it was considered more trouble than it is worth (management just wanted to know the big things going on and not all things). Of course it's better than plenty of other jobs, but the co…
1.) Treat them as engineers who are capable, able to communicate problems or expected delays, and professionals who want to grow. 2.) Treat them as assembly line workers who constantly want to screw around and need to be whipped back into shape.
I'd argue maybe a third is the startup mentality where you need to sell your life to the company, but maybe that's a mutually exclusive thing.
In my experience, the second comes from the same mentality as the old waterfall companies. Spec everything, trust no developer, micromanage, etc. Developers are a risk, not an asset, and never trust them at a management level. I would never work for a company like that, and avoid them like the plague.
Regardless, both of the views above seem to be a self fulfilling prophecy. Professional shops who treat developers as engineers produce some quality stuff and usually on time. Sweat shops have a lot of failed and over-budget projects and a high turnover.
Re: The art of interrupting software engineers
#65Judging by all the negative responses do most people see themselves as some sort of vigilante programmer in their company? I'm not a PM but I sympathize with how difficult it is to discern where a project is up to when it comes to software, especially when you can't come up with short enough milestones...
Re: The art of interrupting software engineers
#66Earlier quoted context omitted.
Pivotal also has thing where everyone is expected to pair program all the time. I think I would despise the environment but it’s clearly not for everyone, myself included.
I thought I would hate pair programming, but it turned out to be, BY FAR, the best thing that ever happened to me professionally. That said, it really isn't for everybody. But you may want to give it a chance.
Re: The art of interrupting software engineers
#67I only read the first paragraph and couldn’t read anymore. I’m unsure why he cannot Know when a story will be delivered. A story should fit into a sprint and so he should reasonablely expect that it’s delivered at the end of that sprint. If it’s not going to be delivered then this information should be relayed back to the pm. Going and pestering the team is only going to slow down development process and increase the…
Indeed. I got about that far before I quit reading and started fantasizing about the unspeaking things I would do to the idiot that wrote this if I ever met him. Things involving sharp blades and fire.
Re: The art of interrupting software engineers
#68Earlier quoted context omitted.
My reaction to this would be the work committed to was unclear. A task should have all the items clarified before being committed to. If there are questions throughout the iteration then the work was poorly planned. It should be a rarity that a task was ill defined. My view is that a PM is available as a resource to clarify as needed. Meetings between the "doers" of a team and the PM should not be forced, especially…
Changing requirements is fine, though, so long as there's a discussion. Engineering explains what it might involve and the PM gets to decide if they think the change is worth it. Generally once a week is fine. Changes at sub-weekly cadence suggest deeper problems that need to be sorted out. My personal preference is for very fine-grained stories rather than giant chunks of acceptance criteria. The latter tend to turn…
Changing requirements should only happen outside the scope of committed work; otherwise you're building churn, poor features, and poor code.
This lever of "committed work" can be adjusted per team (1 week, 2 weeks, 4 weeks, and so on).
It seems you agree with my view of a minimum of 1 week before it can change.
I agree also with fine grained tasks/stories. As small as possible and as consistent as possible. They should all have clear DOD's though.
Definitely agree with smallest possible units of value (that also varies per a person).
Re: The art of interrupting software engineers
#69Earlier quoted context omitted.
I thought I would hate pair programming, but it turned out to be, BY FAR, the best thing that ever happened to me professionally. That said, it really isn't for everybody. But you may want to give it a chance.
You also need somebody good to pair with. It can be really infuriating to have to deal with someone who can't keep up but on the other hand if you work with someone you respect, it's great.
If you put two random programmers together and ask them to "pair program", you'll very likely end up with two annoyed people at the end of the day.
I was lucky in being mentored into it by some very seasoned pros, and I learned the tricks of the trade that way.
Re: The art of interrupting software engineers
#70Earlier quoted context omitted.
With a visual system like Kanban, it's quite easy to see what other people are working on. The problem I have with daily syncs is that it's redundant to information already available, and you're forcing people to "meet" without any value. A lot of conversations in that "sync" are just noise to a majority of participants. It's kind of like a bunch of people talking to a wall unless you happen to be associated directly…
For me, what is in a Kanban board is not enough info to be able to determine when I can help unblock other people on my team. I think this probably depends on how you use project-management software and what your team works on; for me, a teammate's item might list "Create pipeline to process dataset Y on hourly basis". If they are running into issues, I don't know if it's something I've seen before with that dataset,…
1. For transparency any member of the team can identify blockers in Kanban by putting them in the blocked column. 2. If you're blocked, and running into issues, you'd reach out to anyone that can help you. Why would you wait for a standup or "talk to the wall" for that? Just be proactive.
Dependencies should be known before committing to a scope of work (iteration) with the team. Planning stage (minimal time investment for scope of work definition) vs committed work stage (in progress iteration).