The evolution of web architecture and design

Look at the computer sitting in front of you, and you see the culmination
of architecture and design going all the way back to Charles Babbage’s
steam-powered analytical engine. You can use a computer without
knowing anything at all about the workings of the underlying mechanism.
However, if you know how it evolved to the point where it is now, you have
a much richer understanding of why it works the way it does. For the same
reason, understanding how the design and architecture of web applications
has evolved provides valuable insight into how and why the architecture
is sound.
Part 1 covers the evolution of the architecture and design of state-ofthe-
art web applications. It does not discuss servlets, JSP, and custom tag
development from an API standpoint because plenty of other texts are
available that focus on those topics. Instead, we examine these APIs from
a design and architecture perspective, describing how to build web applications
that are scalable, maintainable, and robust. Chapter 1 provides an
overview of the topics for the entire book. Chapter 2 covers the evolution
of web development in Java; chapter 3 explores that evolution through
custom JSP tags. Chapter 4 discusses the preferred design and architecture
option, Model 2, along with some architectural options.
The World Wide Web is a perfect example of how a simple idea (pages linked via
hypertext) can lead to extraordinary richness. Originally envisioned as a way to
provide static pages (now affectionately known as “brochure-ware”), the medium
quickly grew to embrace dynamic content. These original efforts were written in
languages like C and Perl. As time and technology progressed, new application
programming interfaces (APIs) sprang into existence, each building and improving
on the preceding technologies. New APIs appear because developers discover
limitations in existing languages and tools. Limitations in existing APIs led to the
repurposing of Java for building dynamic web content, first as servlets, then as
JavaServer Pages (JSP). The history leading from Perl, Common Gateway Interface
(CGI), and C is well documented in just about every book on the servlet and
JSP core APIs.
Developers coming from more traditional application development (for example,
client/server applications) discover that building web applications is fundamentally
different in many ways. Even if you are fluent in Java, the architecture
and design of web applications doesn’t necessarily come naturally. Just as the
switch from console applications to event-driven applications required a major
shift in thinking, the switch from event-driven applications to the stateless world
of web development requires a paradigm shift as well. Even an understanding of
the basic infrastructure of web applications won’t immediately reveal the most
effective architecture and design. Many decisions made early in the design and
development process have unforeseen repercussions later in the process. Because
of the oft-quoted and well-documented cost of architectural and design changes
late in the application lifecycle, it behooves you to get it right from the outset.
This chapter provides an overview of the topics we cover in this book. First, we
discuss the evolution of Java web development and the importance of design patterns.
Next, we examine web application frameworks (which are the topic of
part 2 of this book). Finally, we examine best practices (the focus of part 3), along
with a hot-button issue that falls under that heading. The main goal of this book is
to show you how to apply best software-engineering practices to the development
of web applications in Java.