Thursday, June 28, 2018

Application Lifecycle Management

Application Lifecycle Management
Lifecycle the word means “Series of stages through which something passes during its lifetime.”
Application lifecycle is similar to giving birth to a young one as per the God’s management.
Creating an application is not a big task, but adding the word Management in that Application 
Lifecycle is adding a process of distributing with or governing things or people. 
When Process comes in a picture, we bound to work according to that, which give the 
picture of Application Lifecycle Management.
Accumulation process is not that you are bound to move in that particular line only, but it 
means you are moving in the correct direction which will give success and 99.9% 
assurance that the Project on which you have implemented is having a correct planning, 
great controlling, and using the resources in an organized behavior.
Application Lifecycle Management is controlling of a software application from planning 
phase till it goes LIVE. But in the current era, customers are more demanding, 
technology is expanding so after the software is in a Live state, still, 
continuous improvement and maintenance are going on them, 
so application management lifecycle(ALM) has no retirement age.

Different phases of ALM


1.       Requirement Management
2.       Development and Quality Management
3.       Defect Management
4.       Configuration Management
5.       Reports
6.       Timesheet Management
7.       Build Management
8.       Release Management
9.       Variant Management
Each Phase has its own ownership according to the roles assigned to them.

Phases
Ownership
Open Source Tool
Requirement Management
Stakeholders, Product Manager
Jira Software
Development and Quality Management
Technical Team which include Developers, UI Developers, Testing Team
Jira Software
Defect Management
Testing Team
Jira Software
Configuration Management
Engineering Manager, Technical Architect
Chef, Puppet
Reports
Project Manager
Jira Software
Timesheet Management
Project Manager
Jira Software
Build Management
Release Team
Jenkins
Release Management
Release Team
Jenkins
Variant Management
Engineering manager, Technical Architect
Jira Software
Requirement Management
Requirement document is a high-Level document comprises of all proposed features which
 include the pathway (flow diagram), mock-up, list of all elements, their behavior etc.
Requirement Management is a process of getting all information from the marketing team, 
copywriters and graphic designer which incorporated as per the application and getting signed 
off by the stakeholders and product team. To get all the things to flow in the correct direction 
and maintain the same in the continuous integration process.
Documentation of all the requirements which includes analyzing the requirement along 
with its risk and mitigation plan to be well communicated to the stakeholders of the product 
is called Requirement Management
Development and Quality Management
The process of code review, writing acceptance criteria, reviewing test cases, creating 
test plan is known as Development and Quality Management.
Developer start working on any of the functionality, simultaneously QA folk write the 
acceptance criteria and create the test plan. Both the task go hands-on hand. 
Once the coding is finished, a code is reviewed and assign the task to QA for testing. 
QA test the functionality as per the Acceptance Criteria and Test Plan.
Defect Management
When the product is development state, all the bugs found by a QA or Product team should 
be logged in bug tracking tool (Jira, Mantis). All critical and high priority bugs should be fixed 
in that phase only. But as per the availability and time frame, Minor and trivial bugs are moved
in backlog which can become as a planned bug in next phase/sprint.
When a product is Live and the bug comes from the production server, Root Cause Analysis 
should be done for that bug. So that moving forward the team would not miss that cases. 
And QA also adds that cases in the test cases.
Bug life cycle

Configuration Management
The process of maintaining, tracking, controlling all the cross-functional aspect and interface -
 jumper settings which support the software and hardware configuration required for the application. 
Due to this process engineering manager and infra team control the configuration of all 
hardware and software support.

Reports
For each and every entity/management process has the result, which can we viewed as a report

Timesheet Management
Tracking and reporting for the employee amount of work spent on the project. It generally helpful 
for those working on multiple projects at the same time.
It also helpful for tracking the leaves like sick, vacations and overhead hour’s employee 
devote in the office. This is according to the Labor Laws and Company rules

Build Management
The process of merging the code of all function together to get the software application in workable 
mode. The build process can be done automated as well as manually also.
The main motive of build management to have control over all the code and have version controller. 
Due to this version controller fixing of an issue is done in more quick and reliable.
Release Management

Variant Management
In a competitive era, variant management plays a vital role. Each product maintains different 
variant to get more customer attraction. Adding different variant in the application give benefits 
along with risk is also there, but mitigation plan is also included while doing Variant Management.
Test link
Open source tool which can be integrated with Jira and Jenkins

Wednesday, August 9, 2017

Code for find the multiple of 3

Method to check the number is multiple of 3

