85.

Web Sites

The IBM developerWorks Javazone contains a wealth of information on Java and many tools to use with it.

http://www.ibm.com/developerworks/java

Javaworld is another great site for information on the Java language.

http://www.javaworld.com

The Java Tutorial includes information on many Java APIs, including Swing, JDBC, graphics, and many other topics.

http://java.sun.com/docs/books/tutorial/

The Patterns home page contains links to many varied resources on patterns and their applications:

http://hillside.net/patterns/

AntiPatterns are patterns of design that have time and again shown themselves to result in errors. Check out the AntiPatterns home page:

http://www.antipatterns.com/

The Extreme Programming home page provides many links to useful resources for that methodology (including links to the xUnit tools):

http://xprogramming.com/

JUnit is the xUnit tool for Java unit testing. It has developed a tremendous amount of popularity:

http://www.junit.org/

The following JavaWorld article I wrote a few years back explains the motivation behind adding generic types to Java, and describes several of the major implementation proposals:

http://www.javaworld.com/javaworld/jw-02-2000/jw-02-jsr.html

One algorithm for higher level program analysis that has helped to automatically identify null-pointer exceptions in other languages is set-based analysis. Here's a pointer to a short introduction on it:

http://www-2.cs.cmu.edu/afs/cs/user/nch/www/sba.html

AspectJ, a tool for aspect-oriented programming in Java, has become increasingly popular lately:

http://aspectj.org/servlets/AJSite

The IBM developerWorks article "Incremental Development with Ant and JUnit" describes how to set up a development platform for extreme programming:

http://www-106.ibm.com/developerworks/java/library/j-ant/

ANTLR is a tool for parsing languages in Java.

http://www.antlr.org/

OroMatcher is a Java library that adds support for regular-expression matching (often a very useful thing to have, especially for weeding out saboteurs from program input):

http://www.savarese.org/oro/downloads/

If you're looking for a cheap JDBC driver for moderately large databases, check out Enhydra; it's free! Just be sure to keep out saboteurs.

http://www.enhydra.org/

"XP Distilled" is a short introduction to Extreme Programming, at IBM developerWorks.

http://www-106.ibm.com/developerworks/java/library/j-xp/

When you're working with the more subtle aspects of Java, the Java Language Specification is an invaluable tool for nailing down the language semantics.

http://java.sun.com/docs/books/jls/second_edition/html/j.title.doc.html

Tail recursion was first studied in the context of the Lisp-like languages. Here's a short introduction to the notion of tail recursion (discussed in the CMU Common Lisp User's Manual).

http://www.cis.ksu.edu/VirtualHelp/Info/develop/cmu-user.info.Tail_Recursion.html

Here's an online description of Sun's Java Hotspot Technology:

http://java.sun.com/products/hotspot/

The IBM Java Technology Tools and Products provides some great links to new tools at various stages in the pipeline.

http://www-105.ibm.com/developerworks/tools.nsf/dw/java-devkits-byname?OpenDocument&Count=100

One of the first concerns of many veteran programmers when first learning about extreme programming is how XP fits in with their wealth of accumulated knowledge on good design and design patterns. Martin Fowler, a key figure in both OO-design and Extreme Programming, addresses this concern brilliantly in his online article, "Is Design Dead?" I won't spoil the article by letting you know that his answer is "no."

http://www.martinfowler.com/articles/designDead.html

Jinsight is an IBM alphaWorks tool that lets you visualize and analyze the execution of Java applications, so you can identify potential bug patterns.

http://www.alphaworks.ibm.com/tech/jinsight

iContract allows you to include assertions in your Java programs.

http://www.reliable-systems.com/tools/iContract/iContract.htm

"Contract Soundness for Object-Oriented Languages" by Findler and Felleisen provides an excellent discussion on why iContract (and every other existing contract checker for Java) fails to perform all of the assertion checks necessary in an object-oriented language.

http://www.ccs.neu.edu/scheme/pubs/oopsla01-ff.pdf

Bertrand Meyer explains his approach of "Design by Contract" in his online article, "The Eiffel approach to Separating Interface from Implementation."

http://www.elj.com/eiffel/bm/intimp/

If you're working with multithreaded code, be sure to check out Sun's explanation as to why Thread.stop was deprecated.

http://java.sun.com/j2se/1.3/docs/guide/misc/threadPrimitiveDeprecation.html

"Writing Multithreaded Java Applications" is a good article on that subject from IBM developerWorks.

http://www-106.ibm.com/developerworks/java/library/j-thread.html

"The Rules and Practices of Extreme Programming" is another good online introduction to the subject.

http://www.extremeprogramming.org/rules.html

The Java Tree Builder, is a syntax tree builder used with the Java Compiler Compiler (JavaCC) parser generator. It takes a plain JavaCC grammar file as input and automatically generates the following: a set of syntax tree classes based on the productions in the grammar (using the Visitor design pattern); two interfaces (Visitor and ObjectVisitor); two depth-first visitors (DepthFirstVisitor and ObjectDepthFirst); and a JavaCC grammar with the proper annotations to build the syntax tree during parsing.

http://www.cs.purdue.edu/jtb/

Download a copy of Jython, an implementation of the dynamically typed, object-oriented Python that is written in and 'seamlessly' integrates with the Java language and platform.

http://www.jython.org/

Retrieve your own version of the Extended ML specification here, in PDF format; Extended ML is a framework for specification and formal development of Standard ML programs. It provides a great example of how the semantics of a real-world language can be formally specified.

http://www.dcs.ed.ac.uk/home/dts/pub/eml-final.pdf

Don't forget to download DrJava and take advantage of the power of an IDE with a built-in repl.

http://drjava.sf.net

bitterjava.com is "dedicated to finding and ridiculing the most vile, bitter, disgusting Java programs, architectures, and designs imaginable—all the bad coding practices available."

http://www.bitterjava.com

In "A Taste of Bitter Java" (developerWorks, March 2002), Bruce Tate demonstrates how and why antipatterns (a design solution to a problem that actually results in decidedly negative consequences) are a necessary and complementary companion to design patterns.

http://www-106.ibm.com/developerworks/java/library/j-bitterjava/?dwzone=java

Check out the Eclipse Web site, for more information about the Standard Widget Toolkit.

http://www.eclipse.org/

Check out the Java Bug Parade for many examples of platform-dependent bugs. (You must be registered with the Java Developer Connection to access this list — it's free!)

http://developer.java.sun.com/servlet/SessionServlet?url=http://developer.java.sun.com/developer/bugParade/index.jshtml