This week's book giveaway is in the OCPJP forum.
We're giving away four copies of OCA/OCP Java SE 7 Programmer I & II Study Guide and have Kathy Sierra & Bert Bates on-line!
See this thread for details.
The moose likes Beginning Java and the fly likes Java Future : Tigers and Mustangs and Dolphins Big Moose Saloon
  Search | Java FAQ | Recent Topics | Flagged Topics | Hot Topics | Zero Replies
Register / Login


Win a copy of OCA/OCP Java SE 7 Programmer I & II Study Guide this week in the OCPJP forum!
JavaRanch » Java Forums » Java » Beginning Java
Bookmark "Java Future : Tigers and Mustangs and Dolphins" Watch "Java Future : Tigers and Mustangs and Dolphins" New topic
Author

Java Future : Tigers and Mustangs and Dolphins

somkiat puisungnoen
Ranch Hand

Joined: Jul 04, 2003
Posts: 1312
I found some document about future of java.


Whew! I can just about hear the collective sigh of relief from everyone, both inside and outside of Sun, who contributed to this amazing product. We hope you enjoy working with it. As I've said before, I think Tiger is the highest-quality JDK that we've ever built -- and I've been helping to build these things since JDK 1.1.

This seems an appropriate time to look forward, and in particular at some changes that we're making to the J2SE release model.

The current model has three kinds of releases:

Feature releases are the big ones (1.3, 1.4, 1.5 5.0), with tons of bug fixes and lots of new features. These have generally been about 24-36 months apart.
Maintenance releases, the so-called "dot-dot" releases (1.4.1, 1.4.2, etc.), have lots of bug fixes but no new API features. Lately these have been about 8-10 months apart.
Update releases, the so-called "underscore" releases (1.4.2_01, 1.5.0_01 5.0 update 1), which contain a very small number of bug fixes (typically around 100) carefully chosen to meet urgent customer needs. Sun has shipped these about every 3-4 months.
Going forward we're going to simplify this model and increase the rate at which we ship releases. In particular:
Feature releases will ship every 18-24 months. This will allow the platform to evolve more rapidly so as to better meet the needs of the developer community and compete with .NET.
There won't be any more maintenance releases. Starting with Tiger (5.0) there won't be any more releases the size of 1.4.1 and 1.4.2, i.e., with 1500-2000 bug fixes. There still might be a release called "5.1", but it will just be a special update release.
Update releases will ship every 2-3 months. This will make it possible for critical bug fixes to be delivered to customers in a more timely manner.
Changing the release model is not something we've done lightly; this is the result of several months of investigation and many conversations with partners and developers in the community. A couple additional expected benefits of these changes are:
Releases will more likely ship on time. Within the J2SE engineering organization we've long wrestled with the difficult choice of making the current maintenance release as perfect as possible versus working on great new features for the next big feature release. This conflict has been the proximate cause of many schedule slips over the years. The new release model finally resolves this fundamental tension: J2SE engineers will, by default, always be working on the next feature release. There will be times when they're asked to fix a critical bug in an update release, and even rarer times when some nontrivial work (e.g., to improve performance) will be done in an update release, but these will be the exceptions rather than the rule.
Release adoption will improve. The existing medium-sized maintenance releases have long been a big adoption barrier. Due to the level of change in these releases many users have only been confident enough to adopt them after requalifying all of their applications -- in other words, by treating them much like feature releases in terms of testing. Most users are confident enough in the update releases to just "drop them in" without doing a lot of testing; now they'll be able to do so for a longer time in between feature releases.
These are not easy changes to make. We're still in the middle of figuring out a bunch of the details, so reality over the next couple of years might not exactly match what I've described above. Overall, however, we think that the improved focus and increased agility of the new release model will bring big benefits to the platform and to the Java community.


what do you think about this document and future of java ?


Reference Website
http://weblogs.java.net/blog/mreinhold/archive/2004/09/tigers_and_must.html


SCJA,SCJP,SCWCD,SCBCD,SCEA I
Java Developer, Thailand
Pradeep bhatt
Ranch Hand

Joined: Feb 27, 2002
Posts: 8919

Future of java is bright.


Groovy
Peter van der Linden
author
Ranch Hand

Joined: Sep 28, 2004
Posts: 46
Sun, like every honest software company, has always wrestled with the conflicting goals of
"get the new stuff out there!" versus "fix the old stuff people are heavily using!"

That text can be summarised as:

OLD RELEASE MODEL
- feature release, 2-3 years apart
- maintenance release, 8-10 months apart
- update release, 3-4 months apart


NEW RELEASE MODEL
- feature release, 1.5 - 2 years apart
- maintenance release, no more of these
- update release, 2-3 months apart

So Sun is saying "we will make the biggest releases and the smallest releases come out
TWICE as frequently, and we will do this by taking effort that formerly went into the
medium-sized releases".

Here is what Sun should do, and what I think they will end up doing in any case:
1. there will be a release, 3 times a year, at or near the end of Feb, June, Oct.
this release will usually be a dot-dot release with just bug fixes in it.

2. periodically, marketing will announce a feature release. That will take the place of
the next dot-dot release.

Inside Sun, there will be
two "trains" under development - the next feature release, and the next
dot-dot bugfix release. The bug-fix release code base is brought over into the
feature release at daily or weekly intervals. But no code ever goes from the feature
release into the bugfix release.

In this way customers can be assured that the dor-dot release is stable.
And that the feature release never "drops" a bug fix.
These two attributes are critical.

We'll see. It's good that Sun has planned out how they will make releases. They
now have a target to stick to.

Cheers!

Peter


Author of <a href="http://www.amazon.com/exec/obidos/ASIN/0131482114/ref=jranch-20" target="_blank" rel="nofollow">Just Java(TM) 2 (6th Edition)</a>
 
It is sorta covered in the JavaRanch Style Guide.
 
subject: Java Future : Tigers and Mustangs and Dolphins