Bug Tracking System

What is Bug Tracking ?

Bug tracking is the process of

                      - discovering

                      - capturing

                      - reporting

                      - managing

data on bugs (Errors and Exceptions) that occur in software.  

This process is used by Quality Assurance personals and Programmers to keep track of the errors and malfunctions of the Software product.

Nothing is perfect.. !!  So is the Software...... But errors in software bugs needs to be far more considered. The bugs and errors in software products have damaged the reputation and have been responsible for massive revenue loss and time loss.  

As the software grows in feature, its complexity too increases. Thus possibility for bugs too increases.  At the same time, the time taken to discover and fix bugs too gets crucial. It will definitely be an effect to the product stability and to the whole business. Thus  better Bug Tracking  process would prevent all of this heartache.

What is a Bug Tracking System?

A Bug Tracking or Defect Tracking System is a Software Application that keeps track of the reported bugs in a Software Project.

Typically two types of bug tracking systems can be seen according to the type of project. They are 

•  bug tracking systems  integrated internally with other software project management systems. 
• bug tracking systems that allow end-users to enter  bug reports directly. Normally they are used by open source projects.

In a good software development environment,  bug tracking system is usually an essential software component. It is worthy to mention that  Bug Tracking System provides a record of Software Team's Effectiveness. 

There are two aspects in a bug tracking software. Each aspect has different levels of responsibilities and management priorities within the organization. Below explains each aspect in detail:

1) Task Management System

This is for the Large Scale Overview of the project. In other words, they concentrate on the pig picture analysis of the tasks or issues that needed to be completed for the project.

This includes:  1) Log Management Tools

                         

                         2) Prioritization logic

The tasks carrying out are identifying which bugs should be fixed first and how long each stage would take. In this way it allows to measure the performance of the team.

This can be used by the Upper Level Management to get a higher level understanding of the project flow; whether the development team can meet the targeted deadlines and what are the bottlenecks. Also they are able to obtain a snapshot of where the project is at the current moment.

2) Bug Capturing Tool

This concentrate on the live errors. Provide the developers with environmental data about the errors.

This will collect error related details and categorize the errors, so that the programmers can work right on fixing the error. 

After an error occurs, they collect all the important details like environment, OS, application variables, browser version etc.

Bug capturing tool includes a
    - simple interface for communication about bugs
    - automated notification system to keep the team       on schedule.

Popular Bug Tracking Softwares

                                      Bug Tracking Tools available in the market are innumerable. They have to be chosen as required by your project.  There are variations in these tools. 

For an instance JIRA   supports Agile Planning and Reporting. Also it consists of drag and drop task prioritization. It is also possible to create custom dashboards in JIRA, that contain  everything you need to plan your work. Wheras Bugzilla doesn't contain such features.  But Bugzilla is open-source. 

LeanTesting is web-based and requies no installation. Stryka has a wide area. It is not only a bug tracking tool, but also a Management Tool including requirement management, quality management. It can also be used for test case designing and test case management.      

• Stryka
• Bugzilla
• LeanTesting
• JIRA
• Mantis
• Trac

Android

What is Android

• Open Source and Linux-based  

     Operating System  for Mobile Devices

• Was developed by Open Handset Alliance , led by  Google and several other companies

• The first Beta version of Android was released in 2007 by Google.

Android Versions

Android Features

• Beautiful UI        =>        beautiful and intuitive
• Connectivity       =>        WIFI, bluetooth
• Storage              =>       SQLite is used
• Media Support   =>       png,jpg,gif
• Messaging         =>       sms, mms
• Web browser
• Multi-task
• Multi- language
• Resizable widgets

Android Application Components

• Complete Android application development is dependent on 4 components

•  Activity

- A single screen in the application with UI components - User is going to interact with the device through the Activity - Activity is a java file and an xml file

• Service

- A long running background process without any user interaction- WiFi status, Network status, Media player- Once you start the media player, it’ll start in background

• Broadcast Receiver

