|
 Is IBM or Sun doing it right?
Remember 8 years or so ago when "Java" meant "That thing from Sun"
and people used it here and there to create applets and applications?
Remember 4 years or so ago when "Java" got a reply like "Do you mean
client side or server side?" at which point you then had to further
quantify your response. Do you also remember
yesterday when Java was no longer "That thing from Sun" and is now
"that
thing used everywhere by everybody"?
There was an interesting post on JL recently showing the trend
changes in Java compared to 3 other popular languages. Even while
Java is decreasing, its popularity is magnitudes more popular
than the others. It's interesting that this trend makes Java look like
it's
decreasing according to Google, but what I think is happening is that 4
years ago C# was called C# and Python was called Python and Java was
called Java. Today, Java is no longer called Java. Java is called
"Swing, SWT, Eclipse, NetBeans, J2EE, Spring, Hibernate, JSF,
Enterprise Beans, Persistence Mapping, XML parsing, etc. etc.". The
idea that you can even refer to "Java" anymore and have anyone know in
any sort of specifics what you are talking about is just not accurate.
Client side developers now would probe you to figure out if you are
talking about a RCP framework? Swing? SWT? Server side developers would
want to know are you using JSF, Struts, Spring WebFlow, Wicket or 100
other frameworks that are all Java. If we could combine trends with all
these Java-based technologies into one entity called "Java" in the
Google trends graph, I think we would see a sharp spike around 2001 or
2002 to the moon that is still increasing.
It was right before this explosion that Sun still had total control
over Java, say 2000 or so. Sun could direct the specification, language
and implementation in any direction they wanted. Everyone was just
happy to have a technology that was saving them time and money.
Unfortunately, it seemed Java was a victim of it's own success. It was
so successful that IBM set off working on their own JDK implementation.
A year or two later the Classpath project starting work on a fully
compatible open source implementation of the Java libraries as
well as Blackdown continuing to toil away with porting the JDK to
Linux. Why all the divisions of labor? Why can't this effort and work
be centralized? Well, it seems, that isn't what Sun wanted, so all
these efforts continued forward individually.
Companies and individual developers alike are starting to get annoyed
with this approach. Why are there so many JDKs to choose from on Linux?
Why are there multiple JDKs at all? Why is there still no stable
application framework for me to drag and drop widgets and develop an
application I can ship to a customer? You see where this is going.
There was a need and it wasn't being filled. Eclipse filled the need of
companies and developers to normalize their efforts on a single
platform; on a single technology.
Eclipse has provided consistency and reliability to the Java
developer community that wasn't being provided before. The way this was
done and executed
so well put
companies in a financial position where it was in their best interests
to advance the platform and make sure it was going where they needed it
to go. Out of the gate, Eclipse's development was handled mostly by OTI
and IBM personel, with folks from other tools companies comming into
the mix. A great mix of pragmatic platform folks trying to keep things
general enough for everyone and tool-vendor employees bringing up
points for support that are needed and other issues in the platform
(e.g. task lists, general content assist, highlighting support, etc.).
With a relatively new platform like Eclipse 1.0 or even 2.0, I can
understand the thousands of enhancements and bug fixes pouring in from
the strategic partners could keep a team busy for years, but
what about now? What about now that Eclipse is creeping towards 4.0 and
the platform already supports vendors from the healthcare industry, to
the software development community, to the hotel reservation industry,
to the biomedical industry. Eclipse already supports core features that
make all these people happy? What other vendors could join the
strategic program and possibly guide Eclipse in any way it hasn't
already gone? Anything too specific will not be included in the platform
and should most likely be broken out into an Eclipse project. This is a
fork in the road. Down one path (to the left) you have a steady set of
the same developers that got Eclipse to this point, they don't accept
too specific of changes in platform because it only serves a specific
nitch vendor(s). So what's the incentive for more and more strategic
partners to join which help fund the foundation and the development
significantly? Down the other path (to the right) you allow a slow
trickle of developers into the platform from all over that are constantly
making additions, some very specific to their company's needs, to the
point that over time Eclipse 4.0 and later become a huge mess of every
combination of anything that you could ever consider. At least in the
Linux kernel you can ignore rediculously specific drivers that you
don't need, but if you are shipping a product on the Eclipse platform,
you may need to include the thumbnail generator libraries that Adobe
added when they became a strategic partner (that's a poor example, this
didn't actually happen).
On Javalobby we see people complain day in and day out
about JDK bloat. What are we looking at happening with Eclipse? This is
just the natural progression of every platform. At what point does the
foundation say "Ok stop it, this thing is too huge, let's break
the platform out into sub platforms. Client platform and server platform"
(see here
and here
for reasons why this might happen). Do
they actually break them apart or keep it all together to create a
better out-of-box experience like the JDK has done? What happens in 2,
3, 4 or more years when Eclipse is "functional enough" for all the
companies that bought into the strategic development program, they say
"Hey let's keep our money and drop out, the platform does what we
need." I'm curious what contingency plan there is at the foundation to
handle this situation. I'm not suggesting all the companies drop out,
but if there are 20 or 30 strategic partners right now, and when
Eclipse 4.0 ships, say 10 of them drop out because Eclipse is more than
functional enough, that is a considerable amount of money and man power
being removed from the Eclipse ecosystem. Does IBM come in and anti-up
with resources or does the foundation just start laying people off left
and right to cover that income loss? Here's an idea that I think some
of you see this going: let's say the Eclipse platform gets to version
5.0, there are only 10 strategic partners left and the platform is huge
and robust. No tool vendors or companies see a point in staying
affiliated with the foundation as they have what they need now. Now we
are assuming at this point that Sun hasn't gone into hiding, they've
been enhancing not only the JDK but their application platform
(NetBeans platform) itself for quite a while and it is looking quite
attractive. IBM is faced with a situation where Eclipse could be poised
to start losing interest as the development dwindles and resources
pull out, so they buy back the foundation and assimmilate it back into
IBM and take over complete control of Eclipse and all it's subprojects.
Interesting isn't it? If you think about either approach, the Sun
approach or IBM approach, you can see where the paths diverge and then
converge down the road. Both approaches have merit and will have their
own ups and downs. I think the Eclipse dip is still so many years off
that not many people have considered it, but *everything* takes a dive
at some point and I think this column outlines a potential dip in
Eclipse's development that hasn't been discussed. As hard as we are
being on Sun, who knows, maybe in 2-4 years NetBeans will become the
new golden child and we will all talk about how pointless Look and Feel
is now and the important things for application development are XYZ...
whatever XYZ are at that point.
Until Next Time,
Riyad Kalla
editors@eclipsezone.com
|
21 Ways to Use Spreadsheets in Java Apps!
EZ News Corner
