Core Jini

Overview

The Jini Vision? Network Anything, Anytime, Anywhere!

Jini is truly revolutionary: it enables any device-from enterprise servers to kitchen appliances-to network smoothly, simply, and reliably. Core Jini delivers the first comprehensive, practical explanation of Jini technology-plus all the live Java code experienced developers need to start building solutions right now!

With a Foreword by Sun Microsystems ...

See more details below
Available through our Marketplace sellers.
Other sellers (Paperback)
  • All (16) from $1.99   
  • New (5) from $6.99   
  • Used (11) from $1.99   
Close
Sort by
Page 1 of 1
Showing 1 – 4 of 5
Note: Marketplace items are not eligible for any BN.com coupons and promotions
$6.99
Seller since 2014

Feedback rating:

(5)

Condition:

New — never opened or used in original packaging.

Like New — packaging may have been opened. A "Like New" item is suitable to give as a gift.

Very Good — may have minor signs of wear on packaging but item works perfectly and has no damage.

Good — item is in good condition but packaging may have signs of shelf wear/aging or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Acceptable — item is in working order but may show signs of wear such as scratches or torn packaging. All specific defects should be noted in the Comments section associated with each item.

Used — An item that has been opened and may show signs of wear. All specific defects should be noted in the Comments section associated with each item.

Refurbished — A used item that has been renewed or updated and verified to be in proper working condition. Not necessarily completed by the original manufacturer.

New
PAPERBACK New 013014469X TRACKING NUMBER INCLUDED New Unread Book May have some very minor shelf wear.

Ships from: Plantation, FL

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$38.58
Seller since 2014

Feedback rating:

(0)

Condition: New
PAPERBACK New 013014469X Brand New US Edition Book in Perfect Condition. Fast Shipping with tracking number.

Ships from: Houston, TX

Usually ships in 1-2 business days

  • Canadian
  • International
  • Standard, 48 States
  • Standard (AK, HI)
  • Express, 48 States
  • Express (AK, HI)
$45.00
Seller since 2014

Feedback rating:

(165)

Condition: New
Brand new.

Ships from: acton, MA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
$45.00
Seller since 2014

Feedback rating:

(165)

Condition: New
Brand new.

Ships from: acton, MA

Usually ships in 1-2 business days

  • Standard, 48 States
  • Standard (AK, HI)
Page 1 of 1
Showing 1 – 4 of 5
Close
Sort by
Sending request ...

Overview

The Jini Vision? Network Anything, Anytime, Anywhere!

Jini is truly revolutionary: it enables any device-from enterprise servers to kitchen appliances-to network smoothly, simply, and reliably. Core Jini delivers the first comprehensive, practical explanation of Jini technology-plus all the live Java code experienced developers need to start building solutions right now!

With a Foreword by Sun Microsystems Java and Jini visionary Bill Joy, Core Jini is 100% authoritative!

  • Discover how Jini addresses critical distributed networking problems ignored by "traditional" technologies-and how it can simplify connectivity in both new devices and existing networks.
  • Master the Jini architectural model, including crucial concepts like discovery, leasing, remote events, and transactions.
  • Learn real-world techniques for developing Jini services and applications; implementing discovery using multicast request and announcement protocols; building lookup services and browsers; and much more.
  • See how to manage lease negotiation and relative time; write lease interfaces; handle delegation; and use Jini's Landlord paradigm.
  • Even discover how to use Jini with JavaSpaces, Sun Microsystems' powerful new technology for high-performance distributed and parallel computing!

Core Series books are written by serious programmers for serious programmers! Every Core Series book:

  • DEMONSTRATES how to write commercial quality code
  • FEATURES dozens of nontrivial programs and examples-no toy code!
  • FOCUSES on the features and functions most important to real developers
  • PROVIDES objective, unbiasedcoverage of cutting-edge technologies-no hype!

Core Jini delivers:

  • Systematic coverage of the entire Jini API
  • Insightful descriptions of the entire Jini architecture
  • Step-by-step coverage of building a complete, robust Jini service
  • Detailed guidance on Java properties for controlling and tuning Jini services

This book is also available as part of Core Jini - The Complete Video Course (ISBN: 0-13-086386-6).

Read More Show Less

Editorial Reviews

From Barnes & Noble
The Barnes & Noble Review
Sun's Jini may turn out to be one of the most important technologies of the next decade: a smarter way to network systems without the hassles we've come to accept as inevitable. Xerox PARC researcher W. Keith Edwards was one of the first people outside Sun to discover Jini, and he's just written a remarkably accessible, helpful guide for anyone who wants to develop with it.

All too often, the "first" book on a subject is rushed sloppily to market, but not this time. Edwards truly understands Jini, and CORE JINI does an exceptional job of explaining why it's so important, not only for "non-traditional" devices (which get the hype), but also for enterprise computing (where the money is).

One of the key challenges standing in the way of distributed systems has been the fundamental difference between local and remote systems: in a nutshell, remote systems can fail in all sorts of ways that local systems do not. Traditional approaches to distributed computing try to paper over the distinction, with mixed success. Jini addresses it head on — and Edwards explains how, in-depth. You'll master key Jini concepts such as discovery, Jini's Landlord Paradigm, remote events, and transactions; learn how to build lookup services and lookup service browsers; walk through writing leases and managing lease negotiation; even learn how to work with JavaSpaces, a powerful service built atop Jini which enables high-performance distributed and parallel computing.

The book has been thoroughly vetted by Sun insiders Brian Murphy and Peter van der Linden. There's lots of code, anditruns (what a concept)!

If you're already familiar with Java—and, ideally, at least a bit familiar with RMI—you'll find Jini surprisingly easy to master. Especially if you learn it with W. Keith Edwards' CORE JINI. — Bill Camarda,

Booknews
Offers Java software developers and other technically sophisticated readers an introduction and guide to the new distributed systems technology. Describes it as marking a change from a world in which devices are merely networked, into one in which devices join together to form a true distributed system, a collection of networked components working together. Explains the fundamentals and how to write software to leverage the technology. Annotation c. Book News, Inc., Portland, OR (booknews.com)
Read More Show Less

Product Details

  • ISBN-13: 9780130144690
  • Publisher: Pearson Education
  • Publication date: 6/25/1999
  • Series: Java Series
  • Edition description: Older Edition
  • Edition number: 1
  • Pages: 832
  • Product dimensions: 7.02 (w) x 9.24 (h) x 2.15 (d)

Meet the Author


W. Keith Edwards is a member of the research staff at Xerox Palo Alto Research Center (PARC). He has worked in research and development and as a consultant to several leading companies, including Sun, and holds a Ph.D. from Georgia Tech's Graphics, Visualization and Usability Center.
Read More Show Less

Read an Excerpt

PREFACE:

Preface

This book provides a comprehensive guide to Jini, the new distributed systems technology from Sun Microsystems. Jini has the potential to revolutionize the way we build networked software. In a sense, Jini signals a change from a world in which devices are networked ( meaning that computers simply have the ability to talk to one another) into one in which devices join together to form a true distributed system —a collection of networked components working together.

