Findings from Sprint Retrospective

In this blog I will mention several common issues encountered during Sprint execution and possible actions that can be taken to avoid these during software development.

This is obtained from my experience working on SCRUM in few projects in different organizations and is the result of brainstorming by different team members.

Knowledge of these will help address the common issues right from the beginning. Following issues are covered in more details in this blog:

1. Uncontrolled Changing Requirements
2. Majority of team members are not aware of overall functionality
3. Too many defects post release - Lack of Testing done by Developer pre-release
4. Too many defects post release - Unavailability of Test cases to developers
5. Lack of Reviews or Delayed reviews
6. Lack of Analysis during implementation or Bug fixing
7. Lack of Unit test cases
8. Not planning performance and concurrent test scenarios
9. Lack of separate Testing Environments
10. Sprint Retrospectives is done for namesake
11. Team not co-located
12. Developer skill set not up-to-date
13. Lack of knowledge on Newer unexplored technology

Issues and Prevention Mechanism: 

1.       Uncontrolled Changing Requirements:

• Uncontrolled changing Requirements results in frequent changes and missed implementations.
• Keep Sprints short (say 2-3 weeks). This way we can choose only a limited set of requirements to begin with. This gives time to Business Analysts / Product Owners to work without pressure to come up with detailed requirements for subsequent sprints.
• If a requirement within the current sprint changes, we must either take it as a new requirement which can then be taken in a subsequent sprint or if it is critical, we must re-estimate and then move some other requirement out of the sprint.
• Requirements must be tracked in some SCRUM tool, eg. TFS, rally, JIRA etc. This helps in identifying and shifting efforts, effortlessly. In my opinion Excel does not work in these situations.
• Changing a requirement means a lot as it involves re-analysis, re-design and re-implementation. It also means we need to cleanup previous implementation. This time must be estimated properly otherwise overall quality will suffer.

Note: I have another blog on Change is constant.

2.       Majority of team members are not aware of overall functionality

• Sprint planning session must involve all team members
• Sprint planning involves two parts, first involves analyzing user stories to be included in Sprint and second involves estimation and task break down. Involvement of entire SCRUM team helps all to be on same page.
• High level system design when done collectively by the team in a room helps all members to understand every part of current sprint implementation. In my opinion, this is highly recommended, as it makes up for issues like resource movement, resource unavailability, lack of analysis, lack of skill set.
• Demo of existing functionality and complete understanding of what team wanted to achieve must be clarified upfront to the entire team.
• Any changes to the items agreed upon (requirements / design) must be communicated during stand-ups. During stand-ups this should be communicated in 1-2 lines so that stand-up meeting does not exceed planned time.

3.       Too many defects post release - Lack of Testing done by Developer pre-release

• Yes, developer must test all positive scenarios that they are responsible for before delivering the code for testing. They do not perform tests like boundary conditions or impact on other developers code, but they must verify that whatever they promised to deliver must be in working condition when they handover for testing.
• At times this is not possible, as a developer might be implementing just a part of the overall functionality, so their work might not be testable. For this, we must keep a bucket to do developer testing once that functionality is complete (by all involved developers) and then any one developer can complete a round of scenario testing before handing it over for testing.
• Sprint done criteria must include developer testing and must be conveyed and agreed upon in Sprint planning.
• This eventually saves time because a defect identified at testing duration will involve fixing, build, deployment and re-testing, it’s better to fix it at the first step itself. Moreover developer knows the possible internal problems then the tester who does black-box testing. Using continuous builds, writing unit tests save some time, but nothing can beat a guarantee by developer. 

4.       Too many defects post release - Unavailability of Test cases to developers

• Test cases must be prepared by testers (as they have a different mindset towards software). These test cases must be provided to developers even before development begins, so that they will have fair idea of how their code fits in.
• Test cases must be reviewed by developers as they know the white box aspect of their code and can identify miss at testers end. Test case review must be added as done criteria for User story.
• For re-opened defect fixes, I have seen it helpful for a tester to test on developer’s machine to avoid re-re-opening of the defect as a re-open can mean a serious issue with analysis.

5.       Lack of Reviews or Delayed reviews

• Reviews must be done for everything, including Requirements, Design, Analysis, Code, Test cases, approaches, process and methodology. Lack of review and delay in review amounts to same sort of losses.
• Reviews must be given topmost priority
• If review needs to be done by someone outside team then it must be planned in advance and there must be at least one backup for the reviewer identified.

6.       Lack of Analysis during implementation or Bug fixing

• This is often the cause of defect induction and re-opening of other defects. Proper time must be allocated to analysis.
• Analysis must be reviewed by experienced developers before the fix is made to ensure that all related areas are getting covered.
• A mapping of test cases to application component helps in running test scenarios against the component being developed/fixed

7.       Lack of Unit test cases

