Please fill in the InfoQ Survey! Carin Meier takes a look at the joys of Deep Learning, discussing how Deep Learning is changing how people approach programming, communicate with each other, and even what it means to be human. Changhoon Kim explains how P4 and PISA make network switches programmable and shows interesting applications for tracing, caching, and more.
This is the fourth in a series of articles that will help you think about how you might want to customize your agile approach for your context. This article is about the kind of leadership your project might need and who might provide it.
Teams new to agile or new to an organization need facilitation so they can create their own agile approach that works. London Mar , New York Jun , A note to our readers: As per your request we have developed a set of features that allow you to reduce the noise, while not losing sight of anything that is important.
Get email and web notifications by choosing the topics you are interested in. If we have several agile development teams working on the same codebase, how do we minimize the risk of stumbling over each other? How do we ensure that there always is a clean, releasable version at the end of each iteration? This paper describes an example of how to handle version control in an agile environment with multiple teams - it is the scheme that we migrated to at the company described in " Scrum and XP from the Trenches ".
This paper is not primarily targeted for version control experts, in fact such experts probably won't find anything new here. This paper is aimed at the rest of us, those of us that just want to learn simple and useful ways to collaborate. It may be of interest to anyone directly involved in agile software development, regardless of role - branching and merging is everybody's business, not just the configuration manager. If, after reading it here, you'd like a copy for reference, scroll down for downloadable pdf versions of the cheatsheet and of the entire article.
This paper describes an example of how to handle version control in an agile environment with multiple teams. I'm going to assume that you are familiar with the basic elements of Scrum and XP and taskboards.
I didn't invent this scheme - it is based on the "mainline model" or "stable trunk pattern". See the references section for more info. I wrote this paper because I keep bumping into teams that really need something like this. Most teams seem to like the model quite a lot once they understand it. This is also the scheme that we migrated to at the company described in "Scrum and XP from the Trenches".
It really helped us develop and release software in a more agile manner. By describing the model in an easy-to-read fashion maybe I won't have to explain it as often over a whiteboard: Note that this is only one pattern among many, not a silver bullet.
If you do choose to use this pattern you will probably need to adapt it to match your particular context. In an agile environment with multiple teams the version control model needs to achieve the following goals: This summary is also available as a downloadable pdf. Otherwise we get a mess. The policy describes rules for what kind of stuff is allowed to be checked into this branch. The owner is the person responsible for defining and following up the policy. When is a user story "done"?
More specifically, when your team moves one particular user story into the "done" column on their taskboard, what does that actually mean? So when a team member says that a story is Done and moves the story card into the Done column, a customer could run into the room at that moment and say "Great!
Let's go live now! You can use whatever definition of Done you like. But remember - if the definition is anything less than "releasable" you need to consider: And who will do that other stuff? And what happens if something goes wrong after Done? When a story is Done, it needs a home.
With my definition of Done "releasable" that means there must be some branch in the system that you could release from in order to get that story into production. That's the Done branch. Any branch could be the Done branch. I'm going to use the trunk as the Done branch a good starting point. Sometimes this is called the "mainline". At any moment, the product owner can decide that we should make a new production release directly from the tip of the trunk.
The blue line represents the trunk. Each green ball represents one checkin. So 5 things were checked in during this sprint. We could release from the trunk at any time, although we will typically do it at the end of each sprint. If half the team gets sick near the end of the sprint and they don't have time to finish story 5, we could still make a release.
And, of course, we could choose not to make a release and instead wait another sprint to get story 5 in. If story 3 above is something that I don't want to release, I've essentially killed the branch. Since the branch is no longer releasable, I've violated the branch policy. Releasable means integration tested. And that means we need to run integration tests. So we need to run integration tests before checking in to the trunk.
So where do I check in code that I believe is done, but need to verify before checking in to the trunk? Of course, I could test it locally on my machine, and then check it directly into trunk.
But that's a bit scary, I'm sure you've all run into the "hey but it works on my machine" issue. Another issue is "OK, I'm finished coding for today, I'm going home now. Where do I check in my code? It's not tested yet, so I can't check in to the trunk. We have stuff we'd like to check in, and there's no place we can check in without violating a branch policy.
That's a valid reason to create a new branch. Let's call this a work branch, shared by all members of the team. Some people call it a development branch. Great, so now we have two branches! One stable branch the trunk and one slightly less stable branch the team branch. The team branch is red to highlight that it is less stable, i. OK, so the now team has a place to check in work in progress! At some point hopefully a story will get Done. More specifically, at some point the work branch will get to a point where it is releasable.
At that point we can and should publish to the trunk, i. After that the trunk and the work branch are identical. We can call this "publishing" since we have been doing some work and are now ready to "publish" it back to the trunk for release. Just a helpful metaphor.
Let's say we've implemented two stories: They are Done, i. We have started working on Withdraw, but it is not Done yet. The taskboard would look something like this:. Each yellow stickynote on the board represents a task, i.
For example edit class X, update the build script, etc. Each task typically represents about 1 man-day of work, each story typically represents about 3 - 8 man-days of work. So first our team implements Register.
Checkin to the work branch, run the integration tests, fix some problems, checkin again, run the tests again, works! Publish it to the trunk. Only one checkin was needed. Integration tests pass, so we release to trunk again. Now the team is in the middle of implementing Withdraw. They have done two checkins so far, but aren't done. Note that "release to trunk" doesn't mean that we are copying the code for one specific story to trunk. It means we are copying everything from work to trunk, i.
If the team implements one story at a time, publishing to trunk is trivial. As soon as a story is implemented and tested on the work branch we copy everything from work to trunk. What if we are doing multiple stories simultaneously within the team?More...