Title: Refactoring: Improving the Design of Existing Code
by Martin Fowler, Kent Beck (Contributor), John Brant (Contributor), William
Opdyke, don Roberts

Format: PDF

This book is a guide to refactoring; it is written for a professional programmer. My aim is to show
you how to do refactoring in a controlled and efficient manner. You will learn to refactor in such a
way that you don't introduce bugs into the code but instead methodically improve the structure.
It's traditional to start books with an introduction. Although I agree with that principle, I don't find it
easy to introduce refactoring with a generalized discussion or definitions. So I start with an
example. Chapter 1 takes a small program with some common design flaws and refactors it into
a more acceptable object-oriented program. Along the way we see both the process of refactoring
and the application of several useful refactorings. This is the key chapter to read if you want to
understand what refactoring really is about.
In Chapter 2 I cover more of the general principles of refactoring, some definitions, and the
reasons for doing refactoring. I outline some of the problems with refactoring. In Chapter 3 Kent
Beck helps me describe how to find bad smells in code and how to clean them up with
refactorings. Testing plays a very important role in refactoring, so Chapter 4 describes how to
build tests into code with a simple open-source Java testing framework.
The heart of the book, the catalog of refactorings, stretches from Chapter 5 through Chapter 12.
This is by no means a comprehensive catalog. It is the beginning of such a catalog. It includes
the refactorings that I have written down so far in my work in this field. When I want to do
something, such as Replace Conditional with Polymorphism, the catalog reminds me how to
do it in a safe, step-by-step manner. I hope this is the section of the book you'll come back to
often.
In this book I describe the fruit of a lot of research done by others. The last chapters are guest
chapters by some of these people. Chapter 13 is by Bill Opdyke, who describes the issues he
has come across in adopting refactoring in commercial development. Chapter 14 is by Don
Roberts and John Brant, who describe the true future of refactoring, automated tools. I've left the
final word, Chapter 15, to the master of the art, Kent Beck.

Click to download the free ebook: Refactoring: Improving the Design of Existing Code.pdf

Title: Professional Portal Development with Open Source Tools Java Portlet API, Lucene, James, Slide
Author: W. Clay Richardson
            Donald Avondolio
            Joe Vitale
            Peter Len
            Kevin T. Smith
Format: PDF
Publisher: Wiley Technology Publishing

Portal development projects have become the centerpiece of IT acquisition and development strat-
egy for many organizations. Enterprise integration and Web application developers predictably
groan when they hear the word “portal” — nightmares of proprietary APIs, oversold features, and
shoddy tool integrations. The authors of this book have been involved in over a dozen production
portal efforts over the last several years. In that time, we have dealt with numerous products and
frameworks, including some in-house frameworks based on servlets and JSPs. Through all of this,
we began to wonder whether these commercial suites were really providing any value. We started
to realize that we could put together a framework from open-source products.
We would like to point out that our portal framework is not meant to be an all-or-nothing solution.
We present a number of tools that you may use to satisfy your enterprise portal needs, and we
demonstrate how to use them, but because portal efforts are largely integration efforts, it would be
folly to presume that anyone will drop all of their current systems and pick up our framework.
This book explains a set of tools at the foundation of an open-source portal framework, and
demonstrates how to build your own portal using open-source tools. However, before describing
the structure of the book, it makes sense to cover some fundamental concepts addressed therein.

Click to download the book: Professional Portal Development with Open Source Tools Java Portlet API, Lucene, James, Slide.pdf

Title: Creating Games in C++: A Step-by-Step Guide

By David Conger, Ron Little
...............................................
Publisher: New Riders
Pub Date: February 21, 2006
Print ISBN-10: 0-7357-1434-7
Print ISBN-13: 978-0-7357-1434-2
Pages: 464

