Wednesday, July 18, 2012

Essential-Software-Testing-a-Use-Case-Approach Free E-Book

Aglie Methodology Performace Testing - About Complete Methodology

An Agile Methodology

Prescriptive software methodologies typically employ sequential, step-wise wise models consisting of requirements analysis, design, implementation, and integration testing.

Figure 1

Historically, this approach does not react well to changing requirements, is difficult to estimate for time and cost, and is architecturally fragile.

Agile methodologies provide a collection of foundational values, guiding principles and development practices that to address the challenges of prescriptive, weighty methodologies to  produce software in a lighter, faster, more people-centric manner.  Agile methodologies work best with motivated, reliable people who desire to work together to fulfill their stakeholder's business goals.  Slackers, complainers, and lazy developers need not apply!

Figure 2

Agile developers have as their foundation the following values:  

·         Individuals and interactions over processes and tools
·         Working software over comprehensive documentation
·         Customer collaboration over contract negotiation
·         Responding to change over following a plan

Guiding principles emerge from the foundational values:

·         Software is the primary goal.
The developer's highest priority is to satisfy the customer through early and continuous delivery of quality software.

·         Embrace change
Changing requirements are expected and embraced throughout the software lifecycle.

·         Frequent delivery
Software is delivered at frequent intervals with a preference for shorter timescales.

·         Encourage collaboration and promote communication
Developers and Stakeholders should collaborate throughout the software lifecycle.  The most efficient and effective method of communication is face-to-face conversation. Immediate feedback is desirable and preferred.

·         Trust is essential
The best architectures, requirements, and designs emerge from self-organizing teams.  Equip the developers with the tools and environment to be successful and trust them to get the job done.  Allow the team to self-organize based on its strengths and weaknesses to accomplish the work.

·         Be proactive
As the project grows in size and complexity, proactively seek principles and practices that increase efficiency so the team can continue at the same development pace while maintaining quality and sanity.

·         Strive for quality work
Continuous attention to technical excellence and good design enhances quality.

·         Keep it simple
Suspect complicated solutions without justification. Maximizing the amount of work not done is essential.

·         Introspection is vital
At regular intervals, the team determines the strategies and practices that worked and those that did not. Reflect on way to become more effective and tune and adjust the team’s strategy and practices.

The Guiding Principles drive development practices:

·         Active stakeholder participation
Collaborate with the stakeholder who has the authority and ability to provide information relevant to the system under construction and to make pertinent and timely decisions regarding it.

·         Agile Modeling
Communicates and establishes the “good enough” solution model.

·         Simple design
Resist the desire to complicate and code for the future – keep design and development simple.

·         Standards
Consistent design and coding standards resolve ambiguity and increase communication.

·         Small releases
Partitioning a large effort into small, incremental releases delivers working software to stakeholders faster and reacts quicker to changing requirements.

·         Pair programming
Two heads are often better than one!

·         Iterative, incremental development
Partition the solution into units that can be completed and tested within a series of development cycles.

·         Test Driven development
Defines the requirements of the code and fosters refactoring.

·         Refactoring
Improves the structure and clarity of the code without changing the functionality.

·         Continuous integration
Identifies integration errors faster.

·         Position for next project
Use the artifacts and successful practices from one project to inform and position the next project for success.

Agile methodologies vary by team and mature over time so starting with a broad vision is helpful to transition from a prescriptive methodology.  The following is an agile methodology that retains familiar procedural steps, but incorporates agile principles and practices using four phases.

Figure 3

Phase 1: Domain Understanding (Conception)
a. Understand the application from the perspective of the stakeholder
Time to accomplish: normally accomplished in days; sometimes 1 week
Inputs: customer collaboration, requirements documents, legacy code
Possible artifacts that demonstrate understanding:
·         High level problem statement
·         Generalized use cases that captures the intentions of a user
·         High level activity diagram
·         High level work flow
Agile practices employed:
·         Active stakeholder participation

b. Estimate the solution to the problem
Time to accomplish: Hours
Inputs: High level use cases, project requirements
Artifacts:  project estimate
Agile practices employed:
·         Active stakeholder participation
·         Small releases

Phase 2 - Model the solution to the problem (Elaboration)
Time to accomplish: Several days to 1 week for large problem domains
Inputs: High level use cases, project requirements from Phase 1
·         Agile class diagrams depicting data layer objects
·         Agile class diagrams depicting business layer objects
·         Agile sequence diagrams for complex logic
·         User interface mock-ups and flows
·         Others as “painfully” required
Agile practices employed:
·         Active stakeholder participation
·         Agile Modeling
·         Style and modeling standards
·         Simple design
·         Model refactoring

Phase 3 - Implement the solution to the problem (Construction)
Time to accomplish: Weeks to months
Inputs: Design Model from Phase 2
Artifacts: Working code
Agile practices employed:
·         Active stakeholder participation
·         Test Driven development
·         Pair programming
·         Accomplished in iterations
·         Develop Incrementally
·         Code refactoring
·         Coding standards

Phase 4 - Verify the solution (Transition)
Time to accomplish:  Hours to Days
Inputs:  Implementation from Phase 3
Artifacts:  Proven and tested code
Agile practices employed:
·         Active stakeholder participation
·         Continuous Integration Testing; run the test suite at least daily, email the results to team

Amazon Deals