agile on SWiK

AgileDraw.org - Main / HomePage

Sun, 07 Sep 2008 10:01:37 -0700

Next-Generation Object-Oriented Databases

Sun, 07 Sep 2008 01:05:21 -0700

7 Agile Leadership Lessons for the Suits

Sat, 06 Sep 2008 13:04:20 -0700

Most articles about the value of Agile are written by and for developers. This one takes the viewpoint of the boss. CIO Eugene Nitzker attended this year's Agile conference and returned with several suggestions for CIOs, IT managers and programming team leaders. This isn't the geeky stuff that developers talk about among themselves; rather, he explains the strategic adjustments that would-be Agile companies need to adopt. If you've been struggling to convince your IT manager that Agile is a Good Thing, perhaps a printout of this article -- delicately and anonymously dropped on his desk -- will speak to his own concerns.

How to manage long breaks in your software side projects - (37signals)

Sat, 06 Sep 2008 09:01:14 -0700

Static analysis tool helps software engineers find bugs during builds

Sat, 06 Sep 2008 00:04:09 -0700

Klocwork Insight allows software engineers to view and correct their own code before it's submitted to QA. More than that, Mentor Graphics found this static analysis tool's capabilities fit well with agile practices.

データベースもアジャイル開発に対応したい! (1/3) − @IT

Fri, 05 Sep 2008 23:58:30 -0700

データベースもアジャイル開発に対応したい! (1/3) − @IT

Fri, 05 Sep 2008 23:58:30 -0700

Jiemamy でアジャイルに DB 設計する．データベースの進化的設計．考え方もためになる

One day of TDD, and other thoughts on testing

Fri, 05 Sep 2008 16:04:11 -0700

Reflections on spending one day doing TDD. Then other thoughts about how testing has changed my developer habits.

Agilo for Scrum

Fri, 05 Sep 2008 13:58:41 -0700

Trac Extension

Scrum Cheat Sheet

Fri, 05 Sep 2008 09:05:09 -0700

The Scrum Cheat Sheet gives a quick reference to - the Roles: Product Owner, Scrum Master and Team, - the Artefacts: Sprint/Product Backlog and Burndown Chart, - the Ceremonies: Sprint Planning, Daily Scrum and Retrospective, and explains briefly how these three main aspects of Scrum are related. The PDF download is for free :-) Have fun agila

agile-trac – Trac

Fri, 05 Sep 2008 08:58:57 -0700

Buildix " About

Fri, 05 Sep 2008 07:59:25 -0700

Agile Data Home Page

Fri, 05 Sep 2008 06:58:48 -0700

Multithreaded Testing with JUnit and Java 5 Concurrency

Fri, 05 Sep 2008 05:04:49 -0700

This entry describes a technique for writing multi-threaded automated (*Unit-style) stress tests in a safe and reliable fashion by leveraging the concurrency utilities added in Java 5. It's a technique that should not be used gratuitously as it's more heavy-weight than a standard unit-test, but is appropriate for in some scenarios. It's surprisingly simple considering what it's doing. A complete, easy-to-run example is referenced at the bottom.

InfoQ: Ivar Jacobson on UML, MDA, and the future of methodologies

Fri, 05 Sep 2008 04:58:45 -0700

Setting the git commit author to pair programmers' names — Bryan Helmkamp

Thu, 04 Sep 2008 17:56:29 -0700

[index]

Thu, 04 Sep 2008 15:59:17 -0700

Ivar Jacobson: Developers are too fashionable

Thu, 04 Sep 2008 12:59:17 -0700

One of the fathers of software development processes says the industry is too fashionable, needs to stop re-inventing the wheel, and focus on being more creative.

Songbird path to Agility - Part II

Thu, 04 Sep 2008 10:57:19 -0700

Previously, we’ve examined the new development practices that the Songbird team adopted to plan and track a release. Everyone on the team was very eager to put them to the test. Unfortunately, at the time, we were still in the middle of the 0.3 release cycle and new work could only be started once that release was completed. During the 0.3 release, everything was still treated as a bug, but in fact, many bugs were stories and tasks in disguise. We decided to apply some of the newly defined tracking principle to help us guide and finish the cycle, so we could start fresh with our next release as soon as possible.

Cuánto es?

The first step was to add cost to everything. We introduced a new cost field in Bugzilla and put a cost value on everything according to our new scale of 1, 2 and 3 points. With costing in place, we were in a position to compute how much points the team was able to complete in a typical work week. That total, normalized per work day became our team velocity.

Below is a chart representing our velocity over many — one week — iterations during the 0.3 release (code name Bowie). The blue line is the number of points the engineering team completed, averaged per work day. The red line tracks the cost of new things being introduced, normalized per work day. The green line tracks the net velocity.

It quickly became apparent that as the team took things off the pile, new work was being identified and added. We had to keep track and take this into account. We named this intake to globally represent new functionality, regressions and newly discovered bugs.

The net velocity gave us an indication on how well we were doing overall. When it gets in negative territory, we are losing ground.

You can see below 3 events that had clear impact on intake, namely scope creep (some features were not well defined upfront), and bug intake due to public feedback from a blessed build and a release candidate.