Do you love video games? Ever wondered if you could create one of your own, with all the bells and whistles? It's not as complicated as you'd think, and you don't need to be a math whiz or a programming genius to do it. In fact, everything you need to create your first game, "Invasion of the Slugwroths," is included in this book and CD-ROM. Author David Conger starts at square one, introducing the tools of the trade and all the basic concepts for getting started programming with C++, the language that powers most current commercial games. Plus, he's put a wealth of top-notch (and free) tools on the CD-ROM, including the Dev-C++ compiler, linker, and debugger--and his own LlamaWorks2D game engine. Step-by-step instructions and ample illustrations take you through game program structure, integrating sound and music into games, floating-point math, C++ arrays, and much more. Using the sample programs and the source code to run them, you can follow along as you learn. Bio: David Conger has been programming professionally for over 23 years. Along with countless custom business applications, he has written several PC and online games. Conger also worked on graphics firmware for military aircraft, and taught computer science at the university level for four years. Conger has written numerous books on C, C++, and other computer-related topics. He lives in western Washington State and has also published a collection of Indian folk tales.

Click to download the free ebook: Creating Games in C++: A Step-by-Step Guide.chm

Title: C++ for Programmers: Deitel® Developer Series
       by Paul J. Deitel - Deitel & Associates, Inc.; Harvey M. Deitel - Deitel & Associates, Inc.
Format: CHM
Publisher: Prentice Hall
Pub Date: January 23, 2009
Print ISBN-10: 0-13-700130-4
Print ISBN-13: 978-0-13-700130-9
Web ISBN-10: 0-13-701849-5
Web ISBN-13: 978-0-13-701849-9
 
Pages: 1056

Welcome to C++ for Programmers! At Deitel & Associates, we write programming language professional books and textbooks for publication by Prentice Hall, deliver programming languages corporate training courses at organizations worldwide and develop Internet businesses. This book is intended for programmers who do not yet know C++, and may or may not know object-oriented programming.
Features of C++ for Programmers

The Tour of the Book section of this Preface will give you a sense of C++ for Programmers' coverage of C++ and object-oriented programming. Here's some key features of the book:

    * Early Classes and Objects Approach. We present object-oriented programming, where appropriate, from the start and throughout the text.
    * Integrated Case Studies. We develop the GradeBook class in Chapters 3–7, the Time class in several sections of Chapters 9–10, the Employee class in Chapters 12–13, and the optional OOD/UML ATM case study in Chapters 1–7, 9, 13 and Appendix E.
    *Unified Modeling Language? 2 (UML 2). The Unified Modeling Language (UML) has become the preferred graphical modeling language for designers of object-oriented systems. We use UML class diagrams to visually represent classes and their inheritance relationships, and we use UML activity diagrams to demonstrate the flow of control in each of C++'s control statements. We emphasize the UML in the optional OOD/UML ATM case study
    *Optional OOD/UML ATM Case Study. We introduce a concise subset of the UML 2, then guide you through a first design experience intended for the novice object-oriented designer/programmer. The case study was reviewed by a distinguished team of OOD/UML industry professionals and academics. The case study is not an exercise; rather, it's a fully developed end-to-end learning experience that concludes with a detailed walkthrough of the complete 877-line C++ code implementation. We take a detailed tour of the nine sections of this case study later in the Preface.
    * Function Call Stack Explanation. In Chapter 6, we provide a detailed discussion (with illustrations) of the function call stack and activation records to explain how C++ is able to keep track of which function is currently executing, how automatic variables of functions are maintained in memory and how a function knows where to return after it completes execution.
    *Class string. We use class string instead of C-like pointer-based char * strings for most string manipulations throughout the book. We include discussions of char * strings in Chapters 8, 10, 11 and 19 to give you practice with pointer manipulations, to illustrate dynamic memory allocation with new and delete, to build our own String class, and to prepare you for working with char * strings in C and C++ legacy code.
    * Class Template vector. We use class template vector instead of C-like pointer-based array manipulations throughout the book. However, we begin by discussing C-like pointer-based arrays in Chapter 7 to prepare you for working with C and C++ legacy code and to use as a basis for building our own customized Array class in Chapter 11.
    *Treatment of Inheritance and Polymorphism. Chapters 12–13 include an Employee class hierarchy that makes the treatment of inheritance and polymorphism clear and accessible for programmers who are new to OOP.
    * Discussion and Illustration of How Polymorphism Works "Under the Hood." Chapter 13 contains a detailed diagram and explanation of how C++ can implement polymorphism, virtual functions and dynamic binding internally. This gives you a solid understanding of how these capabilities really work. More importantly, it helps you appreciate the overhead of polymorphism—in terms of additional memory consumption and processor time. This helps you determine when to use polymorphism and when to avoid it.
    *Standard Template Library (STL). This might be one of the most important topics in the book in terms of software reuse. The STL defines powerful, template-based, reusable components that implement many common data structures and algorithms used to process those data structures. Chapter 20 introduces the STL and discusses its three key components—containers, iterators and algorithms. Using STL components provides tremendous expressive power, often reducing many lines of non-STL code to a single statement.
    *ISO/IEC C++ Standard Compliance. We have audited our presentation against the most recent ISO/IEC C++ standard document for completeness and accuracy. [Note: A PDF copy of the C++ standard (document number INCITS/ISO/IEC 14882-2003) can be purchased at webstore.ansi.org/ansidocstore/default.asp.]
    *Future of C++. In Chapter 21, which considers the future of C++, we introduce the Boost C++ Libraries, Technical Report 1 (TR1) and C++0x. The free Boost open source libraries are created by members of the C++ community. Technical Report 1 describes the proposed changes to the C++ Standard Library, many of which are based on current Boost libraries. The C++ Standards Committee is revising the C++ Standard. The main goals for the new standard are to make C++ easier to learn, improve library building capabilities, and increase compatibility with the C programming language. The last standard was published in 1998. Work on the new standard, currently referred to as C++0x, began in 2003. The new standard is likely to be released in 2009. It will include changes to the core language and, most likely, many of the libraries in TR1. We overview the TR1 libraries and provide code examples for the "regular expression" and "smart pointer" libraries.
    *Debugger Appendices. We include two Using the Debugger appendices—Appendix G, Using the Visual Studio Debugger, and Appendix H, Using the GNU C++ Debugger.
    *Code Testing on Multiple Platforms. We tested the code examples on various popular C++ platforms. For the most part, the book's examples port easily to standard-compliant compilers.
    * Errors and Warnings Shown for Multiple Platforms. For programs that intentionally contain errors to illustrate a key concept, we show the error messages that result on several popular platforms.