The distinction between networked devices and true distributed systems is an important one. Simple networked systems have simple communication patterns (usually peer-to-peer or client/server), and tend to be static, long-lived entities. Distributed systems, on the other hand, are composed of numerous constituent pieces. Any of these pieces can come or go without bringing down the whole system, and the system can respond to changes in its environment and its constituency in reliable and predictable ways. In a nutshell, Jini moves us from a world in which the "system" is the individual networked device, to one in which the "system" is the collection of all these devices working together.

This book serves two purposes. First, it provides a broad introduction to the core technologies of Jini. This introduction will be useful to Java developers who need to understand Jini, and to other technically-savvy readers who need to understand how Jini fits into the world, and why it is significant. Second, the book provides a deep understanding of how to build working softwarethat leverages Jini. This second focus is intended for a range of developers, including those who are building Jini-enabled software for small devices such as PDAs, to those building LAN-based networked systems such as for the small-office/home-office (SOHO) or remote-office/home-office (ROHO), all the way up to enterprisewide network services and possibly the Internet itself.

These two goals of the book are largely represented by the book's two parts. Part I introduces Jini history, looks at Jini's place in the world—in particular, how Jini is different from what came before it—and provides some details on getting started with the technology and deploying it in actual use. Part II provides an in-depth look at the core Jini concepts, such as leasing, lookup, discovery, and transactions, as well as some extensive examples that illustrate particular aspects of Jini. Finally, the remainder of the book provides appendices and reference materials.

The philosophy taken by this book is that developers learn by reading code. You will no doubt notice if you page through this book, especially the chapters in Part II, that there are a great many code examples here. Some of these are "stand-alone" Jini programs—they typically introduce some concept in the smallest number of lines possible, in the interest of clarity. Others are utility programs that cover "holes" in the Jini APIs. These programs will find their way into the toolchests of programmers working with Jini.

Throughout this book, though, I have provided a number of longer examples that share a common theme: Taken together, these examples can be used as applications in "live" Jini networks, and can interoperate with each other. This approach is very much in keeping with the Jini design philosophy itself—large numbers of cooperating applications working together to provide some service—and happens to be a good way to illustrate the ideas in Jini by using discrete chunks of code rather than monolithic, multithousand line applications. Each of these examples illustrates one or more key points of the Jini architecture. They can be extended by you, and applied to any number of domains, from small, intelligent devices all the way up to enterprise software systems.

One thing this book does not provide is an introduction to Java itself. Jini is a layer atop Java—much like the Java Foundation Classes (JFC) or Java Database Connectivity (JDBC). Like these other layers, Jini introduces some new concepts and extends the Java programming model, but at its core, Jini remains pure Java. This book assumes that you are familiar with Java programming and, with one exception, does not cover the facilities available in the core Java class libraries or the language.

The one exception is the Java Remote Method Invocation system (RMI). RMI is used extensively in Jini. In fact, Jini leverages new features in RMI that only appeared in Java 2 (also popularly known as JDK1.2), such as the RMI activation framework. Thus, there is an RMI primer in Appendix A of this book that serves as an introduction to this technology for those who may be unfamiliar with it.

A Roadmap

Part I of this book, "Foundations," provides some necessary background reading Jini. This information will be useful for savvy readers who just need to understand Jini, what it does, and how it works. But it's also "required reading" for developers who want to build actual, running Jini programs—the chapters in this part highlight the philosophical differences between Jini and "classical" networked and distributed systems technologies. If you have a good understanding of this material, you're ready to build software that's consistent with the Jini aesthetic.

Chapter 1, "A New Computing Paradigm," looks at the history and motivation of Jini. You'll see how Jini is really the fulfillment of the original Java promise: of collections of software and hardware, working together simply and without administration. This chapter also covers the process of getting and installing the Jini software.

Chapter 2, "Distributed Systems," provides a glimpse at the basics of distributed systems, and how Jini differs from traditional distributed systems software. Even if you're a handy network programmer, you may want to take a look at this chapter. Jini is fairly unique in the distributed systems world, and it's interesting to see the roots of Jini and understand what problems it's good at solving.

Chapter 3, "The Jini Model," introduces the basic concepts in Jini. Fortunately there are very few of these—only five. Understanding these concepts and how they connect to each other will make later reading much easier.

Chapter 4, "Deployment Scenarios," covers some scenarios for deploying Jini services. These are development targets, if you will—ways that you as a developer can deploy Jini code that you write. Jini is perhaps unique in all the Java libraries provided by Sun, in that it is specifically designed to support devices which may not have Java Virtual Machines (JVMs) embedded in them. Jini can be used to connect devices with only limited computational ability, just as it can be used to connect large servers and other machines running full-fledged JVMs. This chapter will help you understand the options available to you if you're designing for Jini.

These first four chapters comprise Part I of this book—they provide a broad introduction to the Jini technology and how it fits into the world. Part II, "Building with Jini," is a very in-depth look at particular aspects of Jini. It is designed for the professional Java developer who is writing new Jini services or building Jini-enabled devices. Some of the chapters in this part are In Depth chapters that dive deeply into a particular aspect of the Jini technology. Others are structured around large examples that show Jini being applied to real problems.

Chapter 5, "Getting Started with Jini," begins with a series of programs designed to introduce you to the core Jini concepts. This series is a set of "Hello, World" style programs that are evolved to illustrate ideas such as lookup, discovery, leasing, and remote events. This chapter is your first introduction to building Jini software from scratch, and covers almost all the basic Jini ideas, as well as an example of using the RMI activation framework.

Chapter 6, "In Depth: Discovery," is an in-depth chapter looking at Jini's discovery protocols. These are the means by which Jini services notify the world of their existence, and Jini client applications learn about the clusters or "communities" of services that are available to them. We'll look under the hood at these protocols—understanding what's really going on there is key to understanding how to use them effectively. By the end of this chapter you should understand these protocols well enough to be able to implement them "by hand" if you need to.

Chapter 7, "Using Attributes to Describe Services," talks about the Jini notion of attributes . Attributes are objects that can be associated with services to provide descriptive information about them, or even provide additional functionality (such as user interfaces) to extend the behavior of services. This chapter talks about how to use attributes, and how the Jini attribute model meshes nicely with JavaBeans.

Chapter 8, "In Depth: Using Lookup Services," moves on to the next major phase in a Jini application's life cycle, the use of the Jini lookup service. Lookup is how applications learn about particular services within a particular community. In this in-depth chapter, you'll see how both clients and services use lookup, and learn how to use some high-level "convenience" APIs to simplify the responsibilities of services with regard to lookup. We'll pay special attention to the issues around federating and connecting Jini communities into larger structures.

At this point you should understand the basics of what you need to know to build a very functional and useful Jini client application that can participate in the discovery and lookup process, and allow you to find and browse any Jini service on the network. Chapter 9, "A Jini Lookup Service Browser," introduces a long application that exercises the ideas in the previous chapters. This application is a browser that can find lookup servers and the services registered there, and allow you to view and control the attributes of those services. The code in this chapter builds up a toolkit of useful components for displaying and using service information, which you can reuse in your own applications.

