XP consists of these phases: Exploration, Planning, Iterations to Release, Productionizing, Maintenance and Death[1].

[Image source: http://www.extremeprogramming.org/map/images/project.gif]

Exploration phase: Exploration phase is about customer communication. Customers write some story cards where they include their wish to be included in first release. Each story card is a feature to be added in the program. And this phase is also about developers familiarize themselves with the tools and technology. Testing of technology. This phase will last from few weeks to few months, depending upon how familiar the technology is.

Planning phase: Planning phase is normally not more than 2 months, where developers the time estimate each story requires and agree on the contents for the first small release. Overall release plan is also made in this phase.

Iteration to release phase: On Iterations to release phase each story are divided into several iterations which will take around one to four weeks. The first iteration is about coming up with whole system architecture, which is done by selecting the stories that will give the structure of whole system.

Programmer work on each story at a time using pair programming, where the analysis, design, planning for test and test. The first iteration is the story with the highest business value and the last iteration the system is ready for production.

Production phase: Production phase the software is tested again and checked for the performance of the system before release. New changes may be introduced in this phase, which will need quick decision if they are included in this release or not.

Maintenance phase: Maintenance phase require incorporating new people in team and require an effort also for customer support. This phase is after the first release. Production phase is also running during this phase.

Death phase: The last phase is the Death phase, when customer have no any stories to implement, which satisfies customer needs.  All necessary documentation is written in this phase. This phase may also occur if the development is stopped because of not delivering the desired product or is too expensive for further development.

Different software quality control on XP.

There are 12 different aspects in XP which are focused for maintaining the software quality[2]. Each of the points are distributed among all the different phases of XP.

1. Simple design: On each iteration, when developers choose some task to perform then they are focused on the need of current iteration only, which make it simple to view and have control over. They don’t have to think about the whole project or next iteration.

2. Testing:  On XP tests are done at least once for each story[3]. Which reduce the chances of finding a big bugs at the end of project. And because it is done quite frequently it’s easy for developers to test and correct small piece of code then the whole project.

2.1 Unit testing: Unit testing is a test of methods, classes, properties and assemblies performed by developers who write the code. On XP, developers write unit test before writing the actual code (classes, methods or properties). So that when they start writing code, it is automatically tested by unit testing software.

2.2 Functional testing: This is the testing of the software, if it meets the customer story. This test is done at the end of the development in traditional way, which result in finding more bugs and hard to fix. But on XP it is done after each iteration, satisfying the need stated on the customer story card.

3. Refactoring: Refactoring the process where developers continues to edit the code throughout the project life. It is done to remove redundancy and unused functions..

4. Continuous integration: Each small part of code that are adding in the system are tested automatically. This adding of code is done frequently with the test done on each time.

5. Small releases: The development process in XP is simple where developers release a small working product in a first release and go on adding small functionality more on each iteration. This way of working a small bit at a time, makes developers easy to work, which result in less chances of making error.

6. Coding standards: Each XP team follow their standard manner of writing codes. This standardization of code makes developers easy to understand the code written by other.

7. Planning game:

7.1 Release Planning: During this planning phase customer provides requirement for the system in customer story cards, which is later determined by developers for when to release.

7.2 Iteration Planning: This planning is done only by developers. They spit requirements into different tasks. Time required to complete each task is assigned and matched with the original customer story when finished.

8. Customer on-site: Customer representative is always co-located with developers which help in fast response to developers if something is going wrong. And if developers are ahead of schedule then the customer can add more requirement in the iteration.

9. Pair programming: Pair programming is a practice where two programming works together, where one write codes and other checks if it is written correctly. The person writing the code is thinking “tactically” whereas the other person is thinking “strategically”, ensuring the coding standards are followed[3].

10. Collective ownership: On XP development method everyone have access to any code and can be edited by anyone in the team. This will facilitate with the fast editing of code when there is any error.

11. Metaphor: Use of simple and meaningful words and descriptions for developer can easily guess and work with.

12. 40-hour week: XP tries not to make its developers tired because tired developers tends to make more mistakes. So without more time on work, XP have fix time in a week to work, keeping developers fresh and active every time they work.

Reference

[1] Ioannis G. Stamelos, Panagiotis Sfetsos, Agile software development methods

[2] Yael Dubinsky, Orit Hazzan, Improvement of software quality: introducing extreme programming into a project-based course

[3] Dave Rooney, Enabling software quality using Extreme programming

[4] Beck, Embracing Change With Extreme Programming

[5] Nicholas R. Zuiderveld, eXtreme Programming and SCRUM, A Comparative Analysis of Agile Methods

]]> http://www.sandeshshrestha.com/blog/extreme-programming-xp/feed/ 0 http://www.sandeshshrestha.com/blog/selection_sorting/ http://www.sandeshshrestha.com/blog/selection_sorting/#comments Sun, 18 Dec 2011 14:24:47 +0000 Sandesh http://www.sandeshshrestha.com/blog/?p=52 Selection sort works by finding the smallest item in the array and exchange in with the first entry. Then, find the next smallest item and exchange in with the second entry, which continue till all array is sorted.

