Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Follow the author
OK
The Jini(TM) Specification (The Jini(TM) Technology Series) 1st Edition
This book contains the formal specification for the Jini technology. It offers a review of distributed computing fundamentals, an overview of the Jini architecture, and an introduction to the key concepts that are the source of the technology's simplicity and power--remote objects, leasing, distributed events, and a two-phase commit protocol. The formal specification provides the definitive description of every element of the Jini architecture, including detailed information on such topics as:
* Jini Discovery and Join protocols * Jini Entry usage and the AbstractEntry class * Jini Distributed Leasing concepts * Jini Distributed Event programming model * Jini Transaction model and semantics * Jini Lookup service and lookup attribute schema * Jini device architecture
As networks continue to pervade our personal and professional lives, there is an urgent call for the flexible and robust network infrastructure that Jini represents.
- ISBN-100201616343
- ISBN-13978-0201616347
- Edition1st
- PublisherAddison-Wesley Pub (Sd)
- Publication dateJanuary 1, 1999
- LanguageEnglish
- Dimensions7.4 x 0.71 x 9.21 inches
- Print length288 pages
Discover the latest buzz-worthy books, from mysteries and romance to humor and nonfiction. Explore more
Editorial Reviews
Amazon.com Review
The book starts with what Jini is and how it works. (In short, Jini allows Java clients to invoke remote services easily through Java.) The authors present a chat message server and explain the Jini architecture where clients look up and "lease" remote services.
The heart of this book is its coverage of classes in the Jini specification. First there's an overview of Jini illustrated with a printer service. Then it's a close look at how clients "discover" Jini services, either through multicast or unicast protocols. (The authors also present useful built-in utility classes here.)
Next comes material on storing entries for Jini services (used for identifying them across the network) and the classes used to "lease" remote services. An interesting section on remote events contrasts them with local JavaBean events. Then it's on to Jini transactions, including the two-phase commit process used to manage work done remotely.
Later the book turns to the new JavaSpaces classes, which permit sharing data between Java processes in order to facilitate parallelism. An intriguing appendix reprints a white paper in which the Sun team outlines its philosophy of distributed computing. (They argue that local and remote objects need to be handled differently: object location transparency is a myth.)
With a mix of technology briefing and nuts-and-bolts detail, The Jini Specification delivers a valuable perspective on the latest advance in Java distributed computing from Sun. --Richard Dragan
Review
From the Inside Flap
Perfection is reached, not when there is no longer anything to add,
but when there is no longer anything to take away.
-- Antoine de Saint-Exupery
The Jini architecture is designed for deploying and using services in a network. Networks are by nature dynamic: new things are added, old things are removed, existing things are changed, and parts of the network fail and are repaired. There are therefore problems unlike any that will appear in a single process or even multiple processes in a single machine.
These differences require an approach that takes them into account, makes changes apparent, and allows older parts to work with newer parts that are added. A distributed system must adapt as the network changes since the network will change. The Jini architecture is designed to be adaptable.
This book contains three parts. The first part gives an overview of the Jini architecture, its design philosophy, and its application. This overview sets up the following sections, which contain examples of programming in a Jini system. The first section of the introduction is also usable as a high-level overview for technical managers.
The sections of the introduction that contain examples are designed to orient you within the Jini technology and architecture. They are not a full tutorial: Think of them as a tour through the process of design and implementation in a Jini system. As with any tour, you can get the flavor of how things work and where you can start your own investigation.
The second part of the book is the specification itself. Each chapter of the specification has a brief introduction describing its place in the overall architecture.
The third part of the book contains supplementary material: a glossary that defines terms used in the specifications and in talking about Jini architecture, design, and technology, and two appendices. Appendix A is a reprint of "A Note on Distributed Computing," which describes critical differences between local and remote programming. Appendix B contains the full source code for the examples in the introductory material. History
The Jini architecture is the result of a rather extraordinary string of events. But then almost everything is. The capriciousness of life--and to the fortunate, its occasional serendipity--is always extraordinary. It is only in retrospect that we examine the causes and antecedents of something interesting and decide that, because they shaped that interesting result, we will call them "extraordinary." Other events, however remarkable, go unremarked because they are unexamined. Those of us who wrote the Jini architecture, along with the many who contributed to its growth, are lucky to have a reason to examine our particular history to notice its pleasures.
This is not the proper place for a long history of the project, but it seems appropriate to give a brief summary of the highlights. The project had its origins in Sun Microsystems Laboratories, where Jim Waldo ran the Large Scale Distribution research project. Jim Waldo and Ken Arnold had previously been involved with the Object Management Group's first CORBA specification while working for Hewlett-Packard. Jim brought that experience and a long-term background in distributed computing with him to Sun Labs.
Soon after joining the Labs, Jim made Ann Wollrath part of the team. Soon after, observations about many common approaches in the field of distributed computing led Jim, Ann, and the other authors to write "A Note on Distributed Computing," which outlined core distinctions between local and distributed design. Many people had been trying to hide those differences under the general rubric of "local/remote transparency." The "Note" argued that this was not possible. It has become the most cited Sun Laboratories technical report, and the lessons it distills are at the core of the design approach taken by the project.
At this time the project was using Modula 3 Network Objects for experiments in distributed computing. As Modula 3 ceased to be developed, the team looked around for a replacement language. At that time Oak, the language an internal Sun project, seemed a viable replacement with some interesting new properties. To a research project, the fact that Oak was commercially insignificant was irrelevant. It was at this time that Ken rejoined Jim on his new team.
Soon after, Oak was renamed "Java."
When it was still Oak, it once had a remote method invocation mechanism, but that was removed when the mechanism failed--it, too, had fallen into the local/remote transparency trap. When Bill Joy and James Gosling wanted to create a working distributed computing mechanism, they asked Jim to lead the effort, which switched our team from the laboratories into the JavaSoft product group. As the first result of this effort, Ann, as the Java RMI architect, steered the team on an exploration of what could be done with a language-centric approach to distributed computing (most distributed computing systems are built on language-neutral approaches).
After RMI became part of the Java platform, Bill Joy asked the team to expand its horizons to include a platform for easier distributed computing, coining the name "Jini."1 He convinced Sun management to put the RMI and Jini project into a separate unit. This new unit started with Jim, Ann, Ken, and Peter Jones, and was soon joined by Bob Scheiffler who had extensive distributed computing experience from the X Windows project that he ran. This put together the original core architectural team: Jim, Ann, Ken, and Bob.
As the team grew, many people had a hand in the direction of various parts of the architecture, including Bryan O'Sullivan who took over the design of the lookup discovery protocol. Mike Clary took the project under his wing to give it time to grow. Mark Hodapp joined the team to manage its software development and run it in partnership with its technical leadership. Gary Holness, Zane Pan, Brian Murphy, John McClain, and Bob Resendes all reviewed the primary architecture documents and had responsibility for various parts of the tool design, implementation design, and the implementations themselves. Laird Dornin and Adrian Colley joined the RMI sub-team to continue and expand its development. Charlie Lamb joined the architectural team to oversee work with outside companies, starting with printing and storage service standards. Jen McGinn joined the team to document what we had done, later with the help of Susan Snyder on production support. Jimmy Torres started out as our release engineer and has changed to working on helping build our public developer community. Frank Barnaby took over the release engineering duties. Helen Leary joined early and kept our infrastructure humming along.
Our QA team was Mark Schuldenfrei and Anand Dhingra, managed by Brendan Daly. Alan Mortensen wrote the conformance tests and their infrastructure. Emily Suter and Theresa Lanowitz started out our marketing team, with Franc Romano, Donna Michael, Joan MacEachern, and Paula Kozak joining later. Jim Hurley started setting up our support organization, and Keith Thompson and Peter Marks joined to work on sales engineering. Samir Mitra led a marketing and business development team that included Jon Bostrom, Jaclyn Dahlby, Mike McNerny, Miko Matsamura, Darryl Mocek, Sharam Moradpour, and Vince Vasquez. Many others, too numerous to mention, did important work that made the Jini architecture possible and real. Acknowledgments
As the specifications were written, almost every member of the team made important contributions. Their names are listed above; we note the fact here to express our gratitude. A good idea and a dollar will buy a bad cup of espresso--you need people who will make that idea live, sand off any rough edges, and help you rework any bad parts of the idea into good ones. We had those people--some of the best we've ever worked with. Without them the Jini architecture would be some rather nice ideas on paper. Because of their commitment to adopt the vision as their own, to make it better, and to make it real, there are people (like you, the reader) who care about these ideas and can do something with them. We thank the entire team for what they have done to improve the Jini architecture and to help us write and release the Jini technology.
Bill Joy created the environment in which the Jini architecture could be developed and nurtured, and fed the architecture with his own reviews and ideas. His vision and support inside and outside of Sun made the project possible. This book itself is also his idea.
Bob Sproull gave the Large Scale Distribution project scope and support that has continued to this day, through all its many twists and turns, even after we were no longer were part of his Sun Labs organization. Mike Clary's protection and guidance was critical to fostering the creative atmosphere around the Jini project.
Jen McGinn and Susan Snyder did a lot of work to make this book possible, including hours in front of a screen converting the specification documents from their original form into that of the book. Jen also worked hard to improve the content of the specifications and introductory material during their creation, making them clearer and their English more correct. Dick Gabriel contributed to the content and organization of the Jini Architecture Specification, making it clearer and easier to use.
Many people reviewed the introductory material, making comments that improved it tremendously: Liz Blair, Charlie Lamb, John McClain, Bob Resendes, and Bob Sproull. Lisa Friendly has applied her experience as series editor with the Java Series to help us create this sibling Jini Series. We would also like to thank the people at Addison-Wesley's Professional Computing group who worked with us on this book and the series: Mike Hendrickson, Julie DeBaggis, Sarah Weaver, Marina Lang, and Diane Freed. And without Susan Stambaugh's help, communicating with Bill (and sometimes Mike) is not merely difficult, but probably theoretically impossible.
To these and many others too numerous to mention we give our thanks and appreciation for what they did to make these ideas and this book possible.
------------------------------------------------------------------------
1. Jini is not an acronym. To remember this, think of it as standing for "Jini Is Not Initials." It is pronounced the same as "genie."
0201616343P04062001
From the Back Cover
This book contains the formal specification for the Jini technology. It offers a review of distributed computing fundamentals, an overview of the Jini architecture, and an introduction to the key concepts that are the source of the technology's simplicity and power--remote objects, leasing, distributed events, and a two-phase commit protocol. The formal specification provides the definitive description of every element of the Jini architecture, including detailed information on such topics as: Jini Discovery and Join protocols Jini Entry usage and the AbstractEntry class Jini Distributed Leasing concepts Jini Distributed Event programming model Jini Transaction model and semantics Jini Lookup service and lookup attribute schema Jini device architecture
As networks continue to pervade our personal and professional lives, there is an urgent call for the flexible and robust network infrastructure that Jini represents.
0201616343B04062001
About the Author
Bryan O'Sullivan, while at Sun Microsystems, Inc., developed the Jini Discovery and Join Protocol. He supports his rock climbing habit by designing and building distributed systems.
Robert W. Scheifler, is a Senior Staff Engineer and one of the original architects of Jini technology with Sun Microsystems, where he has been responsible for the design and implementation of the lookup service and the associated discovery protocol and attribute schema. Before joining Sun, he spent nine years as Director and then President of the X Consortium, a non-profit organization devoted to the development and evolution of the X Window System. He was chief architect of the X Window System protocol, and created the Consortium originally while a principal research scientist at the MIT Laboratory for Computer Science.
Jim Waldo is a Distinguished Engineer with Sun Microsystems, where he has been the lead architect for the Jini project since its inception. Prior to the Jini project, Jim worked in Sun's Java Software group and in Sun Microsystems Laboratories, doing research into the areas of object-oriented programming and systems, distributed computing, and user environments. Jim is also on the faculty of Harvard University, where he teaches distributed computing in the department of computer science.
Ann Wollrath is a Senior Staff Engineer with Sun Microsystems where she is the architect of the Java Remote Method Invocation (RMI) system and one of the original architects of the Jini technology. Previously during her tenure at Sun Microsystems Laboratories and at the MITRE Corporation, she researched reliable, large-scale distributed systems and parallel computation.
0201616343AB04062001
Excerpt. © Reprinted by permission. All rights reserved.
The emergence of the Internet has led computing into a new era. It is no longer what your computer can do that matters. Instead, your computer can have access to the power of everything that is connected to the network: The Network is the Computer(tm). This network of devices and services is the computing environment of the future.
The Java programming language brought reliable object-oriented programs to the net. The power of the Java platform is its simplicity, which allows programmers to be fully fluent in the language. This simplicity allows debugged Java programs to be written in about a quarter the time it takes to write programs in C++. We believe that use of the Java platform is the key to the emergence of a "best practices" discipline in software construction, to give us the reliability we need in our software systems as they become more and more widely used.
The Jini architecture is designed to bring reliability and simplicity to the con-struction of networked devices and services. The philosophy behind Jini is language-based systems: a Jini system is a collection of interacting Java programs, and you can understand the behavior of this Jini system completely by under-standing the semantics of the Java programming language and the nature of the network, namely that networks have limited bandwidth, inherent latency, and partial failure.
Because the Jini architecture focuses on a few simple principles we can teach Java language programmers the full power of the Jini technology in a few days. To do this we introduce remote objects (they just throw a RemoteException), leasing (commitments in a Jini system are of limited duration), distributed events (in the network events aren't as predictable on a single machine), and the need for two-phase commit (because the network is a world of partial failures). This small set of additional concepts allows distributed applications to be written, and we can illustrate this with the JavaSpaces service, which is also specified here.
For me, the Jini architecture represents the results of almost 20 years of yearning for a new substrate for distributed computing. Ever since I shipped the first widely used implementation of TCP/IP with the Berkeley UNIX system, I have wanted to raise the level of discourse on the network from the bits and bytes of TCP/IP to the level of objects. Objects have the enormous advantage of combin-ing the data with the code, greatly improving the reliability and integrity of sys-tems. For me, the Jini architecture represents the culmination of this dream.
I would like to thank the entire Jini team for their continuing hard work and commitment. I would especially like to thank my long time collaborator Mike Clary for helping to get the Jini project started and for directing the project; the Jini architects Jim Waldo, Ken Arnold, Bob Scheiffler, and Ann Wollrath for designing and implementing such a simple and elegant system; Mark Hodapp for his excellent engineering management; and Samir Mitra, for committing early to the Jini project, helping us understand how to explain it and what problems it would solve, and for driving the key business development that helped give Jini technology the momentum it has in the marketplace today. I would also like to thank Mark Tolliver, the head of the Consumer and Embedded division, which the Jini project became part of, for his support.
Finally, I would like to thank Scott McNealy, with me a founder of Sun and its longtime CEO. It is his continuing support for breakthrough technologies like Java and Jini that makes them possible. As Machiavelli noted, it is hard to intro-duce new ideas, and support like Scott's is essential to our continuing success.
Bill Joy
Aspen, Colorado
April, 1999
Product details
- Publisher : Addison-Wesley Pub (Sd); 1st edition (January 1, 1999)
- Language : English
- Paperback : 288 pages
- ISBN-10 : 0201616343
- ISBN-13 : 978-0201616347
- Item Weight : 1.55 pounds
- Dimensions : 7.4 x 0.71 x 9.21 inches
- Best Sellers Rank: #9,061,278 in Books (See Top 100 in Books)
- #5,144 in Running Meetings & Presentations (Books)
- #83,343 in Professional
- Customer Reviews:
About the author

Discover more of the author’s books, see similar authors, read book recommendations and more.
Customer reviews
- 5 star4 star3 star2 star1 star5 star50%0%50%0%0%50%
- 5 star4 star3 star2 star1 star4 star50%0%50%0%0%0%
- 5 star4 star3 star2 star1 star3 star50%0%50%0%0%50%
- 5 star4 star3 star2 star1 star2 star50%0%50%0%0%0%
- 5 star4 star3 star2 star1 star1 star50%0%50%0%0%0%
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on Amazon-
Top reviews
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
- Reviewed in the United States on June 19, 2000Since it has so many glowing reviews, I'll give it a review that may be uselful to the authors for future additions.
I don't understand why Sun Microsystems, on their website and in thier books, (and this book is no exception) do not use UML to describe their libraries and frameworks. I, for one, learn a lot about dependencies and collaborations between classes when UML is employed. In the sections that have real code examples, it would be helpful to have a snippet of UML describing the section of Jini critical to that example, for instance.
Furthermore, in the earlier sections of the book, the overview, the authors use what I call "system collaboration diagrams", even better would be when they are explaining code snippets to highlight in their system collaboration diagrams what part of the system they are showing an example of.
I guess I just found the explaination of the examples lacking. The examples themselves are excerpted, making them hard to follow. For instance, it is confusing to see an ordinary method being called (from within an excerpt) with no class or object qualified before it. Is it in the superclass? In the implementation? If in the superclass, how far up? This is especially difficult when referring to the DEM of Java, which sometimes seems counterintuitive to beginners.
My rule of thumb is one should never look at a piece of code and get "nervous" about what a symbol or method is supposed to be doing there.
- Reviewed in the United States on November 30, 1999Jini has to be about the hottest new Java technology to be released in years. Imagine a world of plug-and-play networked devices, which can be installed and seamlessly integrated with your LAN simply by connecting them to your network. A laptop on-the-go can just plug in to an unfamiliar network, and access the printer or Internet proxy server, without the need to install any drivers. Mixing Unix and Wintel devices? Not a worry. Jini promises to let them talk to each other.
That's the vision behind Jini. But that vision goes much further. Not only can hardware devices talk to one another, but also software services. In a Jini world, you won't care whether how a device works, or whether it is software or hardware based. An Internet based fax service will act as a fax, as will a hardware device. You'll just look for a fax service, without worrying how the service is implemented. Of course, someone needs to write the software that will power Jini services. That's where The Jini Specification comes in.
The book is divided into two main sections, an overview and the specification for Jini. The overview provides an easily accessible overview of what Jini is, how it works, and what it can achieve. There are also several examples of Jini services and clients, to give you some practical experience with building Jini software applications.
From there, the book dives headfirst into the actual specification. The first part of the book is good for managers, and software developers alike. The coverage of the specification, however, is designed as a reference for developers as they construct Jini software. This is where many readers could become lost, unless they are already using Jini in action. The first part of the book is a guide to Jini, the second intended only as a reference during development. Finally, a glossary of Jini terms and an essay on distributed computing is included, along with the full source code from the overview.
The Jini Specification is a must-have for anyone considering Jini development. It provides an excellent guide to Jini technology for those considering designing Jini-based systems, and a comprehensive printed reference for those who will implement them. -- David Reilly, for the Java Coffee Break