Chapter 10, "In Depth: Leasing," gives in-depth coverage of the notion of leasing, which is how Jini manages resources held by remote systems. Leasing is also the key to Jini's ability to "self-heal" a large distributed system. In this chapter, we'll talk about the benefits of leasing, and cover some common idioms that arise again and again when programming with leases.

While Chapter 10's focus is on the ideas behind leasing, and in particular how clients can use leasing, Chapter 11, "Exporting Leased Resources," talks about how Jini services can implement leasing. This is the other half of the leasing equation that is started in Chapter 10. With these two chapters, you can "close the loop," exporting a leased resource to a client, which then uses the lease consumer APIs to control it.

While the chapters on discovery, lookup, and leasing provide the basics of what you have to do to write a functional Jini service, Chapter 12, "The Well-Behaved Service," provides a summary of the extra steps you can take to provide a useful and useable service. This chapter talks about service administration, the join protocol—which governs how services interact with their communities—and how to provide user interfaces for services.

After this coverage of what it takes to be a "good" service, we're ready to build a complete, sophisticated Jini application. Chapter 13, "A Complete Example: The Print Service," presents a long example of a service that allows clients to connect to it to print documents. This program supports administration, persistence, and self-description through attributes, and can serve as the basis for many of the services you will write. And, of course, you'll be able to use this service in conjunction with the other examples in this book.

Next, Chapter 14, "In Depth: Remote Events," provides a look at how Jini supports asynchronous notifications between programs. Jini extends the local Java event model with events that can be sent between objects in different JVMs. This remote event model has different semantics than the usual JavaBeans event model—this chapter looks at why this is, and explores some common idioms for using remote events. The remote event model lends itself to the creation of event "adaptors" that can plug into the event pipeline to provide such services as forwarding or storage of events. One of the examples here looks at an "event mailbox" adaptor that can be a useful service in many Jini communities.

While the preceding chapters cover topics that are considered core and fundamental to Jini, the next two chapters are a bit different. The next chapters cover topics that are actually implemented as services atop the core Jini infrastructure.

Chapter 15, "JavaSpaces," provides an introduction to Sun's JavaSpaces service. This service provides an extremely useful object storage engine. Many applications that use Jini will need a way to store persistent data, and share it for use by other applications. JavaSpaces provides an easy object-based way for them to do this. And JavaSpaces can even serve as the basis for new styles of distributed computation. This chapter looks at the JavaSpaces programming model and philosophy.

Chapter 16, "Distributed Transactions," covers transactions, which are one of the most technical concepts in Jini. Transactions are a way for cooperating processes to ensure the integrity of their data. Essentially, transactions are a way to make sure that either an entire set of operations happen completely, or that none of them happen at all. Those of you familiar with database programming are no doubt familiar with transactions, and their power in preventing partial failures. The Jini model, while based on the familiar two-phase commit protocol used in database systems, is actually somewhat different. This chapter explores those differences, and shows how to build programs that can use transactions to safely group their operations.

Finally, the two appendices in this book provide some useful reference and background material. Appendix A is a primer on the RMI technology, in particular, the features that have been added as of the Java 2 release. The RMI activation framework, which provides a way for objects to be automatically reconstituted from persistent storage when needed, will be used heavily by many Jini applications, and is important to understand. In general, a good grounding in the ideas of RMI is necessary for getting the most from Jini.

Appendix B provides a reference to the various system properties that can be useful when developing with Jini. You can use these properties to control and tune the behavior of Jini, as well as some basic Java features, in your applications.

Conventions Used in This Book

This book follows a number of conventions to help you get the most out of it. Throughout the text, you'll see a number of callouts that designate particular items of interest. These callouts, called Core Note, Core Alert, and Core Tip, provide useful information that is important enough that it should not be lost in the text. Core Alerts are used for potential pitfalls in developing Jini applications. Examples might include portions of the Jini API that are unimplemented or perhaps behave differently than the specs indicate. Core Tips are pointers to common and useful ways to accomplish particular results. Examples might include common idioms or patterns that can make your life as a developer easier. Core Notes are extra information that might help you make sense of some aspect of Jini, or just provide fodder for Silicon Valley cocktail party conversations.

Getting Sample Code from the Internet

All the code samples in this book have been collected together, and are available electronically from the Prentice Hall ftp site. To download the code, point your web browser at ftp://ftp.prenhall.com/pub/ptr/sunsoft_books.w-053/corejini . Save the file to your computer's hard disk, and extract the contents. If you're on Windows, use your favorite unzipping utility, such as WinZip. On Solaris and other UNIX platforms, use a command like unzip corejini.zip .

The unzip process will create a directory called corejini under whatever directory you ran the unzipper. For consistency with the rest of this book, I'd recommend unzipping the contents into C:\files\corejini (on Windows) and /files/corejini (on Solaris).

Under the corejini directory you'll find separate subdirectories for each of the chapters in this book that contain code samples.

Feedback

No book is perfect, especially one that covers a topic as new and as rich as Jini. Even though this book has been thoroughly reviewed a number of times, I have no doubt that errors do remain, or that improvements can be made. If you find a "bug," either in the text or in one of the example programs, or if you think of anything that might make this book more useful to you or other readers, please drop me a note:

 

kedwards@parc.xerox.com

Further Information

Many of the chapters in this book have a "Further Reading" section at the end of them, with pointers to books, papers, and resources on the Internet that may extend your Jini knowledge.

Read More Show Less

Table of Contents

Foreword
Foreword
Introduction
Introduction
Acknowledgments
Pt. 1 Foundations 2
Ch. 1 A New Computing Paradigm 4
Ch. 2 Distributed Systems 38
Ch. 3 The Jini Model 56
Ch. 4 Deployment Scenarios 104
Pt. 2 Building with Jini 120
Ch. 5 Getting Started with Jini 122
Ch. 6 In Depth: Discovery 196
Ch. 7 Using Attributes to Describe Services 248
Ch. 8 In Depth: Using Lookup Services 272
Ch. 9 A Jini Lookup Service Browser 340
Ch. 10 In Depth: Leasing 396
Ch. 11 Exporting Leased Resources 450
Ch. 12 The Well-Behaved Service 480
Ch. 13 A Complete Example: The Print Service 508
Ch. 14 In Depth: Remote Events 558
Ch. 15 JavaSpaces 634
Ch. 16 Distributed Transactions 686
Pt. 3 Appendices 718
App. A An RMI Primer 721
App. B Common Java and Jini System Properties 749
Index 755
Read More Show Less

Preface

PREFACE:

Preface

This book provides a comprehensive guide to Jini, the new distributed systems technology from Sun Microsystems. Jini has the potential to revolutionize the way we build networked software. In a sense, Jini signals a change from a world in which devices are networked ( meaning that computers simply have the ability to talk to one another) into one in which devices join together to form a true distributed system —a collection of networked components working together.

