Category Archives: understanding the benefits and risk of independent test

Capability Maturity Model (CMM) and It’s Levels

In this article, we will discuss about the Capability Maturity Model (CMM) and it’s different levels. It would help you for self study.

As far as professional training in software testing is concerned, software training institutes in Pune happen to be a good option. They provide job oriented training in software through their software courses in Pune.

Coming back to our topic of discussion which is the CMM model,

CMM is a standard for measuring the maturity of an organization’s software life cycle. It is a technique used to create and refine a company’s SDLC. CMM can be utilized to survey an organization against a scale of five process development levels in light of certain Key Process Areas (KPA). It depicts the maturity of the organization in view of the venture the organization is managing and the clients. Each level positions the organization as indicated by its standardization of procedures in the branch of knowledge being surveyed.

A maturity model enables:

  • A place to begin.

  • A common language and a shared outlook.

  • The advantage of a community’s previous experiences.

  • A framework in order to set action priorities.

  • A method to define what is the improvement means for your organization.

Software testing training in Pune covers the CMM model as a part of its program. At least a brief insight, if not in great detail.

Five maturity levels of software processes as defined by CMM:

  • Initial maturity level:

At the beginning level, procedures are complicated, even clamorous. Success is probably going to rely on upon individual efforts, and is not thought to be repeatable, in light of the fact that procesees would not be adequately characterized and archived to enable them to be replicated.

  • Repeatable maturity level:

At the repeatable level, essential project administration techniques are set up, and success could be repeated, on the grounds that the imperative processes would have been made built up, characterized, and documented.

  • Defined maturity level:

At the defined level, an organization has built up its own standard software programming process through more noteworthy regards for documentation, standardization, and integration.

  • Managed maturity level:

At the managed level, an organization screens and controls its own procedures through information gathering and its examination.

  • Optimizing maturity level:

At the optimizing level, procedures are continually being enhanced through monitored feedback from existing procedures and acquainting inventive processes with better serve the organization’s specific needs.

The CMM is identical to ISO 9001, one of the ISO 9000 arrangement of standards determined by the International Organization for Standardization (ISO). The ISO 9000 standards indicate a compelling quality framework for manufacturing and administration enterprises; ISO 9001 deals particularly with software development and maintenance. The fundamental contrast between the two system lies in their particular purposes: ISO 9001 indicates a minimum accepted quality level for software processes, while the CMM builds up a system for ceaseless process change and is more unequivocal than the ISO standard in characterizing the way to be utilized with that in mind.

CMM was introduced and is advanced by the Software Engineering Institute (SEI), a R&D centre supported by the U.S. Department of Defense (DoD). SEI was established in 1984 to address software designing issues and, in a wide sense, to propel software engineering methodologies. All the more particularly, SEI was formed for optimizing the process of creating, acquiring, and keeping up heavily software dependent frameworks for the DoD. Since the procedures included are similarly applicable to the software businesses in general, SEI advocates all inclusive reception of the CMM.

This was an insight into the Capability Maturity Model (CMM) and it’s different levels.

Lastly, we would like to say that the software testing in Pune scenario is promising from the aspirants point of view.

To Know More About Testing Course:- 

Best Software Testing Institute In Pune

Security Testing: A Critical Part of Software Testing

Security testing is an important part of software testing and is included in the curriculum of most of the software testing courses in Pune. Look out for a software testing course in Pune with placement. This would help you in getting a job in this field.


Let’s get into the various aspects related to security testing.

Security testing fundamentally refers to a type of software testing that is done to check whether the application or the software is secured or not. It verifies whether the application is powerless against attacks, in the event that anybody hacks the framework or login to the application with no prior approval or authority.

It basically is a type of non-functional testing.

Security testing characteristics:

  • The six basic parameters that need to be covered under security testing are as follows:

– Integrity- The application and related data is authentic.

– Authentication- Data is genuine or not and the application origin.

– Availability- As the name suggests, this tests the accessibility of the software application i.e. it is dependably up and running, data and administrations are accessible at whatever point required. Likewise, this incorporates the bckup records which are promptly accessible of any disappointment happens.

– Confidentiality- Data or information is protected from theft.

– Authorization- Certain users should have access to authorized functions only.

– Non-repudiation- Assurance that the receiver and sender of information can’t deny the fact of having sent or received the data.

  • It is a process to discover that a information framework protects information and keeps up functionality as proposed.

  • Software security is about making software carry on in the sight of a malicious attack.

  • The security testing is carried out to check whether there is any data spillage in the sense by encrypting the application or utilizing extensive variety of softwares and hardwares and firewall and so forth.

