Hello advanced Java developers,
I am Hasan, the founder and moderator of JViews, an online discussion group
primarily for Java/J2EE aspirants (http://groups.yahoo.com/group/JViews)
JViews was setup in early October this year and has grown at a fast pace.
Now, it has more than 500 international members. So far most of the discussion
has centered around core Java but with time, I expect the focus to broaden.
Inspired by Bruce Eckel's online book "Thinking in Java", I am launching
a project on the same line. The book "JavJungle" will be for advanced developers
and will cover topics of practical significance that are otherwise hard to
find anywhere else. Here is a shot description of the proposed contents.

Core Java developer's heaven
The first ever free mock test for the Java developers. This chapter will
provide a mock Sun Certified Java 2 Developer test. The focus will be to
deliver enough guidance so that the real SCJD test can be passed without
difficulty. The material will be divided in 5 parts: 1) a complete mock test
assignment and a sample follow up exam in line with the test given by Sun
2) coverage of relevant topics like Threads, JTable, RMI, object serialization
etc. 3) discussion of best practices for topics like exception handling,
best coding practices, javadoc comments etc 4) complete solution 5) design
choices like RMI vs sockets, subclassing Thread or implementing Runnable

Weaving the web right
A thorough discussion of the web development best practices aimed at enriching
the user experience and improving data integrity. Specifically, how to keep
the user from posting the HTML form twice, how to check for the integrity
of the post at the server preventing the fake (duplicate) posts i.e. if the
user has pressed back/refresh button after submitting the form, how to minimize
network trips e.g. by embedding the logic to check for log in status at the
client side, how to set the cursor in the specified text field upon page
load etc., and the pros and cons of these approaches. Most of this material
has already been covered in the Professional Tips series at JViews. However,
complete real life code examples will be provided along with the theoretical

Objects objects every where..
A primer for future architects. The chapter will be divided into 2 parts.
The first chapter will comprise of a case study covering "tangible" objects
like students, professors, classes, books, reservations, etc. and how to
model them in UML. The focus will be on the application of figurative concepts
like inheritance, composition etc. to real world situations and the conceptual
ideas behind class diagrams, interaction diagrams etc. The second part will
show how to translate this UML model into working Java code.

Java command and control
An introduction to design patterns covering the Command pattern in detail
with its application to the Swing menus and navigational JButtons thus eliminating
the if/else mob from the code. Another complete example will focus on using
the Command pattern on the server side with JSP/servlets.

HTML: From static to dynamic.
Today's dynamic HTML engines provide a very fine layer of abstraction thus
shielding the developer from the intricacies of the underlying HTTP protocol.
This on one hand is beneficial for people just beginning to work on dynamic
HTML but for advanced users, a thorough grasp of the field is not possible
without understanding what's going on under the hood. J2EE practitioners
are even more confused with questions like: what's a container, why did Sun
"invent" JSP when servlets were doing their job well, what is a specification,
what is a reference implementation..etc. Answers to such questions will be
provided with the help of a very simple HTTP server hooked to the simplest
servlet engine prototype. A very simple JSP parser will also be developed
and the reader will be able to understand why was JSP needed in the presence
of servlets and how and why does a JSP convert to a servlet to service the
client request. The HTTP server and the "JSP/servlet engine" will be very
simple programs just to provide a sample of inner workings of a dynamic HTML
service engines. In the end, the importance and explanation of protocols,
specifications, reference implementations etc. will be given.

XMLers primer
No book out of those so far I have read, provide the details of what exactly
is XML and why it is advantageous over XML. This chapter will focus on a
high level explanation of what is lost in HTML is not lost in XML, what is
XSL, why XML is not appropriate for your browser but for the B2B server,
what is XSLT etc. The focus will be on concepts not code. And of course,
the relevance of Java and XML and why Java is the best language to work with

To EJB or not to EJB
I have seen many EJB developers who don't understand the real benefit of
EJBs. The down side is that they will use EJBs in situations where a simple
JSP/servlet solution is more appropriate. A history of distributed systems
and the evolution of the EJB will make clear why and where are EJB a good
choice and where they should be avoided. The chapter will also focus on why
the cost of the application server is not an issue when EJbs are appropriate.

.Net or .Not
A continuation of the evolution narrative of distributed applications and
where this dot on the net fits into it. Aso covered will be its benefits
over J2EE (please don't byte me) and where .Net and not J2EE is the right

What's happening to the enterprise?
Corporate Portals, Corporate Intranets, Enterprise Resource Planning, Enterprise
Application Integration, Enterprise Integration Portals......there are too
many of them. A high level view of what all these are and where today's enterprise
is heading. And of course, how Java fits in this situation.

Tips for the Java learning gurus
A selection of the finest Java/J2EE tips with examples including those and
adding on those presented in the Professional Tips series at JViews.

An interview with Mr. J
A collection of real life job interviews for Java/J2EE aspirants.
Games programmers play
A little bit of organizational behavior involving the office in which all
of us are spend more time than we spend at home (at home the majority of
time we spend is for sleeping). Also included will be the effects of the
overlap of professional life over private life and how to break the net of
fellow conspirators. Some software project management, how to enjoy the work,
hints on managing developers' teams, etc.

It will be an honor if any one of you would like to contribute in this effort.