The distinction between networked devices and true distributed systems is an important one. Simple networked systems have simple communication patterns (usually peer-to-peer or client/server), and tend to be static, long-lived entities. Distributed systems, on the other hand, are composed of numerous constituent pieces. Any of these pieces can come or go without bringing down the whole system, and the system can respond to changes in its environment and its constituency in reliable and predictable ways. In a nutshell, Jini moves us from a world in which the "system" is the individual networked device, to one in which the "system" is the collection of all these devices working together.

This book serves two purposes. First, it provides a broad introduction to the core technologies of Jini. This introduction will be useful to Java developers who need to understand Jini, and to other technically-savvy readers who need to understand how Jini fits into the world, and why it is significant. Second, the book provides a deep understanding of how to build workingsoftwarethat leverages Jini. This second focus is intended for a range of developers, including those who are building Jini-enabled software for small devices such as PDAs, to those building LAN-based networked systems such as for the small-office/home-office (SOHO) or remote-office/home-office (ROHO), all the way up to enterprisewide network services and possibly the Internet itself.

These two goals of the book are largely represented by the book's two parts. Part I introduces Jini history, looks at Jini's place in the world—in particular, how Jini is different from what came before it—and provides some details on getting started with the technology and deploying it in actual use. Part II provides an in-depth look at the core Jini concepts, such as leasing, lookup, discovery, and transactions, as well as some extensive examples that illustrate particular aspects of Jini. Finally, the remainder of the book provides appendices and reference materials.

The philosophy taken by this book is that developers learn by reading code. You will no doubt notice if you page through this book, especially the chapters in Part II, that there are a great many code examples here. Some of these are "stand-alone" Jini programs—they typically introduce some concept in the smallest number of lines possible, in the interest of clarity. Others are utility programs that cover "holes" in the Jini APIs. These programs will find their way into the toolchests of programmers working with Jini.

Throughout this book, though, I have provided a number of longer examples that share a common theme: Taken together, these examples can be used as applications in "live" Jini networks, and can interoperate with each other. This approach is very much in keeping with the Jini design philosophy itself—large numbers of cooperating applications working together to provide some service—and happens to be a good way to illustrate the ideas in Jini by using discrete chunks of code rather than monolithic, multithousand line applications. Each of these examples illustrates one or more key points of the Jini architecture. They can be extended by you, and applied to any number of domains, from small, intelligent devices all the way up to enterprise software systems.

One thing this book does not provide is an introduction to Java itself. Jini is a layer atop Java—much like the Java Foundation Classes (JFC) or Java Database Connectivity (JDBC). Like these other layers, Jini introduces some new concepts and extends the Java programming model, but at its core, Jini remains pure Java. This book assumes that you are familiar with Java programming and, with one exception, does not cover the facilities available in the core Java class libraries or the language.

The one exception is the Java Remote Method Invocation system (RMI). RMI is used extensively in Jini. In fact, Jini leverages new features in RMI that only appeared in Java 2 (also popularly known as JDK1.2), such as the RMI activation framework. Thus, there is an RMI primer in Appendix A of this book that serves as an introduction to this technology for those who may be unfamiliar with it.

A Roadmap

Part I of this book, "Foundations," provides some necessary background reading Jini. This information will be useful for savvy readers who just need to understand Jini, what it does, and how it works. But it's also "required reading" for developers who want to build actual, running Jini programs—the chapters in this part highlight the philosophical differences between Jini and "classical" networked and distributed systems technologies. If you have a good understanding of this material, you're ready to build software that's consistent with the Jini aesthetic.

Chapter 1, "A New Computing Paradigm," looks at the history and motivation of Jini. You'll see how Jini is really the fulfillment of the original Java promise: of collections of software and hardware, working together simply and without administration. This chapter also covers the process of getting and installing the Jini software.

Chapter 2, "Distributed Systems," provides a glimpse at the basics of distributed systems, and how Jini differs from traditional distributed systems software. Even if you're a handy network programmer, you may want to take a look at this chapter. Jini is fairly unique in the distributed systems world, and it's interesting to see the roots of Jini and understand what problems it's good at solving.

Chapter 3, "The Jini Model," introduces the basic concepts in Jini. Fortunately there are very few of these—only five. Understanding these concepts and how they connect to each other will make later reading much easier.

Chapter 4, "Deployment Scenarios," covers some scenarios for deploying Jini services. These are development targets, if you will—ways that you as a developer can deploy Jini code that you write. Jini is perhaps unique in all the Java libraries provided by Sun, in that it is specifically designed to support devices which may not have Java Virtual Machines (JVMs) embedded in them. Jini can be used to connect devices with only limited computational ability, just as it can be used to connect large servers and other machines running full-fledged JVMs. This chapter will help you understand the options available to you if you're designing for Jini.

These first four chapters comprise Part I of this book—they provide a broad introduction to the Jini technology and how it fits into the world. Part II, "Building with Jini," is a very in-depth look at particular aspects of Jini. It is designed for the professional Java developer who is writing new Jini services or building Jini-enabled devices. Some of the chapters in this part are In Depth chapters that dive deeply into a particular aspect of the Jini technology. Others are structured around large examples that show Jini being applied to real problems.

Chapter 5, "Getting Started with Jini," begins with a series of programs designed to introduce you to the core Jini concepts. This series is a set of "Hello, World" style programs that are evolved to illustrate ideas such as lookup, discovery, leasing, and remote events. This chapter is your first introduction to building Jini software from scratch, and covers almost all the basic Jini ideas, as well as an example of using the RMI activation framework.

Chapter 6, "In Depth: Discovery," is an in-depth chapter looking at Jini's discovery protocols. These are the means by which Jini services notify the world of their existence, and Jini client applications learn about the clusters or "communities" of services that are available to them. We'll look under the hood at these protocols—understanding what's really going on there is key to understanding how to use them effectively. By the end of this chapter you should understand these protocols well enough to be able to implement them "by hand" if you need to.

Chapter 7, "Using Attributes to Describe Services," talks about the Jini notion of attributes . Attributes are objects that can be associated with services to provide descriptive information about them, or even provide additional functionality (such as user interfaces) to extend the behavior of services. This chapter talks about how to use attributes, and how the Jini attribute model meshes nicely with JavaBeans.

Chapter 8, "In Depth: Using Lookup Services," moves on to the next major phase in a Jini application's life cycle, the use of the Jini lookup service. Lookup is how applications learn about particular services within a particular community. In this in-depth chapter, you'll see how both clients and services use lookup, and learn how to use some high-level "convenience" APIs to simplify the responsibilities of services with regard to lookup. We'll pay special attention to the issues around federating and connecting Jini communities into larger structures.

At this point you should understand the basics of what you need to know to build a very functional and useful Jini client application that can participate in the discovery and lookup process, and allow you to find and browse any Jini service on the network. Chapter 9, "A Jini Lookup Service Browser," introduces a long application that exercises the ideas in the previous chapters. This application is a browser that can find lookup servers and the services registered there, and allow you to view and control the attributes of those services. The code in this chapter builds up a toolkit of useful components for displaying and using service information, which you can reuse in your own applications.

