| Andrew Cooke | Contents | Latest | RSS | Twitter | Previous | Next

C[omp]ute

Welcome to my blog, which was once a mailing list of the same name and is still generated by mail. Please reply via the "comment" links.

Always interested in offers/projects/new ideas. Eclectic experience in fields like: numerical computing; Python web; Java enterprise; functional languages; GPGPU; SQL databases; etc. Based in Santiago, Chile; telecommute worldwide. CV; email.

Personal Projects

Lepl parser for Python.

Colorless Green.

Photography around Santiago.

SVG experiment.

Professional Portfolio

Calibration of seismometers.

Data access via web services.

Cache rewrite.

Extending OpenSSH.

Last 100 entries

LPIR - Steganography in Practice; How I Am 6; Clear Explanation of Verizon / Level 3 / Netflix; Teenage Girls; Formalising NSA Attacks; Switching Brakes (Tektro Hydraulic); Naim NAP 100 (Power Amp); AKG 550 First Impressions; Facebook manipulates emotions (no really); Map Reduce "No Longer Used" At Google; Removing RAID metadata; New Bike (Good Bike Shop, Santiago Chile); Removing APE Tags in Linux; Compiling Python 3.0 With GCC 4.8; Maven is Amazing; Generating Docs from a GitHub Wiki; Modular Shelves; Bash Best Practices; Good Emergency Gasfiter (Santiago, Chile); Readings in Recent Architecture; Roger Casement; Integrated Information Theory (Or Not); Possibly undefined macro AC_ENABLE_SHARED; Update on Charges; Sunburst Visualisation; Spectral Embeddings (Distances -> Coordinates); Introduction to Causality; Filtering To Help Colour-Blindness; ASUS 1015E-DS02 Too; Ready Player One; Writing Clear, Fast Julia Code; List of LatAm Novels; Running (for women); Building a Jenkins Plugin and a Jar (for Command Line use); Headphone Test Recordings; Causal Consistency; The Quest for Randomness; Chat Wars; Real-life Financial Co Without ACID Database...; Flexible Muscle-Based Locomotion for Bipedal Creatures; SQL Performance Explained; The Little Manual of API Design; Multiple Word Sizes; CRC - Next Steps; FizzBuzz; Update on CRCs; Decent Links / Discussion Community; Automated Reasoning About LLVM Optimizations and Undefined Behavior; A Painless Guide To CRC Error Detection Algorithms; Tests in Julia; Dave Eggers: what's so funny about peace, love and Starship?; Cello - High Level C Programming; autoreconf needs tar; Will Self Goes To Heathrow; Top 5 BioInformatics Papers; Vasovagal Response; Good Food in Vina; Chilean Drug Criminals Use Subsitution Cipher; Adrenaline; Stiglitz on the Impact of Technology; Why Not; How I Am 5; Lenovo X240 OpenSuse 13.1; NSA and GCHQ - Psychological Trolls; Finite Fields in Julia (Defining Your Own Number Type); Julian Assange; Starting Qemu on OpenSuse; Noisy GAs/TMs; Venezuela; Reinstalling GRUB with EFI; Instructions For Disabling KDE Indexing; Evolving Speakers; Changing Salt Size in Simple Crypt 3.0.0; Logarithmic Map (Moved); More Info; Words Found in Voynich Manuscript; An Inventory Of 3D Space-Filling Curves; Foxes Using Magnetic Fields To Hunt; 5 Rounds RC5 No Rotation; JP Morgan and Madoff; Ori - Secure, Distributed File System; Physical Unclonable Functions (PUFs); Prejudice on Reddit; Recursion OK; Optimizing Julia Code; Cash Handouts in Brazil; Couple Nice Music Videos; It Also Works!; Adaptive Plaintext; It Works!; RC5 Without Rotation (2); 8 Years...; Attack Against Encrypted Linux Disks; Pushing Back On NSA At IETF; Summary of Experimental Ethics; Very Good Talk On Security, Snowden; Locusts are Grasshoppers!; Vagrant (OpenSuse and IDEs); Interesting Take On Mandela's Context; Haskell Cabal O(n^2) / O(n) Fix; How I Am 4

© 2006-2013 Andrew Cooke (site) / post authors (content).

Java Generics: A Review

From: "andrew cooke" <andrew@...>

Date: Sat, 13 Jan 2007 01:03:04 -0300 (CLST)

This is the first draft of a review for Slashdot.


Background to Generics

If you're a Java programmer you've probably heard of generics, an
extension to the type system that was introduced in Java 5.  They give
you, as a programmer, a way to write code even when you don't know exactly
what classes will be used.

The obvious example is collections - the author of a List class has no
idea what type of objects will be stored when the code is used.

Before generics, if you wanted to write code that handled unknown
classes you had to use make use of inheritance: write the code as if it
would get Objects, and then let the caller cast the result as
necessary.  Since casts happen at runtime any mistakes may cause a runtime
error (a ClassCastException).

