Some notes on web services, REST & Fluent Interface. Theoretically we can make use any language to write web service client, & of course that's the exact reason web service was invented offering loose coupling for implementing distributed computing environment for businesses. But there were many requirements (schema definition/validaion, security,performance, service discovery, SLAs,BLAs, language etc..) to achieve high cohesion, hence SOAP, XML, UDDI & WSDL were necessary. I guess for most of integrations these technologies make developer's life un-necessarily tougher & are forced to learn/unlearn these vocabulary.They are all XML-RPC in disguise & may not be much better than the existing binary RPC solutions (RMI,CORBA, COM...). I am leaning towards REST proponents who are arguing that this complexity is not really worth of benefits it offers & is really waste of time, bandwidth & finally money. These are looking similar to EJBs as I am going through this book (considered as first printed book on REST)
If we see the existing web service landscape (I am referring WSDL, SOAP only), most of them are giving SDK for different languages (eBay SDK, Google Data API...) proving that SDK is more important than the WSDL. SDK always beats the SOAP toolkit hands down.

SOAP prevent independent evolution of client & server. For exampleSOAP toolkits provide (Jax-ws,Axis) code generation with strongly typed APIs, even adding new optional parameter, system will break until we generate thte stub again,Which basically diefies the logic of loose coupling.

With REST,HTML forms provide default & hidden variables,Service end point change is effortless, we can have re-directs based on situation & also partition, scale well depending on the requirements.Means don't have redeploy & test specifically for this.

separating reads from writes. SOAP has no inherent support for this, although we can design.
caching GET requests including hardware solutions, Caching @ HTTP always yields better results.
compression: Since REST uses HTTP, you can use compression such as gzip.
No need for additional jars or library
explorability -clicking around a RESTful API in their browser & use right away.
REST architecture serves as the basis for the most biggest and most successful information system the world has ever seen

Cons of REST
security: Though, security considered as weakest area of REST not sure why (HTTPS, authentic)
Tools will make working with SOAP just simple, IDE & tools cannot provide same kind features as SOAP to REST.
(Anyway we had same arguments for using EJB in the past as well)


Here is a sample Java APIs for web service APIs to help out developer community to directly working java instead of WSDL. I noted following points from going through the code.

• Contains 28 methods & 768 lines



• Expects user to update the Source code or use the properties file to inject startup values (Namely username, password, AccountID so on & so forth) & is not easy to pass/change these values @ runtime.



• Uses Exception, RemoteException providing little recovery options from service faults & forcing client code to become ugly, clearing suggesting RuntimeExceptions are better suited here to use.



• One single class for many APIs, making shpping client API size bigger if we want to deal with single API only



• No way to see the SOAP XML files that get handshaked b/w client & server.



• Uses Axis for marshalling/unmarshiling, We have Sun benchmarks suggesting latest jax-ws API/implementaion beat Axis/xfire hands down.



• The API is not fluent (or user friendly) & does not make use latest JDK1.5 APIs



• Uses lot of Array values as input/output params making client code uglier

Before providing my solution for this I do understand that I don't have much knowledge of the context (of client applications) using the APIs. So please be adviced I might have over-looked many issues.

I generated stub code using jax-ws APIs & netbeans. JAX-WS is the successor to JAX-RPC. It requires Java 5.0, and is not backwards-compatible to JAX-RPC.Netbeans has amazing plugins for about everything! I also wrote some wrappers around the campaign service API & here is how client code looke in the JUnit test case. (BTW JUnit4 has amazing features with POJO annotations & I guess this unit testing library is the best testimonial of effective usage of the java annotations.)

Now JDK6 users can turn their normal POJO in to web services and deploy it with ease without getting to deal with different web services stack. Before JDK6 one had to download some webservices toolkit and learn how to use

@Test
public void testGetCampaigns() {

List<Campaign>campaigns = new CampaignServiceTemplate() {
@Override
public YAccount getYAccount() {
return YAccount.builder.userName("uyiui")
.password("test123")
.license("uyiuu7687687gg")
.masterAccountID("988533")
.accountId("2086880350")
.build();
}
}.getCampaigns(13897897l,797897l, 89678l);
Assert.assertNotNull(campaigns);
}

Above code definately looks much cleaner easy to use. It makes use of generics, varargs, SOAPHandler java-ws interceptor,template pattern & fluent interface to make code look simpler & robust by validating all the inputs that takes care of all the issues I listed above sample code.

One task which I wanted to avoid was generating the source using tools Axis/jax-ws, if I want to write some adhoc testing I don't think doing in java make really sense. Ruby, Groovy where dynamic class reference options are amazing solutions here.

For stock quote client Groovy code looks something like this.

import groovyx.net.ws.WSClient
proxy = new WSClient("http://www.webservicex.net/stockquote.asmx?WSDL", this.class.classLoader)
quote = proxy.GetQuote('YHOO')
print quote

We, Java programmers are unable to make use of Groovy APIs like this, we will be the losers. Coding can't be simpler/easier than this :-)

But don't get me wrong, Java has a place & will continue to occupy the major portions of software development as Joshua Bloch says "One thing that makes Java such a pleasure to use is that it is a safe language."

So when we stick to Java,fluent interface or easy to use APIs have lot of importance.A fluent interface is a DSL embedded in a language,it consists of a set of classes that have been organized to allow you to write code that nearly reads as English essay. Beautiful Code is often associated with essay-writing.

Reference:

Immutable objects improves the code reliability.

Joshua bloch discusses about the design consideration

Jax-ws faster than Axis - Benchmarks

Java options for writing web service clients

SoapUI has wonderful set of applications & plugins to make web service testinf very easy task. I tried out their NetBeans plug in , It's simply amazing.SoapUI is a great tool for any developer who wants to test web services to verify that they are working correctly.

Good DZone link explaining functional testing using these APIs. I will update my experience after trying these out.

GoAPI -> Good for searching APIs.
Restas Architecture - "Simpler is better, and REST is generally simpler than SOAP"