For a software testing job in Pune, search on the various job portals.

Security testing is a huge subject. Each technology that you utilize, regardless of whether it’s a programming language like .NET or PHP or an element like input validation or authentication, presents another arrangement of security vulnerabilities. Today, we are occupied with giving you a fundamental idea of what security testing is and how it is performed.

Security testing must begin at an early stage to limit defects and cost of quality. It is a decent practice to begin security testing at the time of prerequisite assembling, this guarantees quality of the finished product will be high.

There is no standard approach to test the security of an application, it absolutely relies upon the reason it serves and what are the security hazards present in it. Each time begin security testing by testing the UIs, this is the primary spot of entry for hackers and unlawful users. At that point think what a hacker would likely do in the event that he gets the access or entry into the system, regardless of whether he will steal the credit card data or get access to some personal files and so forth begin some destructive testing i.e. to test what application or system can’t do and after that focus on the error messages you get. When you are finished with every one of these sorts of testing, attempt and burrow further and see what could be the escape clauses with regards to security at the coding level. With some experience, you will have the capacity to perform security testing in a better manner.

Security testing happens to be an important part of software testing and cannot be ignored at any cost. Testing classes in Pune can give you a detailed insight into security testing.

Understanding the Difference Between Severity and Priority

As a part of our software testing series, we focus on one concept each time. Today, we will try to understand the difference between severity and priority. It often becomes confusing as far as these two terms are concerned. We will try to simplify them for you. For studying this subject in depth, one can take the help of software courses in Pune. Many software institutes in Pune conduct such courses.


Regarding the question, what is the difference between severity and priority?

  1. Priority:

Priority characterizes the request in which we ought to determine a defect. Would it be a good idea for to fix it right now, or can we wait for sometime? This priority status is told by the tester to the developer specifying the time period to resolve the defect. On the off chance that a high priority is set, then the developer needs to fix it as early as possible. The priority status is set in light of the customer prerequisites. For instance: If the organization name is incorrectly spelled on the landing page of the site, then the priority is high while severity is low to fix it.

Types of priorities:

  • High:

The defect must be settled at the earliest opportunity in light of the fact that the defect is risking the application or the product on an extreme level. The system can’t be utilized until the repair work has been carried out.

  • Medium:

The defect ought to be resolved in the typical course of development exercises. It can hold up until a new build or version is developed.

  • Low:

The defect is an aggravation which ought to be repaired, however repair can be conceded until after more genuine defect has been fixed.

Learn the other concepts related to software testing by joining software testing classes in Pune. Let’s get on with severity now.

2. Severity:

It is the degree to which the defect can influence the software. At the end of the day it characterizes the effect that a given defect has on the deliverables. For instance: If an application or site page crashes when a remote link is clicked on, for this situation clicking the remote link by an user is rare yet the effect of application crashing is extreme. So the severity is high yet priority is low.

Types of severity:

  • Critical:

The defect that leads to the termination of the total system or at least one segment of the system and causes broad corruption of the data. The fizzled function is unusable and there is no worthy option strategy to accomplish the required outcomes then the severity will be said to be critical.

  • Major:

The defect that leads to the shut down of the total system or at least one part of the system and causes extreme corruption of the data. The fizzled function is unusable yet there exists an adequate option strategy to accomplish the required outcomes then the severity will be assigned as major.

  • Moderate:

The defect that does not bring about the closure, but rather makes the system create erroneous, fragmented or conflicting outcomes then the severity will be expressed as moderate.

  • Minor:

The defect that does not bring about the closure and does not harm the ease of use of the system and the coveted results can be effectively gotten by working around the defects then the severity is said to be as a minor one.

  • Cosmetic:

The defect that is identified with the upgrade of the system where the progressions are identified with the look and field of the application then the severity is expressed as a cosmetic one.

Thus we saw the points of differences between severity and priority. For more details on this, a software testing institute in Pune would be of great help.

Exploratory Testing And It’s Application’s

Let us discuss today, a lesser known form of testing i.e. exploratory testing. It forms a part of the software testing process. Exploratory testing is not given much emphasis in majority of the testing classes in Pune. The reason could be not much use of it in the industry. Best institute for software testing in Pune is the place where you can get trained on software testing.

Moving on to exploratory testing, as its name infers, exploratory testing is about investigating, getting some answers concerning the software, what it does, what it doesn’t do, what works and what doesn’t work. The tester is continually settling on choices about what to test next and where to invest the (limited) time.