• Many managers think that Unit testing is a time investment, however for a not throw away code, Unit tests saves time later during development/testing cycles.
• Unit testing helps to identify defects early in cycle and provides a safety net. You definitely won’t benefit from a safety net which has large holes, so unit testing must be planned from beginning or implemented incrementally to existing application.
• Code refactoring estimate must include fixing failing unit test cases estimate as well. In fact, code refactoring exercise must not begin with coding, but should begin with Unit testing
• Continuous build must include unit test cases run
• Developers must be made aware of importance of Unit testing

8.       Not planning performance and concurrent test scenarios

• Most applications today are used by hundreds and thousands of users. Test cases must include covering the concurrent situations for each such possible flow
• Time for performance testing of the application must be estimated as some functional issues which are not evident during normal testing are discovered during performance testing.
• The sooner the performance testing can be done, the better.  Identifying performance issues and fixing them may take time. Also detecting such issues requires extensive logging in system.

9.       Lack of separate Testing Environments

• The developer’s machines are well equipped with all necessary and extraneous components and are nowhere similar to the actual environment where the application will be finally deployed. Software that runs on developer machine will not necessarily run on a fresh machine. So, the testing environment must be different.
• Separating development and testing environments gives testers their own sweet time to complete and keep track of components that require testing and offers maximum available time to test.
• Performance testing environment should be as close to the actual production environment as possible.

10.   Sprint Retrospectives is done for namesake

• Sprint retrospective is feedback check on the SCRUM process. It must be done seriously
• Action items identified must be assigned owners and a time to accomplish issues identified must be agreed to
• Action items in previous retrospective meetings must be discussed so that the findings are not lost.

11.   Team not co-located

• Team co-location is utmost important for swift communication within team. Testers / Architects / Developers / Managers all must be at the same area or same room if can be arranged for.
• If cannot be achieved due to distributed teams, using phone or video conferencing should be preferred over emails

12.   Developer skill set not up-to-date

• Maintaining a competency matrix and training team members on newer technologies is a win-win situation
• Knowledge of newer technologies equips team members to think in efficient and unique ways to achieve faster or informed results
• Continuous relevant trainings keeps staff motivated, offers job satisfaction to many and employee retention increases.

13.   Lack of knowledge on Newer unexplored technology

• Hiring a consultant for the required period can help achieve mastery in unexplored areas and staff can gain that knowledge.

With time, I will try and update this list and possible resolutions. I would like to know any other issues that you would have identified during Sprint retrospectives and what steps you took to counter them. Please leave them as comments and I would like to add it to the above list.

TagLo on Android

Tag Location - anything, anywhere, anytime

(Android GPS application)

About TagLo :-

TagLo enables you to tag any 'OBJECT' and search its location on Map. Eg. You can tag a ATM location, your favorite coffee shop, a picturesque location, a good hotel in your trip, a house looking for rent, ... You can Tag anything you can see or feel and view it on Map at a later time.

Windows Mobile Development in .Net

For windows mobile development we have 4 choices in .Net:


a) ASP.Net Mobile – Browser based access to the application which is not hosted on Mobile. Application is hosted on a webserver. The advantage is that it supports wide variety of mobile devices as all we access is webserver and it renders HTML ultimately. Drawback is that it cannot use any phone specific features and runs in browser. From VS2008 onwards, there is no explicit template available for ASP.Net Mobile development. Any ASP.Net web application developed, runs on modern mobile web browsers. Some considerations must be taken like not using huge images and large scrollable data. Here is a blog that provides some more information: http://roopeshreddy.wordpress.com/2010/10/25/developing-web-applications-for-blackberry-mobiles-using-microsoft-asp-net/

b) .Net Compact Framework – To develop standalone Windows Mobile application. This is most matured framework so far but UI render engine is old Winform based so UI experience is not great. But the platform is powerful and is directly hosted on mobile device.

c) Silverlight for mobile – This has advantage of rich UI development as with Silverlight apps we see. It has advantage of accessing Phone features but the drawback is that it needs a host like web browser to run and thus cannot run as a standalone application. However, the experience is not at all bad - I would like you to have a look at this 6 mins silverlight video: http://www.youtube.com/watch?v=81MyyagOIog&NR=1
Also, Silverlight is supported from Windows Phone 7 onwards. Windows mobile 6.5 does not have support for this.


d) .Net Micro Framework – This is relatively very new and looks promising. It will allow creation of rich WPF applications on Windows Mobile. The drawback is that as of now it does not have tooling support for development. So even to add a button, we need to do that via code.


For now, I will recommend Silverlight for mobile as it has Rich UI support and Microsoft roadmap looks promising on Silverlight support going forward.

Where is the Requirement Document?

This blog is on an obvious topic. But for those who are still using a Requirement Specification document it can be an interesting read.

When I started with my first project in year 2001 we had a 200+ pages SRS - System Requirements Specifications document. Till year 2007 I worked on several large projects/products and each had a fairly huge Requirement document.