/* Function to check if n is a multiple of 3*/
int isMultipleOf3(int n)
{
    int odd_count = 0;
    int even_count = 0;

    /* Make no positive if +n is multiple of 3
       then is -n. We are doing this to avoid
       stack overflow in recursion*/
    if(n < 0)   n = -n;
    if(n == 0) return 1;
    if(n == 1) return 0;

    while(n)
    {
        /* If odd bit is set then
           increment odd counter */
        if(n & 1)
           odd_count++;
        n = n>>1;

        /* If even bit is set then
           increment even counter */
        if(n & 1)
            even_count++;
        n = n>>1;
    }

     return isMultipleOf3(abs(odd_count - even_count));
}

Short Code - One number is multiple of Another

Function with if else conditions - To find the number is multiple of another

int main
{
int a,b;

printf("enter any two number\n");

scanf("%d%d",&a,&b);

if (a%b==0)

printf("this is  multiple number");

else if (b%a==0);

printf("this is multiple number");

else

printf("this is not multiple number");

return 0;
}

Wednesday, April 19, 2017

Release Process for Production





Centralized Release Process for Cloud Application: High-level steps proposed in order to smoothed the release-deployment process.
These steps would be documented and the ticket gets assigned to the person performing the task.

Day 1 Regression


Day 2 Staging


Day 3 Production 

Monday, February 17, 2014

Integration Testing: Why? What? & How?




"Unit testing" focuses on testing a unit of the code. 
 
"Integration testing" is the next level of testing. This 'level of testing' focuses on testing the integration of "units of code" or components.

How does Integration Testing fit into the Software Development Life Cycle?
Even if a software component is successfully unit tested, in an enterprise n-tier distributed application it is of little or no value if the component cannot be successfully integrated with the rest of the application.
Once unit tested components are delivered we then integrate them together. 
These "integrated" components are tested to weed out errors and bugs caused due to the integration. This is a very important step in the Software Development
 Life Cycle.
It is possible that different programmers developed different components.
A lot of bugs emerge during the integration step.
In most cases a dedicated testing team focuses on Integration Testing.

Prerequisites for Integration Testing:
Before we begin Integration Testing it is important that all the components have been successfully unit tested.

Integration Testing Steps:
Integration Testing typically involves the following Steps: 
Step 1: Create a Test Plan
 
Step 2: Create Test Cases and Test Data
 
Step 3: If applicable create scripts to run test cases
 
Step 4: Once the components have been integrated execute the test cases
 
Step 5: Fix the bugs if any and re test the code
 
Step 6: Repeat the test cycle until the components have been successfully integrated

 What is an 'Integration Test Plan'?
As you may have read in the other articles in the series, this document typically describes one or more of the following: 
- How the tests will be carried out
 
- The list of things to be Tested
 
- Roles and Responsibilities
 
- Prerequisites to begin Testing
 
- Test Environment
 
- Assumptions
 
- What to do after a test is successfully carried out
 
- What to do if test fails
 
- Glossary

How to write an Integration Test Case?
Simply put, a Test Case describes exactly how the test should be carried out. 
The Integration test cases specifically focus on the flow of data/information/control from one component to the other.
So the Integration Test cases should typically focus on scenarios where one component is being called from another. Also the overall application functionality should be tested to make sure the app works when the different components are brought together.
The various Integration Test Cases clubbed together form an Integration Test Suite 
Each suite may have a particular focus. In other words different Test Suites may be created to focus on different areas of the application.
As mentioned before a dedicated Testing Team may be created to execute the Integration test cases. Therefore the Integration Test Cases should be as detailed as possible.


 Working towards Effective Integration Testing:
There are various factors that affect Software Integration and hence Integration Testing:
1) Software Configuration Management: Since Integration Testing focuses on Integration of components and components can be built by different developers and even different development teams, it is important the right version of components are tested. This may sound very basic, but the biggest problem faced in n-tier development is integrating the right version of components. Integration testing may run through several iterations and to fix bugs components may undergo changes. Hence it is important that a good Software Configuration Management (SCM) policy is in place. We should be able to track the components and their versions. So each time we integrate the application components we know exactly what versions go into the build process.
2) Automate Build Process where Necessary: A Lot of errors occur because the wrong version of components were sent for the build or there are missing components. If possible write a script to integrate and deploy the components this helps reduce manual errors.
3) Document: Document the Integration process/build process to help eliminate the errors of omission or oversight. It is possible that the person responsible for integrating the components forgets to run a required script and the Integration Testing will not yield correct results.
4) Defect Tracking: Integration Testing will lose its edge if the defects are not tracked correctly. Each defect should be documented and tracked. Information should be captured as to how the defect was fixed. This is valuable information. It can help in future integration and deployment processes.

Summary:
Integration testing is the most crucial steps in Software Development Life Cycle. Different components are integrated together and tested. This can be a daunting task in enterprise applications where diverse teams build different modules and components. In this article you learned the steps needed to perform Integration Testing.