- Registered for system announcements
Eg: when headset is plugged in it is detected, charger connected, charger disconnected,

power button pressed

- Broadcast announcements are sent to the application with the help of broadcast receivers

• Content Provider

- Enable to share the data between two applications
Eg: WhatsApp can read the Contacts data,  since Contacts provide content providers

Android Environment Setup

• Java JDK5 or later version  with its environment variables set
• One of the Android IDE

                         -   Android Studio

                         -   Eclipse

   

GIT

               It is the widely used Version Control System. It an actively maintained Open Source project initially developed  by Linus Torvalds, the famous creator of the Linux operating system kernel. 

     Git owns many forward characteristics compared to other software version control systems  in the fields of Performance, Security, Flexibility etc.  Some of the  especial characteristics are  stated below.

• Committing changes, merging, branching are optimized for performance

• Unlike other version control systems, Git is not fooled by the name of the file in determining the history  and it focuses on the file content.

• Git  Repository are secured with cryptographically secure hashing algorithm SHA1. Thus protects the code and the change history against malicious change.

• It supports various kinds of non-linear development  workflows 

 In this blog we will discuss on the Git branching feature and the Git Tag feature procedures. Thus is suitable for a one with the basic git command knowledge.

Git Branching  

There is a central repository referred to as the Origin.  Each developer push and pull to the origin. But besides the central push-pull relationship ,  there is an Decentralized  feature to form sub-teams and pull changes form these peers  before pushing the work to the Origin.

For that Git contains branching feature. What is the use of keeping the code in a separate branch.

1. You are about to make an implementation of major or disruptive change
2. You are about to make some changes that might not be used
3. You want to experiment on something that you are not sure it will work
4. When you are told to branch out, others might have something they need to do in master

 There are mainly two types of branches helpful for a systematic development procedure. They are
                                                           01) Main Branches
                                                           02) Supporting Branches

Main Branches

They are in the central repository and holds down two branches as master and develop. These two branches are parallel.

   Master        => main branch which reflects the source code in the production-ready state.

   Develop     => main branch which reflects the latest delivered development changes for the next   release.


As shown in the diagram, after the initial development version if there are any new features to be added these developments are done in the develop branch. 

When the source code in the develop branch reaches a stable point,and ready to released, then source code is merged with the master branch

Supporting Branches

Next to the main branches master and develop,  there are variety of support branches to support the parallel development between team members. 

Unlike main branches, these have a limited life time period, since they will be removed eventually.

These type branches are categorized by how we use them. for an instances, see the figure below with an Feature branch. 

Feature branches above are for the new feature developments for distant future releases.  The Feature branch will exist as long as the feature is in development. Eventually it is merged back to the develop branch which is shown in the figure.

Feature branch typically exist in developer repo only and not in origin.

Creating a feature branch

When developing a new feature, begin it in a feature branch. To begin it

                                         `$ git checkout -b myfeature develop`

Then you will checkout from the develop branch and switch to the branch "myfeature". Once the feature development is over in the supporting branch, changes have to be incorporated to the develop branch for them to be added to the upcoming release. 

For that  first switch to the develop branch

                                          `$ git checkout develop`

Then merge the myfeature branch to the develop branch. Here --no-ff flag always create a new commit object. This avoids  the loss of historical existence info of the feature branch
                                          `$ git merge --no-ff myfeature`

Then delete the feature branch as 
                                          `$ git branch -d myfeature`
Lastly push the committed change to the develop branch 
                                          `$ git push origin develop`

The first diagram shows the above described process. The second diagram shows the merge without the flag. 
  There are other two supply branches as Release branches and Hotfix branches. It is about the basic branching system of the Git. 

Git Tagging

 What is a tag in Git?

 Tag is used in the version maintenance of a software system. Tag is a way to mark a point in time in your repository.  In other words a tag represents the version of a  particular branch at a time whereas the branch is a separate thread of development.  

In Git we are not tagging branches and we are tagging commits.  We can say tag is an annotated pointer to a commit. It is shown in the figure below.

  Let's see some operations with tags. 

