Thursday, April 21, 2016

Single Virtual Machine in Azure - How to achieve maximum availability with minimum cost?

You already would know by now that if you host Single VM in Azure, there is no SLA provided by Microsoft.

What does that mean? It would mean that if this machine goes down, the time to bring this up is not guaranteed.

After reading whole Article, you may say that the solution is not using 1VM. And you are correct, this article suggests alternative means at almost the cost of 1VM and if you originally decided to use single VM then it answers few questions to justify that decision. I hope it will be useful read.

Why can the VM go down?
  •  Hardware Failure on the rack in DataCenter where VM resides
  •  DataCenter down (most likely due to terrorist attack, war, power grid failure, natural calamity) 
  • AppFabric internal maintenance (more on this below)

What is AppFabric Internal Maintenance?
AppFabric may need to upgrade its environment for major updates. This happened thrice in year 2015 in Azure China (as confirmed from an Azure China support personnel). The maximum downtime during this upgrade is 15 mins. However, this 15 mins is not guaranteed and in addition, it can also happen during the day time (peak times) and not necessarily when no one is using your application.
You would be made aware of this scheduled maintenance 1 to 2 weeks in advance.

How to achieve maximum availability with minimum cost?
We can answer it now. But let’s combine this question with one more question.

Why should you backup your Azure VMs?
  • Chances of it being corrupted while you are upgrading your custom software installed on it 
  • Chance of it being corrupted while you are upgrading third party software on it eg. OS / SQL Server 2014.
  • Malicious employee or hacker erasing some key system files

What are the options when VM gets corrupted and we want to fix it?
  • Install new OS if that’s the reason it got corrupted
  • Install your custom software if that caused the corruption. You would most likely get latest from your source safe repository Release branch.
  • Install any accompany software if VM crashed, eg if your custom software is Drupal based and VM crashed, it may require you to install Linux, Apache, Drupal, MySQL, etc.

Key is the time it takes to bring your VM up. Are you okay with that? If not, then you may need to back up your VM (a copy of VM hence) and bring the backup up when original VM crashes.

Where can you keep your Azure VM backup?
  • On-premises
  • On Page Blob on Cloud which is triple replicated
  • Use Azure Backup Service which allows point in time restores and provide a UI to manage backups. As of April 2016, the backups are not cross region. So if all DC in a region are down, I would assume that your backup would be lost.

Let’s come back to our original question and view it along with need for Backup:

How to achieve maximum availability with minimum cost?
By using 2 VMs instead of 1 but pay only for 1.


Add two VMs in one Availability Set. Then from Azure portal mark 1 VM as Shutdown (De-allocated). Microsoft does not charge you for De-allocated VM.

  • With two VMs, you get a SLA from Microsoft of 99.95% availability
  • You are saved from entire DataCenter crash due to above SLA
  • During scheduled AppFabric maintenance day, you can bring your second VM online for 100% availability on that day.
  • Fastest possible VM restore in case of a crash, simply bring the other VM online.
  • And you don’t need to worry about taking and paying for Azure Backup Service!!

How much do you need to pay extra anyways?
  • VHD of Shutdown VM still requires space on Page Blob, you need to pay for that. But Page Blob price is so much less that you will not care to spend that much. 
  • Let’s say if in a year Azure AppFabric maintenance happens thrice, then you have to pay 3 days of another VM cost which is the cost of keeping your service highly available.

So that’s it. I believe this is the cheapest solution with High Availability plus backup with Single VM. If you see issues with this Solution, please post your comments and I will update it.

Some more FAQs on using Single VM:

Q. When we shut down the second VM and bring it up, will the public IP change?
A. the Public IP will not change as you have two VMs in a cloud service.

Q. When we shut down – de-allocate the VM, will all software on it be lost and we need to re-install it again.
A. No. VHD still exists and everything is retained.

Q. In case of planned outage, will the VM be up in maximum X minutes? What is that X?
A. During the planned maintenance window, each virtual machine (VM) that is not in an availability set may experience a reboot. The Virtual Machine will have approximately 15 minutes of total downtime. Temporary disk and Azure storage disks will be preserved during the maintenance. Microsoft informs you of the maintenance in at least 1 or 2 weeks prior to the outage, and the maintenance will be executed within twelve (12) hours from the announced start time. Please be noted that VMs that belong to an availability set and Cloud Services web and worker role instances will not be impacted by this maintenance operation.

Sunday, May 26, 2013

TOGAF Overview

In this series of blogs, I will try to summarize TOGAF, The Open Group Architecture Framework. I have done my TOGAF9.1 certification in year 2012. I have been part of two teams which were in transitioning phase from a baseline architecture to the next generation architecture.

