Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-17T17:26:32Z

Jnvarava:

==Generic Programming==
Generic programming is a style of computer programming in which algorithms are written in terms of to-be-specified-later types that are then instantiated when needed for specific types provided as parameters. This enables writing common set of functions which differ only in the types on which they operate. This reduces duplication. Software entities created using generic programming are known as ''generics'' in [http://en.wikipedia.org/wiki/Ada_(programming_language) Ada], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel], [http://en.wikipedia.org/wiki/Java_(programming_language) Java], [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#], [http://en.wikipedia.org/wiki/F_Sharp_(programming_language) F#], and [http://en.wikipedia.org/wiki/Visual_Basic_.NET Visual Basic .NET]; parametric polymorphism in [http://en.wikipedia.org/wiki/ML_(programming_language) ML], [http://en.wikipedia.org/wiki/Scala_(programming_language Scala] and [http://en.wikipedia.org/wiki/Haskell_(programming_language) Haskell], [http://en.wikipedia.org/wiki/template_(programming) template]s in [http://en.wikipedia.org/wiki/C++ C++].

For example, given various data structures and several algorithms, the brute force way would be implement them for each data structure which would mean that various combinations of implementations will be necessary. Generic programming reduces this effort.


==Generics in Java==
===What are Generics?===
Generics were added to Java programming language as a part of J2SE 5.0 release in 2004. They allow programmers to develop generic and compile safe applications which enables a type or method to operate on objects of various type. This feature is well utilized while implementing [http://en.wikipedia.org/wiki/Java_Collections Java Collections]. The reason why people went into generic programming can be well explained using the below example:
<pre>
List list = new ArrayList();
list.add("name");
Integer num = (Integer)list.get(0);
</pre>
In this example, we insert a <code>String</code> into an <code>ArrayList</code> and retrieve element by typecasting with Integer wrapper class. This throws a runtime exception because of Illegal class cast. But if we use generics, runtime exceptions can be avoided and the compiler will be able to catch such issues which in turn help a programmer to build a bug free code. So if we convert the above code to use generic then it would look like this:
<pre>
List<String> list = new ArrayList<String>();
list.add("name");
Integer num = list.get(0); //line 1
</pre>
Here at line 1 the compiler throws an error because the compiler on seeing the declaration of ArrayList will be expecting the list to have just <code>String</code> and thereby the return type of <code>get</code> to be <code>String</code>.

===Implementing Generics:===
Java provides a feature which helps one to implement your own generic types and this will help to build more sophisticated and runtime error free applications. Consider the below example:
<code>
interface List<N> {
void add(N i);
Iterator<N> iterator();
}
interface Iterator<N> {
N next();
boolean hasNext();
}
class LinkedList<N> implements List<N> {
//Business Logic
}
</code>
So here, <code>N</code> can be replaced with any primitive data types or wrapper classes in the business logic. But we need to make sure that placeholders to be replaced with valid subtypes of Object. Generics implementation is not restricted for classes or interfaces, we can have for static/non static methods and constructors.

Example for generic methods:

<pre>
<T> void fromArrayToCollection(T[] a, Collection<T> c) {
for (T o : a) {
c.add(o); // Correct
}
}
</pre>
===Pros and Cons===
Pros:
<ol>
<li>Reduces the number of casts in the program, which in turn reduces the number of potential bugs in the program.</li>
<li>Improves code clarity and maintenance.</li>
</ol>
Cons:
<ol>
<li>Parameter type information is not available at run time.</li>
<li>The automatically generated casts may fail when interoperating with ill-behaved legacy code.</li>
</ol>

==Templates in C++==
===What are templates?===
Templates are functions that can operate with generic types which means that the functionality can be adapted for more than one type of data without repeating the entire code for each type.

===Overview===
Templates can be either function templates or class templates.
====Function Templates====
These are just like regular functions except that they can have arguments of different types. A single function definition works with different kinds of data types. During compile time, the actual functions are generated once the compiler knows the data type being used. This kind of template does not save any memory.

Example
<pre>
template <typename Type>
Type max(Type a, Type b) {
return a > b ? a : b;
}

#include <iostream>

int main()
{
// This will call max <int> (by argument deduction)
std::cout << max(3, 7) << std::endl;
// This will call max<double> (by argument deduction)
std::cout << max(3.0, 7.0) << std::endl;
// This type is ambiguous, so explicitly instantiate max<double>
std::cout << max<double>(3, 7.0) << std::endl;
return 0;
}
</pre>

====Class Templates====
A class template provides a specification for generating classes based on parameters. A class template is instantiated by passing a given set of types to it as template arguments.

Example
<pre>
template <class T>
class mypair {
T values [2];
public:
mypair (T first, T second)
{
values[0]=first; values[1]=second;
}
};
</pre>

===Features of C++ Templates===
Some of the features of C++ templates are:
<ol>
<li>
Implemented in the compiler.<ol><ul>No runtime overhead</ul><ul>Requires template source to be in headers</ul><ul>Latent typing means template instantiator does no type checking</ul></ol>
</li>
<li>Gloriﬁed macro facility<ol><ul>“Macros done right”/“Macros that look like classes”</ul></ol></li>
<li>
Can use template arguments for both classes and straight function</li>
<li>Template specialization<ol><ul>Speciﬁc implementation of a templated type or method</ul></ol></li>
<li>Pattern matching and text replacement<ol><ul>Declarative model (like [http://en.wikipedia.org/wiki/Prolog Prolog])</ul></ol></li>
</ol>

===Pros and Cons===
Usage of templates have both advantages and disadvantages.

Pros
<ol>
<li>Reduction in code size.</li>
<li>They are type-safe, that is, type-checking is done at compile time.</li>
</ol>

Cons
<ol>
<li>Since all compilers are not good at their support for templates, they may not be very portable.</li>
<li>Compilers generate additional code for each template type, this could lead to huge code if usage of templates is not checked.</li>
<li>Information hiding is not achieved as the code is all exposed in the header.</li>
</ol>

==Evolution of Generics==
Here we take Java programming language as an example to explain evolution of generics. Generics were introduced with Java 1.5. However, before that, the codes were bulky and messy but the results were same. Rather than simply using a List<Integer> or Comparable<String>, developers had to deal with a significant amount of inheritance, casting, and instanceof testing. For example, an ArrayList to store only Integers pre-generics might look like the below snippet:
<pre>
public class IntegerList extends ArrayList{
public boolean add(Object o){
if(o instanceof Integer)
return super.add(o);
return false;
}

public Integer get(int index){
return (Integer)super.get(index);
}
}

</pre>
Generics allows to write more modular and reusable code that is adaptable to various datatypes, yet logically restrictive as well. Currently, generics are implemented using erasure, which means that the generic type information is not available at runtime, which makes some kind of code hard to write. Generics were implemented this way to support backwards compatibility with older non-generic code. Reified generics would make the generic type information available at runtime, which would break legacy non-generic code. Generics are implemented using erasure, in which generic type parameters are simply removed at runtime. That doesn't render generics useless, because you get typechecking at compile-time based on the generic type parameters, and also because the compiler inserts casts in the code based on the type parameters.
===Erasure v/s Reification===

Consider the below example, it won't work because of erasure.

<pre>
public class Test<Key, Val> {
public void test(Key key) {
}

public void test(Val value) {
}
}
</pre>
This would give a name clash error for having same erasure and one way to avoid the error is by renaming the method name but this will not the serve the purpose of overloading. Similarly, the below example would give errors because the JVM is not aware of the type T instead views it just as an Object.
<pre>
public class Test {
public <T> void f() {
T t = new T();
}
}
</pre>
So reified generics have support in the compiler for preserving type information whereas type erased generics don't have and that "remember" the class they were created with during runtime. Below are some of the reasons why Java should have reified generics:
<ol>
<li>Type argument erasure cripples frameworks that works with generic types and this results in horrid workarounds</li>
<li>Reified generics allows Typesafe narrowing. Currently in Java, we first test the type of the object using the instanceof operator, and then attempt to downcast it using a C-style typecast</li>
<li>Interoperability between statically-typed is difficult since few support reified generics.</li>
</ol>

But at the same time reified generics have issues and one of the main concern is incompatible with the current collections. So a test on <code>instanceof List<String></code> would now test that the object is an instance of <code>List</code> but also that its elements are of type <code>String</code>. This requires a lot of work around since we need to distinguish between collections making used of reified types from their older types.

==Reference==
<ol>
<li>http://en.wikipedia.org/wiki/Generic_programming</li>

<li>http://en.wikipedia.org/wiki/Generics_in_Java</li>

<li>http://www.oracle.com/technetwork/articles/javase/generics-136597.html</li>

<li>http://download.oracle.com/javase/tutorial/extra/generics/methods.html</li>

<li>http://www.cplusplus.com/doc/tutorial/templates/</li>

<li>http://en.wikipedia.org/wiki/Template_(programming)</li>

<li>http://www.cs.binghamton.edu/~mike/presentations/java-generics-cs580c-fall-2007.pdf</li>

<li>http://jnb.ociweb.com/jnb/jnbJul2003.html</li>

<li>http://tech.puredanger.com/java7/#reified</li>

<li>http://gafter.blogspot.com/2006/11/reified-generics-for-java.html</li>

<li>http://relation.to/21406.lace</li>

<li>http://beust.com/weblog/2011/07/29/erasure-vs-reification/</li>

</ol>

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-17T17:25:36Z

Jnvarava:

==Generic Programming==
Generic programming is a style of computer programming in which algorithms are written in terms of to-be-specified-later types that are then instantiated when needed for specific types provided as parameters. This enables writing common set of functions which differ only in the types on which they operate. This reduces duplication. Software entities created using generic programming are known as ''generics'' in [http://en.wikipedia.org/wiki/Ada_(programming_language) Ada], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel], [http://en.wikipedia.org/wiki/Java_(programming_language) Java], [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#], [http://en.wikipedia.org/wiki/F_Sharp_(programming_language) F#], and [http://en.wikipedia.org/wiki/Visual_Basic_.NET Visual Basic .NET]; parametric polymorphism in [http://en.wikipedia.org/wiki/ML_(programming_language) ML], [http://en.wikipedia.org/wiki/Scala_(programming_language Scala] and [http://en.wikipedia.org/wiki/Haskell_(programming_language) Haskell], [http://en.wikipedia.org/wiki/template_(programming) template]s in [http://en.wikipedia.org/wiki/C++ C++].

For example, given various data structures and several algorithms, the brute force way would be implement them for each data structure which would mean that various combinations of implementations will be necessary. Generic programming reduces this effort.


==Generics in Java==
===What are Generics?===
Generics were added to Java programming language as a part of J2SE 5.0 release in 2004. They allow programmers to develop generic and compile safe applications which enables a type or method to operate on objects of various type. This feature is well utilized while implementing [http://en.wikipedia.org/wiki/Java_Collections Java Collections]. The reason why people went into generic programming can be well explained using the below example:
<pre>
List list = new ArrayList();
list.add("name");
Integer num = (Integer)list.get(0);
</pre>
In this example, we insert a <code>String</code> into an <code>ArrayList</code> and retrieve element by typecasting with Integer wrapper class. This throws a runtime exception because of Illegal class cast. But if we use generics, runtime exceptions can be avoided and the compiler will be able to catch such issues which in turn help a programmer to build a bug free code. So if we convert the above code to use generic then it would look like this:
<pre>
List<String> list = new ArrayList<String>();
list.add("name");
Integer num = list.get(0); //line 1
</pre>
Here at line 1 the compiler throws an error because the compiler on seeing the declaration of ArrayList will be expecting the list to have just <code>String</code> and thereby the return type of <code>get</code> to be <code>String</code>.

===Implementing Generics:===
Java provides a feature which helps one to implement your own generic types and this will help to build more sophisticated and runtime error free applications. Consider the below example:
<code>
interface List<N> {
void add(N i);
Iterator<N> iterator();
}
interface Iterator<N> {
N next();
boolean hasNext();
}
class LinkedList<N> implements List<N> {
//Business Logic
}
</code>
So here, <code>N</code> can be replaced with any primitive data types or wrapper classes in the business logic. But we need to make sure that placeholders to be replaced with valid subtypes of Object. Generics implementation is not restricted for classes or interfaces, we can have for static/non static methods and constructors.

Example for generic methods:

<pre>
<T> void fromArrayToCollection(T[] a, Collection<T> c) {
for (T o : a) {
c.add(o); // Correct
}
}
</pre>
===Pros and Cons===
Pros:
<ol>
<li>Reduces the number of casts in the program, which in turn reduces the number of potential bugs in the program.</li>
<li>Improves code clarity and maintenance.</li>
</ol>
Cons:
<ol>
<li>Parameter type information is not available at run time.</li>
<li>The automatically generated casts may fail when interoperating with ill-behaved legacy code.</li>
</ol>

==Templates in C++==
===What are templates?===
Templates are functions that can operate with generic types which means that the functionality can be adapted for more than one type of data without repeating the entire code for each type.

===Overview===
Templates can be either function templates or class templates.
====Function Templates====
These are just like regular functions except that they can have arguments of different types. A single function definition works with different kinds of data types. During compile time, the actual functions are generated once the compiler knows the data type being used. This kind of template does not save any memory.

Example
<pre>
template <typename Type>
Type max(Type a, Type b) {
return a > b ? a : b;
}

#include <iostream>

int main()
{
// This will call max <int> (by argument deduction)
std::cout << max(3, 7) << std::endl;
// This will call max<double> (by argument deduction)
std::cout << max(3.0, 7.0) << std::endl;
// This type is ambiguous, so explicitly instantiate max<double>
std::cout << max<double>(3, 7.0) << std::endl;
return 0;
}
</pre>

====Class Templates====
A class template provides a specification for generating classes based on parameters. A class template is instantiated by passing a given set of types to it as template arguments.

Example
<pre>
template <class T>
class mypair {
T values [2];
public:
mypair (T first, T second)
{
values[0]=first; values[1]=second;
}
};
</pre>

===Features of C++ Templates===
Some of the features of C++ templates are:
<ol>
<li>
Implemented in the compiler.<ol><ul>No runtime overhead</ul><ul>Requires template source to be in headers</ul><ul>Latent typing means template instantiator does no type checking</ul></ol>
</li>
<li>Gloriﬁed macro facility<ol><ul>“Macros done right”/“Macros that look like classes”</ul></ol></li>
<li>
Can use template arguments for both classes and straight function</li>
<li>Template specialization<ol><ul>Speciﬁc implementation of a templated type or method</ul></ol></li>
<li>Pattern matching and text replacement<ol><ul>Declarative model (like [http://en.wikipedia.org/wiki/Prolog Prolog])</ul></ol></li>
</ol>

===Pros and Cons===
Usage of templates have both advantages and disadvantages.

Pros
<ol>
<li>Reduction in code size.</li>
<li>They are type-safe, that is, type-checking is done at compile time.</li>
</ol>

Cons
<ol>
<li>Since all compilers are not good at their support for templates, they may not be very portable.</li>
<li>Compilers generate additional code for each template type, this could lead to huge code if usage of templates is not checked.</li>
<li>Information hiding is not achieved as the code is all exposed in the header.</li>
</ol>

===Evolution of Generics===
Here we take Java programming language as an example to explain evolution of generics. Generics were introduced with Java 1.5. However, before that, the codes were bulky and messy but the results were same. Rather than simply using a List<Integer> or Comparable<String>, developers had to deal with a significant amount of inheritance, casting, and instanceof testing. For example, an ArrayList to store only Integers pre-generics might look like the below snippet:
<pre>
public class IntegerList extends ArrayList{
public boolean add(Object o){
if(o instanceof Integer)
return super.add(o);
return false;
}

public Integer get(int index){
return (Integer)super.get(index);
}
}

</pre>
Generics allows to write more modular and reusable code that is adaptable to various datatypes, yet logically restrictive as well. Currently, generics are implemented using erasure, which means that the generic type information is not available at runtime, which makes some kind of code hard to write. Generics were implemented this way to support backwards compatibility with older non-generic code. Reified generics would make the generic type information available at runtime, which would break legacy non-generic code. Generics are implemented using erasure, in which generic type parameters are simply removed at runtime. That doesn't render generics useless, because you get typechecking at compile-time based on the generic type parameters, and also because the compiler inserts casts in the code based on the type parameters.
==Erasure v/s Reification==

Consider the below example, it won't work because of erasure.

<pre>
public class Test<Key, Val> {
public void test(Key key) {
}

public void test(Val value) {
}
}
</pre>
This would give a name clash error for having same erasure and one way to avoid the error is by renaming the method name but this will not the serve the purpose of overloading. Similarly, the below example would give errors because the JVM is not aware of the type T instead views it just as an Object.
<pre>
public class Test {
public <T> void f() {
T t = new T();
}
}
</pre>
So reified generics have support in the compiler for preserving type information whereas type erased generics don't have and that "remember" the class they were created with during runtime. Below are some of the reasons why Java should have reified generics:
<ol>
<li>Type argument erasure cripples frameworks that works with generic types and this results in horrid workarounds</li>
<li>Reified generics allows Typesafe narrowing. Currently in Java, we first test the type of the object using the instanceof operator, and then attempt to downcast it using a C-style typecast</li>
<li>Interoperability between statically-typed is difficult since few support reified generics.</li>
</ol>

But at the same time reified generics have issues and one of the main concern is incompatible with the current collections. So a test on <code>instanceof List<String></code> would now test that the object is an instance of <code>List</code> but also that its elements are of type <code>String</code>. This requires a lot of work around since we need to distinguish between collections making used of reified types from their older types.

==Reference==
<ol>
<li>http://en.wikipedia.org/wiki/Generic_programming</li>

<li>http://en.wikipedia.org/wiki/Generics_in_Java</li>

<li>http://www.oracle.com/technetwork/articles/javase/generics-136597.html</li>

<li>http://download.oracle.com/javase/tutorial/extra/generics/methods.html</li>

<li>http://www.cplusplus.com/doc/tutorial/templates/</li>

<li>http://en.wikipedia.org/wiki/Template_(programming)</li>

<li>http://www.cs.binghamton.edu/~mike/presentations/java-generics-cs580c-fall-2007.pdf</li>

<li>http://jnb.ociweb.com/jnb/jnbJul2003.html</li>

<li>http://tech.puredanger.com/java7/#reified</li>

<li>http://gafter.blogspot.com/2006/11/reified-generics-for-java.html</li>

<li>http://relation.to/21406.lace</li>

<li>http://beust.com/weblog/2011/07/29/erasure-vs-reification/</li>

</ol>

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-17T17:24:05Z

Jnvarava:

==Generic Programming==
Generic programming is a style of computer programming in which algorithms are written in terms of to-be-specified-later types that are then instantiated when needed for specific types provided as parameters. This enables writing common set of functions which differ only in the types on which they operate. This reduces duplication. Software entities created using generic programming are known as ''generics'' in [http://en.wikipedia.org/wiki/Ada_(programming_language) Ada], [http://en.wikipedia.org/wiki/Eiffel_(programming_language) Eiffel], [http://en.wikipedia.org/wiki/Java_(programming_language) Java], [http://en.wikipedia.org/wiki/C_Sharp_(programming_language) C#], [http://en.wikipedia.org/wiki/F_Sharp_(programming_language) F#], and [http://en.wikipedia.org/wiki/Visual_Basic_.NET Visual Basic .NET]; parametric polymorphism in [http://en.wikipedia.org/wiki/ML_(programming_language) ML], [http://en.wikipedia.org/wiki/Scala_(programming_language Scala] and [http://en.wikipedia.org/wiki/Haskell_(programming_language) Haskell], [http://en.wikipedia.org/wiki/template_(programming) template]s in [http://en.wikipedia.org/wiki/C++ C++].

For example, given various data structures and several algorithms, the brute force way would be implement them for each data structure which would mean that various combinations of implementations will be necessary. Generic programming reduces this effort.


==Generics in Java==
===What are Generics?===
Generics were added to Java programming language as a part of J2SE 5.0 release in 2004. They allow programmers to develop generic and compile safe applications which enables a type or method to operate on objects of various type. This feature is well utilized while implementing [http://en.wikipedia.org/wiki/Java_Collections Java Collections]. The reason why people went into generic programming can be well explained using the below example:
<pre>
List list = new ArrayList();
list.add("name");
Integer num = (Integer)list.get(0);
</pre>
In this example, we insert a <code>String</code> into an <code>ArrayList</code> and retrieve element by typecasting with Integer wrapper class. This throws a runtime exception because of Illegal class cast. But if we use generics, runtime exceptions can be avoided and the compiler will be able to catch such issues which in turn help a programmer to build a bug free code. So if we convert the above code to use generic then it would look like this:
<pre>
List<String> list = new ArrayList<String>();
list.add("name");
Integer num = list.get(0); //line 1
</pre>
Here at line 1 the compiler throws an error because the compiler on seeing the declaration of ArrayList will be expecting the list to have just <code>String</code> and thereby the return type of <code>get</code> to be <code>String</code>.

===Implementing Generics:===
Java provides a feature which helps one to implement your own generic types and this will help to build more sophisticated and runtime error free applications. Consider the below example:
<code>
interface List<N> {
void add(N i);
Iterator<N> iterator();
}
interface Iterator<N> {
N next();
boolean hasNext();
}
class LinkedList<N> implements List<N> {
//Business Logic
}
</code>
So here, <code>N</code> can be replaced with any primitive data types or wrapper classes in the business logic. But we need to make sure that placeholders to be replaced with valid subtypes of Object. Generics implementation is not restricted for classes or interfaces, we can have for static/non static methods and constructors.

Example for generic methods:

<pre>
<T> void fromArrayToCollection(T[] a, Collection<T> c) {
for (T o : a) {
c.add(o); // Correct
}
}
</pre>
===Pros and Cons===
Pros:
<ol>
<li>Reduces the number of casts in the program, which in turn reduces the number of potential bugs in the program.</li>
<li>Improves code clarity and maintenance.</li>
</ol>
Cons:
<ol>
<li>Parameter type information is not available at run time.</li>
<li>The automatically generated casts may fail when interoperating with ill-behaved legacy code.</li>
</ol>

==Templates in C++==
===What are templates?===
Templates are functions that can operate with generic types which means that the functionality can be adapted for more than one type of data without repeating the entire code for each type.

===Overview===
Templates can be either function templates or class templates.
====Function Templates====
These are just like regular functions except that they can have arguments of different types. A single function definition works with different kinds of data types. During compile time, the actual functions are generated once the compiler knows the data type being used. This kind of template does not save any memory.

Example
<pre>
template <typename Type>
Type max(Type a, Type b) {
return a > b ? a : b;
}

#include <iostream>

int main()
{
// This will call max <int> (by argument deduction)
std::cout << max(3, 7) << std::endl;
// This will call max<double> (by argument deduction)
std::cout << max(3.0, 7.0) << std::endl;
// This type is ambiguous, so explicitly instantiate max<double>
std::cout << max<double>(3, 7.0) << std::endl;
return 0;
}
</pre>

====Class Templates====
A class template provides a specification for generating classes based on parameters. A class template is instantiated by passing a given set of types to it as template arguments.

Example
<pre>
template <class T>
class mypair {
T values [2];
public:
mypair (T first, T second)
{
values[0]=first; values[1]=second;
}
};
</pre>

===Features of C++ Templates===
Some of the features of C++ templates are:
<ol>
<li>
Implemented in the compiler.<ol><ul>No runtime overhead</ul><ul>Requires template source to be in headers</ul><ul>Latent typing means template instantiator does no type checking</ul></ol>
</li>
<li>Gloriﬁed macro facility<ol><ul>“Macros done right”/“Macros that look like classes”</ul></ol></li>
<li>
Can use template arguments for both classes and straight function</li>
<li>Template specialization<ol><ul>Speciﬁc implementation of a templated type or method</ul></ol></li>
<li>Pattern matching and text replacement<ol><ul>Declarative model (like [http://en.wikipedia.org/wiki/Prolog Prolog])</ul></ol></li>
</ol>

===Pros and Cons===
Usage of templates have both advantages and disadvantages.

Pros
<ol>
<li>Reduction in code size.</li>
<li>They are type-safe, that is, type-checking is done at compile time.</li>
</ol>

Cons
<ol>
<li>Since all compilers are not good at their support for templates, they may not be very portable.</li>
<li>Compilers generate additional code for each template type, this could lead to huge code if usage of templates is not checked.</li>
<li>Information hiding is not achieved as the code is all exposed in the header.</li>
</ol>

==Evolution of Generics==
Here we take Java programming language as an example to explain evolution of generics. Generics were introduced with Java 1.5. However, before that, the codes were bulky and messy but the results were same. Rather than simply using a List<Integer> or Comparable<String>, developers had to deal with a significant amount of inheritance, casting, and instanceof testing. For example, an ArrayList to store only Integers pre-generics might look like the below snippet:
<pre>
public class IntegerList extends ArrayList{
public boolean add(Object o){
if(o instanceof Integer)
return super.add(o);
return false;
}

public Integer get(int index){
return (Integer)super.get(index);
}
}

</pre>
Generics allows to write more modular and reusable code that is adaptable to various datatypes, yet logically restrictive as well. Currently, generics are implemented using erasure, which means that the generic type information is not available at runtime, which makes some kind of code hard to write. Generics were implemented this way to support backwards compatibility with older non-generic code. Reified generics would make the generic type information available at runtime, which would break legacy non-generic code. Generics are implemented using erasure, in which generic type parameters are simply removed at runtime. That doesn't render generics useless, because you get typechecking at compile-time based on the generic type parameters, and also because the compiler inserts casts in the code based on the type parameters.
==Erasure v/s Reification==

Consider the below example, it won't work because of erasure.

<pre>
public class Test<Key, Val> {
public void test(Key key) {
}

public void test(Val value) {
}
}
</pre>
This would give a name clash error for having same erasure and one way to avoid the error is by renaming the method name but this will not the serve the purpose of overloading. Similarly, the below example would give errors because the JVM is not aware of the type T instead views it just as an Object.
<pre>
public class Test {
public <T> void f() {
T t = new T();
}
}
</pre>
So reified generics have support in the compiler for preserving type information whereas type erased generics don't have and that "remember" the class they were created with during runtime. Below are some of the reasons why Java should have reified generics:
<ol>
<li>Type argument erasure cripples frameworks that works with generic types and this results in horrid workarounds</li>
<li>Reified generics allows Typesafe narrowing. Currently in Java, we first test the type of the object using the instanceof operator, and then attempt to downcast it using a C-style typecast</li>
<li>Interoperability between statically-typed is difficult since few support reified generics.</li>
</ol>

But at the same time reified generics have issues and one of the main concern is incompatible with the current collections. So a test on instanceof List<String> would now test that the object is an instance of List but also that its elements are of type String. This requires a lot of work around since we need to distinguish between collections making used of reified types from their older types.

==Reference==
<ol>
<li>http://en.wikipedia.org/wiki/Generic_programming</li>

<li>http://en.wikipedia.org/wiki/Generics_in_Java</li>

<li>http://www.oracle.com/technetwork/articles/javase/generics-136597.html</li>

<li>http://download.oracle.com/javase/tutorial/extra/generics/methods.html</li>

<li>http://www.cplusplus.com/doc/tutorial/templates/</li>

<li>http://en.wikipedia.org/wiki/Template_(programming)</li>

<li>http://www.cs.binghamton.edu/~mike/presentations/java-generics-cs580c-fall-2007.pdf</li>

<li>http://jnb.ociweb.com/jnb/jnbJul2003.html</li>

<li>http://tech.puredanger.com/java7/#reified</li>

<li>http://gafter.blogspot.com/2006/11/reified-generics-for-java.html</li>

<li>http://relation.to/21406.lace</li>

<li>http://beust.com/weblog/2011/07/29/erasure-vs-reification/</li>

</ol>

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-17T15:55:32Z

Jnvarava: /* Pros and Cons */

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-17T14:51:22Z

Jnvarava: /* Pros and Cons */

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-17T14:50:47Z

Jnvarava: /* Reference */

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-17T14:50:08Z

Jnvarava: /* Generics in Java */

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-17T14:33:22Z

Jnvarava: /* Generics in Java? */

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-17T14:29:01Z

Jnvarava: /* Generics in Java? */

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-13T22:35:47Z

Jnvarava: /* What are Generics in Java? */

==What are Generics in Java?==
Generics were added to Java programming language as a part of J2SE 5.0 release in 2004. They allow programmers to develop generic and compile safe applications which enables a type or method to operate on objects of various type. This feature is well utilized while implementing [http://en.wikipedia.org/wiki/Java_Collections Java Collections]. The reason why people went into generic programming can be well explained using the below example:
<code>
List list = new ArrayList();
list.add("name");
Integer num = (Integer)list.get(0);
</code>
In this example, we insert a <code>String</code> into an <code>ArrayList</code> and retrieve element by typecasting with Integer wrapper class. This throws a runtime exception because of Illegal class cast. But if we use generics, runtime exceptions can be avoided and the compiler will be able to catch such issues which in turn help a programmer to build a bug free code. So if we convert the above code to use generic then it would look like this:
<code>
List<String> list = new ArrayList<String>();
list.add("name");
Integer num = list.get(0); //line 1
</code>
Here at line 1 the compiler throws an error because the compiler on seeing the declaration of ArrayList will be expecting the list to have just <code>String</code> and thereby the return type of <code>get</code> to be <code>String</code>.

'''Implementing Generics:'''
Java provides a feature which helps one to implement your own generic types and this will help to build more sophisticated and runtime error free applications. Consider the below example:
<code>
interface List<N> {
void add(N i);
Iterator<N> iterator();
}
interface Iterator<N> {
N next();
boolean hasNext();
}
class LinkedList<N> implements List<N> {
//Business Logic
}
</code>
So here, <code>N</code> can be replaced with any primitive data types or wrapper classes in the business logic. But we need to make sure that placeholders to be replaced with valid subtypes of Object. Generics implementation is not restricted for classes or interfaces, we can have for static/non static methods and constructors.

Example for generic methods:

<code>

static <T> void fromArrayToCollection(T[] a, Collection<T> c) {
for (T o : a) {
c.add(o); // Correct
}
}
</code>

==Reference==
1. http://en.wikipedia.org/wiki/Generics_in_Java

2. http://www.oracle.com/technetwork/articles/javase/generics-136597.html

3. http://download.oracle.com/javase/tutorial/extra/generics/methods.html

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-13T22:33:50Z

Jnvarava: /* Reference */

==What are Generics in Java?==
Generics were added to Java programming language as a part of J2SE 5.0 release in 2004. They allow programmers to develop generic and compile safe applications which enables a type or method to operate on objects of various type. This feature is well utilized while implementing [http://en.wikipedia.org/wiki/Java_Collections Java Collections]. The reason why people went into generic programming can be well explained using the below example:
<code>
List list = new ArrayList();
list.add("name");
Integer num = (Integer)list.get(0);
</code>
In this example, we insert a <code>String</code> into an <code>ArrayList</code> and retrieve element by typecasting with Integer wrapper class. This throws a runtime exception because of Illegal class cast. But if we use generics, runtime exceptions can be avoided and the compiler will be able to catch such issues which in turn help a programmer to build a bug free code. So if we convert the above code to use generic then it would look like this:
<code>
List<String> list = new ArrayList<String>();
list.add("name");
Integer num = list.get(0); //line 1
</code>
Here at line 1 the compiler throws an error because the compiler on seeing the declaration of ArrayList will be expecting the list to have just <code>String</code> and thereby the return type of <code>get</code> to be <code>String</code>.

'''Implementing Generics:'''
Java provides a feature which helps one to implement your own generic types and this will help to build more sophisticated and runtime error free applications. Consider the below example:
<code>
interface List<N> {
void add(N i);
Iterator<N> iterator();
}
interface Iterator<N> {
N next();
boolean hasNext();
}
class LinkedList<N> implements List<N> {
//Business Logic
}
</code>
So here, <code>N</code> can be replaced with any primitive data types or wrapper classes in the business logic. But we need to make sure that placeholders to be replaced with valid subtypes of Object. Generics implementation is not restricted for classes or interfaces, we can have for static/non static methods and constructors.

==Reference==
1. http://en.wikipedia.org/wiki/Generics_in_Java

2. http://www.oracle.com/technetwork/articles/javase/generics-136597.html

3. http://download.oracle.com/javase/tutorial/extra/generics/methods.html

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-13T22:33:39Z

Jnvarava: /* What are Generics in Java? */

==What are Generics in Java?==
Generics were added to Java programming language as a part of J2SE 5.0 release in 2004. They allow programmers to develop generic and compile safe applications which enables a type or method to operate on objects of various type. This feature is well utilized while implementing [http://en.wikipedia.org/wiki/Java_Collections Java Collections]. The reason why people went into generic programming can be well explained using the below example:
<code>
List list = new ArrayList();
list.add("name");
Integer num = (Integer)list.get(0);
</code>
In this example, we insert a <code>String</code> into an <code>ArrayList</code> and retrieve element by typecasting with Integer wrapper class. This throws a runtime exception because of Illegal class cast. But if we use generics, runtime exceptions can be avoided and the compiler will be able to catch such issues which in turn help a programmer to build a bug free code. So if we convert the above code to use generic then it would look like this:
<code>
List<String> list = new ArrayList<String>();
list.add("name");
Integer num = list.get(0); //line 1
</code>
Here at line 1 the compiler throws an error because the compiler on seeing the declaration of ArrayList will be expecting the list to have just <code>String</code> and thereby the return type of <code>get</code> to be <code>String</code>.

'''Implementing Generics:'''
Java provides a feature which helps one to implement your own generic types and this will help to build more sophisticated and runtime error free applications. Consider the below example:
<code>
interface List<N> {
void add(N i);
Iterator<N> iterator();
}
interface Iterator<N> {
N next();
boolean hasNext();
}
class LinkedList<N> implements List<N> {
//Business Logic
}
</code>
So here, <code>N</code> can be replaced with any primitive data types or wrapper classes in the business logic. But we need to make sure that placeholders to be replaced with valid subtypes of Object. Generics implementation is not restricted for classes or interfaces, we can have for static/non static methods and constructors.

==Reference==
1. http://en.wikipedia.org/wiki/Generics_in_Java

2. http://www.oracle.com/technetwork/articles/javase/generics-136597.html

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-13T22:17:07Z

Jnvarava: /* What are Generics in Java? */

==What are Generics in Java?==
Generics were added to Java programming language as a part of J2SE 5.0 release in 2004. They allow programmers to develop generic and compile safe applications which enables a type or method to operate on objects of various type. This feature is well utilized while implementing [http://en.wikipedia.org/wiki/Java_Collections Java Collections]. The reason why people went into generic programming can be well explained using the below example:
<code>
List list = new ArrayList();
list.add("name");
Integer num = (Integer)list.get(0);
</code>
In this example, we insert a <code>String</code> into an <code>ArrayList</code> and retrieve element by typecasting with Integer wrapper class. This throws a runtime exception because of Illegal class cast. But if we use generics, runtime exceptions can be avoided and the compiler will be able to catch such issues which in turn help a programmer to build a bug free code. So if we convert the above code to use generic then it would look like this:
<code>
List<String> list = new ArrayList<String>();
list.add("name");
Integer num = list.get(0); //line 1
</code>
Here at line 1 the compiler throws an error because the compiler on seeing the declaration of ArrayList will be expecting the list to have just <code>String</code> and thereby the return type of <code>get</code> to be <code>String</code>.

'''Implementing Generics:'''
Java provides a feature which helps one to implement your own generic types and this will help to build more sophisticated and runtime error free applications. Consider the below example:
<code>
interface List<N> {
void add(N i);
Iterator<N> iterator();
}
interface Iterator<N> {
N next();
boolean hasNext();
}
class LinkedList<N> implements List<N> {
//Business Logic
}
</code>
So here, <code>N</code> can be replaced with any primitive data types or wrapper classes in the business logic. But we need to make sure that placeholders to be replaced with valid subtypes of Object.

==Reference==
1. http://en.wikipedia.org/wiki/Generics_in_Java

2. http://www.oracle.com/technetwork/articles/javase/generics-136597.html

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-13T22:04:46Z

Jnvarava: /* What are Generics in Java? */

==What are Generics in Java?==
Generics were added to Java programming language as a part of J2SE 5.0 release in 2004. They allow programmers to develop generic and compile safe applications which enables a type or method to operate on objects of various type. This feature is well utilized while implementing [http://en.wikipedia.org/wiki/Java_Collections Java Collections]. The reason why people went into generic programming can be well explained using the below example:
<code>
List list = new ArrayList();
list.add("name");
Integer num = (Integer)list.get(0);
</code>
In this example, we insert a <code>String</code> into an <code>ArrayList</code> and retrieve element by typecasting with Integer wrapper class. This throws a runtime exception because of Illegal class cast. But if we use generics, runtime exceptions can be avoided and the compiler will be able to catch such issues which in turn help a programmer to build a bug free code. So if we convert the above code to use generic then it would look like this:
<code>
List<String> list = new ArrayList<String>();
list.add("name");
Integer num = list.get(0); //line 1
</code>
Here at line 1 the compiler throws an error because the compiler on seeing the declaration of ArrayList will be expecting the list to have just <code>String</code> and thereby the return type of <code>get</code> to be <code>String</code>.

'''Implementing Generics:'''
Java provides a feature which helps one to implement your own generic types and this will help to build more sophisticated and runtime error free applications. Consider the below example:
<code>
interface List<N> {
void add(N i);
Iterator<N> iterator();
}

interface Iterator<N> {
N next();
boolean hasNext();
}

class LinkedList<N> implements List<N> {
//Business Logic
}
</code>

==Reference==
1. http://en.wikipedia.org/wiki/Generics_in_Java

2. http://www.oracle.com/technetwork/articles/javase/generics-136597.html

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-13T21:59:00Z

Jnvarava: /* Reference */

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-13T21:58:47Z

Jnvarava: /* Reference */

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-13T21:58:36Z

Jnvarava: /* What are Generics in Java? */

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-13T21:52:21Z

Jnvarava: /* What are Generics in Java? */

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-13T21:51:54Z

Jnvarava: /* What are Generics in Java? */

CSC/ECE 517 Fall 2011/ch6 6c sj

2011-11-13T20:10:21Z

Jnvarava: Created page with "==What are Generics in Java?== Generics were added to Java programming language as a part of J2SE 5.0 release in 2004. ==Reference== 1. http://en.wikipedia.org/wiki/Generics_..."

==What are Generics in Java?==
Generics were added to Java programming language as a part of J2SE 5.0 release in 2004.

==Reference==
1. http://en.wikipedia.org/wiki/Generics_in_Java

CSC/ECE 517 Fall 2011

2011-11-13T19:39:46Z

Jnvarava:

[[Link title]]
*[[CSC/ECE 517 Fall 2011/ch1 1a ms]]

*[[CSC/ECE 517 Fall 2011/ch1 1a cs]]

*[[CSC/ECE 517 Fall 2011/ch1 1a ri]]

*[[CSC/ECE 517 Fall 2011/ch1 1a lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1b sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1b ds]]

*[[CSC/ECE 517 Fall 2011/ch1 1b tj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c cm]]

*[[CSC/ECE 517 Fall 2011/ch1 1c sj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c ka]]

*[[CSC/ECE 517 Fall 2011/ch1 1d sr]]

*[[CSC/ECE 517 Fall 2011/ch1 1e vs]]

*[[CSC/ECE 517 Fall 2011/ch1 1e aa]]

*[[CSC/ECE 517 Fall 2011/ch1 1a sc]]

*[[CSC/ECE 517 Fall 2011/ch1 1e dm]]

*[[CSC/ECE 517 Fall 2011/ch1 1e an]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1e lm]]

*[[CSC/ECE 517 Fall 2011/ch1 1g vn]]

*[[CSC/ECE 517 Fall 2011/ch1 1f rs]]

*[[CSC/ECE 517 Fall 2011/ch1 1f sv]]

*[[CSC/ECE 517 Fall 2011/ch1 1g jn]]

*[[CSC/ECE 517 Fall 2011/ch1 1h ps]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sm]]

*[[CSC/ECE 517 Fall 2011/ch1 1i zf]]

*[[CSC/ECE 517 Fall 2011/ch1 1g rn]]

*[[CSC/ECE 517 Fall 2011/ch1 1i cl]]

*[[CSC/ECE 517 Fall 2011/ch1 1d ss]]

*[[CSC/ECE 517 Fall 2011/ch1 1i lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1h hs]]

*[[CSC/ECE 517 Fall 2011/ch1 1d gs]]

*[[CSC/ECE 517 Fall 2011/ch1 2b ns]]

*[[CSC/ECE 517 Fall 2011/ch1 2b jp]]

*[[CSC/ECE 517 Fall 2011/ch1 2a av]]

*[[CSC/ECE 517 Fall 2011/ch2 2f jm]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ad]]

*[[CSC/ECE 517 Fall 2011/ch2 2e kt]]

*[[CSC/ECE 517 Fall 2011/ch2 2e gp]]

*[[CSC/ECE 517 Fall 2011/ch1 2b qu]]

*[[CSC/ECE 517 Fall 2011/ch2 2c bs]]

*[[CSC/ECE 517 Fall 2011/ch1 2c rs]]

*[[CSC/ECE 517 Fall 2011/ch1 2a ca]]

*[[CSC/ECE 517 Fall 2011/ch1 2b rv]]

*[[CSC/ECE 517 Fall 2011/ch2 2c ds]]

*[[CSC/ECE 517 Fall 2011/ch2 2b sa]]

*[[CSC/ECE 517 Fall 2011/ch2 2f mm]]

*[[CSC/ECE 517 Fall 2011/ch2 2f vh]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ps]]

*[[CSC/ECE 517 Fall 2011/ch3 3a oe]]

*[[CSC/ECE 517 Fall 2011/ch3 3h rr]]

*[[CSC/ECE 517 Fall 2011/ch3 3h ss]]

*[[CSC/ECE 517 Fall 2011/ch3 4b js]]

*[[CSC/ECE 517 Fall 2011/ch3 4b ms]]

*[[CSC/ECE 517 Fall 2011/ch4 4b ds]]

*[[CSC/ECE 517 Fall 2011/ch4 4i aa]]

*[[CSC/ECE 517 Fall 2011/ch4 4i sd]]

*[[CSC/ECE 517 Fall 2011/ch4 4d mt]]

*[[CSC/ECE 517 Fall 2011/ch4 4d ls]]

*[[CSC/ECE 517 Fall 2011/ch4 4d ch]]

*[[CSC/ECE 517 Fall 2011/ch4 4c ap]]

*[[CSC/ECE 517 Fall 2011/ch4 4h sv]]

*[[CSC/ECE 517 Fall 2011/ch4 4e cl]]

*[[CSC/ECE 517 Fall 2011/ch4 4e gs]]

*[[CSC/ECE 517 Fall 2011/ch4 4a ga]]

*[[CSC/ECE 517 Fall 2011/ch4 4f sl]]

*[[CSC/ECE 517 Fall 2011/ch4 4i js]]

*[[CSC/ECE 517 Fall 2011/ch4 4f ss]]

*[[CSC/ECE 517 Fall 2011/ch4 4c dm]]

*[[CSC/ECE 517 Fall 2011/ch4 4g as]]

*[[CSC/ECE 517 Fall 2011/ch4 4g nv]]

*[[CSC/ECE 517 Fall 2011/ch4 4g ms]]

*[[CSC/ECE 517 Fall 2011/ch4 4h kp]]

*[[CSC/ECE 517 Fall 2011/ch4 4h as]]

*[[CSC/ECE 517 Fall 2011/ch4 4j fw]]

*[[CSC/ECE 517 Fall 2011/ch4 4f rs]]

*[[CSC/ECE 517 Fall 2011/ch4 4i lc]]

*[[CSC/ECE 517 Fall 2011/ch17 5b uo]]

*[[CSC/ECE 517 Fall 2011/ch17 5b br]]

*[[CSC/ECE 517 Fall 2011/ch5 5d he]]

*[[CSC/ECE 517 Fall 2011/ch5 6d ny]]

*[[CSC/ECE 517 Fall 2011/ch6 6d sk]]

*[[CSC/ECE 517 Fall 2011/ch6 6e ch]]

*[[CSC/ECE 517 Fall 2011/ch6 6b ra]]

*[[CSC/ECE 517 Fall 2011/ch6 6c sj]]

*[[trial]]