September, 2019

Severity vs. Priority

The severity of a defect is related to how severe a bug is. Usually, the severity is defined in terms of financial loss, damage to the environment, the company’s reputation and loss of life.

The priority of a defect is related to how quickly a bug should be fixed and deployed to live servers. When a defect is of high severity, most likely it will also have a high priority. Likewise, a low severity defect will normally have a low priority as well.

Although it is recommended to provide both Severity and Priority when submitting a defect report, many companies will use just one, normally priority.

In the bug report, Severity and Priority are normally filled in by the person writing the bug report but should be reviewed by the whole team.

High Severity – High Priority bug

This is when major path through the application is broken, for example, on an eCommerce website, every customer gets an error message on the booking form and cannot place orders, or the product page throws an Error 500 response.

High Severity – Low Priority bug

This happens when the bug causes major problems, but it only happens in very rare conditions or situations, for example, customers who use very old browsers cannot continue with their purchase of a product. Because the number of customers with very old browsers is very low, it is not a high priority to fix the issue.

High Priority – Low Severity bug

This could happen when, for example, the logo or name of the company is not displayed on the website. It is important to fix the issue as soon as possible, although it may not cause a lot of damage.

Low Priority – Low Severity bug

For cases where the bug doesn’t cause disaster and only affects a very small number of customers, both Severity and Priority are assigned low, for example, the privacy policy page takes a long time to load. Not many people view the privacy policy page and slow loading doesn’t affect the customers much.

The above are just examples. It is the team who should decide the Severity and Priority for each bug.

Difference between Abstract Class and Interface in C#

Abstract Classes ASP.NET C#CSharp Interfaces MVC

An abstract class is a way to achieve the abstraction in C#. An Abstract class is never intended to be instantiated directly. This class must contain at least one abstract method, which is marked by the keyword or modifier abstract in the class definition. The Abstract classes are typically used to define a base class in the class hierarchy. An Interface member cannot contain code bodies. Type definition members are forbidden. Properties are defined in an interface with the help of an access block get and set, which are permitted for the property.

Difference Between An Abstract Class And An Interface

An Abstract class doesn’t provide full abstraction but an interface does provide full abstraction; i.e. both a declaration and a definition is given in an abstract class but not so in an interface.
Using Abstract we cannot achieve multiple inheritance but using an Interface we can achieve multiple inheritance.
We can not declare a member field in an Interface.
We can not use any access modifier i.e. public, private, protected, internal etc. because within an interface by default everything is public.
An Interface member cannot be defined using the keyword static, virtual, abstract or sealed.

// C# program to illustrate the
// concept of abstract class
using System;

// abstract class 'Test'
public abstract class Test {

// abstract method 'harunu()'
public abstract void harunu();
}

// class 'Test' inherit
// in child class 'C1'
public class C1 : C {

// abstract method 'harunu()'
// declare here with
// 'override' keyword
public override void harunu()
{
Console.WriteLine("Class name is C1");
}
}

// class 'Test' inherit in
// another child class 'C2'
public class C2 : Test {

// same as the previous class
public override void harunu()
{
Console.WriteLine("Class name is C2");
}
}

// Driver Class
public class main_method {

// Main Method
public static void Main()
{

// 'obj' is object of class
// 'Test' class 
// 'Test' cannot
// be instantiate
C obj;

// instantiate class 'C1'
obj = new C1();

// call 'harunu()' of class 'C1'
obj.harunu();

// instantiate class 'C2'
obj = new C2();

// call 'harunu()' of class 'C2'
obj.harunu();
}
}

// C# program to illustrate the 
// concept of interface 
using System;

// A simple interface 
interface harunu{

// method having only declaration 
// not definition 
void show(); 
}

// A class that implements the interface. 
class MyClass : harunu{

// providing the body part of function 
public void show() 
{ 
Console.WriteLine("Welcome to Harunu!!!"); 
}

// Main Method 
public static void Main(String[] args) 
{

// Creating object 
MyClass objharunu = new MyClass();

// calling method 
objharunu.show(); 
} 
}

Archives

The difference between Severity vs. Priority