Saturday, 17 November 2012

Interview Questions on Agile Development Methodologies


 1) What is Agile Development model and explain about different methodologies in Agile Software development?

Agile Development model is an Incremental or iterative model,
It has several methodologies,

Types of Agile Methodologies

o Scrum

o Extreme Programming (XP)

o Agile Unified Process (AUP)

o Dynamic Systems Development Method (DSDM)

o Essential Unified Process (EssUP)

o Exia Process (ExP)

o Feature Driven Development (FDD)

o Open Unified Process (OpenUP)

o Crystal Clear

o Velocity tracking

2) What is the difference between Agile and Waterfall Model?

Difference between Agile and Waterfall Model:
1. The main advantage is the backward scalability in Agile. Under waterfall approach we cannot change the decisions and implementations that we had made under the previous stages. If we want to make changes under waterfall we will have to build the entire project from the scratch once again.
2. The flexibility to error check under any part of the development stage makes Agile more bug free and less erroneous as compared to Waterfall which can only test bugs at the end of the development module.
3. Since Agile provides flexibility to make changes as per customer requirements it is more inclined towards better client satisfaction. This is a real set back for the Waterfall model which doesn't allow any modifications once the module has been completed.
4. Under Agile development modular partitioning of the software can be effectively carried out as compared to its counterpart. Though both of them allows option for segregation the later lacks the modifications in the implementation stage. The rules are set down before the commencement of the project hence it hinders further break down of the logical module. Whereas Agile can be of great help under such situations and can allow simultaneous development of different modules at the same time as per time bound requirement. If we want the project to be more segregated Agile comes as a pain relief for developers.

3) How Agile is different?

Agile is different because
a) Greater Collaboration.
b) Shorter work cycle and constant feedback.
c)  Need to embrace Change. 
d) Greater flexibility.
e) Greater discipline.
f) Greater stakeholder accountability.
g) Greater range of skills.

4) What are the implications for testing in Agile?

- Agile testing must be iterative.
- Testers cannot rely on having complete specification.
- Agile testers must be flexible.

5) What are the Agile quality strategies?

Agile quality strategies are:
a) Re-factoring.
b) Non-solo development.
c) Static and dynamic code analysis
d) Reviews and inspection
- Iteration/sprint demos
- All-hands demo
- Light-weight milestone reviews
e) Short feedback cycles.
f) Standards and guidelines.

6) Explain about the Agile process?

The agile process follows the software development life cycle which includes requirements gathering, analysis, design, coding, testing and delivers partially implemented software and waits for the customer feedback. In the whole process, customer satisfaction is at highest priority with faster development time.

7) What are the new features of agile process?
In agile process new features can be added easily by using multiple iterations. 

1. Iterative: The main objective of agile software processes is satisfaction of customers, so it focuses on single requirement with multiple iterations. 
2. Modularity 
Agile process decomposes the complete system into manageable pieces called modules. Modularity plays a major role in software development processes. 
3. Time Boxing 
As agile process is iterative in nature, it requires the time limits on each module with respective cycle.
4. Parsimony 
In agile processes parsimony is required to mitigate risks and achieve the goals by minimal number of modules. 
5. Incremental 
As the agile process is iterative in nature, it requires the system to be developed in increments, each increment is independent of others, and at last all increments are integrated into complete system. 
6. Adaptive 
Due to the iterative nature of agile process new risks may occurs. The adaptive characteristic of agile process allows adapting the processes to attack the new risks and allows changes in the real time requirements. 
7. Convergent 
All the risks associated with each increment are convergent in agile process by using iterative and incremental approach. 
9. Collaborative 
As agile process is modular in nature, it needs a good communication among software development team. 
Different modules need to be integrated at the end of the software development process. 
10. People Oriented 
In the agile processes customer satisfaction is the first priority over the technology and process. A good software development team increases the performance and productivity of the software.

8) Where the agile methods focus on?

The agile methods are focused on different aspects of the software development life cycle. Some focus on the practices (extreme programming, pair programming), while others focus on managing the software projects (the scrum approach).

9) What are the benefits of Agile Modeling?
 



Agile methodology has an adaptive team which is able to respond to the changing requirements.
The team does not have to invest time and effort and finally find that by the time they delivered the product, the requirement of the customer has changed.
Face to face communication and continuous inputs from customer representative leaves no space for guesswork.
The documentation is crisp and to the point to save time.
The end result is the high quality software in least possible time duration and satisfied customer.
 