Java Logging Frameworks - why to use sl4j?
One of my friend was asking why should I with sl4j over log4j & java logging. My answer was "because it was written by the same author who wrote log4j & is now adopted by finest java framework authors (Tapestry & Wicket)" sl4j is the best available way to solve logging problems. It's latest & hence best suited for any new projects. This way some decisions are easy & safe to make. Logging is one of the most boring & non-debatable topic. At least for issues like this it's best to follow the best minds. During my initial days of coding I have seen mindless java wrappers over existing logging frameworks without any value addition. Log4j is definitely superior option to standard java logging both in terms of speed & availability of appenders. But when we write client apps or want to make our jar size compact & cannot afford to include log4j.jar java logging might be still better option which is rare case anyway. With log4j , in order to bypass the expensive string concatenation if statement was necessary. It would have been nice if APIs to provide some features that would alleviate things like this, and maybe make it easier to toggle the display of log statements for code readability.
if (log.isDebugEnabled()){
log.debug("Logging " + String.valueOf(a) + "some information :"+someBigEntity.toString());
}
I never liked double if conditions. Less if conditions directly proportional to good code quality.
sl4j utilizes parameterized messaging (like logger.debug("The new value {} is replacing {}.", newValue, oldValue);) & does'nt have class loader & memory leak problem. As JVM is becoming smarter & smarter with every new version, micro bench marking knowledge are becoming totally irrelevant. The experience is becoming baggage & anti pattern most of the time as for micro bench marking is concerned.

Here is one experiment I did with latest JVM with decompilation .

public class JavaLogTest {
// Get status from Logger.isDebugEnabled();
private static final boolean DEBUG=false;
public static void main(String[] args) {
if(DEBUG) {
System.out.println("Performance issue");
debug("Some Big"+"Concatenation here"+"& also creation of objects.... "+new java.util.Date()+" which is not good for performance");
}
debug("testing"+" ! testing again");
debug("testing"+new Integer(10).toString() +new java.util.Date());
}
public static void debug(String str){
System.out.println(str);
}
}
I decompiled the class with decompiler & here is the result what I got;

import java.io.PrintStream;
java.util.Date;
public class JavaLogTest{
private static final boolean DEBUG = false;
public JavaLogTest() { }
public static void main(String args[]) {
debug("testing ! testing again");
debug((new StringBuilder()).append("testing").append((new Integer(10)).toString()).append(new Date()).toString());
}
public static void debug(String s) {
System.out.println(s);
}
}
& the results were interesting;
1. It doesn't make sense to use StringBuffer for appending, JVM is intelligent to make use of StringBuilder which is not synchronized also
2. When we append strings only there is no need to use if statement even with log4j
3. We can take out the code from the byte code (pre-processor directive DEBUG) which can reduce the total jar size
I found scala solution for this was interesting. Dynamic languages indeed bring lot of paradigm shift in thinking!

Java Language Vs Java Platform - The paradox :
Now it looks like Java is at crossroad both as language & as platform. There are 2 formidable arguments for both Java platform & as Java language. The companies like Thoughtworks are arguing that Java as programming language has reached it's dead end & dynamic languages JRuby & Groovy are the future. Bruce eckel echoed the same saying Scala is "the current best exit strategy for Java" & adding new features (Closures etc...) will make language complex, big & finally unusable.
Google has provided interesting twist to the above thinking with GWT, GData APIs & Android. Google is saying 'java as language is great, it's static typing, IDEs, large user base helps to create robust application even by mediocre programmers' but not the platform. So GWT is path-breaking technology in that sense as it compiles the java code to javascript code instead of bytecode & so the android.
So what's the truth & future?
Let's analyze how Java performed on it's promise:
Java as a language - My guess is it has done fairly good job here. Market is always right, now we have java programmers outnumbering any other language.
Java as library - If you look into sourceforge.net or any other common place producing software code Java is the #1 language inspite of great productivity provided by the new dynamic languages like Ruby, now we have superior set of libraries in java compared to any other language.
Java as security model - Done fairly good job.
Java as platform - Now we have profilers monitoring everything, Java is becoming full fledged operating system now.
Java has done fairly well on all these account & looks is going to influence in the future as well, we cannot stop Java from evolving & it has to add new features in order to remain competetive (generics, closures & so on...) & has to compete with C# which is adding new features at amazing speed.
Steve Yegge has written a brilliant article defending dynamic languages. Polygot programming (using multiple languages) is also becoming very popular among architects.

Java Performance Considerations: Here is some collection of notes for making java applications perform better & scale better.Usually we need consider the java application performance at 3 levels:

1. Refactoring/writing java code.
2. JVM fine tuning depending on the context.
3. Application server parameter tuning. (server configuration files)

Above all are equally important but I guess 2 & 3 are important for application administrator. I believe every java developer should be administrator as well, so all are important to be considered. General strategies for faster programs, like purging obsolete code, and the well-known 80-20 rule (optimizing the 20 percent of your code that consumes 80 percent of processing time) can be applied while optimizing the existing code or reviewing code . Anyway it's painful to refactor existing code written with old techniques & also by some one else.Whether you are refactoring or writing new code performance improvement techniques should be helpful.By end of the day the speed/efficiency of program depends the # of cpu cycles & memory space that were utilized for accomplishing a task. Balance between the memory & cpu cycles are contextual & I guess that's where technical knack/experience comes into picture.
One of the main technical reason for using the java platform is the availability of inbuilt profiling inspite of productivy power provided by the functional/scripting languages, Profiling provides details about the # of threads, memory utilization & the CPU usage.
We have both commerial & free tools for profiling a application. JConsole/VisualVM & Netbeans inbuilt profiler have fairly good options to generate required reports.
I found Visual VM as the best option for profiling the application. It's lightweight & extremely non-intrusive.
Saving cpu cycles, network calls & keeping source code compact should be the main driving factor for improving performance. Most of the performance improving techniques are obsolete with modren JVMs. For example the usage of StringBuilder (Or using + operator) against the synchronized StringBuilder are becoming non issue with compiler, VM becoming more mature in handling these automatically & even there is no need inline (using final variables).
So micro benchmarking & refactoring of java code has very less relevance in improving performance of java application. Upgrading JDK version should automatically push the performance by 20-30% :-)