TOGAF is an Enterprise Architecture Framework which has evolved from best practices in EA development. The two teams I worked with were not following TOGAF, but several practices they followed overlaps with TOGAF. Based on that experience and the knowledge I have gathered via TOGAF certification I will be writing this blog. Your comments will help me refine it further. I will mainly refer TOGAF documentation while writing this blog.

You can adopt TOGAF as your enterprise architecture framework or you may wish to adopt parts of the TOGAF framework and use them with your existing EA framework. TOGAF works well in both these scenarios.

Before diving into TOGAF, let’s see what an Enterprise Architecture work involves. An Enterprise Architecture encompasses the entire enterprise which starts from the business. When you have Enterprise in your perspective, the entire thought on architecture changes. You do not begin from thinking about 2-3-n tiers, High Availability, Messaging, etc… but your perspective now is what are the business processes and how IT can help evolve or support these business processes. You begin with understanding the Business Architecture, what Architecture Principles will your applications be based on, what will be your Architecture Roadmap to support these Business processes, who your stakeholders will be and how will they be managed, what is the current architecture (if any) and are there any Gaps to support the business processes, how to store reusable Architecture Building Blocks, how to Migrate from existing architecture to the target state architecture, what all applications will be required and how will they be governed, how will a change in architecture be implemented… and the list goes on.

Implementing Enterprise Architecture is not a one person job and neither is it a single project within Organization. It’s a practice which must be setup within the organization and recognized and funded from the CXO level. Enterprise Architecture Practice is not a standalone ivory tower effort. It works in parallel with the PMO and the Operations.

So, will you then not be thinking of 2-3-n tiers, High Availability, Messaging, etc. That depends on what sort of Architect you are. If you are an Enterprise architect, you will think of these when you define architecture principles. If you are a Data Architect, you will define Data Aspects. As an application / solution architect you will identify tiers, messaging in accordance with Architecture Principles laid out and if you are a Technical architect, you will define high availability platforms. Roles and responsibilities of architects will vary in different organization.

I hope this gives a glimpse of what is involved in an Enterprise Level Architecture. TOGAF provides an architecture framework which defines a process following which you will be able to develop an Enterprise Architecture.

TOGAF is developed by The Open Group and consists of seven parts:

1.       Introduction – TOGAF Introduction and common Terminologies and definitions

2.       ADM – Architecture Development Method – An iterative methodology of how to develop an Enterprise Architecture. It has 9 Phases and each phase has Objectives, Steps, Inputs and Outputs. Eg. In Preliminary Phase, one of the objective is “Identify and scope the elements of the enterprise organizations affected by the Architecture Capability” and one of the input is “Board strategies, business plans, business strategy, IT Strategy, business principles, business goals, and business drivers” and an output is “Request for Architecture Work”.

3.       ADM Guidelines and Techniques – This describes several guidelines and techniques which can be applied when performing ADM. Eg. How to do a Gap Analysis?

4.       Architecture Content Framework – When developing Architecture via ADM, several outputs will be produced (Eg. Project Plans, Architecture Definition Document…). The Content framework provides a way to structure and present these outputs. All outputs of ADM is categorized as a Deliverable, Artifact or a reusable Building Block and the content framework provides definition of each of these. The content framework also provides a meta-model for to structure outputs from all phases. This provides consistency among different architectures.

5.       Enterprise Continuum and Tools – Within an organization, there will be a continuum of architectures from foundational to specific architectures. This part of TOGAF classifies the entire spectrum and also provides guidance on how to partition the architecture and how to maintain Architecture Repository.

6.       TOGAF Reference Models – TOGAF provides two reference architecture models. Technical Reference Model (TRM) and Integrated Information Infrastructure Reference Model (III-RM). TRM provides a foundation which includes services and functions required to build more specific architectures. It essentially is a taxonomy of components and structure which is generic to all architectures. III-RM is also a taxonomy and is applicable to organization which have silos and would need information to flow out and aggregated.

7.       Architecture Capability Framework – Provides guidance on how to setup Architecture capability in the organization in a Phased manner.

This blog provides an overview of what TOGAF has to offer. This introduces you to several terms without going into detail. I hope the blog still offers enough information to inspire you to give a look to TOGAF.
In the next blog, we will look into the different Architectures supported by TOGAF i.e. the Business, Data, Information and Technical Architectures.

Wednesday, April 24, 2013

Practical Scrum - Story Point Estimation