Chapter 10, "In Depth: Leasing," gives in-depth coverage of the notion of leasing, which is how Jini manages resources held by remote systems. Leasing is also the key to Jini's ability to "self-heal" a large distributed system. In this chapter, we'll talk about the benefits of leasing, and cover some common idioms that arise again and again when programming with leases.

While Chapter 10's focus is on the ideas behind leasing, and in particular how clients can use leasing, Chapter 11, "Exporting Leased Resources," talks about how Jini services can implement leasing. This is the other half of the leasing equation that is started in Chapter 10. With these two chapters, you can "close the loop," exporting a leased resource to a client, which then uses the lease consumer APIs to control it.

While the chapters on discovery, lookup, and leasing provide the basics of what you have to do to write a functional Jini service, Chapter 12, "The Well-Behaved Service," provides a summary of the extra steps you can take to provide a useful and useable service. This chapter talks about service administration, the join protocol—which governs how services interact with their communities—and how to provide user interfaces for services.

After this coverage of what it takes to be a "good" service, we're ready to build a complete, sophisticated Jini application. Chapter 13, "A Complete Example: The Print Service," presents a long example of a service that allows clients to connect to it to print documents. This program supports administration, persistence, and self-description through attributes, and can serve as the basis for many of the services you will write. And, of course, you'll be able to use this service in conjunction with the other examples in this book.

Next, Chapter 14, "In Depth: Remote Events," provides a look at how Jini supports asynchronous notifications between programs. Jini extends the local Java event model with events that can be sent between objects in different JVMs. This remote event model has different semantics than the usual JavaBeans event model—this chapter looks at why this is, and explores some common idioms for using remote events. The remote event model lends itself to the creation of event "adaptors" that can plug into the event pipeline to provide such services as forwarding or storage of events. One of the examples here looks at an "event mailbox" adaptor that can be a useful service in many Jini communities.

While the preceding chapters cover topics that are considered core and fundamental to Jini, the next two chapters are a bit different. The next chapters cover topics that are actually implemented as services atop the core Jini infrastructure.

Chapter 15, "JavaSpaces," provides an introduction to Sun's JavaSpaces service. This service provides an extremely useful object storage engine. Many applications that use Jini will need a way to store persistent data, and share it for use by other applications. JavaSpaces provides an easy object-based way for them to do this. And JavaSpaces can even serve as the basis for new styles of distributed computation. This chapter looks at the JavaSpaces programming model and philosophy.

Chapter 16, "Distributed Transactions," covers transactions, which are one of the most technical concepts in Jini. Transactions are a way for cooperating processes to ensure the integrity of their data. Essentially, transactions are a way to make sure that either an entire set of operations happen completely, or that none of them happen at all. Those of you familiar with database programming are no doubt familiar with transactions, and their power in preventing partial failures. The Jini model, while based on the familiar two-phase commit protocol used in database systems, is actually somewhat different. This chapter explores those differences, and shows how to build programs that can use transactions to safely group their operations.

Finally, the two appendices in this book provide some useful reference and background material. Appendix A is a primer on the RMI technology, in particular, the features that have been added as of the Java 2 release. The RMI activation framework, which provides a way for objects to be automatically reconstituted from persistent storage when needed, will be used heavily by many Jini applications, and is important to understand. In general, a good grounding in the ideas of RMI is necessary for getting the most from Jini.

Appendix B provides a reference to the various system properties that can be useful when developing with Jini. You can use these properties to control and tune the behavior of Jini, as well as some basic Java features, in your applications.

Conventions Used in This Book

This book follows a number of conventions to help you get the most out of it. Throughout the text, you'll see a number of callouts that designate particular items of interest. These callouts, called Core Note, Core Alert, and Core Tip, provide useful information that is important enough that it should not be lost in the text. Core Alerts are used for potential pitfalls in developing Jini applications. Examples might include portions of the Jini API that are unimplemented or perhaps behave differently than the specs indicate. Core Tips are pointers to common and useful ways to accomplish particular results. Examples might include common idioms or patterns that can make your life as a developer easier. Core Notes are extra information that might help you make sense of some aspect of Jini, or just provide fodder for Silicon Valley cocktail party conversations.

Getting Sample Code from the Internet

All the code samples in this book have been collected together, and are available electronically from the Prentice Hall ftp site. To download the code, point your web browser at ftp://ftp.prenhall.com/pub/ptr/sunsoft_books.w-053/corejini . Save the file to your computer's hard disk, and extract the contents. If you're on Windows, use your favorite unzipping utility, such as WinZip. On Solaris and other UNIX platforms, use a command like unzip corejini.zip .

The unzip process will create a directory called corejini under whatever directory you ran the unzipper. For consistency with the rest of this book, I'd recommend unzipping the contents into C:\\files\\corejini (on Windows) and /files/corejini (on Solaris).

Under the corejini directory you'll find separate subdirectories for each of the chapters in this book that contain code samples.

Feedback

No book is perfect, especially one that covers a topic as new and as rich as Jini. Even though this book has been thoroughly reviewed a number of times, I have no doubt that errors do remain, or that improvements can be made. If you find a "bug," either in the text or in one of the example programs, or if you think of anything that might make this book more useful to you or other readers, please drop me a note:

 

kedwards@parc.xerox.com

Further Information

Many of the chapters in this book have a "Further Reading" section at the end of them, with pointers to books, papers, and resources on the Internet that may extend your Jini knowledge.

Read More Show Less

Introduction

This book provides a comprehensive guide to Jini, the new distributed systems technology from Sun Microsystems. Jini has the potential to revolutionize the way we build software. In a sense, Jini signals a change from a world in which devices are networked (meaning that computers simply have the ability to talk to one another) into one in which devices join together to form a true distributed system-a collection of networked components working together.

The distinction between networked systems and true distributed systems is an important one. Simple networked systems have simple communication patterns (usually peer-to-peer or client/server), and tend to be static, long-lived entities. Distributed systems, on the other hand, are composed of numerous constituent pieces. Any of these pieces can come or go without bringing down the whole system, and the system can respond to changes in its environment and its constituency in reliable and predictable ways. In a nutshell, Jini moves us from a world in which the "system" is the individual networked device, to one in which the "system" is the collection of all these devices working together.

This book serves two purposes. First, it provides a broad introduction to the core technologies of Jini. This introduction will be useful to Java developers who need to understand Jini, and to other technically-savvy readers who need to understand how Jini fits into the world, and why it is significant. Second, the book provides a deep understanding of how to build working software that leverages Jini. This second focus is intended for a range of developers, including those who are buildingJini-enabled software for smalldevices such as Personal Digital Assistants (PDAs), to those building LAN-based (local area network) networked systems for the small-office/home-office (SOHO) or remote-office/home-office (ROHO), all the way up to those building enterprisewide network services and possibly software for the Internet itself.

These two goals of the book are largely represented by the book's two parts. Part I introduces Jini history, looks at Jini's place in the world-in particular, how Jini is different from what came before it-and provides some details on getting started with the technology and deploying it in actual use. Part II provides an in-depth look at the core Jini concepts, such as leasing, lookup, discovery, and transactions, as well as some extensive examples that illustrate particular aspects of Jini. Finally, the remainder of the book provides appendices and reference materials.