Performance related decisions while coding/designing happes based on CPU Vs Memory, I tried out printing sizeOf various java objects.

new SimpleDateFormat() : 4248 bytes

StrigBuffer : 72 bytes
StringBuilder : 72 bytes

new String() : 40 bytes
new String("1234") : 48 bytes

Boolean.TRUE : 16 bytes
new Object() : 8 bytes

new Integer(2) : 16 bytes

new Vector() : 80 bytes
new ArrayList(0) : 40 bytes
new ArrayList() : 80 bytes
Collections.EMPTY_LIST : 16 bytes
Collections.emptyList() : 16 bytes

class T { } 24 bytes
class T1 { int a=10; } 24 bytes
class T2 { int a=10; SimpleDateFormat sdf=null; } 32 bytes
class T3 { int a=10; Object obj=null;} 32 bytes
class T4 { int a=10; int getA() { return a; } void setA(int _a) { a=_a;} } 24 bytes

JVM Options:
Josep D. Mocker has done a wonderful job of collecting JVM options in a single place - this compilation will be more useful if any real time problems were solved with these options.There is well written document about profiling about the profiler by NetBeans, but applicalbe to java in general
OutOfMemoryException->Most of the time this problem can be sloved by setting maximum memory, but even after setting to hight value (>2GB) there is possibility of outofmemory error because of permanent generation memory that is allocated for classloader.
The permanent generation is allocated outside of the normal heap and holds objects of the VM itself such as class objects and method objects. If we have programs that load many classes (like deployment of many BPEL processes in a batch), we may need a larger permanent generation. It's a separate heap inside the heap, the standard value for this is 48MB.
This bug can be solved by setting these 2 JVM parameters:-XX:PermSize=256m -XX:MaxPermSize=256m
Since the sizing of this is done independently from the other generations, this means that even if you setup a heap of 2Gb, you might still encounter problems in the permanent generation cause if you do not specify this it will fallback on the defaults .The same value has been assigned for 2 values because we want to minimize large garbage collection here.
In the past I have tried to check with various parameters & could not see any improvements whatsoever on performance.
Sun Hot-Spot Engineering team says JRE6 works best with default options rather than fine tuning; You can look into these benchmarks for details. Long back I wrote simple code to do profiling, you can re-use this poor man's profiler if you don;t have patience to set up a profiler or if you want monitor some portion of the the code,feel free to use this code. I also likes this simple idea for load testing simple web applications.
Server Fine tuning:
Weblogic (BEA,Oracle), Websphere (IBM)have wealth of information about the configuration in their sites. I found these 20 Tips for Using Tomcat in Production useful .

JVM Tuning options - Good collection of tuning options.

2008 - Programming Technologies to look for:
Comet Programming:
a web server sends data to a web browser (client) asynchronously without any need for the client to explicitly request it, So it's a server side AJAX (supported in Tomcat6). This is great feature & opens up lot of possibilities with server side events. It's like RMI's Callbackinterface where client can listen to events from UnicastRemoteObject.It has great potential where it's not advisable for client to poll . Servlet2.5/Tomcat6 will support Comet programming & I am sure all the frameworks will start laveraging the same. But I am little skeptical about the popularity of this; although the statements from several authors are exciting.

Web Technology Frameworks:
I tried out some samples with component frameworks. Since I have been working swing programming model, it was so easy to write Listener anonymous classes. I wrote samples with GWT, wings & Echo.I did more work with wingS as they were using YUI library as backbone.
I also followed Wicket & Tapestry very closely. I am yet to work with real project to really appreciate the necessity of having to define HTML & Java artifacts for each page. zk framework,JSF & many other frameworks compete for this space. Wicket is my favorite component oriented framework although I am not sure it's scalability capabilities. As tapestry claims to work well with highly scalable sites, there is neither such explicit asserstions or sample sites avaiable for Wicket to prove that it's possible to create highly scalable sites, anyway I am excited to work with new Wicket release that will get released in coming months leveraging JDK1.5 features. Although personally I love swing programming model,my guess is page-centric MVC is going to be mainstream web programming model in 2008 as well. RoR, Grails are offering great productivity gains in this space. Grails1.0 got released in Feb 1'st week & I believe that 2008 will be Grails year as for as page centric web sites development is concerned & it's going to be Wicket year for developing complex web applications.

Closures & DSLs with dynamic languages:
Last year there was lot of discussion on aspect oriented programming & dependency injection. Dynamic lanaguages have brought lot changes to the programming parctices with Groovy & Ruby leading the way.It was difficult to commit to any of these two languages (Groovy & Ruby (JRuby) ) , Although Groovy looks to be easiest to select for Java programmer I was little skeptical as Sun choose to invest over Ruby/JRuby over Groovy & Thoughtworks , a technically intelligent company invested in Ruby. But after trying out few samples I am convinced that Groovy is the best way for dynamic programming for Java programmers. Closures, DSLs & weak typing languages are simply unstoppable on JVM. I bought Groovy In Action book.

Closures:-> As a swing programmer, I have been using anonymous classes a lot. Spring's JDBCTemplate... & other template wrappers were huge hits for me. Not only closures will help solving resource handling( File, Database, User Interfaces, transactions (open<>close)), they also help better thinking (recurse & iterative). Joel explained them well here. The main point I guess with closures is that we can assign a variable to a method & use just like any object & you can pass on these parameter to a other methods as explained superbly here.
I used to wonder about the reason for final variable only accessibility in anonymous classes. I found explanation here, where Guy Stele says java should not allocate any memory in heap without "new" call & allowing non-final variables violates this. He also says dynamic class loading ,reflection already violates this principle. Anyway it's clear that anonymous classes are not equal to closures. Paul Graham argued brilliantly for closures saying succinctness is power long back. Paul's concern over java for not providing power & Joel concern of java being simple, I guess are now solved with dynamic languages.With James Gosling asserting that it was resource/time constraint that prevented Closure inclusion in original JDK, closures are likely to reach java mainstream this year.

