One can guarantee (to some extent) object cleanup by using a try/finally block, but that puts the responsibility on the consumer of a particular class, not the class’ designer. Obviously the dispose() method comes from the C++ destructor concept, which never really got ported to Java (other than the half-a$$ attempt called finalize().

Generics are wonderful! They increase the readability and intentionality of the code. They allow other people that are using your code to more easily know how to use it, and better than comments they are compile time checked. So, if you don’t know what a collection takes, the generics force you to know.
(By the way, C# 2.0 has Generics and it was just released to MSDN on Oct. 28th)

With Generics:

list.get(i).getValue();

vs. Without Generics:

((MyObject) list.get(i)).getValue();

The other thing is that Generics are not only useful for Collections classes, but can be used by other, more general classes. It allows you to provide general functionality and an implementer to declare their own type safety mechanisms.

public  <T extends Person & Comparable>void doSomething(T person) {
    // ...
}

Again, with something like this you don’t have to test if the object passed in is both a Person and Comparable, you know that the compiler has confirmed this for you.

In the end, I think generics have the possibility of reducing errors and increasing readability of the intentions of the programmer, both of which are Good Things &mark;.

Freedom is needed by good programmers, and freedom helps the programmer to flourish, to dream up solutions that are ever more elegant and useful. Freedom languages are needed by good programmers as an outlet for their personal or open source projects so that they can implement ideas more quickly and with more butter. There is so much risk though in the business(millions$$$$) world that the advantages of freedom languages and features are outweighed.

PROPERTIES

I think properties as an implementation detail may be redundant. They do though have a tendancy to communicate to developers the make-up of a state of an object. The ‘Get’ word can mean different things and has the possibility to confuse what is a method accessing state and what is a method performing some action. The real world command ‘Get me some milk’ can have many different steps behind it, you could be getting in your car and going to the store, or you could be opening the refridgerator, pulling out the milk and checking for it’s expiration. The possibly exists to put many different steps behind a property, for sure, but this is typically done when wanting to present the action as state, rather than action (ahhhh abstraction). Subtle difference? Large difference? What does the tech blogging world or Geoff think?

I CAN’T STAND GENERICS

They make no sense to me. Maybe I haven’t had so much experience with them because .NET doesn’t have a similiar type of thing, but Generics to me go one step too far in the battle for type safety. To me, if you don’t know what is going to be in a certain arraylist then you don’t understand what the system is doing. Generics add COMPLEXITY to development in that you have to think through an extra set of technical implementation details when you really want to be thinking about the problem and how to solve it. The complexity is unneeded and detrimental to a languages ease-of-use.