This is an approach that is most valuable when there are no or poor details and when time is extremely restricted.

Characteristics of exploratory testing:

  • Exploratory testing is a hands-on approach where testers are involved in minimum amount of planning and maximum level of test execution.

  • Test logging is embraced as test execution is performed, documentation of the key parts of what is tested, any defects discovered and any contemplations about conceivable further testing.

  • The test design and test execution exercises are performed in parallel normally without formally reporting the test conditions, test cases or test scripts. This does not imply that other, more formal testing procedures won’t be utilized. For instance, the tester may choose to use BVA yet will thoroughly consider and test the most essential limit values without fundamentally writing them down. A few notes will be written amid the exploratory-testing session, so that a report can be created thereafter.

  • The planning includes the formation of a test sanction, a short revelation of the scope of a short (1 to 2 hour) time-boxed test effort, the goals and conceivable ways to deal with be utilized.

  • It can likewise serve to complement one other, more formal testing, setting up more prominent trust in the software. Along these lines, exploratory testing can be utilized as a check on the formal test process by guaranteeing that the most genuine defects have been discovered.

  • Exploratory testing is portrayed in [Kaner, 2002] and [Copeland, 2003] Other methods for testing in an exploratory way (‘attacks’) are depicted in [Whittaker, 2002].

These were a few characteristics of exploratory testing. For training and placement in the field of software testing, opt for a software testing course in Pune with placement.

Pros of exploratory testing:

  • After introductory testing, most bugs are found by some kind of exploratory testing. This can be shown legitimately by expressing that programs that pass certain tests tend to keep on passing similar tests and will probably fail different tests or situations that are yet to be investigated.

  • Less planning is required, vital bugs are discovered quickly, and the approach has a tendency to be more mentally stimulating to execute than scripted tests.

  • Testers can utilize deductive thinking in light of past outcomes to manage their future testing on-the-fly. They don’t need to finish a present arrangement of scripted tests before concentrating in on or proceeding onward to investigating a more target rich environment. This likewise quickens bug recognition when utilized shrewdly.

Cons of exploratory testing:

  • Free-form exploratory testing ideas, when returned to, are probably not going to be performed in the very same way. This can be an advantage in the event that it is vital to discover new errors or a con in the event that it is more essential to repeat particular details of the prior tests. This can be controlled with particular instructions to the tester or by creating automated tests where doable, suitable, and vital (and preferably as near the unit level as could be expected under the circumstances).

  • Tests created and performed on-the-fly can’t be surveyed ahead of time and along these lines avoid errors in code and the test cases. It can be hard to demonstrate precisely which tests have been run.

This was regarding exploratory testing. Hope that the article turned out to be informative for you. For getting a job in software testing, be a trained professional with the help of testing courses in Pune.

Concept Of Alpha Testing

Today, we are going to study about alpha testing in this article. It is a very important phase in the software testing process. A software testing course can help you prepare for a career in this field.

If you are based in Pune, a software institute in Pune will offer you various testing related courses.


Let’s come back to discussing alpha testing.

Alpha testing is amongst the most widely practiced software testing strategy utilized as a part of software development. Its especially utilized by the product development companies.

Alpha testing can be termed as a kind of acceptance testing; performed to distinguish every single conceivable issue/bugs before releasing the software product to end users or public. The main of this testing is to recreate genuine users by utilizing blackbox and whitebox techniques. The point is to execute all the tasks that a run of the mill user may perform. Alpha testing is done in a lab scenario and generally the testers are in house representatives of the company. To put it as straightforward as could be possible, this sort of testing is called alpha simply because it is done at an early time, close to the end of the development of the product, and prior to beta testing.

Some characteristics of Alpha testing:

  • Alpha testing is simulated or real time environment testing by potential clients/end users or an independent test team at the developers’ site. Alpha testing is regularly utilized for off-the-rack software as a type of internal acceptance testing, before the software product goes to the beta testing phase.

  • Alpha testing is nothing but testing of an application when the development phase is going to end. Small design related changes can even now be executed on account of alpha testing.

  • Alpha testing is normally carried out by a team that is not a part of the design team, yet at the same time, within the organization, e.g. in-house software testing engineers, or software QA engineers.

  • This test is conducted at the developers location. Developers keep an eye on the users and note down the issues observed by them.

  • Alpha testing is the final round of testing before the product is released to the end user. It has two stages:

    • In the first phase of alpha testing, the software product is tested by the in-house team of developers. They utilize either debugger software, or hardware based debuggers. The objective is to discover the bugs really fast.

    • In the second phase of the alpha testing process, the product is given over to the software QA team, for additional testing in an environment that is identical to the proposed use.

  • Alpha testing makes use of both the black box and white box testing techniques.

  • Security testing and reliability testing are not a part of the in-depth alpha testing.

  • A lengthy execution cycle can be required in case of alpha testing.

  • Critical bugs or fixes can be tended to by developers promptly in Alpha testing.