Some useful links on this topic:
Review of Groovy/Grails books from Matt Raible
Higher Order Functions with Groovy - GINA book doesn't cover this topic
Closures samples
Some closure theory
Closure proposals from Bob lee (Guice creator) & Josh Bloch where they argue removal of new keyword to support closures.
comparison of different closure proposals:
Closure Debate from IBM
Language comparison:
A closure sample in Groovy

Some how Fluent interfaces were not familiar or popular in Java world. Standard Java bean definition is not really good way to define & populate objects. Martin Fowler defined them as back as Dec 05. Although fluent interface & builder pattern cannot be implemented in java easily my guess it's happening mainly because of Java Bean spec (which are well used by frameworks(ex.hibernate) & tools (IDEs)), we can also write java code like,
new Person("test","test").email("praveenm").firstName("Praveen").lastName("Manvi"); instead of calling set method on each variable. Many JDK standard classes like StringBuffer, ProcessBuilder already using this. I guess more & more APIs will start using fluent interfaces like JAXB2 commons.I am also planning to write a plug-in in netbeans/eclipse to extract fluent interfaces from existing classes. Venkat provides a very neat explanation about the necessity & usage of DSLs & XML limitations to be used as full fledged DSL.
Cloud Computing, Grid computing, Virtualization might reach masses this year.
OSGI - OSGi is going to change the deployment and run time model for enterprise apps.(Although I am not able fully appreciate/understand the value even after going through literature, The immedeate advanatage I see as of now as a Swing programmer that I can run may java apps with single JVM which is painful now), Although Oracle, Bea (Oracle?), IBM & more importantly Spring showing lot of interest & excitement, Sun doesn't seem to be that excited
So exciting days ahead...

Best Java Minds:
One of the best way to learn any technology is to follow the best minds. Here I have collected the set of authors & their blogs who have made(and making) huge contribution to the Java.
It's interesting to see their activities in coming days

James Gosling - Father of Java
Rod Johnson - Author of Spring Framework. Finally, provided promising solution to the lunacy of EJB that triggered new EJB3/Java EE to evolve. It looks like now Rod wants to be actively part of next javaEE spec.
Gavin King - Father of Hibernate. Saved lot of time of writing and maintaining hand written SQL in java & telling world that transparent persistence a good thing & is huge advantage, which some reason TopLink/entity beans failed confirm
Clinton Begin & his team - Creators of superb SQL Data mapper framework iBatis - Making working SQL easy even for legacy DBMS where selling 'hibernate' to paranoid DBAs is a difficult task. It has also influenced JDBC4 to evolve.
Bruno Lowagie - Author of iText (iText is an open source Java library for PDF generation and manipulation & regarded as one of the best library)
Gregor Kiczales - AspectJ Author, Showing cross cutting concerns could be handled in a intelligent/non intrusive way.
Ceki - Log4j. The de-facto standard for Java Logging.
Doug Cutting - Lucene. Developed the de-facto full-text search engine for Java.
James Duncan Davidson - Ant and Tomcat.
Joe Walnes - XStream and SiteMesh. Top class framework for handling XML & web templates.
OpenSymphony -Copmany behind great frameworks like SiteMesh, Quartz, Webwork, Xwork
Erik Thauvin - Java pointers - A Java Crawler Great Collection of links, although he has stopped now adding anymore links citing the time it takes to come up with valid links, but still it's good to visit his old collections. I am planning to start this again in 2008

Java Swing isn't that bad because of these guys
Eugene Belyaev - Creator of IntelliJ IDEA. #1 IDE using just Swing.
Karsten Lentzsch - JGoodies. Superb contribution to java swing
Doug Lea - util.concurrent. Superb framework for parallel stuff. More important in Swing than anything else.
Romain Guy with amazing swing skills. Author of Filthy Rich clients
Ethan Nicholas Author of Yahoo SiteBuilder
Chet Haase - Co-Author of Filthy Rich clients
Jfreecharts - I was not able get the author details of this excellent framework

Gurus - Although they have not made any significant contributions to Java, but they have definitely has huge impact on the way software is created.
Martin Fowler - Probably the best writer who can be called as true technical Guru with amazing writing skills. Defining patterns samples...
Erich Gamma - JUnit, Design Patterns and Eclipse
Jack Shirazi - Java Performance. created website on performance tuning
Ward Cunningham and Kent Beck - Extreme Programming.

http://www.angelfire.com/tx4/cus/people/ - The list of language creators

Java Links - Collection of Useful Java links

Many a times colleagues & friends who want to learn java were asking me to provide some good links to go through to start with. I compiled some set of useful links. I hope that this will be useful to all the people who want to know about Java.
In Java world, the difficulty isn't to find good API but is to use it well. Moreover, the Java API is too large to memorize all. That's why, the internet links are important. You name any task there will be minimum more than 10 ways of accomplishing in Java, that's the strength of Java. But irony is that's fastly becoming weakness as well compared to RoR & .NET at least in developing web applications. Having lot many options is not always good :-)
Each technology (Desktop, Enterprise, Content Management, Web applications...) is so big that each has enormous amount of information to learn. Here I have included the links that are generic in nature useful for starters.

Resources from creator of Java - I always maintained that Java API (JavaDoc & Java source code) is "the best" resource, Most of us don't realize this.
Java 6 - Programmer Guide
Java 1.5 API Specification
Sun Tutorials
Technical Articles from sun based on category

Most Java books are written by people who couldn't get a job as a programmer, since programming pays more than book writing. Most of the time they are outdates & comes with bad examples. This is especially true for free books, but I guess these books (Especailly first 2) deserves reading.

eBooks - Free
Java Language Specification - James Gosling- Father of Java It's like Ritchie book in C,
Thinking in Java - Bruce Eckel One of the best writer, Has also written books like Thinking in C++ along with other Java books. Now a days he is putting efforts behind Adobe Flex, RIAs
Object-Oriented System Development - Dennis de Champeaux, Douglas
Mastering Enterprise JavaBeans 3.0 - Ed Roman, EJB3.0 is definately not as bad as earlier versions.
Processing XML with Java - Elliotte Rusty Harold, I think we should avoid XML as much as possible, if required Groovy provides better alternative compared to Java
The J2EE Architect's Handbook - Ashmore - Don;t carried awayby the asserions
Servlets and JavaServer Pages: The J2EE Technology Web Tier - Falkner and Jones
Java Design patterns - James W. Cooper - Examples are provided in Swing
Well written set of Java Series books from Sun.