This blog is about how to come up with a release plan using story point estimation technique. I am writing this blog while I am working on sprint 4 of our project. We are following a two week sprint cycle and our project will be completed in Sprint 8. When I say sprint 8, it’s the commitment from my entire team and we have not estimated any of our tasks in hours.

I am the tech lead, developer and the scrum master on my team. I also write integration tests. Scrum master can be a dedicated role as well as shared one.

This blog assumes that you understand scrum, so will not explain what a story point is or what velocity is. In a line, Story Point is an abstract measure of size of user story and velocity = total story points burned in a Sprint.

This is how we began to estimate our Release date. We added all our stories to product backlog. We use Jira as scrum tool. The stories were then prioritized and based on priority, we selected 30 user stories for our first release. These story names were then written on sticky notes. Then we called for a release planning meeting.

This meeting happened four times with a duration of 1 to 1.5hrs each. Participants were the entire team which is three developers (including me), 1 tester and product owner. We used Fibonacci sequence as story point estimation technique. We gathered in a room, sat on a big oval table and created 9 virtual columns. Column headers were 1, 2, 3, 5, 8, 13, 20, 40, and 100.

Product owner picked a medium complexity story (complexity was decided by me as medium). Then he started explaining what that user story means, what all it involves and when will it be considered complete. All team members asked questions to get more clarification. Ultimately everyone’s query was answered. Team discussed that as part of this user story we will need some UI changes, a new method in business logic, some normal stored procs and roughly 2-3 automated integration tests. They trusted me that based on entire stack it is a medium complexity and placed it in column numbered 5.

Then we picked next story, product owner explained and team asked questions and thought among themselves that what will be required technically at a high level. They concluded that this story is less in complexity than previous one but was not very straightforward too. As it was low in complexity so it was kept at column numbered 3 to the left of column numbered 5.

Next story went to column numbered 13 as it was more complex than the one we placed in column 5. Next went to column numbered 1 as it was the easiest one. Then the next story was thought of between 13 and 20, but as we did not have any other column, I asked team to put it in 20.

The stories which went to 40 or 100 was discarded by me. I asked product owner to break these further before next meeting so that each short story is 20 or less. There were few 13 and 20 numbered stories which logically could be split to shorter independent ones. This was done instantaneously and the new stories then moved to 5 or 8 numbered columns.

Before you get bored, let me say that this went on and after 4 meetings, all release 1 stories were in one of following columns 1, 2, 3, 5, 8, 13, 20. During these discussions, some moved to backlog and others were picked from backlog by product owner as he got more understanding from team inputs.

Team again trusted me and kept iteration length as 2 weeks. We started coding sprint 1. We did a sprint planning meeting. How we did it will be covered in another blog. At end of sprint 1, we checked how many stories we completed. We completed two from column numbered 5, one from column numbered 13. Total sum of story points completed in sprint 1 = 2*5 +13= 23.

In sprint 2, we completed 20 and in sprint 3, we did 22 story points.

From this we deducted that we are doing an average of Math.Floor((20+22+23)/3) = 21 story points in one sprint. We have total 160 story points estimated in our Release 1. So with 21 as average, we should be done in sprint 8. Each sprint being 2 weeks plus schedule and feature buffer, we now have a release date with us.

This is just one of several methods of estimating a scrum project. Others are via historical results, or via forecasting by deducing hours as documented in Mike Cohn book Agile Estimating and Planning chapter 16.

In this blog, intentionally to keep it simple, I did not explain sprint planning meeting and also did not talk about certain things like project schedule buffers, backlog grooming etc..

I will extend on few of these points in part 2 of this blog.

Tuesday, December 25, 2012

Practical Scrum - Scrum of Scrums

Scrum works best when the team size is small and co-located. In my previous blog, I talk about a co-located scrum team structure and how common IT roles maps to the Scrum team.
There will be times when the product will be too large for small scrum teams to work on. This is where you break your product functionally to smaller streams and have different coordinating teams working on it. Scrum of Scrum (SOS) is multiple scrum teams working and coordinating on the same product or towards the same goal. The word ‘same’ is key here as if the products are different you need different scrum teams altogether and no coordination is required.

You can also use SOS if the product team is at several locations and each location has fully functional Scrum teams. This makes product execution across multiple locations manageable.

Guidelines for Product work distribution among Scrum teams 