Advantages of alpha testing:

  • Clear perspective of the reliability pf the product is given at an early stage.

  • It helps in reproducing the real time user conduct and his environment.

  • It helps in recognizing genuine threats or bugs and permits quick action towards their resolution.

Disadvantages of alpha testing:

It is not possible to test the software with in depth functionality being covered, as it still lies in the development phase.

That was regarding alpha testing and the various aspects related to it. Doing a software course is what is recommended, if you want to enter the field of software development or software testing.

A Look Into The Incremental Model of Software Testing

Today, we will take a look into what is the incremental model of software testing. We will check out what it is? It’s advantages, disadvantages and when is it ideal to use. You can learn the various models in software testing, by enrolling for a software testing course in Pune. Choose a good software testing institute in Pune, for the same. Moving on to the incremental model of software testing….

In case of the incremental model, the entire requirement is isolated into different builds. Multiple development cycles exist over here, converting the life cycle into a “multi-waterfall” cycle. Cycles are separated up into littler, all the more effortlessly managed modules. Incremental model is a kind of software development model like V-model, Agile model and so forth.

In this model, every module goes through the necessities, design, execution and testing stages. A working rendition of the software is delivered amid the principal module, so you have a working software at an early stage amid the software life cycle. Each subsequent release of the module adds function to the prior release. The procedure proceeds till the total system is accomplished.

Every cycle goes through the phases of requirements, design, coding and testing stages. What’s more, each resulting release of the system adds functionality to the past released until all outlined functionality has been integrated in the software product.

The system is put into production when the initial increment is conveyed. The primary addition is frequently a core product where the essential requirements are tended to, and supplementary elements are included in the following augmentations. Once the core product is broke down by the customer, there is plan advancement for the following addition.

Model characteristics:

  • System development is separated down into numerous smaller development ventures.

  • Incomplete systems are progressively developed to create a final entire system.

  • Highest priority requirement is handled first.

  • Once the increment id is created, requirements for that increment are frozen.

Advantages of using the Incremental model:

  • Allows development of working software at a quick pace and at an early stage amid the software life cycle.

  • This model is more adaptable – cheaper and easier to alter the requirements and scope.

  • It is simpler to test and debug amid a smaller cycle.

  • In case of this model, the customer can give his feedback on each build.

  • Brings down introductory conveyance cost.

  • Less demanding to manage the risks in light of the fact that the risky pieces are recognized and dealt with, amid a cycle.

Disadvantages of using the incremental model:

  • Requires proper planning and design.

  • Requires a precise and complete understanding of the entire framework before it can be dissected and constructed in an incremental manner.

  • The total cost incurred is greater than the waterfall model.

When can it be used?

  • This model can be utilized when the requirements of the total framework are plainly defined and understood.

  • Significant requirements must be characterized; in any case, a few details can advance with time.

  • There is a need to get a product to the market as early as possible.

  • New kind of technology is being utilized

  • Assets with required expertise set are not accessible

  • There are some high risk prone components and goals.

These are some of the ideal situations where an incremental model can be put to use.

Thus we saw the various aspects related to the incremental model of testing. Hope that it helped you in understanding the concept.

Meanwhile, for learning software testing, you can look out for software testing classes in Pune.

Understanding the Testing Psychology!

This topic is a bit different from those taught in any software testing course. Today, we will be seeing as to what is the psychology of testing.

Tester and developer mindset:

The reviewing and testing of the softwares is unique in relation to the development and analysis of it. By this, we intend to state that on the off chance that we are building or creating applications we are working emphatically to take care of the issues amid the development phase and to make the product as per the client specifications. Nonetheless, while testing or reviewing a software, we are searching for the defects or failures. Therefore, developing the software requires an alternate mindset than that while testing the product.

The right balance between independent and self-testing :

