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: Quickstart Apache Axis2
        A practical guide to creating quality web services
Author: Deepal Jayasinghe
Publisher: Packt Publishing

A new architecture for Axis2 was introduced during the first Axis2 summit, which
was held in 2004 in Colombo, Sri Lanka. This new architecture is more flexible,
efficient, and configurable in comparison to Axis1.x architecture. Some well
established concepts from Axis 1.x, like handlers, have been preserved in the 
new architecture.
Since its introduction less than four years ago, Apache Axis2 has become widely
accepted as a framework for practical Web Service development, which is suitable
not only for commercial application development, but also as a teaching tool and
as a research platform. Apache Axis2 itself has evolved during the past three years,
taking into consideration community requirements, and has acquired a number of
new features. All of these have been contributed in an effort to create a simple and
easy-to-use Web Service framework.
The main goal of this book is to provide an introduction to Axis2. It teaches how
to develop web applications using Axis2 and how to make proper use of available
features. It does not attempt to cover either Web Services or Axis2 in minute detail,
opting rather to provide a good understanding for using both. The in-depth technical
details of Axis2, I believe, are best covered in a book in their own right.
When designing and writing this book, my objective was to achieve a number of
goals. Firstly, I wanted to present a very clear introductory text, free of verbosity
and nonsense, so that a beginner can understand the concepts easily and develop
confidence for using the technology within a short period of time. Secondly, I have,
as far as possible, tried to cover the concepts in the form of a discussion combined
with the instruction style of a tutorial, so that the reader can try out the concepts for
himself/herself and grasp them easily. Because of this most of the chapters contain a
plethora of comprehensive samples. Thirdly, I have intentionally avoided presenting
full descriptions of Axis2 features, while making sure that no important points
have been omitted. Descriptions of some of the minor and rarely used features have
been left out for the sake of simplicity. And finally, I want this book to help you, the
reader, explore, understand, and realize the potential of Web Services and Axis2.

Click to download the free book: Packt Publishing Quickstart Apache Axis2 May 2008.pdf

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: Harnessing Hibernate
Author: James Elliott; Timothy M. O'Brien; Ryan Fowler
Publisher: O'Reilly
Pub Date: April 28, 2008
Print ISBN-13: 978-0-596-51772-4
 
Pages: 380

Overview

Harnessing Hibernate is an ideal introduction to the popular framework that lets Java developers work with information from a relational database easily and efficiently. Databases are a very different world than Java objects, and they often involve people with different skills and specializations. With Hibernate, bridging these two worlds is significantly easier, and with this book, you can get up to speed with Hibernate quickly. Rather than present you with another reference, Harnessing Hibernate lets you explore the system, from download and configuration through a series of projects that demonstrate how to accomplish a variety of practical goals. The new edition of this concise guide walks you through Hibernate's primary features, which include mapping from Java classes to database tables, and from Java data types to SQL data types. You will also learn about Hibernate's data query and retrieval facilities, and much more. By reading and following along with the examples, you can get your own Hibernate environment set up quickly and start using it for real-world tasks right away. Harnessing Hibernate teaches you how to:

Perform Object/Relational mapping

Work with persistent data from Java code

Work with groups and relationships between objects

Extend Hibernate's rich type support for your own needs

Simplify query creation using criteria and examples

Use the Hibernate Query Language (HQL) and understand how it differs from SQL

Use Hibernate in conjunction with Spring

Use Hibernate in conjunction with other packages, such as the Stripes web framework and the Eclipse IDE

Once you're past the first few chapters, you can jump to topics that you find particularly interesting or relevant. All background material and explanations of how Hibernate works and why is in the service of a focused task. Source code can be downloaded from the book's website. If using SQL is an uncomfortable chore, Harnessing Hibernate offers you an effective and trouble-free method for working with the information you store in your applications.

Download link: OReilly Harnessing Hibernate Apr 2008.chm

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