Here are the guidelines that can help you structure the work:
  • No two teams should work on same user story.
  • Strive to allot user stories by features. So, if in Iteration 1, a team was working on user stories of Feature 1, try and assign this feature to the same team in next iterations also. With multiple scrum teams you need to do some more planning. Here, you are just assigning features, the individual tasks are still up to the Scrum team to work on.
  • For ease of planning, Estimation scale has to be same for each user story. To achieve uniformity in scale, it’s recommended to have few initial user stories estimated with all teams or representatives of all teams.
  • Release planning will be done as is done in normal scrum where prioritized user stories will be divided to Iterations considering combined velocity of all Scrum teams.
  • Iteration planning will involve dividing user stories among Scrum teams in proportion of their velocity. Note that velocity will be different for each team.
  • Iteration length for each team should be same. This eases planning and coordination.
  • For dependencies, coordination is of utmost importance and Scrum of Scrum meetings is a good mechanism to share progress.

SOS Meetings for Teams Coordination 
SOS teams coordinates via a meeting in which one representative from each team participates. The meeting time is 15 to 30 min. and frequency of this meeting can be daily (if more coordination is required due to dependency) or sporadic with minimum once in a week.

In my view, Scrum of Scrums usually should be conducted during following occasions:
  • Just after daily stand-up meetings to update other SOS participants about the progress made between last meeting and now and what is planned to achieve before next meeting. Any dependencies among teams is also discussed. Any impediments are brought forward, but resolution is discussed outside this meeting.
  • Just after Release Planning meeting: With an aim to identify any dependencies on user stories that will be accomplished by coordinating scrum teams.
  • Just after the Sprint Planning meeting: To make all teams aware of their Sprint goals and understand deliverables and dependencies.

The Team Structure 
In a previous blog I mentioned the team structure of a co-located scrum team. On top of the description of roles mentioned in that blog, here are some additional points to consider:

Product Owner Role: The scrum of scrums should share the same Product Owner(s) or the Product Owner of each team should coordinate to represent one face to all the teams. They maintain the same Product backlog so that you always deliver the top most priority feature in a coordinated way.
Scrum master Role: Each team has their own Scrum master. The scrum master participates in all regular meetings and also participate in the SOS coordination meeting. However, it’s not required that only Scrum master participates in SOS meetings, it can be anyone from the team.
Developer and Tester Roles: These roles are not shared among the teams. Each team has their own dedicated Developers and Testers.
Specialized Roles (UI Designer / DB Specialist / Technical Writer / Business Analyst etc.): You might consider sharing them. Dedicated resources are always the best as resource sharing causes thrashing and context switching is a costly affair.

A Lean Alternative - Product Coordination Team (PCT)

Lean methodology suggests an alternate to SOS team. The PCT team has representatives from each team just as in SOS. Lean says that SOS tends to be biased towards their own teams and do not think of larger picture of Product Coordination. PCT picks the work from Product Backlog and in an unbiased way places it in each teams Sprint backlog and coordinate the delivery. It’s essentially SOS team without affinity to their own teams. PCT by its name brings a different perspective. A SOS team should work on this perspective for the greater good of product development.

Tuesday, November 13, 2012

Practical Scrum - Define Scrum Team

In this blog, I attempt to define a scrum team structure for a co-located team and how the common project roles fits within the scrum team. This is a guidance and actual team composition depends on the project. The guidance is based on my experience with several scrum projects and some common application of reading various agile / scrum books.
I suggest below team structure:

Scrum Master
100% as pure Scrum master, Or else,
At least 50% pure scrum master and 50% can be any other role.
Tester (a Team member role)
At least 1 per 3 Developers
100% from starting of project
Developers (a Team member role)
Max 6
With more than 6 developers you should consider breaking the project in more streams and do Scrum of Scrum.
Product Owner
Coordinates requirements from n number of end-users / customers and prioritize requirements

Max 6 developers – Where does the magic number 6 comes from? – A team of six developers will mean total 6 dev + 2 testers + 1 scrum master + 1 product owner = 10 persons team. This is just an appropriate size to be fit in a single room or that can be easily managed with information flowing within all. Bigger the team size, it becomes difficult to self-manage and coordinate, information flow becomes too big a task requiring tools or formal processes. Scrum readings also suggests the scrum team size to be from 5 to 9 team members. There are several dedicated blogs which talks about issues with bigger team sizes.
The magic ratio – 1 Tester per 3 developers? – This is a guidance and depending on need you may have 1 Tester for 4 or more developers too. However, various text suggests that this is the magic de-facto ratio.
Can we have more than 1 Product Owner?  – Yes you can, as long as they coordinate and act as one face for developers.
Scrum master Role: Scrum master removes impediments faced by team members, eg. Coordination with other teams for any dependencies. Another major role of Scrum master is to help team adopt Scrum processes, eg. Ensure that daily stand-ups are happening properly and regularly, user stories quality is up-to-date, etc. I propose a 100% committed Scrum master to start with. Later based on scrum maturity of the team, keep it at 100% or less but never below 50%.
Product Owner Role: This is most important role, as a Product Owner (and not a scrum master) decides the priority of features to be implemented. The product owner represents the customers and end-users voice. This perspective is important. To repeat, the product owner is business centric role and not development team centric role.
Tester Role: Scrum or Agile team does analysis, design, development and testing at all times. Its important to have the tester role involved from the beginning i.e. from Iteration zero. Developers are the ones who writes unit tests, and testers are responsible for writing and executing functional tests (automation is desired and developers help can be sought here). Testers also assists Product Owners to come up with Acceptance tests and running the tests. Testers also performs test planning, and can also generate quality matrices if desired by Sr. Management. Main objective of Testers is not to break the system, and this is important. The objective of testers should be to help developers to prevent the defects.