Selection sorting takes (N*N)/2 running time to sort N items.

Tuterial video

Java Code

public class Example
{
	public static void sort(Comparable[] a)
	{
		int N = a.length;
		for (int i = 0; i < N; i++)
		{
			int min = i;
			for (int j = i+1; j < N; j++)
				if (less(a[j], a[min]))
					min = j;
        	  	exch(a, i, min);
		}
	}
	private static boolean less(Comparable v, Comparable w)
	{
		return v.compareTo(w) < 0;
	}
	private static void exch(Comparable[] a, int i, int j)
	{
		Comparable t = a[i];
		a[i] = a[j];
		a[j] = t;
	}
	private static void show(Comparable[] a)
	{
		for (int i = 0; i < a.length; i++)
			StdOut.print(a[i] + " ");
		StdOut.println();
	}
	public static boolean isSorted(Comparable[] a)
	{
		for (int i = 1; i < a.length; i++)
			if (less(a[i], a[i-1]))
				return false;
		return true;
	}
	public static void main(String[] args)
	{
		String[] a = In.readStrings();
		sort(a); // sort
		assert isSorted(a); // check if it sorted properly
		show(a); // displaying the sorted array
	}
}

Primitive data types

• boolean 1 byte
• byte 1 byte
• char 2 bytes
• int 4 bytes
• float 4 bytes
• long 8 bytes
• double 8 bytes

• overhead 16 bytes // overhead includes a reference to the object’s class, garbage collection information and synchronization information
• padding 4 bytes // memory uses padded on a 64-bit machine
• reference 8 bytes // reference to different object or data type

Object : Memory used by an object is equal to the memory used by each instance + overhead (16 bytes) + padding (4 bytes). For example

private class ageGender
{
int age=0;
char gender = ''; //"m" for male and "f" for female
}

The abover object “ageGender” will use 26 bytes
_____________
| overhead           | 16 bytes
| int (age)             | 4 bytes
| char (gender)  | 2 bytes
| padding              | 4 bytes
|____________|

Linked list : To understand the memory used by Linked list, we have to first understand the Linked list first.

Each linked list is a class, which have 1 reference to the first node, 1 int storing the size of linked list and list of a lot of nodes.

Each node is again a class with 2 references, first one is the reference of the class storing the value of that node and second is the reference to the next node. And its a inner class of a Linked list class.
Now if this linked list is storing int values, then it will create Integer class for int value stored in each node.

Linked list (storing int values)
____________
| First node      |
| int                     |
| _________  |
||Node 1         | |
||________  | |
| _________  |
||Node 2         | |
||________  | |
|          .                |
|          .                |
|          .                |
|__________ |

If we examile the above class it will use overhead (16 bytes) + padding (4 bytes) + reference to first node (8 bytes) + size of link list (4 bytes) + reference to each node (8N bytes) memory. In total 32+8N

Node
_______________________
| reference to Integer class     |
| reference to next node           |
|______________________|

Now the memory used by this node is overhead (16 bytes) + 2 reference (2*8 bytes), in total 32 bytes.

Integer class will also have overhead (16 bytes) + padding (4 bytes) + int value (4 bytes), in total 24 bytes of size.
Now the total memory used by Linked list after adding all this will be 32 + (8+32+24)N = 32 + 64N.

Array : In Java array is an object with extra overhead for the length of the array. So an array of integer int[] will require overhead (16 bytes) + length of array (4 bytes) + padding (4 bytes) + list of int values (4N bytes). In total, int[] will require 24+4N memory whereas char[] will require 24+2N memory.

String object : String object is a class containing reference of an array of char[] containing each character of reference, with three extra overheads (offset, count and hash). This means that string object will require overhead (16 bytes) + padding (4 bytes) + offset, count and hash (3*4 bytes), 1 reference to the char array (8 bytes) and a char array (24+2N) memory, in total 64 + 2N memory.
But creating substring from a string will only create a new class but uses the old char array, this means it only require 40 extra bytes.

//Function creating XmlHttpObject
function GetXmlHttpObject(){
var xmlHttp=null;
try{
// Firefox, Opera 8.0+, Safari
xmlHttp=new XMLHttpRequest();
}
catch (e){
// Internet Explorer
try{
xmlHttp=new ActiveXObject("Msxml2.XMLHTTP");
}
catch (e){
xmlHttp=new ActiveXObject("Microsoft.XMLHTTP");
}
}
return xmlHttp;
}

//function to send the post data to send.php file and activate receive().
function send(a){
var parameters = "code=" + encodeURIComponent(a);
http_request=GetXmlHttpObject();
if (http_request==null){
alert ("Your browser does not support AJAX!");
return;
}
http_request.onreadystatechange = receive;
http_request.open("POST", "send.php", true);
http_request.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
http_request.send(parameters);
}

//function to alert() data from send.php
function receive(){
if (http_request.readyState == 4) {
if (http_request.status == 200) {
var result = http_request.responseText;
alert(result);
}
}

send.php

<?php
$a=$_POST["code"];
echo $a;
?>

As in the example below <input> type is set to “email” and required attribute is set to “required“.