Archives for December 2015

Waterfall development model divides the application development process into the following distinct phases

1. Requirement Analysis
2. Design
3. Implementation
4. Testing
5. Deployment

In contrast to the waterfall model ,in agile application is delivered in iterations.After each iteration there is a working software which contains new features.

Following are the advantages of Agile methodology

Changes are easy to accommodate

Waterfall model is rigid. A phase should be completed before next phase can begin.So the first phase should be completed before the next phase can begin.The main problem with this approach is that there is no scope whatsoever to accommodate future changes.So far example once a design phase is completed and implementation phase has started ,there is not much scope for changes in the design.

This is the most important advantage provided by Agile.Agile development model supports further changes.Requirement changes can be easily accommodated in any stage of application development.

Early delivery of working software

Another advantage offered by the Agile model is that a working software is developed early.This gives customers the opportunity to verify and give their feedback.
Software developed using the waterfall model on the other hand is available only after all the phases are complete.So there’s not much scope for the customers feedback in the project lifecycle.Its kind of black box as the customer can see all or nothing.Either customer can access all the features or none of the features.

Defects are discovered early

Unlike waterfall model in which testing is done after implementation phase,in Agile model testing is done in each iteration.This means that software is more robust.

Scope for improvement

In Agile process team can learn from their mistakes and correct in the future development stage.For example in scrum process if there are any challenges in an iteration then team can learn from it in the retrospective.These can be rectified in the future iterations.

Common Agile Frameworks

Agile consists of a group of frameworks.A framework should be chosen based on the project requirement.

Following are some of the common agile frameworks

Extreme Programming(XP)     Focus on technical aspects of the application

Lean software development     Focus on eliminating waste

Scrum        Focus on product delivery

Kanban      Focus on product delivery without overburdening the developers

Crystal Based on the concept that each project may require a tailored set of processes.

Dynamic Systems Development Method which is based on the MSCW for requirements

• M       Must have requirements
• S         Should have requirements ,if at all possible
• C        Could have requirements, but not critical
• W       Won’t have in the current version

Follow on:

In the previous versions of  Java , date and time functionality was implemented using the types defined in the java.util. For example to work with dates there is a java.util.Date type.

Below is a sample code to print the current date

Date date = new Date();
System.out.println(date.toString());

Output
Tue Dec 15 19:42:35 IST 2015

There are few limitations with the date and time types defined in the java.util package.

• There is no way to work with only time or only with dates.Since time and date both are represented by the same type Date.
• Methods are not consistent.                                                                                                                    For example when calling different methods we get some unexpected values.Assume Current date is  “15 Dec 2015 ”
  

  Method	Return value
  date.getDay()	2
  date.getYear()	115
  date.getMonth()	11

As we can see the values returned by the different methods is not what we expected.getDay()          returns 2 ,which is the second day of the week.getYear() returns 115 while the current year is          2015.getMonth() returns 11 while the current month is 12.

•    Date and Time classes defined in the java.util package are not thread safe.

The Date-Time API provided in Java 8 provides the solution to the problems in the legacy Date-Time API.
It consists of different types for working with date and time values.To create objects of these types we use factory methods instead of constructors.
Following are some of the main classes in the Date and Time API in Java 8.

Type	Use
LocalDate	Represents  a date value without a time-zone
LocalTime	Represents  a time value without a time-zone
LocalDateTime	Represents  a date-time value without a time-zone
Year	Represents a year
YearMonth	Represents an year and a month
MonthDay	Represents a combination of month and day
ZonedDateTime	Represents a date-time with a time-zone

The types are defined in the package java.time.To get the date time values we can use the below code. now() method returns the current date or time value.

import java.time.LocalDate;
import java.time.LocalTime;

public class DateTimeApplication{
public static void main(String []args) throws IOException {

LocalDate date = LocalDate.now();
LocalTime time = LocalTime.now();
int year= date.getYear();
MonthDay monthDay = MonthDay.now();
YearMonth yearMonth=YearMonth.now();

System.out.println(date);
System.out.println(time);
System.out.println(year);
System.out.println(monthDay);
System.out.println(yearMonth);
}
}