All of this was carefully reviewed by distinguished industry developers and academics. We believe that this book will provide you with an informative, interesting, challenging and entertaining C++ educational experience.

As you read this book, if you have questions, send an e-mail to deitel@deitel.com; we'll respond promptly. For updates on this book and the status of all supporting C++ software, and for the latest news on all Deitel publications and services, visit www.deitel.com. Sign up at www.deitel.com/newsletter/subscribe.html for the free Deitel? Buzz Online e-mail newsletter and check out our growing list of C++ and related Resource Centers at www.deitel.com/ResourceCenters.html. Each week we announce our latest Resource Centers in the newsletter.

Click to download the book: C++ for Programmers: Deitel® Developer Series.chm

Title: OReilly Head First EJB
Format: PDF

Product Description
What do Ford Financial, IBM, and Victoria's Secret have in common? Enterprise JavaBeans (EJB). As the industry standard for platform-independent reusable business components, EJB has just become Sun Microsystem's latest developer certification. Whether you want to be certifiable or just want to learn the technology inside and out, Head First EJB will get you there in the least painful way. And with the greatest understanding. You'll learn not just what the technology *is*, but more importantly, *why* it is, and what it is and isn't good for. You'll learn tricks and tips for EJB development, along with tricks and tips for passing this latest, very challenging Sun Certified Business Component Developer (SCBCD) exam. You'll learn how to think like a server. You'll learn how to think like a bean. And because this is a Head First book, you'll learn how to think about thinking. Co-author Kathy Sierra was one of Sun's first employees to teach brave, early adopter customers how to use EJB. She has the scars. But besides dragging you deep into EJB technology, Kathy and Bert will see you through your certification exam, if you decide to go for it. And nobody knows the certification like they do - they're co--evelopers of Sun's actual exam!

About the Author
Kathy Sierra, the co-author of Head First Java from O'Reilly, was a master Java trainer for Sun Microsystems, where she taught Java instructors how to teach the latest Java technologies such as EJB and Jini. Currently, she's on the design team for the Sun