Desired Skills and Capabilities for Testing Personnel in a Software Testing Team

Even though software testing is a specific profession many testers have had other careers before becoming testers. However, most of the testers, who have not started their career as testers, either had a background in development or in the domain of the product they happen to work with.

 

Past Background of Testers

There is a general belief that testers should be from a development background. However It is not necessarily so, but having a development background certainly helps. Knowledge of how software development is done provides valuable insight into what could cause errors and how faults can possibly be introduced.

 

Background of product domain too offers great help in a software-testing career. It facilitates the understanding of the requirements and the required test environment. Knowledge of the domain creates valuable credibility from the point of view of the users of the product. In fact it can be a good investment to provide testers without relevant domain knowledge with a feeling for where the product they are working on is going after it is released.

 

Capabilities of Software Testing Professionals

The yardstick for the measure of the capability of software testing professionals remain his/her experience and training in either or all the areas like that of being a user, in development or testing etc.  Irrespective of being our position, our skills of dealing with people like convincing others, criticizing others or receiving criticism, influencing others and making negotiations are very important parts of the role of testing.

 

Software companies prefer to have a variety of personality types within their software testing team. The best combinations may be ensured at times of recruiting. Even if that is not possible, knowledge of certain patterns of behavior can help us enhance the team we are working with.

 

Individual Skills & Personalities:

Testing is a challenging profession. It requires certain skills and capabilities that individual testing practitioners ought to have. It also demands people with certain set of human characteristics or personality types.

 

Every person is born with certain set of personalities. Although peersonalities with which we are born are quite difficult to change, yet there are few personalities that get chiseled into us from then onwards.

 

I am giving below few common traits that will help software-testing engineers in their position as professional testers. Software testing profession demands that a tester must preferably have following basic abilities:

 

1) Intelligence: Because testing is a sort of intellectual activity.

 

2) Creativity: Because testing activity requires great deal of creativity for being effective.

 

3) Endurance: Because testing requires great tenacity against pressure & resistance & the activity needs be carried on despite many odds.

 

4) Systematic Working: Because testing activity must have a reliable coverage.

 

5) Pragmatic: Because testing activity involves great deal of sampling.

 

6) Good communication: Because testing involves many persons having their stake.

 

7) Good courage: Because testing is generally perceived to give unpleasant news.

 

8) Good Maturity: Because testing profession is quite demanding, hence needs good maturity.

 

Professional software testing engineers need to have training and experience in testing domain. Such training can be:

 

1) Education: Education either from an educational institution or in the form of courses in testing theory. The testers should learn to remember and understand test-related terms, concepts, and statements.

 

2) On-the-job training and mentoring: The testers should learn to apply their knowledge.

 

3) Carrying out of testing activities: The testers should learn to see structures and principles and divide the task into smaller tasks.

 

4) Experience exchange and further education: The testers should learn to combine and think in abstract terms.

 

Test Roles and Specific Skills:

Testing is not just one single activity. If we take a close look at the test process and all the tasks testers need to perform, we can see that there are a many different test roles as described below.

 

The testing roles can be defined as:

1) or a person responsible for testing functions

2) Test analyst / Test designer

3) Test executor

4) Test reviewer / inspector

5) Domain expert may be a user representative

6) Test or a person responsible for setting up the test environment

7) Test tool specialist or a person responsible for the test tool

 

Each of these roles requires specific skills and capabilities from the people engaged on these activities, apart from the general traits and skills required for all testers.

 

The following table described few important training & experience requirements:

 

Sr

Testing Role

Training or Experience Requirement

1

Test leader or manager

# Test policy and strategies of the organization


# Testing standards


# Test management: estimation, planning, monitoring, control, reporting & managing people

 

2

Test analyst / Test designer

# Analysis of requirements and other specifications

 

# Design of test cases

 

# Effective usage of test case design techniques

 

# Building and documenting test procedures

 

3

Test executor

Execution, recording, and checking tests

 

4

Test reviewer / inspector

Static test techniques

5

Domain expert

Basic test principles

 

6

Environment Expert

# Platforms

 

# Test database administration

7

Test tool expert

# Platforms

 

# Specific tools

 

Software Testing by Other Professionals:

Even though software testing is a full-fledged profession in itself, yet people from other professions can also participate and contribute in the performance of the testing activities. 

Users too can be very good testers. This applies to both future users of the new product and actual users of similar products or earlier versions of the product. The users obviously see the product from the user's perspective. Users have ideas about the future use of the product, that is helpful in providing an insight into where failures would have the greatest impact for example it can offer useful inputs to the risk management.

 