Listing Your Tags  => list all the available tags in Git

                                       $ git tag

                               => list tags with a particular pattern

                                     $ git tag -l "v1.8.5*"







Creating Tags        => two types of tags as lightweight and annotated

                                     lightweight tag is like a branch that doesn't change. Its just a pointer to a                                                specific commit.

                                     annotated tags are stored as full objects in Git database.  They contain                                                    information like tag name,  email, tag message, date etc. 

                                 

Annotated Tag Creation =>   $ git tag -a v1.4   -m "my version 1.4" 

                   -a specifies an annotated tag and -m for the tag message.

                                     using git show command information can be seen. 

       

Lightweight  Tags  Creation => $ git tag v1.4-lw 

                                                      This time git show command does not show any detail. Instead                                                                shows the command

ScreenCasting

What is Screen Casting... ?

                                                                             

        You might be aware of what is a "Screen Shot". It is a single picture of the screen of your computer.

        But in contrast to it "Screen Casting" is a digital video recording that captures actions taking place on a computer desktop. Screen casting normally contains voice over narration. 

        Thus it becomes a very useful methodology and a procedure in many scenarios to gain higher productivity. Following lists some common and useful instances of screen casting.

1.  To provide answers to some common asked questions of your employers
2. To hire the companys' new hires effectively and free up your time.
3. It is a very productive method to make a software or a product demo
4. To provide clear feedback
5. To create video tutorials


Have you ever wondered how to do this... ?? that is... how to show what's clearly happening on your computer screen...?  Thanks to Screencasting Software  anybody can do it now.

 There are a plenty of screen casting tools. Below lists few

 1.  Adobe Captive
                 -  quite expensive
                 - it takes longer time to work with this tool
                 - not advisable for beginners

2. Camtasia Studio
                 - not free
                 - but a powerful PC only software
                 - not recommanded for beginners

3.   Screenr
                  - web based, java tool, thus no installation
                  - need internet connection
                  - slow to use
                  - it doesn't let webcam to record

4. Jing
                  - same as Screenr
                  - only publishes videos in .swf format
                  - produced .swf videos cannot be converted to mp4 even with file-conversoin utilities

5. SnagIt
                  - overcome the frustrations of Jing
                  - can record for as long as you want
                 
6. Screemcast-O-Matic(SOM)
                 
                   - free
                   - ease of use
                   - records your webcam as well as your screen
                   - Java applet  available which needs no implementation

Configuring Tomcat For SSL

Tomcat is a Web Server for JSP pages. It comes in default for HTTP on port 8080. If required it can be configured to use SSL connection on port 8443.

If you are using Tomcat as a standalone web server, then it is a probably a good idea to configure Tomcat to handle SSL connections. But if you are fronting Tomcat with a web server, and Tomcat serves only as a application server or a Tomcat servelet container, then its BETTER to let the web server function as a proxy for all HTTPS requests and NOT configure Tomcat for SSL.

Why....?

Because in SSL connection the data is encrypted. All that encryption, decryption and handshaking are not just free. Its CPU intensive , thus slows down the transmission speed.

If another web server is used to serve the static content, Tomcat must be freed to focus on its specialty : delivering dynamic content and take data from web server as son as possible.

Following shows set of simple steps to carry out the Tomcat SSL configuration.


STEP 1

cd $JAVA_HOME/bin

Inside this directory is a folder named keytool which is responsible for generating a keystore file.

STEP 2

Then open the terminal

New keystore file is created in the home directory of the user.

keytool -genkey -alias tomcat -keyalg RSA

To specify a different location for the keystore file

keytool -genkey -alias tomcat -keyalg RSA
  -keystore /path/to/my/keystore

It'll ask for some questions .

IMPORTANT
First ask to enter the password for  keystore.  The default password is 'changeit '.  Better to provide the password of your Tomcat server. 

The next important fact is for the first name and last name (first question) provide the host name of the url you are accessing the application. Certificate exception might arise otherwise.