Bert Bates is the co-author of Head First Java. Bert is a software developer and Java instructor, and has been writing code for the last 25 years. His background features a long stint in artificial intelligence, with a client list that includes The Weathe

Click to download: OReilly Head First EJB Oct 2003.pdf

Title: Modern Compiler Implementation in Java
Author: Andrew W.Appel and Jens Palsberg
Format: PDF
Publisher: Cambridge University Press

This textbook describes all phases of a compiler: lexical analysis, parsing, abstract syntax, semantic actions,
intermediate representations, instruction selection via tree matching, dataflow analysis, graphcoloring register
allocation, and runtime systems. It includes good coverage of current techniques in code generation and register
allocation, as well as the compilation of functional and object-oriented languages, which is missing from most books.
The most accepted and successful techniques are described concisely, rather than as an exhaustive catalog of every
possible variant. Detailed descriptions of the interfaces between modules of a compiler are illustrated with actual Java
classes.
 
The first part of the book, Fundamentals of Compilation, is suitable for a one-semester first course in compiler
design. The second part, Advanced Topics, which includes the compilation of object-oriented and functional
languages, garbage collection, loop optimization, SSA form, instruction scheduling, and optimization for
cache-memory hierarchies, can be used for a second-semester or graduate course.
 
This new edition has been rewritten extensively to include more discussion of Java and object-oriented programming
concepts, such as visitor patterns. A unique feature is the newly redesigned compiler project in Java for a subset of
Java itself. The project includes both front-end and back-end phases, so that students can build a complete working
compiler in one semester.
 
Andrew W. Appel is Professor of Computer Science at Princeton University. He has done research and published
papers on compilers, functional programming languages, runtime systems and garbage collection, type systems, and
computer security; he is also author of the book Compiling with Continuations. He is a designer and founder of the
Standard ML of New Jersey project. In 1998, Appel was elected a Fellow of the Association for Computing
Machinery for "significant research contributions in the area of programming languages and compilers" and for his
work as editor-in-chief (1993-97) of the ACM Transactions on Programming Languages and Systems, the
leading journal in the field of compilers and programming languages.

Jens Palsberg is Associate Professor of Computer Science at Purdue University. His research interests are
programming languages, compilers, software engineering, and information security. He has authored more than 50technical papers in these areas and a book with Michael Schwartzbach, Object-oriented Type Systems. In 1998, he
received the National Science Foundation Faculty Early Career Development Award, and in 1999, the Purdue
University Faculty Scholar award.

Download the free ebook: Modern Compiler Implementation in Java.pdf

Title: POJOs in Action Dec 2005
Author: Chris Richardson
Format: PDF
Publisher: Manning

POJOs in Action is a practical guide to using POJOs and lightweight frameworks to
develop the back-end logic of enterprise Java applications. These technologies are
important because they dramatically simplify how you build an application’s busi-
ness and persistence tiers. This book covers key lightweight frameworks: Spring,
JDO,  Hibernate,  and  iBATIS.  It  also  covers  EJB  3,  which  embraces  POJOs  and
some of the characteristics of lightweight frameworks.
 In this book you will learn how to apply test-driven development and object
design to enterprise Java applications. It illustrates how to develop with POJOs and
lightweight frameworks using realistic use cases from a single example application
that is used throughout the book. It even implements the same use case using mul-
tiple approaches so that you can see the essential differences between them.
  A  key  message  of  POJOs  in  Action  is  that  every  technology  has  both  benefits
and  drawbacks.  This  book  will  teach  you  when  to  use—and  when  not  to  use—
each  of  the  frameworks.  For  example,  although  the  emphasis  is  on  the  Spring
framework and POJOs, this book also describes when it makes sense to use EJBs.
It explains when to use an object-oriented design and an object/relational map-
ping (ORM) framework and when to use a procedural design and SQL directly.
This sets POJOs in Action apart from many other books that blindly advocate the
use of their favorite framework.
  Enterprise  Java  frameworks  are  constantly  evolving.  While  I  was  writing  this