The philosophy taken by this book is that developers learn by reading code. You will no doubt notice if you page through this book, especially the chapters in Part II, that there are a great many code examples here. Some of these are "stand-alone" Jini programs-they typically introduce some concept in the smallest number of lines possible, in the interest of clarity. Others are utility programs that cover "holes" in the Jini APIs (Application Programming Interfaces). These programs will find their way into the toolchests of programmers working with Jini.

Throughout this book, though, I have provided a number of longer examples that share a common theme: Taken together, these examples can be used as applications in "live" Jini networks, and can interoperate with each other. This approach is very much in keeping with the Jini design philosophy itself-large numbers of cooperating applications working together to provide some service-and happens to be a good way to illustrate the ideas in Jini by using discrete chunks of code rather than monolithic, multithousand-line applications. Each of these examples illustrates one or more key points of the Jini architecture. They can be extended by you, and applied to any number of domains, from small, intelligent devices all the way up to enterprise software systems.

One thing this book does not provide is an introduction to Java itself. Jini is a layer atop Java-much like the Java Foundation Classes (JFC) or Java Database Connectivity (JDBC). Like these other layers, Jini introduces some new concepts and extends the Java programming model; but at its core, Jini remains pure Java. This book assumes that you are familiar with Java programming and, with one exception, does not cover the facilities available in the core Java class libraries or the language.

The one exception is the Java Remote Method Invocation system (RMI). RMI is used extensively in Jini. In fact, Jini leverages new features in RMI that only appeared in Java 2 (also popularly known as the JDK1.2 and later versions), such as the RMI activation framework. Thus, there is an RMI primer in Appendix A of this book that serves as an introduction to this technology for those who may be unfamiliar with it.

A Roadmap

Part I of this book, "Foundations," provides some necessary background reading on Jini. This information will be useful for savvy readers who just need to understand Jini, what it does, and how it works. But it's also required reading for developers who want to build actual, running Jini programs-the chapters in this part highlight the philosophical differences between Jini and "classical" networked and distributed systems technologies. If you have a good understanding of this material, you're ready to build software that's consistent with the Jini aesthetic.

Chapter 1, "A New Computing Paradigm," looks at the history and motivation of Jini. You'll see how Jini is really the fulfillment of the original Java promise: of collections of software and hardware, working together simply and without administration. This chapter also covers the process of getting and installing the Jini software.

Chapter 2, "Distributed Systems," provides a glimpse at the basics of distributed systems, and how Jini differs from traditional distributed systems software. Even if you're a handy network programmer, you may want to take a look at this chapter. Jini is fairly unique in the distributed systems world, and it's interesting to see the roots of Jini and understand what problems it's good at solving.

Chapter 3, "The Jini Model," introduces the basic concepts in Jini. Fortunately there are only a handful of these. Understanding these concepts and how they connect to each other will make later reading much easier and help you to understand how all the big pieces of the Jini design fit together.

Chapter 4, "Deployment Scenarios," covers some strategies for deploying Jini services. These are development targets, if you will-ways that you as a developer can deploy Jini code that you write. Jini is perhaps unique in all the Java libraries provided by Sun in that it is specifically designed to support devices which may not have Java Virtual Machines (JVMs) embedded in them. Jini can be used to connect devices with only limited computational ability, just as it can be used to connect large servers and other machines running full-fledged JVMs. This chapter will help you understand the options available to you if you're designing for Jini.

These first four chapters comprise Part I of this book-they provide a broad introduction to the Jini technology and how it fits into the world. Part II, "Building with Jini," is a very in-depth look at particular aspects of Jini. It is designed for the professional Java developer who is writing new Jini services or building Jini-enabled devices. Some of the chapters in this part are In Depth chapters that dive deeply into a particular aspect of the Jini technology. Others are structured around large examples that show Jini being applied to real problems.

Chapter 5, "Getting Started with Jini," begins with a series of programs designed to introduce you to the core Jini concepts. This series is a set of "Hello, World"-style programs that are evolved to illustrate ideas such as lookup, discovery, leasing, and remote events. This chapter is your first introduction to building Jini software from scratch, and covers almost all the basic Jini ideas, as well as provides an example of using Java's RMI framework.

Chapter 6, "In Depth: Discovery," is an in-depth chapter looking at Jini's discovery protocols. These are the means by which Jini services notify the world of their existence, and Jini client applications learn about the clusters or "communities" of services that are available to them. We'll look under the hood at these protocols-understanding what's really going on there is key to using them effectively. By the end of this chapter, you should understand these protocols well enough to be able to implement them "by hand" if you need to.

Chapter 7, "Attributes, Templates, and Service Matching," talks about the Jini notion of attributes, which are objects that can be associated with services to provide descriptive information about them. This chapter talks about how to use attributes, how the Jini attribute model meshes nicely with JavaBeans, and the rules for how clients search for services that they need to use.

Chapter 8, "The Service Join Protocol," moves on to the next major phase in a Jini application's life cycle, the use of the Jini lookup service by other services. Any Jini service will need to use the lookup service to join a community and make itself available to other members of that community. In this chapter, you'll learn about some of the responsibilities services have to be well-behaved, how they're assigned IDs that are unique over space and time, and some introductory details about how services are administered.

Chapter 9, "Using Low-Level Lookup Service Interfaces," continues the discussion of using lookup services started in Chapter 8. In this chapter, you'll learn how clients interact with Jini lookup services to find and use services. You'll also see how to write clients that can administer lookup services, and federate them into larger structures.

Chapter 10, "Using the Service Discovery Manager," discusses some new APIs introduced with Jini 1.1. If you've been programming with Jini 1.0, you'll want to pay special attention to this chapter; the ServiceDiscoveryManager provides a useful high-level interface to working with lookup services.

At this point, you should understand the basics of what you need to know to build a very functional and useful Jini client application that can participate in the discovery and lookup process, and allow you to find and browse any Jini service on the network. Chapter 11, "A Jini Lookup Service Browser," introduces a long application that exercises the ideas in the previous chapters. This application is a browser that can find lookup services and the services registered there, and allow you to view and control the attributes of those registered services. The code in this chapter builds up a toolkit of useful components for displaying and using service information, which you can reuse in your own applications.

Chapter 12, "In Depth: Leasing," gives in-depth coverage of the notion of leasing, which is how Jini manages resources held by remote systems. Leasing is also the key to Jini's ability to "self-heal" a large distributed system. In this chapter, we'll talk about the benefits of leasing, and cover some common idioms that arise again and again when programming with leases.

While Chapter 12's focus is on the ideas behind leasing, and in particular how clients can use leasing, Chapter 13, "Exporting Leased Resources," talks about how Jini services can implement leasing. This is the other half of the leasing equation that is started in Chapter 12. With these two chapters, you can "close the loop," exporting a leased resource to a client, which then uses the lease consumer APIs to control it.