Good Java Websites
Sun's Java Site - Official java resources
Java practices - Supereb Collection of Java practices
The Server Side - Interesting discussion but usually consists lot of marketting literature, So
don't believe what ever people say there.
IBM's developerWorks- Wealth of Java information - IBM has made huge java investment in developing literature of building large scale applications.But they are quite slow in supporting new stuff like weblogic guys.
Weblogic - dev2dev - #1 in providing enterprise software
Spring - Lightweight framework providers ,
JBoss - First popular open source application server, Now Gavin King author of HIbernate, Seam works for JBoss
The essential Java language library - The resources you need like you need air
JavaRanch - Good old Java certification site - But you are forced to see all sort stupid questions & answers, If you not interested in certification no need to go here.
O'Reilly's onJava - O'Reilly books are generally good
Good Applet resources
Kick Java
Java open Source Collection - My #1 site for looking into java open source options. All kudos to creators of this site.

Java Tech magazines
Infoq - My favorite, If I start a magazine it is going to be like this (BTW I am planning to launch one)
Net Beans magazine - Good place for all NetBean lovers
Parleys - Belgium based site with lots of quality presentation on various interesting Java areas
JavaWorld IDG's online magazine for Java language and programming professionals--featuring news, views, tips, tools, technologies, and more. But I guess these days we are not getting much content here
Java Report Online Online segments of Java Report, featuring Java Tutor, products and services listing, articles, jobs and more.
About java An in-depth collection of news, tips, articles, and tutorials.
Javaposse News,Interviews about java.
Java Skyline - Magazine for Server Java developers
Java Developer Journal - Self proclaimed #1 magazine, with lot of ads.
Java Jazz Up -free online magazine on Java Technology
DevX - Java zone - Very good articles, again lots of ad
java blogs - A java blog aggregator.

learntechnology.net (EJB, JMS, Ajax, iBatis, Struts, Wicket, ...)
The Java Memory Model (lot of ressources ...)
Free Java EE (J2EE) Training Online

Some interesting DB related links

Storing tree in RDBMS

why too much database normalization can be a bad thing

Managing hierarchial data

Design Patterns - Nice explanation design patterns

I think these are important areas that any Java Programmer must be familar witth.
1. Java Programming
2. Java Collections -> Look at the apache commons as well as Google collections, You will understand both power & shortcomings of Java collections.
3. Java threading Model -> There is going to be lot of investment in coming years as the API that exploit the multiple CPU power are going to be important. Scala/Erlang is also important scripting languages to follow.
4. Understand the servlet model. You can look into source of Wicket or Tapestry pure object oriented component models for developing web applications. My Swing way of developing complex web applications is going to be popular in coming days. (WingS, ZK, Echo, GWT, JSeam)
5. Scripting/DSL is bringing lot of cahnges in development (Groovy looks to be the best bet for Java programmers), So it's also better to focus on Groovy support in Spring, Grails & Seam

Effective Java & Practical Java - The grand-old two books that are suggested for java basics.
I thought it might be helpful for Java programmers to glance through rule list as most of the recommendations here still have relevance.


Effective Java -Joshua Bloch
Creating and Destroying Objects
1: Consider providing static factory methods instead of constructors

Not always the best, Now a days Dependency Injection is better than factories for low coupling
We have 3 ways of instantiating a class,
1. Using 'new' operator
2. Using java reflection Class.forName("myClass")
3. Using clone() bitwise copying
4. Using Serialization (java.io.Serializable)
All have their own use-cases of use.
2: Enforce the singleton property with a private constructor

Over use of Singleton are regarded as bad practice because of increased usage multiple VMs & clustering. We have Singleton Detector (Google code) to find singletons and global state in the Java code that we produce to help us refactor them. This tool which analyzes Java bytecode and detects the use of Singletons.
Item 3: Enforce noninstantiability with a private constructor

Spring does this with abstract class (StringUtils) & static methods- I really likes this idea compared to private constructor.

4: Avoid creating objects

This also needs to be done based on requirement, With modren JVM's it's not so costly as you may think of, You can avoid re-instantiating heavy objects
like SimpleDateFormat in for loops etc... by caching them as private static final member variable. We should avoid creating duplicate objects
5: Eliminate obsolete object references

Google collection APIs should help us for better use of Java collections
6: Avoid finalizers

Why this was invented in the first place, there is no need of finalizers
Methods Common to All Objects