book, all of the frameworks I describe had several releases. EJB 3 appeared, albeit
in draft form. And between the time this book is printed and the time you read it,
some enterprise Java frameworks will have evolved further yet. But the good news
is that this book will remain relevant. POJOs and nonintrusive lightweight frame-
works are here to stay.
 Regardless of how the frameworks evolve, there are some key concepts that will
not  change.  First,  it’s  vital  that  you  objectively  evaluate  the  pros  and  cons  of  a
framework and not be swayed by clever marketing. Second, POJOs and nonintru-
sive frameworks are a good thing. You want to avoid coupling your business logic
to an infrastructure framework, especially if it slows down the edit-compile-debug
cycle. Third, testing is essential. If you don’t write tests, then you can’t be sure that
your application works. And you must be able to write tests, so designing for test-
ability  is  also  important.  Finally,  as  Albert  Einstein  said,  “Everything  should  be
made as simple as possible, but not simpler.”

Download the book: POJOs in Action Dec 2005 .pdf

Title: jQuery in Action
Author: BEAR BIBEAULT
Format: PDF
Publisher: Manning

Do more with less.
 Plain and simple, that is the purpose of this book: to help you learn how to
do more on your web application pages with less script. Your authors, one a
jQuery contributor and evangelist and the other an avid and enthusiastic user,
believe that jQuery is the best library available today to help you do just that.
 This book is aimed at getting you up and running with jQuery quickly and
effectively  and,  hopefully,  having  some  fun  along  the  way.  The  entire  core
jQuery API is discussed, and each API method is presented in an easy-to-digest
syntax block that describes the parameters and return values of the method.
Small examples of using the APIs effectively are included; and, for those big
concepts,  we  provide  what  we  call  lab  pages.  These  comprehensive  and  fun
pages are an excellent way for you to see the nuances of the jQuery methods
in action without the need to write a slew of code yourself.
  All  example  code  and  lab  pages  are  available  for  download  at  http://
www.manning.com/bibeault.
 We could go on and on with some marketing jargon telling you how great
this book is, but you don’t want to waste time reading that, do you? What you
really want is to get your arms into the bits and bytes up to your elbows, isn’t it?
 What’s holding you back? Read on!

Download Link: Manning jQuery in Action Feb 2008.pdf

Title: Manning EJB 3.0 in Action
Author: Debu Panda
           Reza Rahman
           Derek Lane
Format: PDF
Publisher: Manning

One day, when God was looking over his creatures, he noticed a boy named Sadhu whose humor
and cleverness pleased him.  God felt generous that day and granted Sadhu three wishes. Sadhu asked
for  three  reincarnations--one  as  a  ladybug,  one  as  an  elephant,  and  the  last  as  a  cow.  Surprised  by
these wishes, God asked Sadhu to explain himself. The boy replied, "I want to be a ladybug so that
everyone in the world will admire me for my beauty and forgive the fact that I do no work. Being an
elephant will be fun because I can gobble down enormous amounts of food without being ridiculed. I
will like being a cow the best because I will be loved by all and useful to mankind." God was charmed
by these answers and allowed Sadhu to live through the three incarnations. He then made Sadhu a
morning star for his service to mankind as a cow.
EJB too has lived through three incarnations. When it was first released, the industry was dazzled
by  its  innovations.  But  like  the  ladybug,    EJB 1  had  limited  functionality.  The  second  EJB
incarnation was just about as heavy as the largest of our beloved pachyderms. The brave souls who
could not do without its elephant-power had to tame the awesome complexity of EJB 2. And finally,
in its third incarnation, EJB has become much more useful to the huddled masses, just like the gentle
bovine that is sacred for Hindus and respected as a mother whose milk feeds us all.. 
A  lot  of  people  have  put  in  a  lot  of  hard  work  to  make  EJB  3  as  simple  and  lightweight  as
possible without sacrificing enterprise-ready power. EJB components are now little more than Plain
Old  Java  Objects  (POJOs)  that  look  a  lot  like  code  in  a  Hello  World  program.  We  hope  you  will
agree with us as you read through the next Chapters that it has all the makings of a star. 
We’ve strived to keep this book as earthy as possible without skimping on content. The book is
designed to help you learn EJB 3.0 as quickly and as easily as possible. At the same time, we will not
neglect to cover the basics where needed. We will also dive into deep waters with you where we can,
share with you all the amazing sights we’ve discovered and warn you about any lurking dangers. 
This  book  is  about  the  radical  transformation  of  a  very  important  and  uniquely  influential
technology in the Java World. We suspect you are not picking this book up to learn too much about
EJB  2.  You  probably  either  already  know  EJB  2.x  or  are  completely  new  to  the  world  of  EJB.  In
either  case,  spending  too  much  time  on  previous  versions  is  a  waste  of  your  time  --you  won't  be
surprised to learn that EJB 3.0 and EJB 2.x have very little in common. . If you are really curious
about the journey that brought us to the current point, we encourage you to pick up one of the many
good books on the previous versions of EJB.

