First Uncertification workshop at BarCamp Bangalore V
On Nov 17th and 18th I was running an eXtreme Programming Collective at BarCamp Bangalore V which was held at Indian Institute of Management (IIMB). Overall the conference was well attended. There were over 300 participants. The conference organizers did a great job. Everything went smooth. They were also very supportive and helpful.
Big thanks to Sidu from ThoughtWorks who gave me the idea of running a collective during the conference. Sidu and I sat together and planned out the sessions for the collective.
On 17th, we started off the collective by listing all the topics that people were interested in and then prioritizing them. [Customers state the stories and then they prioritize it 😉 ]
It turned out that there were lots of people new to eXtreme Programming and Agile. We had people from varied backgrounds and roles, from game designers to bio-informatics researchers, and from PM’s to Dev’s to QA’s, They wanted to get a quick overview about Agile and XP before we went into the hands-on-sessions. Following is the order in which we decided to address the topics:
1. Agile – Roles, Concepts, and Practices – Aman King gave a very interactive presentation. There were lots of discussions. We starting maintaining a Parking lot if any discussion run over 10 mins. At a point, one of the participants got really annoyed saying everything is going on parking lot.
2. After Aman’s talk, I cleared the topics on Parking lot one by one. We had following topics on the Parking lot:
2.a. How is the role of Scrum Master different from Project Manager’s role
2.b. How do we do release planning in Agile. How do we thin slice the stories such that we take care of dependencies
2.c. What are the different estimation techniques in Agile
2.d. How do we handle Non-functional requirements in Agile? Do we treat them as separate stories or are they part of each story?
This took the whole morning.
In the afternoon:
3. I ran a workshop on Test Driven Development. We had some really interesting conversations. I know for sure that 2 people walked out being convinced that they will try it on their projects. Could not talk to the rest to see what they thought.
That was end of day 1. A long day. Filled with lots of activities and discussions.
Day 2: Sunday, started kind of slow. The plan was to do
4. A Refactoring Fest
5. A Design Fest.
6. Few discussion on Is Design Dead? and Is Enterprise Architecture dead?
But due clashes with other collectives. We could not run the refactoring fest. Instead I ran the TDD workshop again for couple of people who missed it the previous day. There were certainly some Ahhh… moments again.
After lunch, we had a design fest. This had a really good turn out. About 20 people came for this exercise. We split into 3 groups and I gave them the Veterinary Medical Systems problem from OOPSLA 2006‘s designfest. The teams had 1 hr 30 mins to come up with an application design for the problem. There was a lot of confusion around what design meant. Are we talking about screen design, database schema design or the object model? Basically I was looking for object model, but I was also fine with a DB schema design.
The teams went off and started designing. Each team took a different approach to design the application. One team quickly looked at different objects and their relationships. They decided that the problem was data-centric and hence they decided to come up with a Database scheme for their design. They did a great job of identifying the different tables and basically walked thru all the use cases explaining how their data-model would handle them.
Another team looked at the basic use cases and ignored the exceptional use cases to start with. They came up with a fairly decent object model. Later they were trying to adapt the same object model and ended up missing a few scenarios. But had a fairly decent object model.
The last team actually split into 2 groups and came up with 2 different design. It was basically one person who came up with a design. His approach was to find out all the methods required by the application and then extract classes from those methods. What he ended up was with one class with all the behavior and a bunch of Value-Objects or data-holders.
The other part of the team, used an approach where they took one use case at a time. For each use case, they built a user-system interaction model. From this they started writing skeleton code with method sequences. Once they had all the methods in place for a given use case, then they pulled them off to different classes. They could not cover all the use cases, but did an impressive job for the given use case. Their guiding principle was to come up with working code fairly quickly.
Again like with any art, there are no universal rights or wrongs. Each design had its advantages and trade-offs. But it was great to see 20 people come up with 4 completely different design using 4 different approaches.
Everyone stayed back till 6:30 and were very interested in discussing more.