7: Obey the general contract when overriding equals
8: Always override hashCode when you override equals
Now IDE like NetBeans 6 provide the option to automatically do this.
9: Always override toString
This can come handy while analzing the logs, Again with modren debuggers we hardly need toString()
10: Override clone judiciously
Ideally Cloneable should be having clone() method instead of being a marker interface , I am still not convinced on the importance of Marker interfaces
(Serializable, Remote etc...)
11: Consider implementing Comparable
Yes sorting may be required @ any point of time & these days it's better put more work on JVM than the Database
Classes and Interfaces
12: Minimize the accessibility of classes and members
Make all members private, Give me explanation if you think otherwise
13: Favor immutability
I don;t think it's valid with modren JVM's there is no need to make inline (making final) the code, JVM takes care it automatically
14: Favor composition over inheritance
non intrusive model better compared to intrusive model, POJO's better compared to EJB (not the JEE version of course :-))
15: Design and document for inheritance or else prohibit it
Spring is a wonderful example of this principle& struts the worst offender
16: Prefer interfaces to abstract classes
Spring is a wonderful example of this principle& struts the worst offender
17: Use interfaces only to define types
18: Favor static member classes over nonstatic
I guess this is debatable
Substitutes for C Constructs
I am not sure how many people are really interested in converting C programs to Java now a days
19: Replace structures with classes
20: Replace unions with class hierarchies
21: Replace enum constructs with classes
Now we have enum type in Java 5
22: Replace function pointers with classes and interfaces
Methods
23: Check parameters for validity
Throw IllegalArguemtException for any errors & don;t throw checked Exception.
24: Make defensive copies when needed
25: Design method signatures carefully
26: Use overloading judiciously
I say don;t use it.
27: Return zero-length arrays, not nulls
Good point, For objects use Null Object pattern
28: Write doc comments for all exposed API elements
General Programming
29: Minimize the scope of local variables
30: Know and use the libraries
Don;t use any library blindly, Look into the code.
31: Avoid float and double if exact answers
are required
32: Avoid strings where other types are more appropriate
Again debatable point, I have seen people arguing String for even 'id' value, With the popularity of scripting languages I guess over-use of String not an offence as long as it simplifies coding
33: Beware the performance of string concatenation
There is one myth involved with this, Now if you use '+' operator for concatenation, it is better compared to StringBuffer & the Compiler(JDK1.5)
automatically does this for you by using non -synchrized StringBuilder classes.
So use '+' freely, Use StringBuffer if you need synchronization which is rare anyway.
34: Refer to objects by their interfaces
Use Java 5 Generics
35: Prefer interfaces to reflection
Now java reflection performance has improved a lot.
Hibernate used CGLIB (byte code manipulation framework) against java reflection
Now I am sure Gavin King would have selected Reflection with modren JVMs.
36: Use native methods judiciously
I say don;t use it, It's better to re-write
37: Optimize judiciously
38: Adhere to generally accepted naming conventions
Follow the Sun rule, I also discussed in length about java coding conventions in one of my previous blog
8 Exceptions
39: Use exceptions only for exceptional conditions
40: Use checked exceptions for recoverable conditions and
run-time exceptions for programming errors
41: Avoid unnecessary use of checked exceptions
42: Favor the use of standard exceptions
43: Throw exceptions appropriate to the abstraction
44: Document all exceptions thrown by each method
I guess it's better to choose the long meaning names as nobody reads Javadocs these days.
45: Include failure-capture information in detail messages
46: Strive for failure atomicity
47: Don't ignore exceptions
here is ultimate explanation on Exception Handling
Wonderfully explained concept "Runtime=FaultException" & "Checked=Contigency" , a progmatic way of using Checked (extending Exception) & UnChecked (extending RuntimeException)
9 Threads
48: Synchronize access to shared mutable data
49: Avoid excessive synchronization
50: Never invoke wait outside a loop
51: Don't depend on the thread scheduler
52: Document thread safety
53: Avoid thread groups
10 Serialization
54: Implement Serializable judiciously
55: Consider using a custom serialized form
56: Write readObject methods defensively
57: Provide a readResolve method when necessary

---

Practical Java - Peter Haggar

General
Understand that parameters are passed by value, not by reference.
Use final for constant data and constant object references.
Understand that all non-static methods can be overridden by default.
Choose carefully between arrays and Vectors.
Prefer polymorphism to instanceof.
Use instanceof only when you must.
Set object references to null when they are no longer needed. Objects and Equality
Differentiate between reference and primitive types.
Differentiate between == and equals.
Do not rely on the default implementation of equals.
Implement the equals method judiciously.
Prefer getClass in equals method implementations.
Call super.equals of base classes.
Consider carefully instance of in equals method implementations.
Follow these rules when implementing an equals method. Exception handling
Know the mechanics of exception control flow.
Never ignore an exception.
Never hide an exception.
Consider the drawback to the throws clause.
Be specific and comprehensive with the throws clause.
Use finally to avoid resource leaks.
Do not return from a try block.
Place try/catch blocks outside of loops.
Do not use exceptions for control flow.
Do not use exceptions for every error condition.
Throw exceptions from constructors. -> This is very tedeous
Return objects to a valid state before throwing an exception. Performance
Focus initially on design, data structures, and algorithms.
Do not rely on compile-time code optimization.
Understand runtime code optimization.
Use StringBuffer, rather than String, for concatenation. -> Is incorrect statement with JDK5 onwards
Minimize the cost of object creation.
Guard against unused objects.
Minimize synchronization.
Use stack variables whenever possible.
Use static, final, and private methods to allow in lining.
Initialize instance variables only once.
Use primitive types for faster and smaller code.
Do not use an Enumeration or an Iterator to traverse a Vector.
Use System array copy for copying arrays.
Prefer an array to a Vector or ArrayList.
Reuse objects whenever possible.
Use lazy evaluation.
Optimize source code by hand.
Compile to native code. Multithreading
Understand that for instance methods, synchronized locks objects, not methods or code.
Distinguish between synchronized statics and synchronized instance methods.
Use private data with an accessor method instead of public or protected data.
Avoid unnecessary synchronization.
Use synchronized or volatile when accessing shared variables.
Lock all objects involved in a single operation.
Acquire multiple locks in a fixed, global order to avoid deadlock.
Prefer notifyAll to notify.
Use spin locks for wait and notifyAll.
Use wait and notifyAll instead of polling loops.
Do not reassign the object reference of a locked object.
Do not invoke the stop or suspend methods.
Terminate threads through thread cooperation. Classes and Interfaces
Use interfaces to support multiple inheritance.
Avoid method clashes in interfaces.
Use abstract classes when it makes sense to provide a partial implementation.
Differentiate between an interface, abstract class, and concrete class.
Define and implement immutable classes judiciously.
Use clone for immutable objects when passing or receiving object references to mutable objects.
Use inheritance or delegation to define immutable classes.
Call super.clone when implementing a clone method.
Do not rely on finalize methods for non-memory resource cleanup.
Use care when calling non-final methods from constructors.

Some Architectural Notes:

"Practical Guide to Enterprise Architecture" book published by Prentce Hall has very readable contents. I enjoyed reading it. Here are some highlights

Architecture Is Business-Driven. This is the first and most important habit of an architect. All architectural undertakings should be done for the sole reason of solving business problems. Architecture planning is a continuous process that requires full alignment with business goals.