The evaluation made on the thinking of the tester and the developer in the above section is simply to look at the two alternate points of view. It doesn’t imply that the tester can’t be the developer, or that the software developer can’t be the tester, in spite of the fact that they are separate roles to play. Actually, developers are the testers. They generally test their part which they developed. While testing their own particular code they find numerous issues so the software engineers, designers and the developers dependably test their own code before offering it to anybody. In any case we as a whole realize that it is hard to locate our own particular mistakes. Thus, coders, architects, business analyst rely on upon others to help test their work. This other individual may be some other developer from the same team or the Testing pros or professional testers. Offering applications to the testing pros or professional testers, permits an independent testing of the software.

Effective communication and feedback between the tester and developer:

We as a whole commit errors and we at times get irritated and annoyed or discouraged when somebody calls attention to them. It is human psychology. In this way, when as testers we execute a test which is a good test from our perspective since we found the defects and failures in the product. In any case, in the meantime we should be extremely cautious as how we respond or report the defects and failures to the developers. We are satisfied in light of the fact that we found an important bug, however, by what means will the requirement analyst, developers, designers, managers and customers respond ? That’s the question to be asked.

  • The ones who develop the software application may respond protectively and take this reported defect as an individual feedback.

  • The project manager might be irritated with everybody for holding up the venture.

  • The customer may lose trust in the product since he can see the defects.

Since testing can be viewed as an destructive process, we have to take extreme care while reporting the defects and failures as impartially and cordially as would be prudent.

The right balance between self-testing and independent testing needs to be achieved.

This right level of independence helps in keeping away from author bias and is frequently more viable at discovering failures and defects.

There are quite a few levels of independence in software testing which is enlisted here from the least level of independence to the topmost:

i. Testing by the individuals who developed the product.

ii. Testing by someone else inside the same team, e.g. another developer.

iii. Testing by the individual from some other team, for example, an autonomous testing team.

iv. Testing by an individual from another organization or company, e.g. outsourced testing or accreditation by an outer body.

So, this was all about the testing psyche…

For a successful career in software testing, you can opt for a software course in testing, conducted by a

well known software institute in Pune.

Understanding State Transition Testing

Software testing has a lot of jobs to offer. The thing is that you need to acquire the desired skills. For that, choose a software testing institute in Pune that conducts software testing classes in Pune.

Moving on to today’s topic….

State transition testing is utilized where some part of the framework can be portrayed in what is known as a ‘finite state machine’. This basically implies the system can be in a (limited) number of various states, and the transition from one state then onto the next are dictated by the guidelines of the ‘machine’. This is the model on which the framework and the tests are based.

Highlights of the state transition testing process:

  • Any system where you get an alternate output for the same input, contingent upon what has occurred some time recently, happens to be a finite state framework.

  • One of the benefits of the state transition process is that the model can be in depth or as abstract as you need it to be. Where a part of the framework is more essential (that is, requires all the more testing) a more noteworthy profundity of detail can be demonstrated. Where the system is less critical (requires less testing), the model can utilize a solitary state to mean what might somehow or another be a progression of various states.

  • This model consists of four fundamental parts:

– The states in which a software would remain (open or closed or funded/insufficient funds)

– The shift from one state to another (not all transitions are permitted)

– The events that might lead to a transition (closing of a file or withdrawing money from an ATM)

– Call to action as a result of transition(error prompt or successful withdrawal of cash)

That is the reason we can see that in any given state, an event can bring about just a single action, however that a similar event – from an alternate state – may bring about an alternate action and an alternate end state.


On the off chance that a document is open, you can close it. On the off chance that no doc is open, then the action “Close” is not feasible. After you click on “Close” once, you can’t opt for it again for the same document unless you open that document. A document accordingly has two states: open and shut.

Another example is:

In the event that you ask to withdraw Rs 100 from a bank ATM, you might be given money. Later you may make the very same demand however it might decline to give you the cash due to your lacking balance. This later refusal is on the grounds that the state of your account has been transited from having adequate funds to cover the withdrawal to having lesser funds. The transaction that brought for you to change its state was likely the before withdrawal. A state chart can represent a model from the perspective of the framework, the account or the client.

Where can it be put to use?

  • When we have succession of events that happen and related conditions that apply to those events.

  • At the point when the best possible handling of a specific event relies on the events and conditions that have took place previously.

  • It is utilized for real time frameworks with different states and transitions included.

In a practical situation, testers are ordinarily given the state transition diagrams and they are required to decipher it. These outlines are either given by the Business Analysts or the stakeholder and testers utilize these graphs to design the test cases.

Thus, we saw various fundas related to the state transition testing. For more on this and other concepts, join a software testing course in Pune.