Project / Team Lead: This is not a defined role in Scrum. Scrum teams are empowered, self-organizing, enabled to take team specific decisions and are self-managing. They do not need a lead. Also a Scrum master is not the Team Lead. Often Team Leads responsibility is to take decision in case of ambiguity which in Scrum is taken collectively by the entire team. In some setups, a Lead is a single point of communication with Customers, whereas in Scrum, all team members directly interact with the customer all the time. Leads are not required to assign tasks, in scrum, the team assigns tasks to themselves. Another responsibility of Lead is for management reporting which can be done by Scrum master or read the Project Manager Role description in this blog.
Project Manager Role: This is not a defined role in Scrum. In Scrum projects, you do not need a Project Manager. However, I feel a project manager is of great help. The role of Project Manager should be to prevent team from external disturbances. Eg. To generate reports for Sr. Management, for people management, assist in career growth / aspirations, etc. Moreover Project Manager is aware of this projects impact to organization and other projects within Organization likely to impact this project. This is not often the perspective of Scrum master nor the Product Owner. Project manager, from their project execution experience, gauge that something is not correct and can point the team of the possible issues. Project Manager however should not interfere with Team estimates or working style or any other aspect of project development. In Scrum, if used, the project manager role is to support and not a role with authority.
Architect Role: If you need an architect for entire duration of the project, then, one of the developers should be replaced with an architect (i.e. max 5 developers and 1 architect). If you do not need a full time architect, then consider adding an architect for few iterations or else bring architect as per need. In such partial allocations, keep max 6 developers and add additional architect for required duration. In case of on-need basis inclusion, make sure that you have stories that require architects intervention planned accordingly. Partial allocations are always tricky and involves thrashing but at times may be the only option available.
Business Analysts Role: This is not a defined role in Scrum. However, just like you need an architect for technical inputs, you may need a Business Analyst for requirements gathering / analysis. A business analyst should never act as a layer between Team and the Product Owner. A business analyst can assist the product owner to form user stories or run acceptance tests and can help developers with understanding business requirements. Organizations that are incapable of identifying a Product Owner, or organizations working in an offshore scenario, assumes a Business Analyst as a Product Owner. In such cases, a Business Analyst should act as a real Product Owner, the one who prioritizes the requirements and takes Business perspective and not developers view. Business Analyst is a specialized skillset and is not a substitute for a Product Owner and organizations who fail to employ a Product owner are in my view at a very high risk of developing a product which no one needs.  
UI Designer / Technical Writer / Database Specialist: Cross functional team does not mean that a developer is expected to be the UI designer or a technical writer. These are specialized roles. You need one, when you need one. Allocation of these specialized roles should be considered in the similar fashion as mentioned for Architect Role in this blog. Having said this, when you have a specialist working in team, have the knowledge shared to all team members such that in absence of the expert, team members can pick up the work. Pairing or explicit sessions can help here. When required, the team members will help Specialists to accomplish tasks. A team of generalists is the preferred approach in Scrum teams than Silos of Specialists.
To conclude the blog with an example: Let’s say you need a full time UI Designer and a full time Database Specialist and a Technical Writer on need basis then the team structure will be –  
  • 1 – Scrum master
  • 1 – Product Owner
  • Permanent Team Members
    • 4 – Developers (maximum)
    • 1 or 2 – Testers (at least)
    • 1 – Database Specialist
    • 1 – UI Designer
  • Technical Writer – On need basis

Hope this blog helps understand how a scrum team is structured. Consider this as a guidance which you will most likely refine based on the specific project needs.

What if the product is large and not possible with a team of this size. Check my blog on how to scale scrum teams via Scrum of Scrums.

Monday, March 19, 2012

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.

Sunday, November 27, 2011

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.