Download the free pdf ebook: Manning EJB 3.0 in Action.pdf

Title: Struts 2 in Action
Author: Donald Brown,
           Chad Michael Davis,
           Scott Stanlick
Format: PDF
Publisher: Manning

Welcome to Struts 2! If you’ve picked up this book, we suspect you’re a Java developer
working with web applications who’s somehow or other heard about Struts 2. Perhaps
you’ve worked with the Struts 1 framework in the past, perhaps you’ve worked with
another framework, or perhaps this is your first step into Java web application develop-
ment. Whichever path has led you here, you’re probably looking for a good introduc-
tion to the new Struts 2 framework. This book intends to give you that introduction
and  much  more.  If  you’ve  never  heard  of  Struts  2,  we  cover  the  basics  in  enough
depth to keep you in tow. If you know what Struts 2 does, but want a deeper under-
standing of how it does it, we’ll provide that too.
 Struts 2 is a Java web application framework. As you know, the Java world is vast
and a Struts 2 application may travel far and wide in this world of Java. With that said,
one of the biggest challenges faced by a Struts 2 book arises from trying to determine
what content to include. This book could have been three times as long if we’d taken
all  of  the  good  advice  we  received  about  what  to  include.  We  apologize  to  those
whose course of normal development takes them outside the boundaries of our con-
tent. Please believe us when we say that we agonized over what to include and what
not to include.
 Struts 2 is much more than a revision of the Struts 1 framework. If you hadn’t yet
heard anything about Struts 2, you might expect, based upon the name, to find a new
release of that proven framework. But this is not the case. Its relationship to that older
framework  is  based  in  philosophy  rather  than  in  code  base.  Struts  1  was  an  action-
oriented framework that implemented a Model-View-Controller (MVC) separation of
concerns  in  its  architecture.  Struts  2  is  a  brand  new  implementation  of  those  same
MVC principles in an action-oriented framework. While the general lay of the land will
seem familiar to Struts 1 developers, the new framework contains substantial architec-
tural differences that serve to clean up the MVC lines and make the development pro-
cess all that more efficient. We cover the new framework from the ground up, taking
time to provide a true introduction to this new technology while also taking pains to
give an inside view.
 The organization of this book aims to walk you through Struts 2 in a sequence of
increasing complexity. We start with a couple of preliminary chapters that introduce
the technological context of the framework, give a high-level overview of the architec-
ture,  and  present  a  bare-bones  HelloWorld  sample  application  to  get  your  environ-
ment up and running. After this brief introduction, we set off into a series of chapters
that cover the core concepts and components of the framework one by one. We take
time to explain the functionality of each component in depth. We also provide real
code examples as we begin the development of our full-featured sample application,
the Struts 2 Portfolio. Finally, the later chapters provide some advanced techniques
for  tweaking  a  bit  more  out  of  the  core  components,  as  well  as  introducing  some
advanced features of the framework such as plug-ins and Spring integration.

Download the free ebook: Struts 2 in Action (May 2008).pdf

Title: JUnit In Action
Author: Vincent Massol, Ted Husted
Format: PDF
Publisher: Manning

JUnit in Action is an example-driven, how-to book on unit-testing Java applications,
including J2EE applications, using the JUnit framework and its extensions. This
book is intended for readers who are software architects, developers, members of
testing teams, development managers, extreme programmers, or anyone practic-
ing any agile methodology.
 JUnit in Action is about solving tough real-world problems such as unit-testing
