Generics are one of the most complex features of Java. They are often poorly understood and lead to confusing errors. Unfortunately, it won’t get easier. Java 10, release planned for 2018, extends Generics. It’s now time to understand generics or risk being left behind. We start by stepping back into the halcyon days of 2004 and explain why generics were introduced in the first place back. We also explain why Java’s implementation is unique compared to similar features in other programming languages. Then we travel to the present to explaining how to make effective use of Generics. We then explore various entertaining code examples and puzzlers of how Generics are used today. Finally, this talk sheds light on the planned changes in Java 10 with practical code examples and related ideas from other programming languages. If you ever wanted to understand the buzz around higher kinded types or declaration site variance now is your chance!

1. Generics: Past, Present
and Future
@richardwarburto
insightfullogic.com
@raoulUK
cambridgecoding.com

2. binarySearch(List<? extends Comparable<? super T>> list, T key)

3. Past
Present
Future

5. … also generics are added to Java.
Yay!

6. Static Safety Concision
Simplicity
Dynamically Typed
Languages -
Javascript, Ruby,
Python
StringList
Fantom
Generics
Java, Scala, C#, C++
...

7. Past
Present
Future

8. Intersection Types
Curiously Recurring Generics Pattern
Wildcards

9. Intersection
A ∩ B = elements has to be a member of both A and B
Intersection Type
<T extends A & B> = T has to extend A and B

10. <T extends Object & Comparable<? super T>>
T max(Collection<? extends T> coll)

11. A Confusing Intersection Type
<T extends Object & Comparable<? super T>>
T max(Collection<? extends T> coll)
intersection

12. Signature pre-generics
public static Object max(Collection coll)
● max is stuck with this signature to preserve binary
compatibility.
● Can only find the max if the objects are Comparable

13. Type erasure
<T extends Comparable<? super T>>
T max(Collection<? extends T> coll)
Comparable max(Collection coll)
javac compilation

14. Type erasure with intersection
<T extends Object & Comparable<? super T>>
T max(Collection<? extends T> coll)
Object max(Collection coll)
javac compilation

15. Serializable lambdas
<T, U extends Comparable<? super U>> Comparator<T>
comparing(Function<? super T, ? extends U> keyExtractor) {
Objects.requireNonNull(keyExtractor);
return (Comparator<T> & Serializable)
(c1, c2) ->
keyExtractor.apply(c1)
.compareTo(keyExtractor.apply(c2));
}

16. class Enum<E extends Enum<E>>

17. Curiously Recurring Generics Pattern

18. Bounded Wildcards

19. Examples
<T> List<T> unmodifiableList(List<? extends T> list)
<T> int binarySearch(List<? extends T> list, T key,
Comparator<? super T> c)
<T> int binarySearch(List<? extends Comparable<?
super T>> list, T key)

20. It’s all about subtyping!

21. ? super
Commonly used for Functional Interfaces
Comparator<Foo>
always Comparator<? super Foo>
int compare(T o1, T o2);
Comparator<Message> <: Comparator<? super EmailMessage>
Predicate<Foo>
always Predicate<? super Foo>
boolean test(T t);
Predicate<Message> <: Predicate<? super EmailMessage>

22. Adoption and use of Java generics
90% generics use with Collections
○ List<String>, ArrayList<String>,
○ HashMap<String,String>, Set<String>
wildcards 10%
○ Class<?>
http://www.cc.gatech.edu/~vector/papers/generics2.pdf

23. Intersection Types
Curiously Recurring Generics Pattern
Wildcards

24. Past
Present
Future

25. Use-site variance
static void logAllWithAction(List<? extends Message> messages,
Consumer<? super Message> action) {
messages.forEach(action);
}

26. Declaration-site variance
Library:
interface Consumer<? super T> {
void accept(T t);
}
interface StreamStream<? extends T> {
...
}
User code:
static void logAllWithAction(StreamStream<Message> messages,
Consumer<Message> action) {
...
}

27. Declaration-site variance
● User-site variance
○ variance complexity pushed to users
○ can add more verbosity due to annotations
● Declaration-site variance
○ variance complexity pushed to library level
○ List needs to be split in ReadOnly, WriteOnly
○ Adopted by C#, Scala
Improved variance for generic classes and interfaces
http://openjdk.java.net/jeps/8043488

28. Value Types
● “codes like a class, works like an int”
● No Identity
● Just a struct of values

29. Compactness (Less memory)
● No Mark Word
○ Locking
● No klass pointer
● Saving 8-16 bytes depending upon architecture/VM

30. Sequential Locality (Flatness)
0
1
2
...
User
Name
Id
User
0
1
2
...
Name
Id

31. BUT there’s yet generics more complexity
● No Identity, reference equality, locking or condition variables
● So we need to add a new concept to generics
● Explicitly need to opt your generic type into any value:
class ArrayList<any T> implements List<T>

32. Primitive specialisation
List<int> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
State of the Specialization
http://cr.openjdk.java.
net/~briangoetz/valhalla/specialization.html

33. Of interest …
● Unbounded Wildcards
● Type Bounds
● Erasure Problems & Advantages
● Static safety failures
● Other Languages & Features (Lambda Cube)
● Source Code
○ https://github.com/RichardWarburton/generics-examples

34. Conclusions
● Usage patterns change as other features are added
● Generics usage continues to increase in both scale and
complexity
● Most of the complexity burden is on library authors

35. Static Type-safety often involves a tradeoff
between simplicity and flexibility

36. Any Questions?
www.pluralsight.com/author/richard-warburton
cambridgecoding.com
java8training.com
http://manning.com/urma http://tinyurl.com/java8lambdas

37. The End
Richard Warburton
(@richardwarburto)
Raoul-Gabriel Urma
(@raoulUK)

38. Mmmm
Java API
<T> List<T>
unmodifiableList(List<? extends T> list)
vs
<T> List<? extends T>
unmodifiableList(List<? extends T> list)

39. public static <T,K,U,M extends Map<K,U>> Collector<T,?,M>
toMap(Function<? super T,? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper,
BinaryOperator<U> mergeFunction,
Supplier<M> mapSupplier)
From Java 8’s Collectors

41. Higher kinded types
trait Mapable[F[_]] {
def map[A, B](fa: F[A])(f: A => B): F[B]
}
Stream[T] extends Mapable[Stream]
Option[T] extends Mapable[Option]