Hardcore Java 2004

martes, 22 de abril de 2008

Preface Studying a computer language is a career-long process. Many developers make the mistake of thinking that they have learned enough. They get caught in the corporate cycle of build-and-deploy and don’t seek to expand their knowledge. However, we can hardly blame them for that. For one, the build-and-deploy cycle is intensive and carries with it a substantial amount of political pressure: managers don’t want you to spend days reading a book or trying out code snippets when bugs and deadlines are looming. However, developers should take the time to experiment and learn more. When you expand your skills as a developer, there is some initial time investment. However, this will rapidly pay off in increased productivity and quality. Instead of spending hundreds of hours debugging, you can implement coding standards that block bugs and spend a fraction of that time implementing new features. In the end, everyone wins; your company gets higher-quality code and quicker feature turnaround, and you get to spend more time playing Frisbee with your dog. The second problem that the corporate developer has to deal with is that the majority of computer books are often not appropriate for the intermediate to advanced developer. When looking at my rather impressive computer book library, much of it from O’Reilly, I notice that my books tend to fall into two categories: many are introductions to concepts and most of the others are references to concepts. Although these books are very useful, there is a distinct lack of books that target the intermediate to advanced programmer. However, there is one shining exception in my library. In a dusty corner of my desk is a book I bought several years ago. Secrets of the C++ Masters by Jeff Alger (Academic Press Limited) is absolutely essential for an intermediate C++ developer. It begins with the assumption that you know the language and then expands from there. The result is a book that can really transform a developer from the intermediate level to a true guru. That is the goal of this book with regards to the Java™ language. Most of the material is meant to help you avoid many common mistakes made by Java developers. We will also cover nuances of Java, idiosyncrasies of the JDK, and advanced techniques. With luck, this book will increase your productivity and your enjoyment of Java development.

Descarga:

http://rapidshare.com/files/97595170/Hardcore_Java_2004.chm

hacking java - the java professional’s resource kit 1998

Users with intermediate Java skills who are looking for greater in-depth coverage of more higher-end topics will appreciate this helpful guide that takes them to the next level. This book focuses on answering specific questions with combinations of technologies for more advanced applications, and real world advice. - Find out how to speed up Java applets, use animation with Java, extend base classes, and more

- Complete coverage of Java, JavaScript, JDBC, and Java Development Environments all within the context of the solutions and applications

- CD-ROM includes all of the code and tools used in the book as well as additional tools and useful examples

Descarga:

http://rapidshare.com/files/97594119/hacking_java_1999.zip

http://rapidshare.com/files/97594937/hacking_java_-_the_java_professional_s_resource_kit_1998.zip

Getting started with java 1997

Introduction
Java is an object-oriented programming language. Switching to
object-oriented programming (OOP) from other programming paradigms
can be difficult. Java focuses on creating objects (data structures or
behaviors) that can be assessed and manipulated by the program.
Like other programming languages, Java provides support for reading
and writing data to and from different input and output devices. Java uses
processes that increase the efficiency of input/output, facilitate
internationalization, and provide better support for non-UNIX platforms.
Java looks over your program as it runs and automatically deallocates
memory that is no longer required. This means you don’t have to keep
track of memory pointers or manually deallocate memory. This feature
means a program is less likely to crash and that memory can’t be
intentionally misused.
This book is intended to serve programmers who use other languages as a
general introduction to the Java programming language. It introduces the
reader to the major elements of Java programming and provides links and
suggested reading for further exploration. You may order most book titles
from Fatbrain (http://fatbrain.com/). Unlinked titles may be out of print,
but are still useful and generally available. For more extensive lists of
resources, see “Learning more about Java” in the Quick Start.

Descarga:

http://rapidshare.com/files/97593201/getting_started_with_java_1997.pdf

Fundamentals of OOP and Data Structures in Java 2001

Fundamentals of OOP and Data Structures in Java presents the fundamentals of Object-Oriented Programming (OOP) and Graphical User Interface (GUI) programming with Java as the example language. Wiener and Pinson introduce each of the major data structures with supporting, GUI-based laboratory programs designed to reinforce the basic concepts and principles. These laboratories allow the reader to explore and experiment with the properties of each data structure. All source code for the laboratories is available on the Web. By integrating the principles of OOP and GUI programming, this unique book presents the fundamental issues of data structures within the context of paradigms that are essential to today’s professional software developer. The text assumes only an elementary understanding of Java and no experience with OOP.

Descarga:

http://rapidshare.com/files/97592845/Fundamentals_of_OOP_and_Data_Structures_in_Java_2001.pdf

Essentials of the Java Programming part I - part II 2000

If you are interested in learning the Java(tm) programming language but hesitate to dive into overly dense, theoretical resources, Essentials of the Java(tm) Programming Language is the perfect starting point. This accessible, hands-on tutorial employs a “learn-by-doing” approach to introduce you to the basics. It starts with a simple program, then develops it bit by bit, adding new features and explaining important concepts with each subsequent lesson. This simple program grows into a general electronic commerce application that illustrates many of the Java 2 platform’s most important elements. You will learn such Java programming language essentials as: The difference between applications, applets, and servlets/JavaServer Pages(tm) Building a user interface that accepts user input Reading and writing data to files and databases Network communications, including RMI and sockets Collections Serialization Packages and JAR file format Internationalization Security fundamentals, including cryptographic software Essentials of the Java(tm) Programming Language ends with an explanation of object-oriented programming concepts, made far more understandable and relevant as a result of the hands-on experience acquired throughout the book. After working through this book, you will have the foundation necessary to comfortably progress to more advanced learning materials for the Java programming language and utilize the subtleties and more sophisticated capabilities of the language.

Descarga:

parte 1

http://rapidshare.com/files/97589933/Essentials_of_the_Java_Programming_part_I_2000.pdf

parte 2

http://rapidshare.com/files/97590144/Essentials_of_the_Java_Programming_part_II_2000.pdf

enterprise javabeans developer’s guide 1997

Introduction
The Enterprise JavaBeans Developer’s Guide explains how to create
enterprise beans with JBuilder and use them in building distributed
systems. JBuilder has a set of designers, wizards, and tools that greatly
simplifies the creation, testing, and deploying of enterprise beans. You can
create enterprise beans for deployment to the Borland Enterprise Server
5.0, the Borland AppServer 4.5, the BEA WebLogic Servers 6.x and 5.1, the
IBM WebSphere Application Servers 3.5 and 4.0, and the Sun-Netscape
iPlanet Application Server 6.0.

Descarga:

http://rapidshare.com/files/97373622/enterprise_javabeans_developer_s_guide_1997.pdf

Enterprise JavaBeans 3.0 5th Ed 2006

Enterprise JavaBeans™ is the core component technology of the Java Enterprise Edition platform. It is an enterprise infrastructure designed to provide developers with the automatic management of many of the services essential to enterprise applications. The EJB containerthe immediate environment of enterprise bean components and the provider of managed services to themis at the center of this architecture.

However, to use this managed environment in earlier versions of EJB, developers had to write to APIs that focused more on the EJB container’s requirements than on the business logic of enterprise applications. Consequently, EJB development was unnecessarily complex. For example:

• Implementation of various EJB interfaces led to a lot of boilerplate code for methods that were required by the interface, but not needed by the application.

• An XML deployment descriptor was required to integrate the application with its environment and with container services. Access to the components’ environment was clumsy and nonintuitive.

• The design of container-managed persistence made domain object modeling unnecessarily complex and heavyweight. While container-managed persistence was originally conceived as an ease-of-use facility, in practice, it was awkward and limiting.

Descarga:

3ra edicion:

http://rapidshare.com/files/97368688/Enterprise_JavaBeans_3.0_5th_Ed_2006.chm

Workbook de la 3ra edicion:

http://rapidshare.com/files/97373123/Enterprise_JavaBeans_-_JBoss_3.2_Workbook_3rd_Ed_2003.pdf

4ta edicion:

http://rapidshare.com/files/97372947/Enterprise_JavaBeans_4th_Ed_2004.chm

Effective Java - Programming Language Guide - 1st Ed 2001

Topics covered:

• Best practices and tips for Java
• Creating and destroying objects (static factory methods, singletons, avoiding duplicate objects and finalizers)
• Required methods for custom classes (overriding equals(), hashCode(), toString(), clone(), and compareTo() properly)
• Hints for class and interface design (minimizing class and member accessibility, immutability, composition versus inheritance, interfaces versus abstract classes, preventing subclassing, static versus nonstatic classes)
• C constructs in Java (structures, unions, enumerated types, and function pointers in Java)
• Tips for designing methods (parameter validation, defensive copies, method signatures, method overloading, zero-length arrays, hints for Javadoc comments)
• General programming advice (local variable scope, using Java API libraries, avoiding float and double for exact comparisons, when to avoid strings, string concatenation, interfaces and reflection, avoid native methods, optimizing hints, naming conventions)
• Programming with exceptions (checked versus run-time exceptions, standard exceptions, documenting exceptions, failure-capture information, failure atomicity)
• Threading and multitasking (synchronization and scheduling hints, thread safety, avoiding thread groups)
• Serialization (when to implement Serializable, the readObject(), and readResolve() methods)
• 
  

Descarga:

http://rapidshare.com/files/97367162/Effective_Java_-_Programming_Language_Guide_-_1st_Ed_2001.pdf

Effective Enterprise Java 2004

“With this book, Ted Neward helps you make the leap from being a good Java enterprise developer to a great developer!”
—John Crupi, Sun Distinguished Engineer coauthor, Core J2EE Patterns

If you want to build better Java enterprise applications and work more efficiently, look no further. Inside, you will find an accessible guide to the nuances of Java 2 Platform, Enterprise Edition (J2EE) development. Learn how to:

• Use in-process or local storage to avoid the network

• Set lower isolation levels for better transactional throughput

• Use Web services for open integration

• Consider your lookup carefully

• Pre-generate content to minimize processing

• Utilize role-based authorization

• Be robust in the face of failure

• Employ independent JREs for side-by-side versioning

Ted Neward provides you with 75 easily digestible tips that will help you master J2EE development on a systemic and architectural level. His panoramic look at the good, the bad, and the ugly aspects of J2EE development will address your most pressing concerns. Learn how to design your enterprise systems so they adapt to future demands. Improve the efficiency of your code without compromising its correctness. Discover how to implement sophisticated functionality that is not directly supported by the language or platform. After reading Effective Enterprise Java , you will know how to design and implement better, more scalable enterprise-scope Java software systems.

Descarga:

http://rapidshare.com/files/97366551/Effective_Enterprise_Java_2004.chm

Eclipse Rich Client Platform Designing, Coding, and Packaging Java™ Applications 2005

Build Powerful, Cross-Platform Rich Client Applications

Eclipse is more than a state-of-the-art IDE: its Rich Client Platform (RCP) plug-ins form an outstanding foundation for any desktop application, from chat applications to enterprise software front-ends. In Eclipse Rich Client Platform, two leaders of the Eclipse RCP project show exactly how to leverage Eclipse for rapid, efficient, cross-platform desktop development.

In addition to explaining the power of Eclipse as a desktop application development platform, the authors walk step-by-step through developing a fully featured, branded RCP application. They introduce a wide range of techniques, including developing pluggable and dynamically extensible systems, using third-party code libraries, and packaging applications for diverse environments. You’ll build, refine, and refactor a complete prototype; customize the user interface; add Help and Update features; and build, brand, and ship the finished software.

• For every Java developer, regardless of previous Eclipse experience

• Thoroughly covers Eclipse 3.1’s new RCP features and its extensive new tools for designing, coding, and packaging RCP applications

• Presents techniques for branding and customizing the look and feel of RCP applications

• Shows how to overcome the challenges and “rough edges” of RCP development

• Discusses the similarities and differences between RCP and conventional plug-in development

• Includes an overview of OSGi, the base execution framework for Eclipse

If you want to develop and deploy world-class Java applications with rich, native GUIs, and use Eclipse RCPget this book.

Descarga:

http://rapidshare.com/files/97366369/Eclipse_Rich_Client_Platform_Designing__Coding__and_Packaging_Java__Applications_2005.chm

Eclipse A Java Developers Guide 2004

The Eclipse project is moving towards a June release of Eclipse 3.0. The week of February 2-5, 2004, has been a big one for them: more than five hundred developers attended EclipseCon in Anaheim, California, and on the first day of the conference, the new Eclipse Foundation was announced. The press release describes this foundation as “an independent body that will drive the platform’s evolution to benefit the providers of software development offerings and end users.”

Descarga:

http://rapidshare.com/files/97365256/Eclipse_A_Java_Developers_Guide_2004.chm

Developing professional java applets 1998

An applet is a small program that is embedded inside another application. Applets are not intended to run on their own. A Java applet is an applet written in the Java programming language. They are most commonly embedded in web pages to run in the environment of a web browser. Web pages are written in Hypertext Markup Language (HTML). The web browser interprets the HTML source in order to render the pages on a display screen. Without using Java applets, HTML is quite limited in functionality, particularly in graphical user interfaces (GUIs) and multimedia. A Java applet is like a window application running within the embedding web page. It can provide much more sophisticated features in graphical user interfaces for interaction, as well as other functionalities such as animation and special effects.

Descarga:

http://rapidshare.com/files/97361916/developing_professional_java_applets_1998.zip

Developing Java Beans 1997

JavaBeans is one of the most important developments in Java™ since its inception. It is Java’s
component architecture, which allows components built with Java to be used in graphical
programming environments. Graphical development environments let you configure components by
specifying aspects of their visual appearance (like the color or label of a button) in addition to the
interactions between components (what happens when you click on a button or select a menu item).
This means that someone can use a graphical tool to connect some Beans together and make an
application without actually writing any Java code—in fact, without doing any programming at all.
Developing an application isn’t necessarily a matter of producing thousands of lines of code that can
only be read by computer professionals. It’s more like working with Lego blocks: you can build
large structures using snap-together pieces. The result is that applications can be created by people
who are good at designing user interfaces and aspects of the interaction between the user and the
computer. The guts of an application can be written by software developers, who are great at
coding, but not necessarily good at understanding users. This is how it should be, and in fact how it
is in many other industries. The engineer who designed the engine of your car is certainly not the
same person who designed the interior. JavaBeans allows us to make the same kind of distinction in
the software business.
As Beans become widely available, we will see more developers using them to build applications.
But before these applications can be built, someone has to build the components. That’s what this
book is all about.

Descarga:

http://rapidshare.com/files/97361609/Developing_Java_Beans_1997.pdf

Developing Intranet Applications With Java 1998

The first third of Developing Intranet Applications with Java isn’t strictly about Java. Rather, it’s about intranets, with some information about Java development environments and code style. (The author has some novel ideas about pretty-printing.) This may be a selling point for those who have been called upon to set up an intranet and implement Java programs on it all at once; others may consider it filler material. The cool thing in Developing Intranet Applications with Java is that author Jerry Ablan has put together custom software for both the book and its accompanying CD-ROM. The Java Intranet Framework (JIF) is a set of classes you can use as a base for writing corporate intranet tools. In fact, Ablan goes into great detail about using the JIF to write a conference tool, a benefits-management tool, the electronic equivalent of a magnetic in/out board, a product maintenance tracker, and several other tools. It’s interesting to see how the JIF facilitates these products and how you can expand upon them. If you want to see, in detail, how one programmer created a suite of intranet tools, this book is the one for you.

Descarga:

Version 1998:

http://rapidshare.com/files/97359829/Developing_Intranet_Applications_With_Java_1998.rar

Version 1999:

http://rapidshare.com/files/97361303/developing_intranet_applications_with_java_1999.pdf

Developing Enterprise Java Applications with J2EE and UML 2001

Foreword
The history of software engineering is, in effect, the history of abstraction. As complexity
rises, we respond by raising the level of abstraction in our programming languages and in our
methods. Thus, we have seen the move from C to Java, from structured methods to
object-oriented design, and from classes to design patterns to architectural frameworks.
J2EE, the Java 2 Platform, Enterprise Edition, is such a framework. J2EE is a comprehensive
platform for deploying complex systems. It raises the level of abstraction for the
development team by offering a set of mechanisms (JSP, Enterprise JavaBeans, servlets) and
services (JDBC, JNDI, JMS, and RMI to name a few), enabling the team to focus on its core
business value instead of building infrastructure.
As good as J2EE is, however, there is a large semantic gap between what J2EE provides and
what must be crafted for the business. Bridging that gap can only be achieved given a strong,
foundational understanding of J2EE together with a sound architecture for the
domain-specific system. The Unified Modeling Language (UML) comes into play here, for the
UML is essentially the language of blueprints for software. Visualizing, specifying,
constructing, and documenting the key elements of a system are essential as complexity
rises, and this is the very reason for the UML’s existence.
Khawar and Cary bring all of these elements together in this book to help you bridge that
semantic gap. Not only do they cover all of the essential pieces of J2EE thus helping you build
a foundational understanding, they also explain how best to use J2EE’s mechanisms and
services. This book will also guide you in applying the UML to model your systems built upon
J2EE, thus enabling you to better reason about and communicate the analysis and design
decisions your team must make in building quality software.
The authors have a deep understanding of J2EE and the UML and a strong sense of the best
practices that can lead you to the effective use of both. Their experience in building
production systems comes through in their writing, and especially in their comprehensive
case study.
There is an essential complexity in building enterprise systems; this book will help you master
much of that complexity.

Descarga:

http://rapidshare.com/files/97359416/Developing_Enterprise_Java_Applications_with_J2EE_and_UML_2001.pdf

Design Patterns - Java Companion

SOME BACKGROUND ON DESIGN PATTERNS
The term “design patterns” sounds a bit formal to the uninitiated and
can be somewhat off-putting when you first encounter it. But, in fact, design
patterns are just convenient ways of reusing object-oriented code between
projects and between programmers. The idea behind design patterns is
simple– write down and catalog common interactions between objects that
programmers have frequently found useful.
The field of design patterns goes back at least to the early 1980s. At
that time, Smalltalk was the most common OO language and C++ was still in
its infancy. At that time, structured programming was a commonly-used
phrased and OO programming was not yet as widely supported. The idea of
programming frameworks was popular however, and as frameworks
developed, some of what we now called design patterns began to emerge.
One of the frequently cited frameworks was the Model-View-
Controller framework for Smalltalk [Krasner and Pope, 1988], which divided
the user interface problem into three parts. The parts were referred to as a
data model which contain the computational parts of the program, the view,
which presented the user interface, and the controller, which interacted
between the user and the view.

Descarga:

http://rapidshare.com/files/97119758/design_patterns_in_java__pdf_src__1998.zip

Design Java Apps with UML

Este libro es una exelente guia para aprender a crear aplicaciones usando el lenguaje grafico UML, algo que es casi obligatorio.

Descarga: http://rapidshare.com/files/97119416/design_java_apps_with_uml_2000.zip

Developing Enterprise Java Applications with J2EE and UML 2001

The history of software engineering is, in effect, the history of abstraction. As complexity
rises, we respond by raising the level of abstraction in our programming languages and in our
methods. Thus, we have seen the move from C to Java, from structured methods to
object-oriented design, and from classes to design patterns to architectural frameworks.
J2EE, the Java 2 Platform, Enterprise Edition, is such a framework. J2EE is a comprehensive
platform for deploying complex systems. It raises the level of abstraction for the
development team by offering a set of mechanisms (JSP, Enterprise JavaBeans, servlets) and
services (JDBC, JNDI, JMS, and RMI to name a few), enabling the team to focus on its core
business value instead of building infrastructure.
As good as J2EE is, however, there is a large semantic gap between what J2EE provides and
what must be crafted for the business. Bridging that gap can only be achieved given a strong,
foundational understanding of J2EE together with a sound architecture for the
domain-specific system. The Unified Modeling Language (UML) comes into play here, for the
UML is essentially the language of blueprints for software. Visualizing, specifying,
constructing, and documenting the key elements of a system are essential as complexity
rises, and this is the very reason for the UML’s existence.

Descarga: Developing_Enterprise_Java_Applications_with_J2EE_and_UML_2001.pdf

Designing Enterprise Applications with Java 2 Enterprise Edition 2000

THE JavaTM platform was conceived to connect door knobs to light switches—
smart door knobs to smart light switches, certainly, but door knobs to light switches
nonetheless. And yet it is now widely used for building large server-side applications
which run on some of the largest computers in the world. It is the fate of great
inventions to be used in ways unimagined by their creators even when the creators—
like James Gosling, creator of the Java programming language—see a
horizon the rest of us do not glimpse. This is part of what makes an invention great.
In retrospect, the phenomenal success of the Java platform on servers might
seem inevitable. After all, the platform provides exactly what is needed to transform
the Internet from a publishing medium to a transactional one. The Java platform
is available on all of the many different servers where Internet applications
run. “Write Once, Run AnywhereTM”works so the programs can be quickly tested
and deployed. Engineers are several times more productive when they write to the
Java platform. But being the right thing at the right time isn’t the whole story. Two
more elements were needed: Technical leaders who were looking in a different
direction than most of us were, and business leaders who were eager to work
together in new ways so the ideas could become reality. The result was the development
of consistent products across the computer industry in a surprisingly short
period of time.

Descarga: Designing_Enterprise_Applications_with_Java_2_Enterprise_Edition_2000.pdf

Design Patterns Java 1998

The term “design patterns” sounds a bit formal to the uninitiated and
can be somewhat off-putting when you first encounter it. But, in fact, design
patterns are just convenient ways of reusing object-oriented code between
projects and between programmers. The idea behind design patterns is
simple– write down and catalog common interactions between objects that
programmers have frequently found useful.
The field of design patterns goes back at least to the early 1980s. At
that time, Smalltalk was the most common OO language and C++ was still in
its infancy. At that time, structured programming was a commonly-used
phrased and OO programming was not yet as widely supported. The idea of
programming frameworks was popular however, and as frameworks
developed, some of what we now called design patterns began to emerge.
One of the frequently cited frameworks was the Model-View-
Controller framework for Smalltalk [Krasner and Pope, 1988], which divided
the user interface problem into three parts. The parts were referred to as a
data model which contain the computational parts of the program, the view,
which presented the user interface, and the controller, which interacted
between the user and the view.

Descarga: Design_Patterns_Java_1998.pdf