While the chapters on discovery, lookup, and leasing provide the basics of what you have to do to write a functional Jini service, Chapter 14, "The Well-Behaved Service," provides a summary of the extra steps you can take to provide a useful and useable service. This chapter talks about service administration, the join protocol-which governs how services interact with their communities-and how to provide user interfaces for services.

After this coverage of what it takes to be a "good" service, you're ready to build a complete, sophisticated Jini application. Chapter 15, "A Complete Example: The Print Service," presents a long example of a service that allows clients to connect to it to print documents. This program supports administration, persistence, and self-description through attributes, and can serve as the basis for many of the services you will write. And, of course, you'll be able to use this service in conjunction with the other examples in this book.

Next, Chapter 16, "In Depth: Remote Events," provides a look at how Jini supports asynchronous notifications between programs. Jini extends the local Java event model with events that can be sent between objects in different JVMs. This remote event model has different semantics than the usual JavaBeans event model-this chapter looks at why this is, and explores some common idioms for using remote events. The remote event model lends itself to the creation of event "adaptors" that can plug into the event pipeline to provide such services as forwarding or storage of events. One of the examples here looks at an "event mailbox" adaptor that can be a useful service in many Jini communities.

While the preceding chapters cover topics that are considered core and fundamental to Jini, the next three chapters are a bit different. These last chapters cover topics that are actually implemented as services atop the core Jini infrastructure.

Chapter 17, "JavaSpaces," provides an introduction to Sun's JavaSpaces service. This service provides an extremely useful object storage engine. Many applications that use Jini will need a way to store persistent data, and share it for use by other applications. JavaSpaces provides an easy object-based way for them to do this. And JavaSpaces can even serve as the basis for new styles of distributed computation. This chapter looks at the JavaSpaces programming model and philosophy.

Chapter 18, "Distributed Transactions," covers transactions, which are one of the most technical concepts in Jini. Transactions are a way for cooperating processes to ensure the integrity of their data. Essentially, transactions are a way to make sure that either an entire set of operations happen completely, or that none of them happen at all. Those of you familiar with database programming are no doubt familiar with transactions and their power in preventing partial failures. The Jini model, while based on the familiar two-phase commit protocol used in database systems, is actually somewhat different. This chapter explores those differences, and shows how to build programs that can use transactions to safely group their operations.

Chapter 19, "Helper Services," covers some new services introduced in Jini 1.1 to aid in Jini development. Much like the Transaction Manager service, these are "utility" services that are meant to be used by other clients and services to simplify development. This chapter talks about the EventMailbox service, the LookupDiscoveryService, and the LeaseRenewalService. These are important new additions to Jini that should be in any programmer's toolbox.

Finally, the two appendices in this book provide some useful reference and background material. Appendix A is a primer on the RMI technology, in particular, the features that have been added as of the Java 2 release. The RMI activation framework, which provides a way for objects to be automatically reconstituted from persistent storage when needed, will be used heavily by many Jini applications, and is important to understand. In general, a good grounding in the ideas of RMI is necessary for getting the most from Jini.

Appendix B provides a reference to the various system properties that can be useful when developing with Jini. You can use these properties to control and tune the behavior of Jini, as well as some basic Java features, in your applications.

Conventions Used in This Book

This book follows a number of conventions to help you get the most out of it. Throughout the text, you'll see a number of callouts that designate particular items of interest. These callouts, called Core Note, Core Alert, and Core Tip, provide useful information that is important enough that it should not be lost in the text. Core Alerts are used for potential pitfalls in developing Jini applications. Examples might include portions of the Jini API that are unimplemented or perhaps behave differently than the specs indicate. Core Tips are pointers to common and useful ways to accomplish particular tasks. Examples might include common idioms or patterns that can make your life as a developer easier. Core Notes are extra information that might help you make sense of some aspect of Jini, or just provide fodder for Silicon Valley cocktail party conversations.

Getting Sample Code from the Internet

All the code samples in this book have been collected together, and are available electronically from my Web site. To download the code, point your Web browser to ...

Read More Show Less

Foreword

Much of the early history of the Jini technology has been documented and, at least anecdotally, is well known. Most people who have followed the evolution of this technology over the past six to twelve months know that Bill Joy provided the inspiration and initial direction, and that Jim Waldo - as lead architect - is the creator; without whom this truly revolutionary technology would not exist.

Most people also know that the work on which the Jini technology is based began within Sun Microsystems Laboratories at Sun's east coast facility just outside Boston. While with "the labs," Jim Waldo ran the Large Scale Distribution research project and, along with Ann Wollrath, Peter Jones and Ken Arnold, investigated and developed some of the key Jini concepts. The concepts developed in those early days, concepts such as leasing, distributed events and lightweight transactions, addressed issues in the field of distributed computing in a way that was contrary to the standard approach of attempting to hide distinctions between local and remote systems (sadly for some, this is still the standard approach).

The team of Waldo, Wollrath, Jones and Arnold made up the kernel of the Jini engineering team. The team eventually moved from the labs into the JavaSoft product group where they began to investigate how a language-centric approach could be applied to the distributed computing concepts developed in the labs. As a result of this collaboration, Ann Wollrath created Java RMI which has become one of the most interesting and useful components in the Java language; and Ken Arnold created JavaSpaces technology as well as having begun work on what would become the Jinilightweight transaction model.

What people probably don't know about the early history of the Jini technology is that when Bill Joy asked the team to expand their prior work to design a new platform for distributed computing, the team as moved out of JavaSoft in order to provide insulation from the kind of large company politics that can kill a new and radical idea. As a matter of fact, the Jini project actually began life in Sun Microsystems' Human Resources division! It was at about this time that Bob Scheifler (of X Consortium fame), Bryan O'Sullivan and Mark Hodapp joined the Jini team as architects and manager respectively. These individuals provided the missing pieces necessary for the project to continue to grow and thrive. The team eventually grew to include about fifteen development engineers. To this day, the development team here on the east coast remains small, focused and highly productive. The Jini team is made up of some of the finest people and brightest minds I have ever had the pleasure of knowing.

Until the summer of 1998, very few people - both internal and external to Sun - were aware of the existence of the Jini project. Just as with the Java language, there were moments where the future of the project was tentative at best, the project owes a debt of gratitude to Bill Joy and Mike Clary, both of whom put their professional reputations on the line to fight for the project's survival. Ultimately, the project survived because of these individuals, and because of the dedication of the team and the vision of Sun's CEO, Scott McNealy.

The Jini project once again demonstrates Sun's ability to think and act in revolutionary ways. Where other companies could never allow themselves to move beyond the safety of the status quo, Sun continues to shatter it. Just as the now legendary story tells how the Java language (known as Oak at that time) was one demo away from cancellation. The project was only able to do so because the culture established within Sun allows - even encourages - such things.

You should note that the Jini technology is radical not only in its technical design, but also in its business model. The concept of the Sun Community Source License (SCSL - pronounced "scuzzle") originated within the Jini project. Although some might say this move was not bold enough, placing a key technology under community source requires great vision and courage, especially when such an action represents a move away from the safety of traditional models. The SCSL represents a move away from the safety of traditional models. The SCSL represents a "call to arms" within the developer community. Through the SCSL, anyone can participate in the growth and evolution of the Jini technology.