legacy applications, writing real tests for real objects, employing test metrics, auto-
mating tests, testing in isolation, and more.

Special features
Several special features appear throughout the book.

Best practices
The JUnit community has already adopted several best practices. When these are
introduced in the book, a callout box summarizes the best practice.

Design patterns in action
The JUnit framework puts several well-known design patterns to work. When we
first discuss a component that makes good use of a design pattern, a callout box
defines the pattern and points out its use in the JUnit framework.

Software directory
Throughout the book, we cover how to use extensions and tools with JUnit. For
your convenience, references to all of these software packages have been col-
lected in a directory in the references section at the end of this book. A bibliogra-
phy of other books we mention is also provided in the references section.

Roadmap
The book is divided into three parts. Part 1 is “JUnit distilled.” Here, we introduce
you to unit testing in general and JUnit in particular. Part 2, “Testing strategies,”
investigates different ways of testing the complex objects found in professional
applications. Part 3, “Testing components,” explores strategies for testing com-
mon subsystems like servlets, filters, JavaServer Pages, databases, and even EJBs.

Download the book: JUnit In Action.pdf

Title: Lucene in Action
Author: ERIK HATCHER OTIS GOSPODNETIC
Format: PDF

Lucene started as a self-serving project. In late 1997, my job uncertain, I
sought something of my own to market. Java was the hot new programming
language, and I needed an excuse to learn it. I already knew how to write
search software, and thought I might fill a niche by writing search software in
Java. So I wrote Lucene.
 A few years later, in 2000, I realized that I didn’t like to market stuff. I had
no interest in negotiating licenses and contracts, and I didn’t want to hire peo-
ple and build a company. I liked writing software, not selling it. So I tossed
Lucene up on SourceForge, to see if open source might let me keep doing
what I liked.
 A few folks started using Lucene right away. Around a year later, in 2001,
folks at Apache offered to adopt Lucene. The number of daily messages on
the Lucene mailing lists grew steadily. Code contributions started to trickle in.
Most were additions around the edges of Lucene: I was still the only active
developer who fully grokked its core. Still, Lucene was on the road to becom-
ing a real collaborative project.
 Now, in 2004, Lucene has a pool of active developers with deep understand-
ings of its core. I’m no longer involved in most day-to-day development; sub-
stantial additions and improvements are regularly made by this strong team.
 Through the years, Lucene has been translated into several other program-
ming languages, including C++, C#, Perl, and Python. In the original Java,
and in these other incarnations, Lucene is used much more widely than I ever
would have dreamed. It powers search in diverse applications like discussion
groups at Fortune 100 companies, commercial bug trackers, email search sup-
plied by Microsoft, and a web search engine that scales to billions of pages. When,
at industry events, I am introduced to someone as the “Lucene guy,” more often
than not folks tell me how they’ve used Lucene in a project. I still figure I’ve only
heard about a small fraction of all Lucene applications.
 Lucene is much more widely used than it ever would have been if I had tried
to sell it. Application developers seem to prefer open source. Instead of having to
contact technical support when they have a problem (and then wait for an answer,
hoping they were correctly understood), they can frequently just look at the
source code to diagnose their problems. If that’s not enough, the free support
provided by peers on the mailing lists is better than most commercial support. A
functioning open-source project like Lucene makes application developers more
efficient and productive.
 Lucene, through open source, has become something much greater than I
ever imagined it would. I set it going, but it took the combined efforts of the
Lucene community to make it thrive.
 So what’s next for Lucene? I can’t tell you. Armed with this book, you are now
a member of the Lucene community, and it’s up to you to take Lucene to new
places. Bon voyage!

Download the book: Lucene in  Action.pdf

Title: How Tomcat Works

Title:GoF Design Patterns with examples using Java and UML2Benneth Christiansson Bio:
Benneth Christiansson is a former senior lecturer and
researcher at Karlstad university.
Nowadays he works as Curriculum Manager, Open Source
Evangelist and Senior Consultant at Redpill Linpro AB.
The largest provider of Open Source solutions and services
in the Nordic area.
Benneth occupies a genuine experience as both instructor
and author, with several published books and publications.
The idea that lead to this book originated during the
participation of a Java Architect training program taught at
Logica Sverige AB Karlstad office. During the course the authors
identified the lack of a quick-guide to the basic GoF design
patterns. A book that could be used as a bare bone reference as well
as a learning companion for understanding design patterns. In the book
all patterns are exemplified using Java and UML2 notation. The book
also focuses on benefits, drawbacks, applicability and indicates
successful real life usage of the individual patterns.
Co-authors are all employees at different Logica Sweden AB offices.

