At the end of the day, "agile" wasn't originally the monstrosity that scrum-fetishists have turned it into. It was simply these few lines:
"Individuals and interactions over processes and tools Working software over comprehensive documentation Customer collaboration over contract negotiation Responding to change over following a plan"
It is precisely at this beginning point where most "Agile" teams fall flat on their faces. Instead, it is all about process, rather than said individuals/interactions. Scrum rituals are done because, well, everyone else does them, so that's considered "correct". Whether or not there is any value in the process is secondary.
It seems local variations in development processes as the #1 blocker to more cross-team collaboration, so it is enthusiastically steamrolling them.
If you're trying to plan out which individual stories your eng team will be working on 6 months from now, or you have a half-dozen "Sprint Retrospectives" with the same complaints every sprint from your team with no changes being made - you've probably made a wrong turn somewhere.
Having a two week period with a decided set of work allows you to peacefully do this work isolated from incoming requests - unless they are critical, they will always be delayed to the next sprint. Without sprints, our direction and priority changed daily, with no ability to say "we haven't planned for this, please wait". The result was it was incredibly hard to get anything done, and attention was always scattered.
I am happily back at a place that is doing sprints, and I am sure the problems at my previous organization were far bigger than not having them, but sprints do seem like a great tool to isolate the developer from exterior fluctuations. Granted, a great project manager can probably do the same thing.
If you have constant and regular changes in priorities that appears to be an issue with whoever is doing the prioritizing/planning for your team and not a consequence of a specific process.
Without sprints, when the next semi-important bug comes down from production, its pretty hard to justify that its more important than the feature you are building, or especially the tech debt cleanup you are doing. Everything tends to be "important" so if there is no culture of picking a set of work and sticking to it, attention is constantly distracted from one thing to the next.
For me at least, programming is all about some momentum - its hard to get rolling but once you are, you can keep going. Sprints give me the room to have bouts of momentum, stopping every two weeks to adjust direction, and then starting up again. Without them, it feels more like pacman - darting and reacting rather than holding a steady direction.
Ideally, at the end of a sprint you'll have a concrete deliverable. Because this deliverable is concrete and not ongoing, the team should (theoretically) be able to switch entirely to a different project (or priority) afterward when business circumstances demand it.
That's where the "agility" comes in. If, on the other hand, the work is being produced as a continuous flow--without hard cut-offs--then there's no set point where the team can switch priorities without leaving behind a half-finished state.
Obviously, YMMV on how this all shakes out in practice.
I do think it's useful to have some cadence for important meetings, but the arbitrary timeframe should not be treated as a goal or even something worth dignifying in and of itself. It's simply a tool, nothing more and nothing less, and we should expressly state its purpose and discard it in situations where it ceases to be useful.
I actually do like the default Agile meetings, but I think they're usually implemented haphazardly. I would prefer standups at the end of the day so that they run no risk of destroying the context of a programming task or block me from starting my work day. I like IPM/sprint planning to refine stories and make sure they're ready to work. I like having a "definition of done" to create a shared agreement of what my commitments are and whether I've met them. I like retro to evaluate how we're doing as a team and to improve processes and working culture. I like technical retros to share learning and troubleshoot architectural problems and identify useful areas of research.
All of these things are great when done well and for the right reason. All of them can be sources of misery when they are done ineptly or as mere formalities, with no underlying sense of purpose.
Two advantages, people that have got "into" the work flow in the morning need to break anyway, people that use the morning for "admin" and then afternoon for work can finish their housekeeping with the standup.
Same applies at the next order of magnitude, start/finish sprints in the middle of the week, not the beginning or end. No one wants to sit in a review on a Friday afternoon.
Retrospectives make sense at the end of the working week. Planning makes sense at the beginning.
As a both a runner and a developer, I find this quite funny and a bit wrong. The fact that we call them sprints can be a bit wrong or confusing if you put them in a different context, but what I can say is that almost every serious runner will constantly check their laps, be it miles, be it km, you will always look at your watch to see how you performed in your last km and if you are on track.
That's what I see useful in sprints, the fact that you stop for a bit and see where you are, you have the time to discuss things that might have gone wrong and try to fix them before it gets out of hand. But in the end I can understand people who dislike the system, because I've worked with a lot of managers with no technical knowledge trying to manage technical projects.
Unlike in a run, where I know the exact moment and location I have reached my halfway point, in a real software project I don’t even know what the actual distance to be covered will be.
What sprints force you to do is basically make sure you’re running full tilt for every 400m distance, which is fine if the eventual distance ends up being 800m for example, but if it ends up being 26 miles instead, you’re just gonna burn out well before.
Um, yeah, that's a sprint. That's exactly how it's supposed to work. Like you say, it's a good way to work. What do you think a sprint is?
I've worked in non-sprint models - i.e. no regular time-based cadence - and found them harder. It's very easy for a feature to scope creep if you've not got any regular schedule, and it's harder to feel a sense of achievement if you're not releasing regularly.
I was contrasting with that model, though it sounds like I might not be accurately characterizing sprints. We've had some features that have taken over a year to complete, such as a major rearchitecture. The (generally senior) dev assigned to that task has a lot of latitude to break it up according to their judgement, submit individual parts on their own timeline, etc., all while minimizing bookkeeping and coordination with others. As long as they're continuing to make forward progress according to an initially vague, sensible, iterative plan, we tend to leave our established devs to their own devices. For newer devs and where multiple devs are collaborating on a feature together, we encourage at least weekly check-ins.
I definitely wouldn't want to work in a model where you're expected to just take as long as it takes. Integrating a branch that's been going for 6 months is a nightmare; even when it goes well it's immensely stressful. Reintegrating your work back into the rest of the system can easily feel like it's taking "the other 90% of the time" - or even be impossible, if someone else has changed the system in an incompatible way in the meantime. Even if you were regularly merging code changes to master, if you try to release 6 months of work when none of it's ever been deployed to production yet then there's always the sinking feeling that maybe it's all just going to break. Or worst of all, maybe it works perfectly the way you thought it was meant to, but you misunderstood the spec and so all your work is useless.
I'm a bit confused by you talking about an "iterative" plan, because I don't see how you can meaningfully iterate if you're not delivering changes regularly - indeed "iteration" often gets used to mean the same thing as "sprint".
The assigned dev absolutely breaks the big feature into reasonably atomic pull requests, ideally no more than a few hundred lines but sometimes a few thousand. The critical difference, I think, is that none of that breaking up is super planned out, and it's certainly not formalized prior to development. The changes often trickle out over several releases. Collaborators may help advise on where to break things up, but ultimately it's up to the dev to use good judgement.
I agree that 6 months of unmerged development is absolutely a horrible situation that's best to avoid.
If your product priorities are stable for 6 months at a time, you're in a rare position. And I'd worry about knowledge sharing and maintainability if whole functional areas were being implemented by one person on their own. I agree with avoiding having two people working on the same area in parallel if at all possible, and there's certainly an overhead to not having the same person do a series of related tasks, but if we're planning to share maintenance responsibility for that area of the code (which is what being on the same team means) then I think spreading out the development work is worth the overhead. And fundamentally if no-one else on the team can understand Bob's architecture then better to find that out sooner rather than later.
> The critical difference, I think, is that none of that breaking up is super planned out, and it's certainly not formalized prior to development. The changes often trickle out over several releases. Collaborators may help advise on where to break things up, but ultimately it's up to the dev to use good judgement.
Scrum doesn't favour large amounts of up-front planning - ideally you don't plan beyond the end of the sprint - but you define the user-facing change you're trying to make, at least in enough detail to a) tell whether it's actually done or not b) estimate enough to let you prioritize. Even if your priorities are stable enough that you don't need to do the latter, I think I'd always want to define what I'm aiming for in each release ahead of time - otherwise it's just too easy to scope creep and end up with those 6 months of unmerged changes. And if that goal isn't something user-facing then you're kidding yourself, IME - it's just too easy to overengineer or overarchitect and produce a bunch of churn that doesn't actually achieve anything, unless you're constantly keeping in mind what this change is actually supposed to achieve.
On one recent team, we did 2 week sprints with a couple releases per week (basically, one per feature that finishes and makes it through QA).
The 2 week cycle was our planning/work prep cadence. If a feature isn't fleshed out by its owners and stakeholders prior to the start of the sprint, we're not going to ask any devs to pick it up during that sprint. If it is ready, we'll start to plan it, and estimate how long it will take, talk about debt-vs-speed tradeoffs, etc.
I think I might dislike the model you describe because it seems potentially isolated around "my feature" vs "the rest of the team's feature," and because I think making the planning cycle 4 weeks instead of two might cause more planning pain for each release.
We don't have "planning cycles" except for quarterly prioritization to realign on which features matter the most (exceptional features occasionally get prioritized outside the process). When you finish one project, you pick another that's interesting to you that's near the top of the priority list, with support from our Product team and Engineering Operations.
If we estimate what can get done for a given time period, we can evaluate whether we're correct. Do it a few times, we get really good in estimating. We can try and estimate the future. As soon as new things come in that we didn't plan for, we know immediately that we're going to slip, and may even be able to figure out by how much, or what we have to drop to still hit the date (or if we need to evaluate if more people would be helpful; PM triangle here). Likewise if we learn our estimates are wrong, we can start predicting we're going to miss the mark, literally as early as humanly possible.
Doing it this way is in response to longer term milestones; if you only estimate/evaluate once before delivery (if even that; oftentimes milestones are just "on time" or "behind", there isn't any acceptance that a date and set of features won't be hit, and it turns into a death march), you only get one chance to evaluate and respond. Likewise with two, three, etc milestones. Sprints just try to break the work up to do it more often, to try and recognize you're behind, sooner, and so can respond. They don't have to be two weeks; it's a tradeoff, the more measurements the faster you'll recognize you're off, but the more work it is just to measure.
If you don't have deadlines that the rest of the org has to organize around, or to communicate to a customer, just a very clear set of priorities, and you just pull from the top from, you don't benefit from Scrum. Which is perfectly okay. Just, oftentimes businesses -do- need things by a given date, or need to respond in some way. Sprints just help give you evaluations to determine that you're on track. Or not.
Sure. Ideally it would be broken up into tickets that fit inside individual sprints, but sometimes particularly hard problems are just going to roll over. That's fine and nobody should feel bad about it.
I hated agile the first time I met it because the team had no autonomy and a bad culture. When you actually have the ability to treat your process like a tool, none of this is a silver bullet, but it's a fine tool.
Among other things, releasing something on a consistent schedule. I hope you (and the rest of HN) will forgive me for making this little meme: https://i.imgflip.com/4g6z3o.jpg
Disclaimer: These are subjective opinions, and I recognise that some developers thrive in this environment. Also, this is a comment on Agile in the wild, rather than in principle.
That's what a sprint is.
Every 4 weeks, we release whatever has been merged in the last 4 weeks. One dev might have 8 independent changes in a release or 0. We typically have a handful of significant changes that land each release and a bunch of minor improvements. Still, there's not much effort to estimate when any particular feature might land.
When a large feature is getting close to completion, the dev might choose to push a little bit to hit a particular release. There's not really any external pressure to do that, though.
That's still a sprint?
An insight of Agile is that your have to pick either a feature based release schedule or a time based release schedule, not both, which is impossible and that time-based is better.
And not the work adapt to a mechanistic interaction style.
When we need frequent feedback we do frequent feedback. When we need deep group planing we do group planing periods. When we need intensive coding we do intensive coding with occasional follow ups. We track progress, we monitor workforce. When someone hit the wall that person cries for help and we do something about it - depends on the trouble what and how. In one position we used it but was sooo mechanistic and insufficient to address the varying needs that it died off quickly.
I believe it cold be great for certain situations. Simple repetitive ones? But otherwise looks like yet another holy grail management method people hype for a while and might join the club of all other holy grail management techniques being praised to the heavens in their time throughout the history so the world was adjusted to those not the other way around. Then found yet another holy grail out of disappointment.
Not to mention that seemingly no one knows what it is exactly and how it should be used, some do this was, some do that way. And so we are back to the adaptive management now. : )
It must be good for a certain set of situations but it is odd that this is a crucial bit in interviews if someone have experience in it or not, like if it was impossible to adapt to the management style of the task at hand and it would require special skills or capabilities requiring preexisting abilities or formal training....
I don't have a great opinion of sprints for a couple of reasons. I used to have a job that did sprints. Development was often rushed to fit the sprints which led to a high rate of defects. And now I'm working with a vendor that does development in sprints. When we ask them for changes, it adds a large amount of lag to actually getting them because we have to wait up to 2 weeks for them to reprioritize, and then at least 2 weeks for release.
I'm so glad that our company doesn't have them—I think it's a significant factor in me grinding it out for 9+ years. We have feature releases every 4 weeks. If your feature is merged before QA, it goes out in that release. Otherwise, it gets delayed till the next release, and we don't make a big deal about it—several other features will still be in the release.
I feel like it gives me a lot more agency and ownership of my work. I think it's the right amount of subtle deadline pressure, relying on my intrinsic motivation to get my feature shipped and move onto the next one. Or to have the freedom to determine that it's not ready yet and spend a little more time to avoid shoving out a pile of technical debt.
I'm curious to see what I'm missing, though. Anyone love sprints? Anyone working in a non-sprint model and hate it?