Also noticeable is a week when the team was not as productive as usual. With that information in hand, we were able to have open conversations about the state of progress and try to determine the cause for it. Sometimes, a low velocity is simply because work gets accumulated in a week and does not get checked in until the next. We call this carry over. Other time, there are some inevitable distractions such as a move, interviews, equipment failure, etc. In other cases, the team is just having a bad week.

With this in place, we were able to understand the rate at which the team was completing work. We created a burn down chart that tracked the total points of known work left. Using the team velocity, we could forecast an expected release date with a simple best fit projection. When the line crosses the X-axis, you are done and can ship.

If you compare the two charts, you can see how much influence intake had on the release. This became a key component to take into account in our planning. By budgeting points towards intake, it allowed us to reserve some engineering capacity to take change into account upfront and have a more realistic schedule.

Where does intake come from?

By formally tracking our intake, we were able to better characterize the nature of change. Most of our intake comes from change introduced when features start to materialize in the product and can be tested. This is a desirable effect of adopting an Agile practice. Other contributors are defects being reported by existing users, which is a benefit of early releases. Less desirable intake come from regressions or new tasks that resulted from bad assumptions or misunderstandings. Those can usually be mitigated by increasing unit tests coverage and more upfront detailed planning.

Full Agile cycle

Let’s take a look at another release cycle. Dokken was our second release in which we used the new process from inception. The charts below represents velocity and burn down respectively. Note that the scale on the velocity has increased. There is more dynamic range. Because the release started from day 0, we noticed a ramp up in the velocity. We learnt not to be necessarly alarmed by this. In a new release cycle, the team needs some time to “prime the pump” of development. As the release progressed and we got better visibility of the team progress, we decided that we should defer feature work that was identified as nice-to-have. This is another thing we did during planning. We prioritized work in must have for the release, hope to have for the release and nice to have - mainly cosmetic changes, low risk bugs - buckets. This gave us a pre-negotiated way to easily shift features as the release progressed.

By actively tracking and managing the intake, we were able to steer the release and deliver within weeks of the projected date. Not great, but better than our previous releases. Dokken was a particular difficult release as we undertook a lot of device support work, which can lead to nasty device compatibility problems.

Embracing change

The next release, named Eno presented some interresting characteristics. The intake was relatively high thru the release but the team was also maintaining a higher velocity. This is a good example of the team achieving a good level of agility. Change is being introduced throughout the release and the team is well prepared to tackle it. Also notice that the spike in intake due to feedback from release candidate has a corresponding level of increase in team velocity. This is due to the shortening of feedback loop. With proper ownership, the developers are able to respond in real time to issues being discovered.

Notice how the burn down trend is converging almost linearly. This means that the team is achieving a sustainable pace, leading to more predictable ship date.

Achieving high velocity

Our latest release, Fugazi is another example of a successful cycle. This was the shortest release cycle the team ever undertook, with only 4 weeks of planned development work and 3 weeks of QA. In order to maintain our original release date, we had to defer some lower priority work in iteration 3. Despite the shorter release period, the team actually completed more points per iteration than any other release. We maintained an unprecedented high velocity, which in turn allowed for a high level on intake to be absorbed, so all the planned must have featured could be kept in the release and still hit our original target date.

DIY tools

In the last part of the series, we’ll cover the tools we created to make the tracking easier and how they are being used on a daily basis to help us steer the release. Stay tuned.

Seven Principles of Lean Software Development - Respect People

Thu, 04 Sep 2008 08:00:46 -0700

Do you work in a group or a team? If you can see your work environment objectively you will know whether your colleagues are eager to work and solve technical problems in your project or rather they are told what to do by the manager. If you are told what to do i.e. your team lead decides what you should work on next (or even tell you how to work) you work in a group.

agile-trac – Trac

Thu, 04 Sep 2008 04:00:01 -0700

agile42: Download

Thu, 04 Sep 2008 03:00:36 -0700

PeerReviewPlugin - Trac Hacks - Plugins Macros etc. - Trac

Thu, 04 Sep 2008 01:59:38 -0700

AgileTrac

Thu, 04 Sep 2008 01:59:38 -0700

Agilo Demonstration Project - Trac

Wed, 03 Sep 2008 23:59:28 -0700

Django 1.0 Released!!

Wed, 03 Sep 2008 22:59:32 -0700

" No, you’re not hallucinating, it’s really here. Around three years ago, Adrian, Simon, Wilson and I released some code to the world. Our plan was to hack quietly on it for a bit, release a solid 1.0 release, and then really get the ball rolling. Well[...]"

InfoQ: Agile Business Rules

Wed, 03 Sep 2008 15:00:43 -0700

[from bushwald] Agile Thinkers: Israel Gat - The Equipoise of Agile

Wed, 03 Sep 2008 12:00:35 -0700

Introduction to UML 2 Component Diagrams

Wed, 03 Sep 2008 10:56:29 -0700

The Big Development Project: How much should it cost?

Wed, 03 Sep 2008 08:00:27 -0700

Some people think that agile and budgeting are incompatible. The product is ready when the product owner says it is. But before starting a project, most managers want at a least budget. So the product owner puts together his wish list and asks the ScrumMaster what it will cost to build. The answer comes back – usually a long time and whole lot of money! Then the customer turns pale as he tries to decide what it will really cost, whether he can afford it and whether it’s worth it. But there is a better way: the product owner can perform a double worst case analysis. This quick and easy tool uses the project’s business value to determine a reasonable price for the software investment.