Users are best involved in requirements' analysis – which remains the starting point. Users can also be extremely useful in the test, even if he/she does not have an in-depth knowledge of the domain.

 

Developers can be good testers. They know how difficult requirements analysis is, how difficult design is, and how difficult coding is, and this means that they have insight into where errors may have been made, and hence where the faults may be.

 

Developers are best involved in static testing. They can also contribute in dynamic testing, not least in component testing and component integration testing.

 

Requirement of Interpersonal Skills:

Interpersonal skills are important in the roles of testing. Testers need to have ability to:

 

1) Provide constructive criticism and receive criticism

 

2) Influence people

 

3) Do negotiations

 

Providing constructive criticism is very difficult for most of the people. No professional ever wishes to hurt others - most of the people prefer to have peace with others instead of blaming & pointing out failures.

 

Again we need to consider what testing is. It may be seen as a destructive activity, since the tester has to find and register failures. However, registration of failures is not criticizing the developer. Testing is a very constructive development activity. It makes useful contribution to the possibility of everybody reaching the common goal of delivering a product of a good quality, learn, and becoming even better in the future.

 

Testers do however have to give criticism from time to time. The basic rules for doing this are:

 

1) Stay calm

 

2) Keep focussed to the facts

 

3) Never blame

 

4) Keep an open mind, as you too could be wrong.

 

Receiving criticism is just as difficult as providing it. We feel threatened, and some of our needs like respect, recognition, and security appear to be at stake.

 

Testers do however have to take criticism from time to time if we want to get better at our job. The basic rules for bearing criticism are:

 

1) Listen carefully for the smallest piece of truth

2) Whenever in doubt, ask for clarification of views and goals

3) When you find that the criticism is genuine, have courage to admit to it frankly, otherwise you will loose your credibility.

 

Testing involves interaction with many other developments and supporting activities. Here the tester remains dependent on the decisions and schedules of other people.

 

Generally testers find themselves with a feeling that they are being victimized. They find themselves in impossible situations, and they don't do much about it because: "This is just the way things are!" There is no reason for bending under this "law of necessity." In fact testers can usually influence more than they think - especially if they start early.

 

Some of the areas, where testers are dependent on others, but where they can also use their influence, are:

 

1) Delivery order: By asking and explaining why

 

2) Delivery quality: By defining entry criteria

 

3) Delivery date: By negotiating with other managers

 

4) Planning of test activities: By talking to other managers

 

5) Allocation of resources: By negotiation with management

 

6) Classification of failures: By using a scheme

 

7) Training: By asking and participating

 

8) Process improvement: By contributing and participating

 

When we assert our influence on other people it is useful to remember that demands create resentment, while requests for help usually create kindheartedness.

 

Like in all other communication we need to listen first and then talk. When we listen we must listen for reasons, goals, fears, and threats from the other party's point of view. And when we talk, we most of all have to explain. We have to explain our reasons, goals, fears, and threats.

 

Most of the time we can come to an agreement simply by talking and explaining our needs and constraints to each other.

 

However, sometimes we get into a situation where we have to negotiate, that is, to engage in bargaining to reach agreement.

 

A few basic rules about negotiations are:

 

1) Look behind the positions to the real interests

2) Work with best alternative to a negotiated agreement

3) Walk away if negotiation is going nowhere

4) Identify options as parts of the solution

5) Go for a win-win solution

6) Aim at an atmosphere of common problem solution

Conclusion: For being a Good Software Testing Professional, following ten traits are quite essential

 

1) Be an explorer & don't be afraid to venture into the unknown.

 

2) Be a trouble shooter having ability to diagnose if something doesn't work.

 

3) Be relentless & keep trying, don't rule out any failure for being a fluke.

 

4) Be creative & adventure with an off-the-wall approach.

 

5) Try to achieve perfection if not cent per cent, at least close to it.

 

6) Try to exercise best judgment as to a) What to test? b) How long to test? & c) Whether it is truly a bug?

 

7) Be tactful & diplomatic with courage to tell the developers that their code is really bad.

 

8) Be persuasive with an ability to convince others on your point especially on the reason why a bug needs to be fixed.

 

9) Try to do many things as per the pre defined plans & not on the spur of the moment.

 

9) Assign different tasks to the team members according to their skills & preferences.

 

10) Maximize diversity of your team to reach more beneficial conclusions & in turn better decisions.

