The Codebase System Property. JavaSpaces in Practice What is even more important, it can be run with no more effort that running a typical Java application with a main method. Part Three highlights some practical applications including implementing smart proxies, location-based services and agent systems, together with guidelines and tips for testing and tuning JavaSpaces. It is also well written and clearly presented, a rarity in technical books these days. Tips and Rules in This Book.

Author:Grotaxe Tagal
Language:English (Spanish)
Published (Last):2 August 2019
PDF File Size:6.65 Mb
ePub File Size:19.10 Mb
Price:Free* [*Free Regsitration Required]

Part 1 on entries, covers entry design, evolution, and distributed data structure design. Part Two covers designs and idioms associated with remote events, code mobility, and combining the use of both transient and persistent space. Part Three deals with the practical design and application of space-based systems. Chapter summary Part 1: Entries The first four chapters of this part cover designing entries and data structures and some of the forces that influence their design. There is plenty more on designing space-based systems in the other sections too, but they build on some of the principles discussed in this first section.

Chapter 1: Introduction In the first chapter we are going to take a look at JavaSpaces in general, starting with some foundation principles and outlining the terms that we intend to use throughout the book. We will also be taking a brief peek "under the hood" to see how Spaces are built, and the differences between transient and persistent Spaces. Chapter 2: Designing entries In the first chapter in the entries section we take a look at designing entries.

We start off with a simple entry and discuss the rules governing its design. The chapter concludes by looking at the payload idiom, which can be used to reduce the indexing burden on a JavaSpace.

Chapter 3: Evolving entries The second chapter in this section discusses the implications of evolving entry classes to satisfy new requirements as systems change over time. Initially we investigate the standard Java technique used for maintaining class compatibility and how it can result in data loss under some circumstances.

We then investigate the implication of evolving classes used as key fields in an entry and conclude by proposing alternative designs. Chapter 4: Simple distributed data structures This is the first of two chapters that look at the forces affecting the design of distributed data structures.

We start off by looking at some simple examples of ordered and unordered data structures and how we can use them to help us build a system that records and reports on errors encountered by other Jini services. The chapter concludes by looking at how to iterate over distributed data structures by using the "timeout iterator" idiom. Chapter 5: Hierarchical distributed data structures In the second of the two chapters about distributed data structures we look at how to design hierarchical data structures such as graphs and trees.

We take the example of a large organizational hierarchy which is represented in XML and iteratively examine the forces that affect how we can go about designing a useful data structure to hold this data in a JavaSpace. Topics covered include how to edit subtrees, move and delete nodes, matching on subtree and tree walking. This section presents an interesting set of idioms that build on some of the earlier examples by making space-based systems more dynamic and flexible.

This is a reference chapter which you can refer back to if you encounter any problems later on. The chapter concludes by covering leasing, transactions, sequence numbers, and how the Event Mail Box service can be used in conjunction with a space-based client. Using this knowledge we start to build a simple employee system that is dynamically updateable. Initially we implement a solution that uses subclassing, then we briefly delve into how class loaders work and present another simple model that allows you to update the behavior associated with an entry while the system is running.

Chapter 9: Using transient and persistent JavaSpaces In this chapter we investigate how to use both transient and persistent JavaSpaces together in a single system. By using a marker interface with entries, we develop a model where short-lived entries can take advantage of a faster transient space, while longer-lived entries are written to a persistent space.

In this chapter we introduce the concept of adapter proxies, which are also used in later chapters. Part 3: Application In the final part of the book we look at some practical applications for JavaSpaces. The first chapter in this section examines the well-known request-response model and describes how using JavaSpaces can result in more robust and flexible designs.

We finish off by looking at some tuning tips. Chapter Location-based services This chapter looks at location-based services implemented with Spaces, and discusses how the use of generic or more abstract classes can help to reduce complexity and increase flexibility and future growth in these and other Spaces- based systems.

We show how the inherent matching properties of Spaces can be used to implement powerful searching strategies, and make use of their inherent parallel character to optimize the searches. Chapter Bidding and agent systems In this chapter we look at a very simple system in which agents bid to deliver parcels of various sizes in order to effectively share work and distribute resources.

Chapter Tuning space-based systems In this chapter we look at some of the details of building efficient and effective clients of a space; that is, those that use the resources available to them in terms of the systems hardware effectively. They not only go faster, but they also use memory and other computer resources well.

Appendix B: Tips and rules in this book This appendix contains a summary of the tips and rules dotted through this book, alongside the text.


JavaSpaces in Practice







Related Articles