Title:Expert Spring MVC and Web Flow

Title: Core JavaServer Faces, Second Edition
Author: David Geary, Cay Horstmann
Format: CHM
Publisher: Prentice Hall
Pub Date: May 08, 2007
Print ISBN-10: 0-13-173886-0
Print ISBN-13: 978-0-13-173886-7
 
Pages: 752


Overview

JavaServer Faces (JSF) is quickly emerging as the leading solution for rapid user interface development in Java-based server-side applications. Now, Core JavaServer? Faces—the #1 guide to JSF—has been thoroughly updated in this second edition, covering the latest feature enhancements, the powerful Ajax development techniques, and open source innovations that make JSF even more valuable.

Authors David Geary and Cay Horstmann delve into all facets of JSF 1.2 development, offering systematic best practices for building robust applications, minimizing handcoding, and maximizing productivity. Drawing on unsurpassed insider knowledge of the Java platform, they present solutions, hints, tips, and "how-tos" for writing superior JSF 1.2 production code, even if you're new to JSF, JavaServer Pages?, or servlets.

The second edition's extensive new coverage includes: JSF 1.2's improved alignment with the broader Java EE 5 platform; enhancements to the JSF APIs; controlling Web flow with Shale; and using Facelets to replace JSP with XHTML markup. The authors also introduce Ajax development with JSF—from real-time validation and Direct Web Remoting to wrapping Ajax in JSF components and using the popular Ajax4jsf framework.

This book will help you

Automate low-level details and eliminate unnecessary complexity in server-side development

Discover JSF best practices, ranging from effective UI design and style sheets to internationalization

Use JSF with Tiles to build consistent, reusable user interfaces

Leverage external services such as databases, LDAP directories, authentication/authorization, and Web services

Use JBoss Seam to greatly simplify development of database-backed applications

Implement custom components, converters, and validators

Master the JSF 1.2 tag libararies, and extend JSF with additional tag libraries

Download: Core JavaServer Faces, Second Edition.chm

Title:Ajax on Java
       By Steven Douglas Olson
...............................................
Publisher: O'Reilly
Pub Date: February 23, 2007
ISBN-10: 0-596-10187-2
ISBN-13: 978-0-596-10187-9
Pages: 228

This practical guide shows you how to make your Java web applications more responsive and dynamic by incorporating new Ajaxian features, including suggestion lists, drag-and-drop, and more. Java developers can choose between many different ways of incorporating Ajax, from building JavaScript into your applications "by hand" to using the new Google Web Toolkit (GWT).

Ajax on Java starts with an introduction to Ajax, showing you how to write some basic applications that use client-side JavaScript to request information from a Java servlet and display it without doing a full page reload. It also presents several strategies for communicating between the client and the server, including sending raw data, and using XML or JSON (JavaScript Object Notation) for sending more complex collections of data.

The book then branches out into different approaches for incorporating Ajax, which include:

• The Prototype and script.aculo.us Javascript libraries, the Dojo and Rico libraries, and DWR

• Integrating Ajax into Java ServerPages (JSP) applications

• Using Ajax with Struts

• Integrating Ajax into Java ServerFaces (JSF) applications

• Using Google's GWT, which offers a pure Java approach to developing web applications: your client-side components are written in Java, and compiled into HTML and JavaScript

Ajax gives web developers the ability to build applications that are more interactive, more dynamic, more exciting and enjoyable for your users. If you're a Java developer and haven't tried Ajax, but would like to get started, this book is essential. Your users will be grateful.

Download:   Ajax on Java.chm

Title: Addison.Wesley.Domain.Driven.Design.Tackling.Complexity.In.The.Heart.Of.Software

Format: CHM

Author: Eric Evans

Download: click to download