Test Data Effectiveness in Bug Catching

In this write up we would talk about the need for effective test data, re-using test data over time ensuring they have not been corrupted and how test data should take into account: positive, negative, blank and boundary values to ensure they adequately test the application.

In addition to all of these, in my opinion it is very important to focus on your test data generation, depending on the type of testing undertaken. If you see, for functional testing you want a variety of test data covering all the points we mentioned above.

For performance testing too, the same will hold good, but when you scale and increase your load, you would want to ensure that you maintain diversity in your data even when you deal with volumes. For security testing, focus more on the negative data sets or rather illegal ones which you would not expect your regular users to use. Scripts, SQL statements are largely used here like how a hacker would, to gain access to the internals of the application. In case of localization testing, the tester is focusing on creating real time locale specific inputs for which he might have to use translator tools.

The tester will need to pay special attention around the currency, date/time formats, text length, etc. for the test data that he creates here. Prior to localization testing, when globalization and pseudo localization testing are done; the tester is focused more on creating gibberish or garbage data which is non-English to start off with. In cases ofaccessibility and usability testing, the tester is more focused on using tools like screen readers, narrators rather than focusing a lot on actual test data.

For data base testing scenarios, you may not only need test data but also have them populated into the database, for ease of access. So, if you try to see a pattern here, you are really customizing your test data depending on the type of testing you undertake with a goal of finding as many bugs as possible. Since test data creation takes a lot of time, it is a good idea to use tools wherever possible with of course due diligence done by the tester to ensure the validity of such automated test data that is created. Especially for scenarios such as user account and password creations where typically a huge volume of data is needed, a lot of freeware tools are available.

For every test pass, it would help to take care of the following checklist:

1. Understand the focus of the test pass and decide what tests are required
2. Evaluate to see what existing data can be reused
3. Ensure validity of such existing data
4. Analyze gaps for any new data that needs to be created
5. Analyze the data sources (whether data exists in XMLs, local files, data bases, reside in another application etc.) and see if any migrations are needed

Like test case maintenance effort, test data maintenance is a good practice to take on between test passes. The tester can look at any new tools in the market that can be used, any test data clean up that is needed, any new data that can be created, any user inputs from the field / bugs they have filed for which test data is very unique that you can add it to your data repertoire etc. Such pro-active tasks go a long way in saving you time and effort in your subsequent test passes and more importantly help you find realistic and good bugs. At certain times, you as a tester will also be required to share your test data with other teams in the product group including your development team to help them reproduce issues.

Similarly when bug bashes are held, to save time for everyone, along with the basic instructions some test data might also come in handy for the group to use. That said, you need to draw your balance here in how much test data you share with your team, because the test data goes a long way in finding some core bugs; so you would not want to impact the teams creativity and limit the bugs they find by sharing all of your test data.

So, chalk yourself a plan on how and what kind of data you want to generate, use and share with a goal of enhancing your product quality and containing defects as much as you can before product release.

Happy testing!

SoftwareTesting: The Old and the New

Software testing has evolved considerably over the last decade from single dimensional test approaches to multi-dimensional ones. Testing now encompasses broader aspects such as test management through push button test environment creation on the Cloud to dedicated tool evaluations for each kind of testing. There is general consensus worldwide though, on the need for flexibility and creativity in testing and the need to treat testing as more than just another phase performed towards the end of the project.

Traditional software testing that focused on code-level testing has evolved with Distributed and Web Service architectures. Security takes on more importance as there are now multiple integrated systems and multiple interfaces, internal and external. In this context, I would like to delve more into the details of testing Service-oriented architecture (SOA) and SOA based solutions, a subject close to my heart!

The V-Model:

For Web Service architectures and SOA, the V-Model is typically a suitable test methodology that enforces testing discipline throughout the project lifecycle. The project starts with defining the Business User Requirements. The V-Model would recommend that the Business Acceptance Test Criteria for these defined requirements are defined and agreed before moving to the start of the technical design phase. Before moving to the next phase/level of technical design, the model recommends test criteria defined for that level of technical requirements, and so on. The V-Model is simply encouraging the project team to continually determine how they would successfully test the project deliverables.

The V-Model is a suitable test methodology to deliver SOA projects for the following reasons:


1. It encourages a top-down approach with respect to defining the business process requirements, high-level functional technical design, security etc.
2. It then encourages a bottom-up test approach - test individual functions within a service, test an individual service then test a composite set of services through to testing an integrated process and finally testing a complete business system. SOA is loosely coupled services and that is why a bottom up test approach is recommended.
3. The levels reflect different viewpoints of testing on different levels of detail.
4. The V-Model encourages testing throughout the entire Software Development Life Cycle.