Now keystore file is created on your machine.

STEP 3

Now to configure the Tomcat server file , First move to the bin folder in tomcat installation directory.

Open using an editor and  find the following line

<!--
<Connector port="8443" protocol="HTTP/1.1" SSLEnabled="true"
    maxThreads="150" scheme="https" secure="true"
    clientAuth="false" sslProtocol="TLS" />
-->

Modify it as follows after uncommenting

Connector SSLEnabled="true" acceptCount="100" clientAuth="false"
    disableUploadTimeout="true" enableLookups="false" maxThreads="25"
    port="8443" keystoreFile="/Users/loiane/.keystore" keystorePass="password"
    protocol="org.apache.coyote.http11.Http11NioProtocol" scheme="https"
    secure="true" sslProtocol="TLS" />

STEP 4

Now access the Tomcat service as https://localhost:8443. You can access default port 8080 too on http://localhost:8080

Here You Goo....  :)

STEP 5

By doing the above 4 steps, you can successfully enable the secure connection. But in order to avoid some common ssl related errors you might encounter when developing applications that communicates securely this step is gonna be very USEFUL....

Import the server certificate to the trusted Java key store.

• First download the certificate from the server.

access the url of the service from Opera browser. A certificate related warning comes. View certificate details and then export it to hard drive.

• move to $JAVA_HOME /bin folder. Execute the following command there.

keytool -import -alias _alias_name_ -keystore ..\lib\security\cacerts -file _path_to_cer_file

below link takes you to some common ssl related errors and how to solve them.

http://java.globinch.com/enterprise-java/security/pkix-path-building-failed-validation-sun-security-validatorexception/

populate a dropdown according to the selection in another dropdown

                      Suppose two dropdowns as dropdown1 andropdown2. I need to populate the dropdown2 with different values based on the selection in dropdown1. Following shows the two dropdown menus

<select class=" form-control" id="dropdown1">
    <option>--Select--</option>
    <option>Customer</option>
    <option>Staff Member</option>
</select>

<select class=" form-control" id="dropdown2" >
    <option value="None">None</option>
</select>

                    Following javascript code works fine. Values to be populated to dropdown2 are taken into two arrays. Switch statement is used to decide which array is to be populated based on the dropdown1 selection.

                     the function createFunction() will build up the <option> elements in the dropdown1 menu.  

function configureDropDownLists(ddl1,ddl2) {
    var customer= ['None','Name', 'Registered Period', 'Area'];
    var staff = ['None','Designation', 'Department', 'Branch'];


    switch (ddl1.value) {
        case 'Customer':
            ddl2.options.length = 0;
            for (i = 0; i < customer.length; i++) {
                createOption(ddl2, customer[i], customer[i]);
            }
            break;
        case 'Staff Member':
            ddl2.options.length = 0;
            for (i = 0; i < staff.length; i++) {
                createOption(ddl2, staff[i], staff[i]);
            }
            break;

        default:
            ddl2.options.length = 0;
            break;
    }

}

function createOption(ddl, text, value) {
    var opt = document.createElement('option');
    opt.value = value;
    opt.text = text;
    ddl.options.add(opt);
}

 Finally configureDropDownLists(ddl1,ddl2)  function is called on 

the dropdown1 menu as shown menu

<select class=" form-control" id="selectCustomer"    onchange="configureDropDownLists(this,document.getElementById('filterOption'))">
     

    <option>--Select--</option>
    <option>Customer</option>
    <option>Staff Member</option>
</select> 

Including a html file in another html

• Using jQuery following code perfectly works

<html> 
  <head> 
    <script src="jquery.js"></script> 
    <script> 
    $(function(){
      $("#includedContent").load("b.html"); 
    });
    </script> 
  </head> 

  <body> 
     <div id="includedContent"></div>
  </body> 
</html>

• By including an import 

<head>
  <link rel="import" href="/path/to/imports/stuff.html">
</head>

to access the content of the import use link element's .import property as below

var content = document.querySelector('link[rel="import"]').import;