output:
2015-12-15
23:16:41.653
2015
–12-15
2015-12

We can also create objects of these types by specifying values rather using the now() method which returns the current date time value.To do so we use of() methods defined by these types:

LocalDate date=LocalDate.of(2015, 12, 15);
LocalTime time = LocalTime.of(10,15);

output:

2015-12-15
10:15

 

Follow on:

Many times we need to declare multiple variables of the same type to hold related values.For example list of students in a class.As there are lot of students in a class so to store the names of students in  variables we can declare the variables as:

String Student1="John";
String Student2="Priya";
String Student3="Amit";
...

So using variables to store students names means we need to declare lot of variables.This approach has the following disadvantages:

• In case of big collection of data ,the number of variables can increase.
• It is difficult to manage lot of variables specially when assigning or fetching these values.
• The code is difficult to read and understand.

Because of disadvantages arrays are prefered way to store large collection of related data.

For example if we have to assign and read the list of students in a class using variables we will do it as:

InputStreamReader in=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(in);
String Student1=br.readLine();
String Student2=br.readLine();
...

System.out.println(Student1);
System.out.println(Student2);

As you can see there are 2 problems in this approach.

• We have to know in advance the exact number of variables we are going to assign
• Assigning and reading the values makes the code difficult to understand

We can easily assign and read values using array as:

String[] student=new String[2];
InputStreamReader in=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(in);
for(int count=0;count<student.length;count++)
{
student[count]=br.readLine();
}

for(int count=0;count<student.length;count++)
{
System.out.println(student[count]);
}

Arrays can be assigned and retrieved using a for loop.This makes arrays easier to work with a group of data unlike ordinary variables.

Follow on:

Arrays are useful for storing a collection of data.For example if we have a group of student data related to students in a School then we can define an array as:

class Student
{
public int Id;
public String Name;
public String Address;
}

String[] students=new String[10000];
students=getStudents();

The method getStudents() may fetch the list of students from webservice or database.

So arrays are useful for storing a set of data.But the main problem with arrays is that the size of an array is fixed and it can not be changed later on.For example if the number of Students in school increases then we can not increase the size of the array after we have declared the above array.

One solution is to declare the arrays with suffixiet size to accomodate the future requirments.So in the above case we can declare the array of size 15000 ,since we assume the number of students can not be more than that.

String[] students=new String[15000];

But the problem now is that we have declared the size of the array which is much more than the actual number of Students.This means that extra memory is bing allocated for Students.Though that memory will never be used.

For these types of scenarios Arraylist is a better solution.Arraylist differs from arrays since the size of an Arraylist can be altered at runtime.So if we don’t know how many elements an array will contain we can use an ArrayList.

Following are the steps to declare and add elements to an ArrayList

1. Import the required namespaces.
ArrayList class implements the List interface.It extends the AbstractList class.To work with ArrayList<T> in our code we need to import the following package from java.util library:

import java.util.ArrayList;

2. Create an ArrayList object
Once we have imported the required package we can create an object of the generic Arraylist as:
//create a list of Students

public class Student {
public int Id;
public String Name;
public String Address;
}
ArrayList<Student> students = new ArrayList<Student>();

3. Add elements to an ArrayList
For adding elements to arraylist we use the add() method

//add item to list
Student student=new Student(); 
student.Id=1; student.Name="John";
student.Address="Autralia"; 
students.add(student);

For adding element at a specific index we use an overload of add() method as:

student=new Student();
student.Id=2;
student.Name="Amit";
student.Address="India";

students.add(1,student);

Note that we have provided the index as the first parameter.

4. Reset elements at a specific location
We can reset element at a specific index using the set() method as:

student=new Student();
student.Id=2;
student.Name="Marc";
student.Address="UK";
students.set(1,student);

In the above code we are replacing the Student at second position ,”Amit” with Student “Marc”

5.Retrieve elements from the arraylist.
We can retrieve an item from the arraylist using the get() method as:

student=students.get(1);

6.Get the number of elements in ArrayList
There is a size() method which returns the number of elements in an ArrayList at any given time.
So if we execute the above code in sequence then size() will return the value 2.

System.out.println(students.size());

output: 2

Follow on: