Descarga:
parte 1 30 mb http://rapidshare.com/files/75160808/solucionario_Static-_Meriam_and_L._G._Kraige.part1.rar
parte 2 30 mb http://rapidshare.com/files/75170291/solucionario_Static-_Meriam_and_L._G._Kraige.part2.rar
parte 3 18 mb http://rapidshare.com/files/75174701/solucionario_Static-_Meriam_and_L._G._Kraige.part3.rar
.
The course text is Physics, Volume 1 by R. Resnick, D. Halliday, and K. S. Krane (5th ed., Wiley, 2001). This text is required, meaning that you will be assumed to have access to this text to complete reading and homework assignments. It is essential that you have the Fifth Edition, which differs substantially from earlier editions.
Descarga:
Descarga:
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
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 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
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
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™ 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
Book Description
Descarga:
Topics covered:
Descarga:
http://rapidshare.com/files/97367162/Effective_Java_-_Programming_Language_Guide_-_1st_Ed_2001.pdf
“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
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:
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
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
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
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
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:
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
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
Shareapic es un servicio de almacenamiento gratuito de imágenes con características muy interesantes que lo convierten en uno de los mejores de su clase.
Este servicio de hosting gratuito nos provee un espacio ilimitado para almacenar nuestras imágenes y no tiene restricciones en cuanto al tamaño de las fotos que subimos al sistema.
Entre las funciones más destacadas se encuentran:
Después de registrarse de manera gratuita desde este vínculo se puede ver que la interface es muy sencilla y fácil de usar, la carga de las imágenes es bastante rápida y si usamos Windows podemos descargar un pequeño software que nos permite subir varias imágenes al mismo tiempo. Además podemos compartir nuestras imágenes rápidamente usando el código que genera al subir las fotos y que nos permite agregar esas imágenes a las redes sociales más conocidas como FaceBook, MySpace, Hi5 y muchas otras.
En definitiva, Shareapic es un excelente servicio de almacenamiento gratuito de imágenes, repleto de funciones, sin límites y con el que además podemos ganar dinero por medio de PayPal. No se le puede pedir más a un servicio de este tipo.
Además, algo muy interesante es la opcion de tener referidos los cuales son personas que se inscriben a este servicio como recomendados nuestros y cuando ellos esten generando ingresos para ellos nosotros estaremos ganando el 10% de lo que ellos ganan por el hecho de ser nuestros referidos.
Para conseguir referidos pueden agregar su el link que les brindan para ese uso a su firma de su mail o publicarlo en su blog, si se inscriben desde los vínculos en este post quedarán como referidos míos, inscribanse desde aqui por si quieren agradecer por el material que publico en este sitio.
Para inscribirse lo pueden hacer haciendo click en el siguiente banner:
Este es un programa que sirve para visualizar los archivos y aplicaciones creadas con el todopoderoso software de calculo cientifico Mathematica de la empresa Wolfram Research. Esta aplicación solo sirve para visualizar los archivos creados en la aplicacion principal y no para crear ni editar por lo tanto es de libre distribución aunque para descargarlo desde la pagina principal de Mathematica es algo complicado y es por eso que lo pongo aquí para descarga directa.
Los de Wolfram Research han creado una herramienta maravillosa con Mathematica 6.0 para todo estudiante de ingenieria ya que este software hace de todo en lo que se refiere a calculo, fisica, algebra, matematica avanzada, etc,. Además es un lenguaje de programación en el que se pueden crear aplicaciones imponentes para realizar toda clase de calculos.
Les recomiendo que visiten la pagina de Wolfram Research en donde encontrarán toda la información sobre Mathematica 6.0 y la pagina de Proyectos de Demostracion de Mathematica en donde encontraran toda clase de proyectos creados en este sistema y a los que les guste la matematica de ingenieria encontraran cosas interesantisimas.
Descarga:
Parte 1 MathematicaPlayer6.part1.rar
Parte 2 MathematicaPlayer6.part2.rar
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
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
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
Para mi y para miles de estudiantes, el mejor libro de algebra que ha existido y con solucionario de todos los ejercicios resueltos paso a paso.
Descarga Libro: Algebra_de_Baldor.rar
Descarga del Solucionario: Solucionario_de_Baldor.pdf
Preface
This book is about JavaHelp™ from Sun Microsystems. JavaHelp is an online help system
developed for the Java™ programming language. It is similar to other help systems, such as
WinHelp and HTML Help, in that you use a table of contents (TOC), index, or word-search
index to find and display help topics. JavaHelp can be used for many online documentation
purposes, but its primary function is to provide an online help system to support Java
applications.
Of course, as with any new online help system, people have many questions they need
answered and demands they need addressed. This book attempts to address those
questions and demands and teaches you how to develop usable online help systems with
JavaHelp. To provide a comprehensive look at JavaHelp development, this book covers the
main features and options of JavaHelp by presenting the following topics:
• Understanding JavaHelp
• Creating your first HelpSet
• Planning the JavaHelp project
• Preparing help topics
• Creating HelpSet data and navigation files
• Enhancing the HelpSet
• Using the JavaHelp API for advanced presentation options
• Deploying the help system to your users
• Using third-party, help-authoring tools
Descarga: Creating_Effective_JavaHelp_2000.rar
“Comprising far more than an updated reference for Web application development, the ASP.NET Bible provides crucial guidance on leveraging the significant advances ASP.NET represents for the Web developer.”-Michael Lane Thomas, .NET Series Editor
100% Comprehensive
Authoritative
What you need
* Harness the power of ASP.NET for next-generation Web applications
* Build, deploy, and run distributed applications targeting any device
* Master ASP.NET development using both Visual Basic .NET and C#
* If ASP.NET can do it, you can do it too . . .
Completely revamped for the .NET Platform, ASP.NET is an indispensable tool for creating the next generation of Web applications and Web Services. This comprehensive resource gives you in-depth guidance for building dynamic, data-driven applications tailored to any browser or device. Whether you’re a seasoned ASP developer or a Web development newcomer, you’ll find the real-world techniques and insights you need to take ASP.NET programming to the next level.
Inside, you’ll find complete coverage of ASP.NET
* Get up to speed fast on ASP.NET development with both Visual Basic .NET and C#
* Build forms with Web Controls, including Rich Web Controls like AdRotator and Calendar
* Debug ASP.NET pages - and learn how to write high-quality code
* Master ASP.NET database programming with ADO.NET and SQL Server
* Bind data and controls with XML
* Develop, deploy, and use business objects
* Create secure wireless applications using ASP.NET mobile controls
* Use ASP.NET to build, deploy, and publishWeb Services
Companion Web site includes source code from the book:
www.hungryminds.com/extras
* Test your Web Service prior to deployment with the Web Service help page
* Learn how to use page output caching with ASP.NET
Reader Level: Beginning to Advanced
Shelving Category: Programming/Web Development
Descarga: ASP.NET_Bible.rar
The J2EE(TM) Platform has become the technology of choice for developing professional e-commerce applications, interactive Web sites, and Web-enabled applications and services. Servlet and JSP(TM) technology is the foundation of this platform: it provides the link between Web clients and server-side applications. In this 2nd edition of the worldwide bestseller, the authors show you how to apply the latest servlet and JSP capabilities. Unlike other books that treat servlet or JSP technology in isolation, Core Servlets and JavaServer Pages provides a unified treatment, showing you when servlet technology is best, when the JSP approach is preferred, and when (and how) servlets and JSP should work together.
Part I provides exhaustive coverage of the servlet 2.4 specification. It starts with server configuration, basic syntax, the servlet life cycle, and use of form data. It moves on to applying HTTP 1.1, cookies, and session tracking. Advanced topics include compressing Web content, incrementally updating results, dynamically generating images, and creating shopping carts.
Part II gives an in-depth guide to JSP 2.0. It covers both the “classic” JSP scripting elements and the new JSP 2.0 expression language. It shows how to control the content type, designate error pages, include files, and integrate JavaBeans components. Advanced topics include sharing beans, generating Excel spreadsheets, and dealing with concurrency.
Part III covers two key supporting technologies: HTML forms and database access with JDBC(TM). It explains every standard HTML input element and shows how to use appropriate JDBC drivers, perform database queries, process results, and perform updates. Advanced topics include parameterized queries, stored procedures, and transaction control.
Design strategies include ways to integrate servlet and JSP technology, best practices for invoking Java code from JSP pages, plans for dealing with missing and malformed data, and application of the MVC architecture.
Handy guides walk you through use of three popular servlet and JSP engines (Apache Tomcat, Macromedia JRun, and Caucho Resin) and some of the most widely used database systems (MySQL, Oracle9i, Microsoft Access).
Volume 2 of this book covers advanced topics: filters, custom tag libraries, database connection pooling, Web application security, the JSP Standard Tag Library (JSTL), Apache Struts, JavaServer Faces (JSF), JAXB, and more.
The same clear step-by-step explanations that made the first edition so popular
Completely updated for the latest standards: servlets 2.4 and JSP 2.0
Hundreds of completely portable, fully documented, industrial-strength examples
Descarga: Core_Servlets_And_Java_Server_Pages_Volume_1_Core_Technologies_2nd_Ed_2003.rar
Completely revised and up-to-date coverage of
Generic programming, restrictions and limitations, type bounds, wilcard types, and generic reflection
Swing GUI development, including input validation and other enhancements
Exception handling and debugging, including chained exceptions, stack frames, assertions, and logging
Streams and files, the new I/O API, memory-mapped files, file locking, and character set encoders/decoders
Regular expressions using the powerful java.util.regex package
Inner classes, reflection, and dynamic proxies
Application packaging and the Preferences API
The seventh edition of Core Java™ 2, Volume I, covers the fundamentals of the Java 2 Platform, Standard Edition (J2SE™). A no-nonsense tutorial and reliable reference, this book features thoroughly tested real-world examples. The most important language and library features are demonstrated with deliberately simple sample programs, but they aren’t fake and they don’t cut corners. More importantly, all of the programs have been updated for J2SE 5.0 and should make good starting points for your own code. You won’t find any toy examples here. This is a book for programmers who want to write real code to solve real problems.
Volume I concentrates on the fundamental concepts of the Java language, along with the basics of user-interface programming and provides detailed coverage of
Object-oriented programming
Reflection and proxies
Interfaces and inner classes
The event listener model
Graphical user-interface design with the Swing UI toolkit
Exception handling
Stream input/output and object serialization
Generic programming
For the same real-world treatment of enterprise features and advanced user-interface programming, look for the forthcoming new edition of Core Java™ 2, Volume II—Advanced Features.
It includes new sections on metadata and other J2SE 5.0 enhancements along with complete coverage of: Multithreading • Distributed objects • Databases & bull; Advanced GUI components • Native methods • XML Processing • Network programming • Collection classes • Advanced graphics • Internationalization • JavaBeans
Descarga: Core_Java__2_Volume_I_-_Fundamentals__7th_Ed_2004.rar
JavaServer Faces promises to bring rapid user-interface development to server-side Java. It allows developers to painlessly write server-side applications without worrying about the complexities of dealing with browsers and Web servers. It also automates low-level, boring details like control flow and moving code between web forms and business logic.
JavaServer Faces was designed to support drag and drop development of server-side applications, but you can also think of it as a conceptual layer on top of servlets and JavaServer Pages (JSP). Experienced JSP developers will find that JavaServer Faces provides much of the plumbing that they currently have to implement by hand. If you already use a server-side framework such as Struts, you will find that JavaServers Faces uses a similar architecture, but is more flexible and extensible. JavaServer Faces also comes with server-side components and an event model, which are fundamentally similar to the same concepts in Swing.
JavaServer Faces is quickly becoming the standard Web-application framework. Core JavaServer Faces is the one book you need to master this powerful and time-saving technology.
Without assuming knowledge of JSP and servlets, Core JavaServer Faces:
shows how to build more robust applications and avoid tedious handcoding
answers questions most developers don’t even know to ask
demonstrates how to use JSF with Tiles to build consistent user interfaces automatically
provides hints, tips, and explicit “how-to” information that allows you to quickly become more productive
explains how to integrate JSF with databases, use directory services, wireless apps, and Web services
teaches best practices and good habits like using style sheets and message bundles
covers all of the JSF tags and how to create new tag libraries
Descarga: Core_JavaServer_Faces_2004.rar
Java Data Objects (JDO) streamlines development by providing Java-centric mechanisms for making objects persistent, and standard APIs for connecting application code with underlying persistent datastores. Core Java Data Objects is the definitive, comprehensive guide to JDO persistence for every experienced Java developer.
Using realistic code examples, this book’s expert authors cover creating, reading, updating, and deleting persistent objects; object lifecycles and state transitions; JDO classes and APIs; queries, architecture, security, and much more. They show how to integrate JDO with EJB, JTA, JCA, and other J2EE technologies; and introduce best practices for using JDO in both standalone programs and J2EE components.
If you want to spend more time solving business problems and less time worrying about persistence, you need JDO. And you need the one book that’ll help you make the most of JDO: Core Java Data Objects.
Every Core Series book:
DEMONSTRATES how to write commercial quality code
FEATURES nontrivial programs and examples–no toy code!
FOCUSES on the features and functions most important to real developers
PROVIDES objective, unbiased coverage of cutting-edge technologies - no hype!
Core Java Data Objects delivers:
Practical examples showing how JDO can be applied to existing applications
Powerful insights for using JDO to architect new systems more effectively
Step-by-step guidance for integrating JDO with other J2EE technologies
Best practices for using JDO in real-world business environments
Descarga: Core_Java_Data_Objects_2003.rar
Completely revised and up-to-date coverage of
Multithreadingincluding the java.util.concurrent library, locks, condition objects, futures, thread pools, thread-safe collections, threads and Swing
Collection classescollections framework, concrete collections, and generic utility methods
Annotations and metadatausing annotations to automate programming tasks, JDK™ 5.0 standard annotations, the apt tool for source-level annotation processing, and bytecode engineering
Advanced Swing and AWTlists, trees, tables, and other advanced components; image processing and printing
JavaBeans™including property editors, customizers, and long-term persistence
XMLDOM and SAX parsers, XPath, and XSL transformations
The seventh edition of Core Java™ 2, Volume II, covers advanced user-interface programming and the enterprise features of the Java 2 Platform, Standard Edition (J2SE™). Like Volume I (which covers the most important language and library features), this book has been completely updated and revised for J2SE 5.0. All of the sample programs have been updated and carefully crafted to illustrate practical solutions to the type of real-world problems professional developers encounter.
Descarga: Core_Java_2__Volume_II_-_Advanced_Features__7th_Ed_2004.rar
In the world of software, a pattern is a tangible manifestation of an
organization’s tribal memory. A pattern provides a common solution
to a common problem and so, within the culture of one specific
organization or within one domain, naming and then specifying a
pattern represents the codification of a common solution, drawn from
proven, prior experience. Having a good language of patterns at your
disposal is like having an extended team of experts sitting at your side
during development: by applying one of their patterns, you in effect
take the benefit of their hard-won knowledge. As such, the best
patterns are not so much invented as they are discovered and then
harvested from existing, successful systems. Thus, at its most mature
state, a pattern is full of things that work, absent of things that don’t
work, and revealing of the wisdom and rationale of its designers.
Deep, really useful, patterns are typically ancient: you see one and
will often remark, “Hey, I’ve done that before.” However, the very
naming of the pattern gives you a vocabulary that you didn’t have
previously and so helps you apply that pattern in ways you otherwise
might have not have realized. Ultimately, the effect of such a pattern
will be to make your system simpler.
Patterns not only help you build simpler systems that work, but they
also help you build beautiful programs. In a culture of time starvation,
writing beautiful software is often impossible. That’s sad, for as
professionals, we strive to build things of quality. By applying a good
set of patterns, it is possible to bring a degree of elegance in to your
systems that might otherwise have been lacking.
Descarga: Core_J2EE_Patterns_Best_Practices_And_Design_Strategies.rar
Real-time systems have to respond to externally generated input stimuli within a finite and predictable time. Their correctness depends not only on the logical results of the computations, but also on the time at which those results are produced.
When Java emerged as a serious programming language in 1994, it was treated with disdain by much of the real-time community. Although the language was interesting from a number of perspectives – not least the fact that it had an integrated concurrent object-oriented programming model – the whole notion of Java as a real-time programming language was laughable. “Java and Real-time” was considered, by many, an oxymoron. What we failed to appreciate was the determination of the Java community to propagate the language into every conceivable application area.
Just over 10 years since its first conception, Java, augmented by the Real-Time Specification for Java, is one of the most exciting developments in real-time systems so far this century. The approach has been to extend the concurrency model so that it supports real-time programming abstractions and to provide a complementary approach to memory management that removes the temporal uncertainties of garbage collection.
This book is concerned with both concurrent and real-time programming in Java. To fully understand the facilities available for real-time programming, it is first necessary to have a good appreciation of the strengths and weaknesses of multi-threaded programming in conventional Java. Once this understanding has been achieved, the motivations for the Real-Time Specification become apparent and the full details of the real-time functionality can then be presented.
Descarga: Concurrent_and_Real-Time_Programming_in_Java_2003.rar
The J2EE specification encompasses applications ranging from database
access to web applications to e-mailing systems. Because the topics are
so varied, the CodeNotes format is compressed and certain background
information has been omitted. However, a significant number of examples
and background articles can be found on the CodeNotes website.
Descarga: CodeNotes_for_J2EE_2001.rar
If you’re basing your livelihood on Java these days, you are going to run across at least one
enterprise application programming project; if it hasn’t come upon you already, it’s just around
the corner. I’ve been faced with more than twenty at this point in my career, and see many
more in my future. Each time I get into these projects, I find myself paging through book after
book and searching the Web, looking for the same information time after time. Additionally,
I’ve developed a bit of a toolkit for handling common enterprise tasks.
What I have determined is that there are many terrific books on specific technologies like
Enterprise JavaBeans, servlets, and the Java Message Service. These books cover the details
of these APIs and explain how to use them. I have also found, though, that there is no
resource in existence that describes connecting these components in an intelligent way. No
coherent examples are documented and explained that tell how best to code façade patterns,
attach entity beans to directory servers, use servlets and JSP with EJB without killing
performance, or a host of other common tasks. At the same time, these very issues are the
heart of my job description, and probably of many other programmers’ as well.
Descarga:
Building_Java_Enterprise_Applications_vol_I_Architecture_2002.rar
This book takes you on a guided tour to building applications with the WebSphere Studio Visual Editor for Java and JavaBeans. Along the way, you’ll learn the basics of how to develop Java applets and applications, as well as more advanced topics such as using relational databases and eXtensible Markup Language (XML) documents to store your application data. By the end of the tour you’ll be able to use WebSphere Studio to build your own applications and you’ll understand why JavaBeans are so useful for application programming.
If you’re new to Java and Java development environments, that’s OK. This book assumes you have some basic knowledge of the Java programming language, but you certainly don’t need to be an expert to follow the tour. You do need to be running one of the Windows operating systems, and as long as you’re comfortable with Windows, the Internet, and Web browsers, you’re ready to learn Java.
If you are already familiar with Java and Java development environments, that’s OK, too. You’ll still benefit from going through the tour, because it will teach you many of the WebSphere Studio features that will let you build your Java applications easier and faster.
This book uses the “show and tell” approach. If you flip through the pages, you’ll notice that they are loaded with pictures showing how your applications should look at each step along the way. In addition, we’ve included two CDs that contain all the tools you’ll need to follow along with the lessons.
Descarga: Building_Applications_With_WebSphere_Studio_And_JavaBeans_A_Guided_Tour_2003.rar
Table of Contents
Bluetooth for Java
Introduction
Chapter 1 - Introducing Bluetooth
Chapter 2 - Bluetooth 1.1
Chapter 3 - Before You Get Started
Chapter 4 - Understanding the Java Bluetooth API
Chapter 5 - Bluetooth with J2ME MIDP
Chapter 6 - Creating a Bluetooth Print Server with JPS API
Chapter 7 - Java and OBEX
Chapter 8 - Using a Bluetooth Simulator
Chapter 9 - Bluetooth Security
Chapter 10 - Wireless Embedded Systems with the Micro BlueTarget
Chapter 11 - Enterprise Bluetooth Applications with the Ericsson BlipNet
Chapter 12 - Bluetooth and Jini
Appendix A - javax.bluetooth
Appendix B - javax.obex
Appendix C - Java Bluetooth Development on the PalmOS Platform
Appendix D - BlipNet 1.1 API
Index
List of Figures
List of Tables
List of Listings
List of Sidebars
Descarga: Bluetooth_For_Java_2003.rar
In Beyond Java, Bruce chronicles the rise of the most successful language of all time, and then lays out, in painstaking detail, the compromises the founders had to make to establish success. Then, he describes the characteristics of likely successors to Java. He builds to a rapid and heady climax, presenting alternative languages and frameworks with productivity and innovation unmatched in Java. He closes with an evaluation of the most popular and important programming languages, and their future role in a world beyond Java.
If you are agree with the book’s premise–that Java’s reign is coming to an end–then this book will help you start to build your skills accordingly. You can download some of the frameworks discussed and learn a few new languages. This book will teach you what a new language needs to succeed, so when things do change, you’ll be more prepared. And even if you think Java is here to stay, you can use the best techniques from frameworks introduced in this book to improve what you’re doing in Java today.
Descarga: Beyond_Java_2005.rar
 | Copyright | ||||||||||||||||
| Preface | ||||||||||||||||
| Who Should Read This Book? | ||||||||||||||||
| Organization of This Book | ||||||||||||||||
| Conventions Used in This Book | ||||||||||||||||
| Comments and Questions | ||||||||||||||||
| Acknowledgments | ||||||||||||||||
| Chapter 1. The Inevitable Bloat | ||||||||||||||||
| Section 1.1. Bloat Drivers | ||||||||||||||||
| Section 1.2. Options | ||||||||||||||||
| Section 1.3. Five Principles for Fighting the Bloat | ||||||||||||||||
| Section 1.4. Summary | ||||||||||||||||
| Chapter 2. Keep It Simple | ||||||||||||||||
| Section 2.1. The Value of Simplicity | ||||||||||||||||
| Section 2.2. Process and Simplicity | ||||||||||||||||
| Section 2.3. Your Safety Net | ||||||||||||||||
| Section 2.4. Summary | ||||||||||||||||
| Chapter 3. Do One Thing, and Do It Well | ||||||||||||||||
| Section 3.1. Understanding the Problem | ||||||||||||||||
| Section 3.2. Distilling the Problem | ||||||||||||||||
| Section 3.3. Layering Your Architecture | ||||||||||||||||
| Section 3.4. Refactoring to Reduce Coupling | ||||||||||||||||
| Section 3.5. Summary | ||||||||||||||||
| Chapter 4. Strive for Transparency | ||||||||||||||||
| Section 4.1. Benefits of Transparency | ||||||||||||||||
| Section 4.2. Who’s in Control? | ||||||||||||||||
| Section 4.3. Alternatives to Transparency | ||||||||||||||||
| Section 4.4. Reflection | ||||||||||||||||
| Section 4.5. Injecting Code | ||||||||||||||||
| Section 4.6. Generating Code | ||||||||||||||||
| Section 4.7. Advanced Topics | ||||||||||||||||
| Section 4.8. Summary | ||||||||||||||||
| Chapter 5. You Are What You Eat | ||||||||||||||||
| Section 5.1. Golden Hammers | ||||||||||||||||
| Section 5.2. Understanding the Big Picture | ||||||||||||||||
| Section 5.3. Considering Technical Requirements | ||||||||||||||||
| Section 5.4. Summary | ||||||||||||||||
| Chapter 6. Allow for Extension | ||||||||||||||||
| Section 6.1. The Basics of Extension | ||||||||||||||||
| Section 6.2. Tools for Extension | ||||||||||||||||
| Section 6.3. Plug-In Models | ||||||||||||||||
| Section 6.4. Who Is the Customer? | ||||||||||||||||
| Section 6.5. Summary | ||||||||||||||||
| Chapter 7. Hibernate | ||||||||||||||||
| Section 7.1. The Lie | ||||||||||||||||
| Section 7.2. What Is Hibernate? | ||||||||||||||||
| Section 7.3. Using Your Persistent Model | ||||||||||||||||
| Section 7.4. Evaluating Hibernate | ||||||||||||||||
| Section 7.5. Summary | ||||||||||||||||
| Chapter 8. Spring | ||||||||||||||||
| Section 8.1. What Is Spring? | ||||||||||||||||
| Section 8.2. Pet Store: A Counter-Example | ||||||||||||||||
| Section 8.3. The Domain Model | ||||||||||||||||
| Section 8.4. Adding Persistence | ||||||||||||||||
| Section 8.5. Presentation | ||||||||||||||||
| Section 8.6. Summary | ||||||||||||||||
| Chapter 9. Simple Spider | ||||||||||||||||
| Section 9.1. What Is the Spider? | ||||||||||||||||
| Section 9.2. Examining the Requirements | ||||||||||||||||
| Section 9.3. Planning for Development | ||||||||||||||||
| Section 9.4. The Design | ||||||||||||||||
| Section 9.5. The Configuration Service | ||||||||||||||||
| Section 9.6. The Crawler/Indexer Service | ||||||||||||||||
| Section 9.7. The Search Service | ||||||||||||||||
| Section 9.8. The Console Interface | ||||||||||||||||
| Section 9.9. The Web Service Interface | ||||||||||||||||
| Section 9.10. Extending the Spider | ||||||||||||||||
| Chapter 10. Extending jPetStore | ||||||||||||||||
| Section 10.1. A Brief Look at the Existing Search Feature | ||||||||||||||||
| Section 10.2. Replacing the Controller | ||||||||||||||||
| Section 10.3. The User Interface (JSP) | ||||||||||||||||
| Section 10.4. Setting Up the Indexer | ||||||||||||||||
| Section 10.5. Making Use of the Configuration Service | ||||||||||||||||
| Section 10.6. Adding Hibernate | ||||||||||||||||
| Section 10.7. Summary | ||||||||||||||||
| Chapter 11. Where Do We Go from Here? | ||||||||||||||||
| Section 11.1. Technology | ||||||||||||||||
| Section 11.2. Process | ||||||||||||||||
| Section 11.3. Challenges | ||||||||||||||||
| Section 11.4. Conclusion | ||||||||||||||||
| Chapter 12. Bibliography | ||||||||||||||||
| Section 12.1. Books | ||||||||||||||||
| Section 12.2. Referenced Internet Sources | ||||||||||||||||
| Section 12.3. Helpful Internet Sources | ||||||||||||||||
| Section 12.4. Other References | ||||||||||||||||
| Colophon | ||||||||||||||||
Descarga: Better_Faster_Lighter_Java_2004.pdf.rar