Few months back during a conversation I realized that I have not seen a SRS document from year 2007. These projects were much larger and were Enterprise scale with geographically distributed teams. So, then what happened to the Requirement Document? What led to collapse of Requirement document and what replaced it?

Giving it a thought I think a shift to agile methodology provided clients the flexibility to change the requirements. Maintaining requirement documents along with code with short iterations is a tough job and often the effort would go waste when requirements would evolve or change in subsequent iterations. Following drawbacks of keeping requirements in a document were evident:

• Frequent changes require revisiting entire related requirements. Relating requirements in a document was not an easy task either.
• Changes in Requirement would affect not only code, but Technical design document, test cases document, etc. and keeping traceability between Requirements and these artifacts is not again an easy task that can be accomplished via documents.
• Change to Requirements also affects Project plan and getting a real time report for this required a lot of efforts

Clearly, evolved the need for a tool sophisticated enough to accomplish above tasks. There are several tools available in market that would capture the requirements in form of User Stories and then link test cases to these along with any technical design and could also link code committed to a particular user story. Requirements could be categorized, prioritized; defects could be associated with Requirements. These tools would also integrate the estimates to accomplish the change and provide on-demand and live reporting with most features entailing entire Software Development Lifecycle. When required, the tools will filter the data as desired and export it in many different formats.

  

This tool completely replaced the need for a requirement document.

But does it mean that requirement capturing techniques like conducting workshop, interviewing clients, use case diagrams are also out of picture. Answer to this is a big NO. Requirement capturing is THE most important aspect of the project as this is the way you define and redefine what the end user actually need. Only that you document the requirements in a tool which allows traceability and visibility than using a stale document which will become obsolete by the next iteration.

Closing this blog, I also recall that I have not seen a Technical Design document from Year 2007 onwards. Few important very complex things where various components are interacting did require some sort of technical design document, but then I did not see a Tech design for many complex functionalities. A self-organizing strong team would infer the design from the code. So, code is the only documentation we had from a long time now. Do you also work in similar pattern these days? Do you like it? Probably this will need another blog to talk about this.

 

Agile Development – Change is constant!

Often I see that whenever there is a change in requirements from the client, the developers tends to get de-motivated.. unwilling to change the codebase.. I hear comments like: 

• They are not clear on what they want 
• They should first define their requirements and then move forward with this 
• Our marketing team would accept just everything that client wants without pushback 
• Frequent changes will destroy the design

.. all pointing that we developers are unhappy and someone there is not doing the job correctly.

Times have changed and we are agile. Change is reality; business is changing every second. Think as if you have your own business - would you not like to make changes as you go, may be your vision changes with market, may be you want to do something different based on your competitors or based on some new innovative ideas and so on.. When your customer is asking for a change, it means a lot to them. It means a lot to the value to end-users that will be offered by the product you are eventually helping them to create. By buying into this change you are helping a wider community.

Agile methodology is all about accepting the fact that - change is constant. Agile helps to manage change. Does agile then mean that we keep changing things? I guess no. We should definitely reason and demand that why there is a change. We should evaluate and suggest the client if the change is not for good or if there are better alternatives. However, we should also understand that why someone wants to change and if this is genuine change, then we should embrace it.

Ten tips for Clients and developers involved:  

1. Reasons for change should be conveyed. People should buy into the idea. It also will help you validate and understand implications of the change and also invite other cheaper/better ways to have that incorporated. 
2. Frequent changes means that something could be going wrong. May be vision has a problem. May be execution strategy is not concrete, may be this is not the right time to start... And yes, implementing a change does costs something. 
3. A change control board (CCB) consisting of client stakeholder (Product owner and others) and vendor management/arch/lead responsible for change management should be trusted.
4. Change needs time to implement, this should be scoped well and included in the plan.
5. Developer’s can fix a problem as a hack or can provide proper desirable fix. If time will not be provided to implement the changes, changes can still be done but will involve hacks. Hacks will deteriorate the overall quality making system costlier and difficult to change as month’s passes by.
6. Design a flexible architecture which meets the current spec out requirements. Don’t overdesign and do accept the fact that design will change.
7. You can minimize the efforts by using appropriate design patterns, by following design principles.
8. Follow agile, follow refactoring, follow TDD... They will ease changing code.
9. Enjoy changing code, see how your design handles the change, you will definitely learn new ways of refactoring and also newer ways to design your next system.
10. Refactoring is fun. Once you achieve it and then when you see cleaner code you feel happy about it. And once change is delivered and it’s making difference in end-users life, that’s the real reward you get.

Next time you are facing a change, do question it and once answered, embrace it with affection. Change is good.

 

AOP using Unity2.0

AOP using Unity 2.0: http://www.codeproject.com/KB/architecture/aopusingunity2.aspx

ASP.Net Web Application Migration to Windows Azure

My blog - Web Application Migration to Cloud - http://blogs.globallogic.com/aspnet-application-migration-to-windows-azure