Challenges:

Some of the new challenges in testing SOA solutions as opposed to the traditional applications, typically are:

1. Services that do not have a user interface
2. Data driven business logic within services
3. External services to the organization
4. The quality of service software will be vital to promote reuse and facilitate business agility. Services that have known bugs and quality issues will not be reused by the development teams. A significant increase in testing activities and test assets (functional, performance and security regression suites that include sophisticated harnesses and stubs) will be required at a service (program) level
5. Predicting the future usage of services to assist with performance, load, stress, scalability
6. As your SOA evolves, security testing will have a higher priority and profile within your organizations test strategyIn SOA, Services are based on heterogeneous technologies.

No longer can we expect to test an application that was developed by a unified group, as a single project, sitting on a single application server and delivering through a standardized browser interface. The ability to string together multiple types of components to form a business process requires unconstrained thinking from an architects perspective, and test planning and scheduling complexities from a testers perspective.

In SOA, application logic is in the middle-tier, operating within numerous technologies, residing outside the department, or even outside the company. We know that to test SOA, you need to go far beyond merely testing a user interface or browser screen. Web Services (WSDL/SOAP) will be an important component for many SOAs, but if youre only testing Web Services, you are not likely to test the entire technology stack that makes up the application. What are the transactions happening at the messaging layer? Is the right entry being reflected in the database? In fact, many perfectly valid SOA applications will house business logic entirely outside of the Web Services.

To address the above challenges, organizations need to review and enhance their current test methodology. Many Test Tool vendors have now recognized the new SOA test challenges and have developed a new breed of tools to help organizations to plan, manage and automate SOA functional, performance and security testing.

Testing SOA solutions:

How do you test SOA architecture? You dont. Instead, you learn how to break down the architecture to its component parts, working from the most primitive to the most sophisticated, testing each component, then the integration of the holistic architecture. In other words, you have to divide the architecture into domains, such as services, security, and governance and test each domain separately using the recommended approach and tools. SOA is loosely coupled with complex interdependencies and a SOA testing approach must follow the same pattern.

You can broadly categorize SOA testing into the following phases:

1. Governance Testing
2. Service-component-level testing
3. Service-level testing
4. Integration-level testing
5. Process/Orchestration-level testing
6. System-level testing
7. Security Testing

Test Tools:

As discussed earlier, tools are key in every phase of testing. SOA requires a comprehensive test tool strategy. Some of the commercial and open source tools available in the market that could be explored for SOA testing initiatives would be:

Commercial:

1. Green Hat GH Tester
2. Mercury suite of products
3. Parasoft SOAtest
4. AdventNet QEngine
5. Borland SilkPerformer SOA edition
6. iTKOs LISA product suite

Open Source/ Freeware:

1. SOAP UI
2. PushToTest TESTMAKER
3. AutoStub (an internal tool developed by Torrry Harris, belonging to the SOAizer™ stack)

Conclusion:

As conclusion, a few key recommendations for testing SOA initiatives would be:

1. Design your SOA project test approach alongside the definition of business requirements and highlevel technical design. Ensure the test teams are involved right from the start.
2. Static test techniques such as formal inspections are a must to ensure the business requirements and technical designs are defined to standards and are complete. Strong governance and discipline are essential to successfully delivering SOA.
3. SOA is driven by business and not technology. The test team will have to ensure the key business stakeholders and users are actively involved throughout the project life cycle and not just at the start and the end.
4. The Test team must be aligned to business domains not technologies. This will enable a successful implementation of a Risk Based approach to testing. The test team must also be technical and be able to white box test the entire SOA platform.
5. Security assessment and testing must take place throughout the entire project life cycle.
6. Many organizations will need to perform a leap of faith. The majority of testing activities now need to be performed during the business requirements analysis, design and service build phases. To achieve delivery agility and true service reuse, each individual service must be delivered to the Integration and UAT test phases with well-defined functional test coverage and guarantees on performance, scalability and security. Simply put, services must come with a Quality statement!
7. Test Tools are now a must. Organizations must invest appropriately in a test tool strategy.

You should not be surprised that many of the recommendations outlined in this paper are not new. Many of them are already defined as best practices. SOA demands strong governance, well-defined standards, processes and disciplines. If Quality is at the heart of your SOA, then the promises of SOA will be delivered.