O''''Reilly Network For Information About''''s Book part 6 pps

2
2.4.1. Servlets
As applets were winding down on the client side, the server side was just getting
going. Servlets gave Java developers a way to write applications that would run in
the browser. An application would get a request over HTTP, and build a plain web
page, with no Java, that would return to the client. Since the web pages were built
server side, they could take dynamic content, like the results of database queries,
back down to the client. So-called web-based applications finally delivered the
goods: now, you could run enterprise applications on a client. You'd only have to
deploy them on a server.
It didn't take long to understand that the clients could be within the firewalls of a
company, but they didn't have to be. Since people everywhere had Internet access,
it opened up the possibility of selling a whole new kind of product: information.
The new economy was born. At least in part, it was powered by Java, and the
companies that built the servers, databases, and software. Start-up companies
sprung up to take advantage of this opportunity. Enormous paper wealth was
created. Venture capitalists funded good ideas and bad. A drive for customers fed
the fury of the storm. The rules were simple: he who gets the most customers wins.
Start-ups were often willing to spend far more to acquire a customer than that
customer could possibly generate.
Real wealth was created, too. Companies like eBay and Amazon fueled a new kind
of economy without buildings or walls. This new sophisticated commerce drove a
new need for new tools. Sun, Oracle, BEA, and IBM worked on new standards to
enable enterprise on the Web. IBM coined the term e-business to stand for a new,
powerful way to serve customers.
2.4.2. J2EE
J2EE, or Java's enterprise edition, included many new ways to connect to the

enterprise. Under great expectations, the Enterprise JavaBeans? (EJB) spec
emerged to add a rich set of tools that would let you program distributed,
transactional, secure, and persistent applications, without coding those services
yourself. Clustering features enabled good scalability and reliability. These
features let major companies move into the Java world without reservation.
Though EJB never quite fulfilled its promise, the specification is an extraordinary
example of how an idea can energize a community. The specifications behind EJB
are tremendously important, and for the most part, are factored very well. Java
thrived on the server side and was off to the races again.
2.4.3. Industry Standards
It's tough to unite through common interests. Java never could have thrived to the
extent that it has with only Sun behind it. Some unifying force needed to hold them
together. A common enemy in Microsoft was the perfect catalyst.
Software is more prone to monopolies than most other industries because software
moves fast and obsolescence can devastate a company. For this reason, market
share tends to favor the market leader heavily. So it stands to reason that market
leaders love to be proprietary. They can increase market share through their
leadership position, and lock their customers in to extend the monopoly. Certainly,
Microsoft is not the first company to use this strategy. IBM was incredibly
proficient at this game.
If being pro
prietary works for the market leader, the followers need open standards
to level the playing field. If you can't build dominant share, you can lend your
customer safety by creating partnerships and embracing a common standard. In
this way, your customers are not nearly as afraid of obsolescence.
The Unix operating system helped smaller proprietary server vendors survive for
years in the face of market dominance by Intel and Microsoft. After supporting
proprietary systems aggressively for decades, IBM is embracing open standards in
many areas, including relational databases (where it trails Oracle), operating
systems (where it made mainframes a much safer solution with the open source

Linux environment), and now, with Java.
IBM is now the most prevalent Java developer. It claims to have more Java
developers than any other company, including Sun. I believe IBM. It has been
working to catch BEA's Web Logic application server for years, and has now
passed BEA. I'd expect IBM to exercise its dominance to build in proprietary
features that interest its customers. I would also expect IBM to take a harder line
with the Java Community Process (JCP), to force through changes that it finds
most interesting. Failing that, it may leave the JCP and seek another avenue for
e
stablishing standards. If it does, this strategy should not come as a surprise. It's the
prerogative of the market leader, and the dance goes on.
2.4.4. Open Source
Many open source communities look down on Java. That's ironic, because Java has
more thriving open source software than any of the alternatives. When you build
something that's both hip and popular, people want to play with it and share their
creations. Add a massive community that's stretching a language in unexpected
ways, and you need only to stand back and watch interesting things happen. And
boy, did Java open source happen.
At first, Sun resisted the open source community . Sun developer, James Duncan
Davidson, worked to change that. He built two of the most important Java
applications ever in Tomcat (that showcased servlets) and Ant (that builds nearly
all Java applications today). He then pushed them out to the open source
community.
The typical open source development cycle works as follows (and shown in Figure
2-4):
1. Build. Once Java geeks solve a problem often enough, they often build the
solution with their own resources. Sometimes, they're solving business
problems. Other times, they're just having fun.
2. Use. Users then exercise the solution. Those that don't get used atrophy and
die.

3. Refine. Users then refine the solution, to match their requirements.
4. Contribute
. Users then contribute to the project, either with feedback or with
code enhancements. They are willing to do so, because they won't have to
maintain enhancements.
Figure 2-4. The open source feedback cycle is tremendously important to Java

In this way, some fantastic frameworks evolved to form the foundation of Java
web-based development. Today, you'd be hard-pressed to find a major company
that does not take advantage of open source software. These solutions are
pervasive in the Java community:
 Developers use JUnit to build automated test cases, which run with every
build.
 IT shops run Apache Web Server as their preferred web server.
 Customers deploy many lightweight applications with Tomcat as a servlet
container.
 Developers look to Hibernate for persistence.
 Web-based developers use Struts to separate model, view, and controller
layers of their applications.
 Programmers worldwide use Ant to build applications.
 Other frameworks like Lucene (search), Spring (infrastructure), Tapestry
(web-based component design), JBoss (J2EE), and many others seem to be
gaining popularity as well.
You might think that open source development would threaten software companies
that build software, but the converse is true. Open source has served Java very
well. Innovation in the open source community keeps tremendous pressure on
software companies to keep up. That's healthy. If you're providing real value, you'll
thrive. If you try to live off of technology that's well understood and popular, you'll
die. Open source software raises the bar of what you've got to do to make money.
IBM has dealt with the pressure well. BEA is withering under the heat, with IBM

above and JBoss below. Either you will see BEA innovate, or an open source
framework like JBoss, Geronimo, or Spring will catch it on the low end. Either
way, you'll win.
You could even argue that open source software is driving the most important
innovation in the Java space. Open source is driving adoption and implementation
of integrated development environments, aspect-oriented programming,
lightweight containers, persistence, unit testing, and the best web MVC
frameworks. It's driving the actions of the largest and most powerful Java vendors.
That's an incredible testament to the might of the Java open source community.




2.5. Aftermath
I believe that Java is now the most successful programming language ever. It
redefined the way we package and deliver software. It changed the way we feel
about interpreted languages, and the way we build Internet applications. Java
changed the very economics of application development by bringing deployment
and management into the overall equation. It built a new affinity for libraries, with
strong web-based support. Java ushered in a massive wave of important standards
that now form the very foundation of enterprise software development. Java has
changed the rules of the gameJava completely rewrote the rulebook defining what
it takes to be a commercially successful programming language.
In some ways, Java's new rulebook will serve us well. To achieve similar success,
a new language will need to be portable and encourage a vibrant open source
community. It will need broad appeal, across low-level programmers and
architects. It will need to embrace compelling standards.
But technology is only part of the problem. For a new language to succeed, you'll
also need a compelling business reason to switch. In some ways, Java held us back
by discouraging competition. You may be tempted to use Java, even if it's the

wrong tool for the job. You may work harder than you have to, because you're not
free to explore alternatives. And this situation may lure us into a false sense of
security, just as so many Java developers feel so comfortable wholly inside Java's
cocoon.