Communication Is King. Enterprise architecture must be communicated to all parties across all IT organizations and lines of business on an ongoing basis. This should include strategy, goals, and objectives. Its purpose is to increase awareness throughout an enterprise. It must also include a statement of shared values that are endorsed and supported by the executive team and incorporated into the IT governance model.

Unification Is Queen. For enterprise architecture to succeed, it must be unified across the enterprise. Success and failure of all forms of architecture depend upon the joint efforts of all business and IT areas, their support of the architecture, and consistent implementation.

The Frog Is a Prince. Support from the executive team is essential for the practice of architecture, but a successful architecture starts almost at a grass-roots level by seeking support from line managers and their direct reports where the sell is the hardest. Getting buy-in from the troops (Seek first to understand, then be understood) will shield the architecture from passive resistance.

K.I.S.S.: Keep Infrastructure Simple. Information technology assets and the elimination of the endless combinations of platforms that use disparate technologies are the main inhibitors of change and result in an inflexible architecture. A goal of sound enterprise architecture is the destruction of incompatible technologies. If infrastructure is kept simple and consistent, enterprise architecture can leverage existing skill sets, training, support, and services in a cost-effective and agile manner.

Agility Is Key. Sometimes the best solution for a particular business problem requires adoption of a technology and/or approaches that are not mainstream. Agile enterprise architecture will allow the modification of standards to support business requirements, and it will seek out alternate ways to integrate the technology with the current architectural model.
Crawl Before You Walk. Expectations should be managed. The best architecture for an enterprise is one that evolves versus one that is created. Each iteration of the architecture should build upon previous versions and provide an incremental improvement to the organization. Enterprise architecture should also focus initial efforts on near-term opportunities—what is within reach—that can provide immediate business benefit. Small but quick wins will help win allies from both the business and technology areas and will best demonstrate the value of agile enterprise architecture.

---

It's very important to capture & communicate business/technology drivers well in succinct manner to all the stake holders.Defining architecture satisfying all the stake holder is a very difficult task. Un-informed stake holders will have unrealistic architecture goals. CEO expects application to scale for decades, Manager wants no duplication efffort at any cost & expect that to come completely from architecture, Developers exepects libraries to ease out their coding & Designers expect check lists.


All the stake holders are correct in their own way on the expectation from architecture, but unfortunately Architecture cannot accomplish all the individual requierements & it's important to set the expectation clearly.

Architecture -> Is About Making Technology choices. In my openion this is the most important feature that will have huge impact on any projects. Application maintainence, Deveoper availability should be given as much importance as techincal excellence of the tools that we choose.
Architecture -> Is About understanding the context. All patterns/anti patterns work with aparticular context. If we miss out this context the patterns/anti pattern knowledge can have adverse impact on our judgements.
Architecture -> Is About understanding of problem space & strong connection with business. Respecting the domain experts & their openion is very important here.
Architecture -> Is not just about Reusable artifacts but flexible artifacts. There will be always better ways for implementiion techniques as time progresses. So "re-use" is overloaded word. So I guess flexibility is more important thatn reuse. Interfaces & Dependency Injection (Spring is excellent in serving this pupose & latest version gets you out of XML hell as well :-)) is more important as they give the power of changing the implementation with better means over the time without much pain.
Architecture -> Is about understanding varying scalability requirements, Every one don't require eBay or Amezon kind of requirements. I have personally executed 3 eBay projects as a lead & the rules of the game is totally different for those kind of applications.
Architecture -> Is About breaking rules.eBay doesn't rely on transactions. The data is heavily de-normalized, Most of the processing happens at the application tier. The asynchronous channels are heavily used. ThreadLocal's are used heavily. Scratch DB is preferred way to store the session data. Scaling happens @ the web-tier & EJB's doesn't even qualify as contenders & the XSL templates rule the presentation layer.These rules are definitely not suited all kinds of applications. It was very difficult for me to come out of hang-over of eBay code base.

Architecture -> Is about understanding the Return On Investment & ability to predict the future with political, local & legal aspects in the mind. Documenting patterns & anti-patterns in these areas will be invaluable as experience/historical knowledge holds the key.

Identifying the need of different stake folders & making sure that architecture artifact look relevant to all stake holders is important.So it is better to write different documents focusing on different stakeholders.It is important to keep the theme same in all artifacts. For Example,"System Architecture" document should capture the over-all technical decisions that were made along with explaining the rational & tried alternatives. This document should act as technical design review check list. It's important document non-functional or operational requirements as clearly as possible. Architecture goals and means (usually debating 2-3 options for achieving the same).Integration of various application modules (critical ones).
For any web based applications screens plays very important role & they capture the requirements in best manner. This exercise ideally should be part of requirements definition & this "System architecture" definition process should begin sometime during the middle of requirement definition. Unfortunately it's a tedious task define the screens manually& as of now there is no credible way to convert HTML directly into production by few tweaks (Frameworks like Tapestry & Wicket web frameworks certainly makes better compare to other approaches).
"Application Architecture" Should capture the different technical layers & their components. It also should capture the over-all application modules & their relationships. Integration is the most painful aspect development as it not only involves code integration it also requires to people also communicate & integrate. More emphasis should be given in declaring the interfaces & handshaking mechanisms between the teams & modules.

Conclusion:
Software Architecture is very challenging, I guess aspiring Architects need to focus get in touch with real developers & do active coding rather than relying on marketing literature available in Internet. The best brains sitting in ivory tower developing specification (Martin Fowler calls them Harvesting frameworks) really doesn't add much value compared to specification/frameworks that comes out as by-product of developing real time applications like Spring, Rails. (Non Harvesting frameworks). Unless Software Architects stop forming their opinions based marketing literature and blogs, they will be forced to be called as "White Elephants" of software industry.

Some tips on developing Swing applications:

I recently developed one small application in swing . Here are some comments on tricks & libraries I used.

1. Using Template Method Pattern to simplify code

ActionTemplate :

JButton button = new JButton("Ok");
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event){
//do some stuff here
}
});