Generics fix this.  They let you treat write code in which the classes are
named (a parameter) and the compiler can then check that the use of these
class parameters is consistent in your program.  So if you have a List of
Foo instances you write List<Foo> and the compiler
knows that when you read that list you will receive a Foo, not an
Object.


History

I'll get to the book in a moment, but first a little history.  If you know
any type theory - particularly as used in functional languages like ML and
Haskell - then you'll recognise it as "parametric
polymorphism".  You'll also know that it is incredibly useful, and wonder
how Java programmers could ever have managed without it.

Which explains why Philp Wadler, one of the people responsible for
Haskell, was part of a team that wrote GJ (Generic Java), one of the
experimental Java mutations (others included PJ and Pizza) that, back in
the day (late 90s) helped explore how parametric polymorphism could be
added to Java, and which formed the basis for the generics
introduced in Java 5.

So if you want to understand generics, Wadler is your man.  Which, in
turn, explains why I jumped at the chance to review O'Reilly's `Java
Generics and Collections', by Maurice Naftalin and Philip Wadler.


The Book

This is a moderately slim book (just under 300 pages).  It looks like any
other O'Reilly work - the animal is an Alligator this time.  It's well
organised, easy to read, and has a decent index.

There's an odd discrepancy, though: Wadler is the generics Guru; this is
going to be `the generics reference'; generics are sexy (in
relative terms - we're talking Java here) and collections are not; the
title has "Java Generics" in great big letters with "and Collections" in
little tiny ones down in a corner.  Yet very nearly half this book is
dedicated to collections.

So in the next section I'll justify the `reference' comment above, and in
the one after I'll take a look at the collections half of the book and ask
to what extent it's padding.


Part I - Generics

This is a great, practical read.  It starts simply, introducing a
range of new features in Java 5, and then builds rapidly.

If you are completely new to generics, you'll want to read slowly.
Everything is here, and it's very clear and friendly, but there are not
the chapters of simple, repeated examples you might find a fatter book. 
Within just 30 pages you meet pretty much all of generics,
including wildcards and constraints.

If that makes your head spin, don't worry.  Read on.  The next hundred or
so pages don't introduce any new syntax, but instead discuss a wide range
of related issues.  The chapters on "Comparisons and Bounds" and
"Declarations" contain more examples that will help clarify what
generics do.  And the following chapters on "Evolution",
"Reification", and "Reflection" will explain exactly why.

So the first seven chapters introduce generics and then justify the
implementation - any programmer that takes the time to understand this
will have a very solid base in generics.

The next two chapters, however, were my favourites.  "Effective Generics"
and "Design Patterns" give sensible, practical advice on using generics in
your work, including the best explanation of <X extends Foo<X>> I've seen
yet (so if you don't know what I am talking about here, read the book).

(A practical note here - if at all possible, use Java 6 with generics.
Java 5 had some sneaky bugs).


Part II - Collections

This part of the book was more along O'Reilly's `Nutshell' lines: the
different chapters explore different collection types in detail.  I must
admit that at first I skipped this - it looked like API docs
re-hashed to extend the size of the book.

But then I felt bad, because I was supposed to be reviewing this book
(full disclosure: if you review a book for Slashdot you get to keep it). 
And you know what?  It turned out to be pretty interesting.
I've programmed in Java for (too many) years, and I guess I've not been
quite as dedicated to tracking how the librray has changed as I should
have - I learnt a lot.

The way I see it now, this part is a bonus: the first half, on
generics, makes this book one of the standards; the second half is an
extra treat I'm glad I stumbled across (I guess if you're some kind of
collection-fetish maybe it's even worth buying the book for).


Conclusions

I've used generics since the first beta release of Java 5 and had
experience with parametric polymorphism in functional languages before
that (in other words, I can tell my co- from my contra-variance).  So I
guess I'm heading towards the more expert end of the spectrum and I was
worried I'd find the book boring.  It wasn't.  After claiming to be expert
I don't want to spoil things with evidence that I'm actually stupid, but
reading this book cleared up a few `misunderstandings' I'd had.  I wish I
had read it earlier.

If you're new to generics, and you don't mind thinking, I recommend this
book.  If you're a Java programmer who's a bit confused by "<? super Foo>"
then this is the book for you.

The only people who shouldn't read this are people new to Java.  You need
to go elsewhere first.  This is not a book for beginners.

A great book in the classic - practical, concise and intelligent -
O'Reilly mould.

Andrew

Java Generics: A Review (Final Version)

From: "andrew cooke" <andrew@...>

Date: Sun, 14 Jan 2007 07:35:23 -0300 (CLST)

This has been "pending" on Slashdot all day, so I've put it here -
http://www.acooke.org/andrew/writing/compjava.html#generics

Andrew

Comment on this post