I joined the Jini project in 1997. At that time, I was designing and implementing middleware for a fairly large telco-based distributed system at another company. The project was exciting and the work environment was one of the best I had ever experienced. When I was contacted about the possibility of joining the Jini development team, the Jini project was in its infancy and its future was still in doubt. Although the project's status might have made some people question the prudence of joining a project with such an uncertain future, five minutes into the description of the Jini vision, I knew this is where I wanted to be. I remember thinking to myself (with apologies to Jon Landau and Bruce Springsteen), "I've seen the future of software, and it's name is Jini." The concepts being described to me, even at that early stage (and even though they were being presented by a manager!), were so elegant and so compelling that I knew this was the opportunity to be a part of something that could change the world.

When I was approached about reviewing this book, my first reaction was reluctance. A book review is certainly a lot of work. But more importantly, when a new technology gains notoriety, it is not uncommon for many poor quality texts attempting to "cash in" on the popularity of the latest "hot" technology to begin to appear. I thought this text might possibly be in that category. When I learned that not only was this book to be part of Prentice Hall's respected "Core" series, but also that the author was Keith Edwards of Xerox's Palo Alto Research Center (PARC), I began to understand that this book had potential to be something special. To my delight, I was not disappointed!

Keith Edwards clearly understands the concepts behind the Jini technology. He has thoroughly analyzed the Jini specifications and presents the designs reflected in those specifications in a way that will be accessible to the beginner as well as the hardened veteran. Keith also presents an accurate description of the Jini philosophy on distributed computing, emphasizing the difference between local and remote systems; a description that remains true to the intent of the Jini architects. Keith's explanations of key concepts such as discovery, lookup, leasing, distributed events and transactions are excellent, and even the experienced reader will benefit from them.

The text covers everything you need to know to build clients and services that run in a Jini environment and which must behave as good "Jini citizens." The explanations are thorough and easy to follow, and are supplemented with example code that accurately demonstrates all the important concepts. Although much of the publicity surrounding the Jini technology emphasizes the role of devices in a Jini environment, Keith stresses through his well-written explanations and examples that the power of this technology can be applied to the enterprise as well as to devices.

Thus, whether you are a beginner or an experienced Java programmer, whether your world involves devices or software services for the enterprise, this book will help you gain a thorough understanding of this new and exciting technology. Jump in and have fun as Keith introduces you to a radically new way to build distributed systems.

Brian Murphy
Sun Microsystems
Burlington, Massachusetts
June 1999

Twenty years ago I was a student at U.C. Berkeley, working on what would become a popular version of the UNIX operating system. At the time computers were most frequently used by professionals, and had software that was relevant to this use.

In the last twenty years we have seen the emergence of the personal computer, with much wider use, but the complexity of the systems today exceeded the professional systems of twenty years ago, creating untold frustration. A better way of constructing new systems is needed, to reduce this frustration and better match the computing devices to human uses.

Almost a decade ago I came across a book by Jacques Attali called Lignes d'Horizon. A colleague, John Gage, and I were traveling a lot together, and John was translating this book from French to English for his personal use. In this book we found great speculations about the computing world of the future, the idea of "nomadic computing," and we saw a linkage between these concepts and our desire for simpler, more reliable, and more human-centered computing. This set us off toward the design of a new computing substrate for the imagined future world of nomadic devices and pervasive embedded computing.

Hence Jini. Jini leverages the Java programming language to provide a simple substrate for distributed computing. Distributed computing is different, mostly because partial failures occur. If we don't handle failure, distributed systems paradoxically become less reliable as they get larger, rather than more reliable as the existence of redundant parts would suggest. Jini provides the tools for dealing with this and for dealing with the limited bandwidth and latency inherent in distributed computation.

The computing world of the future is a connected world, where "The Network is the Computer®." Java brings reliable object-oriented programming to the network. Its rapid rise reflects the power of objects to structure software, and the additional reliability and productivity that results from its modern design. Jini extends Java's benefits to distributed applications, which are structured as a set of communicating Java applications without requiring complicated underlying operating systems to be understood to understand the meaning of a distributed program.

Because Jini is simple, we can teach it, and the principles of distributed programming, to Java programmers in just a few days. By learning about the Jini philosophy, the uses of remote objects, leasing, distributed events and transactions you will be learning about both the essential elements of Jini and some basic principles of distributed programming. Core Jini will aid both the student, the professional programmer writing a production application, and those curious about this new approach and new basic platform for distributed computing.

Bill Joy
Aspen, Colorado
June 1999

Read More Show Less

Customer Reviews

Be the first to write a review
( 0 )
Rating Distribution

5 Star

(0)

4 Star

(0)

3 Star

(0)

2 Star

(0)

1 Star

(0)

Your Rating:

Your Name: Create a Pen Name or

Barnes & Noble.com Review Rules

Our reader reviews allow you to share your comments on titles you liked, or didn't, with others. By submitting an online review, you are representing to Barnes & Noble.com that all information contained in your review is original and accurate in all respects, and that the submission of such content by you and the posting of such content by Barnes & Noble.com does not and will not violate the rights of any third party. Please follow the rules below to help ensure that your review can be posted.

Reviews by Our Customers Under the Age of 13

We highly value and respect everyone's opinion concerning the titles we offer. However, we cannot allow persons under the age of 13 to have accounts at BN.com or to post customer reviews. Please see our Terms of Use for more details.

What to exclude from your review:

Please do not write about reviews, commentary, or information posted on the product page. If you see any errors in the information on the product page, please send us an email.

Reviews should not contain any of the following:

  • - HTML tags, profanity, obscenities, vulgarities, or comments that defame anyone
  • - Time-sensitive information such as tour dates, signings, lectures, etc.
  • - Single-word reviews. Other people will read your review to discover why you liked or didn't like the title. Be descriptive.
  • - Comments focusing on the author or that may ruin the ending for others
  • - Phone numbers, addresses, URLs
  • - Pricing and availability information or alternative ordering information
  • - Advertisements or commercial solicitation

Reminder:

  • - By submitting a review, you grant to Barnes & Noble.com and its sublicensees the royalty-free, perpetual, irrevocable right and license to use the review in accordance with the Barnes & Noble.com Terms of Use.
  • - Barnes & Noble.com reserves the right not to post any review -- particularly those that do not follow the terms and conditions of these Rules. Barnes & Noble.com also reserves the right to remove any review at any time without notice.
  • - See Terms of Use for other conditions and disclaimers.
Search for Products You'd Like to Recommend

Recommend other products that relate to your review. Just search for them below and share!

Create a Pen Name

Your Pen Name is your unique identity on BN.com. It will appear on the reviews you write and other website activities. Your Pen Name cannot be edited, changed or deleted once submitted.

 
Your Pen Name can be any combination of alphanumeric characters (plus - and _), and must be at least two characters long.

Continue Anonymously

    If you find inappropriate content, please report it to Barnes & Noble
    Why is this product inappropriate?
    Comments (optional)