This is how usually we handle the actions (I don't believe in separating out actionlisteners code from components declarations, it is always easier/better to keep them as near as possible) Anonymous classes provides easier way of achieving this;

from the above code I noted that,
1. In anonymous class, I will never use ActionEvent class & I don't want see it. It's an intrusive model.
2. Many times I want to handle actions asynchronously (like using SwingUtilitilities.invokeLater() routine), I don't want to repeat in every action listeners code.
3. I also want to display a wait cursor during this time & should be optional way of passing the icon @ runtime;
4. I also want to print the time taken & memory consumed for each actions; & I don;t want to repeat that, I also want to take that out from the code once the application in production.
6. actionPerformed method name is not intuitive, although ActionEvent not used 90% of time I do use it 10% of time when I write inner or separate ActionListener classes, it should be available for me.

Here is how I propose to handle this using template pattern.
ActionTemplate is abstract class having clicked() as abstract method & with default implementation for all other features.

button.addActionListener(new ActionTemplate() {
public void clicked(){
//do some stuff here
}
});
This is fine for me 90% of time.Now code is less & looks simpler. This is clearly non-intrusive model & all the extra features are defaulted and can be easily changed by over-riding when required. (Convention over configurations)

In case to handle the event asynchronously whenever some tasks lot of time, we can over-ride isAsynchronus call. isAsynchronus() will return false by default.

button.addActionListener(new ActionTemplate() {
public void clicked(){
//Some lengthy stuff here, So cannot make AWTDispatch thread to wait till it's completed
}
public boolean isAsynchronus(){
return true;
}
});

Similarly there can be callback methods for setting the wait cursor, monitoring completion status, (getWaitCursorIcon(), done() etc...)
We can also get the ActionEvent which is member variable for ActionTemplate class.

Similarly for WindowTemplate we can add closed, closing, max(), min() etc...
& for MouseTemplate methods like pressed(), clicked(), hover(), rightClikced(), doubleclicked() etc...
These will easier to understand & code than their Listener counterparts. I guess this approach is near to closures. Lack of closure in java is really a bottleneck while coding event handling. We are forced to deal with anonymous & final variables

Although I don't feel these tricks can be used in large projects (As adding more APIs to likely to confuse more) but this type of techniques will be very useful when we write applications in a very small team or by a single person, where using AOP, XML, Properties file based action handling framework using reflection is not an option (because of learning curve & the increase in total java source/jar size)

2. Window Dissolving tricks
While going through the Swing Hacks book, I came across one dissolving hack. I also wrote some inspired from that, although they are too simple but can give window closing a different experience :-), Feel free to copy & use it from here.

3. External libraries
There is no point re-inventing the wheel, there are abundant high quality JFC components freely available, but the problem is most of them will come big baggage (in terms of size & API complexity).
I used these libraries & had no problem whatsoever with these.
JFreeCharts - For reporting through charts
iText - For Generating the pdf reports
I have used these excellent libraries in the past (but with J2ee applications)
DesignGridLayout - As layout manager

It is always better to code these in such a manner that if even when we take out these jars, application should work properly.It is always better to make these libraries not to be part of core functionalities. I handled these by neglecting ClassNotFoundException in appropriate place where-ever I am using such libraries. In case of applet & webstart it is not practical to use these heavy libraries as they increase the download time & there might be issues with licensing as well. So for an applet/java webstart versions JFree charts, iText & other external jars will not be included, I just remove these jars from library to make it light weight, that's it no code change required :-)

4. Layout Manager
I did not wanted to use the GridBagLayoutManager, it was regarded as un-necessarily complex for developing Swing applications. I tried out generating UI with my favorite IDE NetBeans. I did not like the code it generated. May be I need adjust with this kind of code in future. First the code generated was looking ugly & I wanted to use my custom components which I need to add & I like doing small tasks by defining actionlisteners there itself, the code generated lot of default methods. As of now I can think of using it only for prototype.


I looked into layout managers who all claimed to be better alternative to GridBagLayoutManager, I actually looked into the code of most of these layout managers & they are indeed provide lot ease in developing layouts,some introduce more complexity
I came across this debate on from layout manager showdown, All kudos to John for the splendid job done by comparing layout managers.
I found MigLayout to be best in solving all types of complex requirements, But for my screens I found DesignGridlayout the simplest after going through the sample code. As it is based in standard JDK library, this should be first choice for developing simple grid based screens.

For example, I wanted to design my layout something like this;

& it took 12 lines to do that, & code was too simple.

public void build(DesignGridLayout layout){
layout.row().center().add(title());layout.row().height(10);
layout.row().center().add(new JLabel("Email ")).add(user());
layout.row().height(5);
layout.row().center().add(new JLabel("Password ")).add(pwd());
layout.row().height(5);
layout.row().center().add(new JLabel("Exam List")).add(examList());
layout.row().height(5);
layout.row().center().add(signIn());
layout.row().height(15);
cancelButton = new JButton("Cancel");
loginButton = new JButton("Ok");
layout.row().center().add(loginButton).add(cancelButton);
}

It was such a simple task to develop for other such screens as well

5. Code Samples from Experts
Swing Hacks & Filthy Rich Clients are the best books on swing written by highly credible authors. The source code that comes with these books are also excellent resources.
There are quite very nice ideas explained well for developing custom components. Source code for the both the books can be freely downloaded, but I suggest to buy the books.

These are the excellent code I re-used in my application
Pieter-Jan Savat's wonderful utility on page turning effects in swing.
Simon's flashy & bouncy effects with swing.
Hyper Link listener for handling links

6. Leveraging New JDK1.5 APIs Features:
Using new JDK1.5 features can simplify the coding to great levels; JDK1.5 has been one of the biggest release in java's history.
For example, now it is possible to add data to the to list like this;
List l= list("praveen","manvi","test"); using

public static List list(T... elements) {
List list = new ArrayList(elements.length);
for (T elem : elements){
list.add(elem);
}
return list;
}

These tricks will be useful especially writing Models for UI components. The above sample shows the usage of improved for() loop, generics & variable argument options.
I found this explanation good with samples.