<<Understanding JavaSpaces

JavaSpaces has been a bit of an unknown technology for a long time.
It's one of those technologies that programmers know is out there, but
haven't actually used enough to say they understand what it's for or
what it can do for them.

JavaSpaces is, in very simple terms, a kind of client/server map, a
grid in which data lives. This map doesn't have a distinct key, using
a sort of query-by-example to retrieve data. It also has notification
capabilities.

In concept, that's really it. If you can wrap your head around the
idea that it's a map in which an entry's data determines how that
entry is accessed, you've mastered most of JavaSpaces already – the
rest is simple implementation.

JavaSpaces has a number of uses, especially in massive parallel
applications. One example is that of a job producer, e.g. "calculate
this" applications where the calculations vary widely in complexity;
JavaSpaces allows a high-powered CPU to grab certain computations
while letting lower-powered CPUs select others. Also, if more
computing power is needed, adding more power is only a matter of
running more clients to select tasks from the JavaSpace. Another
example is that of queueing updates to a datastore; storing data into
a JavaSpace is not only very fast (subject to network throughput, of
course, which would also affect direct data storage), but provides
easy audit capabilities (through notification events) and also means
that the persistence engine's speed can't impact the application.
(This is a common requirement for financial applications, where
milliseconds count.)
Using JavaSpaces
JavaSpaces requires an implementation. It's built on JINI, so the
beginning of a JavaSpaces exploration should start with a download of
the JINI starter kit, which includes Outrigger, Sun's implementation
of JavaSpaces.

In addition to the JINI starter kit not being documented very well,
Outrigger isn't especially good either, so an easy and convenient
addition to the JINI download is Blitz1. Blitz replaces Outrigger as
well as providing some easy startup scripts and some diagnostic tools.
A commercial implementation with the ability to distribute the Space
is GigaSpaces2. (These are merely some candidates, not meant to be
representative of the entire JINI or JavaSpaces communities.)

Running a Blitz instance is as simple as installing Blitz, going to
its directory, and typing ".\blitz.bat". This will show a decent
amount of information in the log as various services start, including
registration services and an HTTP server (defaulting to port 8080).
When initialization is complete, you have a working JavaSpace in
action. The diagnostics tool ("dashboard.bat") shows information about
memory usage, transactions, and entry counts in the space.

Entries in a JavaSpace are basically simple Java Objects that follow a
few simple rules:

     * All data persisted in the space must be exposed in public fields.
     * The Entry interface must be implemented. This is a marker
interface, requiring no methods to conform to the interface contract.
     * Objects must be used for the properties (i.e., no primitive
fields.) This makes sense especially in light of query-by-example,
which uses nulls to indicate wildcards. <

An entry can contain data and/or functionality, and can implement any
interface or class that conforms to the requirements for JavaSpaces.
Thus, a fairly common pattern is:

     * Implement a Command interface in an Entry, along with any data
required to perform the command
     * Store the Command into the JavaSpace
     * Have a computing resource retrieve the Command and execute it,
storing any results back into the JavaSpace for consumption if necessary

Connecting to a JavaSpace is fairly simple and flexible. The
Lookup.java class provided in the Blitz examples connects to every
service registrar it can find, which is acceptable development
behavior but not likely to be good in production; however, changing
this is fairly easy.

Using the Lookup class and searching for an implementation of
JavaSpace05.class (suggested, if it's available) will return a
reference to the first JavaSpace it finds, provided one is available3.

There are five basic operations associated with JavaSpaces. They are:

    1. Read an entry matching a template, leaving it in the JavaSpace
    2. Take an entry matching a template from the space, removing it
from the JavaSpace
    3. Write an entry into the JavaSpace
    4. Register a callback for events in the JavaSpace
    5. Issue an event in the JavaSpace

Of these, each can be associated with a Transaction, and the read/take
operations can also block, wait for matching entries, or
"readIfExists," which will block if there's an entry that might become
available to satisfy the operation; otherwise it returns.4
("takeIfExists" is also in the API.)

In addition, if JavaSpace05 is used, the "take" operation can populate
a list of entries matching the template, for bulk processing of
entries in the JavaSpace, as can the "write" operation (for writing
sets of data). JavaSpace05 also includes a way to get references to
sets of information (the "contents" method.)

Templates in JavaSpaces are instances of classes implementing the
Entry interface (i.e., they're entries) that use "null" as a wildcard.
Thus, if an Entry implementation has string properties A, B, and C, a
template might populate A with "data" while leaving B and C null; a
take operation would retrieve the first entry of that class that had
"data" in the "A" property. (The list form of take() would return all
entries that had "data" in the "A" property.5)

Believe it or not, this summarizes JavaSpaces. JavaSpaces can
legitimately be used as a datastore (i.e., sets of heterogenous or
homogenous Entries), as a queue (i.e., lists of Entries containing
data, consumed by external processing agents), and as a distributed
processing facility (i.e., Entries containing data and processing
capabilities, offloaded to external computing devices).
An Actual Application

Discussing JavaSpaces is all well and good, but that leaves it still
in the realm of theory and not practice. Let's change that, by
implementing a compute server. Our compute server will be functional,
but not complete – it won't implement security, computational limits,
or account tracking, but will allow us to signal processes and gather
results.

We'll use GigaSpaces for the implementation, although any JavaSpaces
implementation should work.

Our requirements are that the external clients will provide a subclass
of our ComputeTask class. Our ComputeTask class will contain a status
and a UUID for identification. The internal clients – which will be
executing the processes – will call a method in the ComputeTask.

The key value proposition of JavaSpaces in this situation is that if
the internal client process becomes overloaded for any reason, it will
be very, very simple to connect another "internal client" to the
JavaSpace to double computational power; each client would add nearly
linear scalability to the grid. It's possible to get the same kind of
linear capabilities from other technologies, but the nearly
transparent nature of the JavaSpace model along with the simplicity of
the clients serves as an advantage.

The first step is to download GigaSpaces' Community Edition from
http://gigaspaces.com/. This requires registration; if this is a
concern for you, feel free to substitute Blitz, Outrigger from the
JSTK, or any other compliant JavaSpace implementation, any of which
provide the JavaSpaces API features we'll be using. The compute server
shown here has no dependency on any specific JavaSpaces implementation.

The next step is to consider our basic data model. The entities are
fairly simple: a ComputeTask class (which does nothing in and of
itself, but provides UUID and status for descendants), a SubmitTask
class (and a parent) which provide some handy utility methods for
adding ComputeTasks to the JavaSpace, and a multithreaded
ComputeClient, which actually does the work of executing the ComputeTask.

It's worth reiterating that the practice followed in this engine is
very much insecure. One of the issues not being discussed in this
article is the security manager and policies; if you'd like, please
read "Discovering a Java Application's Security Requirements6" for one
method of determining required security policy entries.

In addition, the "multithreaded client" is very primitive, as is the
ComputeTask itself. The codebase monitors no information, doesn't
indicate that it's "running" (instead it removes it from the space
entirely), offers no status information. Only one hundred tasks will
be run (although it'd be trivial to change it to an infinite number of
tasks.) That said, this task server does work, and is a workable
starting point for creating a more capable task server. (Incidentally,
while this code is entirely written from scratch, except for Dan
Creswell's service locator classes, there are other similar
implementations of the same kind of structure elsewhere.)

Here's the runtime of a given ComputeClient task. It initializes a
counter (to limit the number of tasks to 20), then creates a template
to use to look for available tasks (i.e., tasks whose status is
STATUS_NEWTASK). Then it looks for the tasks for 5000 ms; if it finds
one, it removes it from the space, executes the task (which is
expected to populate a "result" field in the ComputeTask) and stores
it back into the JavaSpace for retrieval by any external clients. The
code is fairly straightforward, if not very robust. (Adding
transaction support wouldn't involve much, actually.)

public void run() {
     int tasksRun = 0;
     ComputeTaskImpl template = new ComputeTaskImpl();
     template.setUuid(null);
     template.setStatus(ComputeTask.STATUS_NEWTASK);

     while (tasksRun < TASKS_PER_THREAD) {
         try {
             ComputeTask task = (ComputeTask) getSpace().take(template,
                                                              null,

SCAN_TIME_MILLIS);
             if (task != null) {
                 task.execute();
                 task.setStatus(ComputeTask.STATUS_FINISHEDTASK);
                 submit(task, null, Lease.FOREVER);
                 tasksRun++;
             }
         } catch (Exception e) {
             log.log(Level.SEVERE, e.getMessage(), e);
         }
     }
}

The actual task itself is very, very simple. Here's an addition task,
for example. It's vast overkill to use a JavaSpace for simple
addition, but it's a proof of concept – more complex tasks would
follow the same pattern.

public class SimpleAdditionTask extends ComputeTaskImpl {
     private transient Logger
log=Logger.getLogger(this.getClass().getName());
     public Integer firstNumber=null;
     public Integer secondNumber=null;

     // fulfills Entry requirements to have public no-arg constructor
     public SimpleAdditionTask() {
     }

     public SimpleAdditionTask(int f, int s) {
         firstNumber=f;
         secondNumber=s;
     }

     public void execute() {
         result=firstNumber+secondNumber;
         log.info("SimpleAddition has run! (result="+result+")");
     }
}

The execute() method is the one of most interest – note that it simply
executes the task (the addition) and stores the result into the
"result" property which is contained in ComputeTaskImpl.
(Incidentally, the result here is an Integer, not an int; the
JavaSpace API mandates that persisted fields in a JavaSpace are
public, Serializable objects.)

Source code for the entire server is available on TheServerSide.com.

The last step is to run the actual application. Start GigaSpaces, then
set your classpath to include jsk-platform.jar and jsk-lib.jar.
Execute "java -Djava.security.policy=policy.all
com.tss.javaspaces.compute.internal.ComputeClient"; it will block the
command shell until it completes. The security policy in "policy.all"
clears all security.

With the same classpath and JVM option, execute the
com.tss.javaspaces.compute.util.SubmitTask class; it has a main()
method that creates a single SimpleAddition task, submits it, then
watches for the result for the task it submitted (which it looks for
by UUID and status).

You should see the ComputeClient class show the SimpleAddition's log
statement, and then the SubmitTask should get the result itself. You
now have a simple, but working, Compute Server.

Hopefully this explained JavaSpaces to you clearly enough that you can
see some potential applications for it and not lack any confidence
that it can be executed efficiently and properly.>>

You can read this at:

http://www.theserverside.com/tt/articles/article.tss?l=UsingJavaSpaces

Gervas

<<In my previous article I laid out some differences between the various
technologies that get lumped under the term "grid computing" and how Web
services and grid computing can work together. Now I would like to describe in
more detail how "space" style grid computing actually works, using open source
JavaSpaces as an example.

To recap, "space" style distributed computing is characterized by
loosely coupled systems, which are coordinated through a single
service acting as a shared associative memory for data containing
objects. In a Web service context, the service would take a request
that requires extensive computation or other resources and create an
object representing the job. This object would be written into a space
where worker processes have registered as having the capability of
doing specific kinds of jobs. On completion of the job, the Web
service would get back an object containing the results and format a
reply to the requesting system.

The Example Problem

I am going to use an example that is a simple version of a general
information lookup problem: given a partial description, locate all
the entities that might fit that description. In this case we have a
word which may or may not be spelled correctly. This may come from a
court reporter notes trying to represent what a witness said
phonetically. We have the attempt at spelling the word plus some
context as to the way the word was used. We need to find a list of
words that might have been intended. This will be done by creating an
object containing the information we have and letting lookup workers
try to match it.

What a JavaSpace Holds

In order to place objects in a JavaSpace, you must have a class which
implements the Entry interface (which extends the Serializable
interface). Furthermore, each field must have a public object
reference - no primitives. Here is the Java class I used - "Metaphone"
is the name of the phonetic encoding algorithm. Entries are used both
to represent jobs and as templates by which workers notify a space
that they want entries having certain characteristics.

public class MetaphoneLookupEntry implements
net.jini.core.entry.Entry {

public String word ; // the starting point word
public String domain ; // ie names, places, companies, etc
public Boolean filled = Boolean.FALSE ;
public String code ; // metaphone code
public String worker ; // so we can track who does what public
String[] matching ;
public MetaphoneLookupEntry() {
}
public MetaphoneLookupEntry(String wd, String type ){ word = wd ;
domain = type ;
}
}

A worker will calculate the Metaphone code for a word and use that to
look up possible matches in a list for the specified domain. Matches
go into the "matching" String array and the "filled" field will be set
to TRUE. If there is no match the String array will be empty.

Basic JavaSpace Operations

JavaSpaces support four basic operations that turn out to provide
tremendous capabilities for organizing distributed computing. Note
that a space does not modify an entry object, it only holds objects
and communicates with other programs. The basic operations are
"write," "take," "read" and "notify." For the lookup service we only
need the simplest versions.

The "write" operation puts an object into a space and specifies the
length of time the entry will be valid, known as the lease duration.
For a Web service, the lease should be short so that a failure becomes
apparent quickly. For example, a service needing a lookup might write
a MetaphoneLookupEntry with name="pittsburgh", type="place" and the
filled field equal FALSE into a space with a lease time of 10 seconds.

The "take" operation uses an Entry as a template where data fields
that are null act as wild cards and data fields that have values must
be matched. A worker that knows how to look up "place" names would
create a MetaphoneLookupEntry object where domain="place,"
filled=FALSE and all other fields remain null so anything will match
and use that in a "take" operation. "Take" operations also specify an
amount of time to wait. The "take" operation will either return an
Entry with a job or null indicating that no job is available.

The "read" operation is similar to "take," but only gets a copy, the
original Entry remains in the space. The "notify" operation sets up a
call-back link by which the space server will notify a worker when a
matching Entry has been written into the space.

An Example Sequence of Events

Here is how a Web service could make use of a JavaSpaces service. We
assume that one or more worker processes has done a "take" operation
with a template specifying type="place" and filled=FALSE. Note that
the worker process thread will be stalled until the take returns or
the lease times out. Any number of worker process threads may be in
this state.

   * The Web service does a write operation with an Entry having
type="place," name="pittsburgh" and filled=FALSE. Immediately it does
a "take" with the same values except having filled=TRUE, this will
retrieve the Entry when a worker writes it back to the space.

   * One of the worker "take" operations succeeds, resulting in an
Entry specifying a needed lookup. The worker fills in the matching
String array, sets filled=TRUE and writes the Entry back to the space.

   * The Web service "take" with filled=TRUE succeeds, recovering the
Entry with lookup results filled in with possible matches. In the word
list I used, "Pitsburg", "Pittsboro", "Pittsburg" and "Pottsboro" were
found as phonetic matches.

Advantages and Disadvantages

Although JavaSpaces servers are not trivial to set up, they are much
easier than any other type of grid computing server. Furthermore, the
simplicity of the interface makes the learning curve easier. The
greatest advantage of the JavaSpaces approach is the ease with which
additional workers can be added to the grid.

It should be clear from the example that there is a lot of extra
communication traffic in a JavaSpaces solution so the only reason to
use JavaSpaces or any other form of grid computing in support of a Web
service is a requirement for computing power or special resources that
are not feasible to supply on the server directly.>>

You can read this at:

http://searchsoa.techtarget.com/tip/0,289483,sid26_gci1251765,00.html

Gervas

Hi,

It would help if we could see what commands you have been running thus
far and the internet references you've looked at.  Could you post those
please?

To the best of my knowledge there are a number of resources concerning
getting started with Javaspaces based on Jini 2.1 that work perfectly
well.  In addition various of the JavaSpaces implementations provide out
of the box installers and examples which should also work.

Finally, I would suggest you sign up on JAVASPACES-USERS at Sun:

http://archives.java.sun.com/javaspaces-users.html

Best,

Dan.

Sravan Kumar Patti wrote:
> Hi,
>
> I am working on javaspaces. I am using jini2.1 and jdk1.6.0_02.
> Initially I had problems running javaspace programs. But I figured out
> using an IDE. Later I tried all of the commands for running javaspace
> programs without an IDE that are available on internet and nothing
> worked out. I think all the commands available on the web till now are
> for older versions of jini.
> Can anyone help me out in running javaspaces programs with the commands
> for the environment jini2.1 and jdk1.6.0_002?
>
> Thank you,
> Sravan Patti.
>
>

<<In my  previous article I laid out some differences between the
various technologies that get lumped under the term "grid computing"
and how Web services and grid computing can work together. Now I would
like to describe in more detail how "space" style grid computing
actually works, using open source JavaSpaces as an example.

To recap, "space" style distributed computing is characterized by
loosely coupled systems, which are coordinated through a single
service acting as a shared associative memory for data containing
objects. In a Web service context, the service would take a request
that requires extensive computation or other resources and create an
object representing the job. This object would be written into a space
where worker processes have registered as having the capability of
doing specific kinds of jobs. On completion of the job, the Web
service would get back an object containing the results and format a
reply to the requesting system.

The Example Problem

I am going to use an example that is a simple version of a general
information lookup problem: given a partial description, locate all
the entities that might fit that description. In this case we have a
word which may or may not be spelled correctly. This may come from a
court reporter notes trying to represent what a witness said
phonetically. We have the attempt at spelling the word plus some
context as to the way the word was used. We need to find a list of
words that might have been intended. This will be done by creating an
object containing the information we have and letting lookup workers
try to match it.

What a JavaSpace Holds

In order to place objects in a JavaSpace, you must have a class which
implements the Entry interface (which extends the Serializable
interface). Furthermore, each field must have a public object
reference - no primitives. Here is the Java class I used - "Metaphone"
is the name of the phonetic encoding algorithm. Entries are used both
to represent jobs and as templates by which workers notify a space
that they want entries having certain characteristics.

public class MetaphoneLookupEntry implements
net.jini.core.entry.Entry {

public String word ; // the starting point word
public String domain ; // ie names, places, companies, etc
public Boolean filled = Boolean.FALSE ;
public String code ; // metaphone code
public String worker ; // so we can track who does what public
String[] matching ;
public MetaphoneLookupEntry() {
}
public MetaphoneLookupEntry(String wd, String type ){ word = wd ;
domain = type ;
}
}

A worker will calculate the Metaphone code for a word and use that to
look up possible matches in a list for the specified domain. Matches
go into the "matching" String array and the "filled" field will be set
to TRUE. If there is no match the String array will be empty.

Basic JavaSpace Operations

JavaSpaces support four basic operations that turn out to provide
tremendous capabilities for organizing distributed computing. Note
that a space does not modify an entry object, it only holds objects
and communicates with other programs. The basic operations are
"write," "take," "read" and "notify." For the lookup service we only
need the simplest versions.

The "write" operation puts an object into a space and specifies the
length of time the entry will be valid, known as the lease duration.
For a Web service, the lease should be short so that a failure becomes
apparent quickly. For example, a service needing a lookup might write
a MetaphoneLookupEntry with name="pittsburgh", type="place" and the
filled field equal FALSE into a space with a lease time of 10 seconds.

The "take" operation uses an Entry as a template where data fields
that are null act as wild cards and data fields that have values must
be matched. A worker that knows how to look up "place" names would
create a MetaphoneLookupEntry object where domain="place,"
filled=FALSE and all other fields remain null so anything will match
and use that in a "take" operation. "Take" operations also specify an
amount of time to wait. The "take" operation will either return an
Entry with a job or null indicating that no job is available.

The "read" operation is similar to "take," but only gets a copy, the
original Entry remains in the space. The "notify" operation sets up a
call-back link by which the space server will notify a worker when a
matching Entry has been written into the space.

An Example Sequence of Events

Here is how a Web service could make use of a JavaSpaces service. We
assume that one or more worker processes has done a "take" operation
with a template specifying type="place" and filled=FALSE. Note that
the worker process thread will be stalled until the take returns or
the lease times out. Any number of worker process threads may be in
this state.

   * The Web service does a write operation with an Entry having
type="place," name="pittsburgh" and filled=FALSE. Immediately it does
a "take" with the same values except having filled=TRUE, this will
retrieve the Entry when a worker writes it back to the space.

   * One of the worker "take" operations succeeds, resulting in an
Entry specifying a needed lookup. The worker fills in the matching
String array, sets filled=TRUE and writes the Entry back to the space.

   * The Web service "take" with filled=TRUE succeeds, recovering the
Entry with lookup results filled in with possible matches. In the word
list I used, "Pitsburg", "Pittsboro", "Pittsburg" and "Pottsboro" were
found as phonetic matches.

Advantages and Disadvantages

Although JavaSpaces servers are not trivial to set up, they are much
easier than any other type of grid computing server. Furthermore, the
simplicity of the interface makes the learning curve easier. The
greatest advantage of the JavaSpaces approach is the ease with which
additional workers can be added to the grid.

It should be clear from the example that there is a lot of extra
communication traffic in a JavaSpaces solution so the only reason to
use JavaSpaces or any other form of grid computing in support of a Web
service is a requirement for computing power or special resources that
are not feasible to supply on the server directly.>>

You can read this at:

<http://searchwebservices.techtarget.com/tip/0,289483,sid26_gci1251765,00.html?t\
rack=NL-449&ad=586258&asrc=EM_NLT_1307248&uid=5532089>

<<<Jan>
I recall Gregg as (sort of) advocating Jini over both, WS-* and REST
</Jan>

There no "sort of" with Gregg and Jini :-) But his advocacy has made me
curious enough to pick up a book on Jini to explore the technology
because there are some particular use cases where a SOA implemented
using Jini may indeed be viable. But to borrow a phrase from Steve,
there is a degree of "formalism" around Jini that allows me to wrap my
head around it.>>

You can read the full message of which this is an extract on my SOA
Group at:

<http://tech.groups.yahoo.com/group/service-orientated-architecture/message/6767\
>

It strikes me that when looking for technologies in which to implement
SOA, people are beginning to discover, or rediscover the virtues of
Jini.  When choosing a suitable technology for SOA, Web Services and
REST seem the main contenders, CORBA being looked on as a mainly
legacy technology.  Jini, however is perceived as having a place in
the SOA scheme of things.  Gergg has done more than whole marketing
departments to argue Jini's case.  I think he deserves some sort of
marketing advocacy medal from Sun, or at least a fat salary and a
chauffeur-driven Rolls-Royce Phantom as Jini Envangelist :).

It would be very interesting to hear of case studies using
Jini/JavaSpaces with or without, say, Web Services to implement a SOA
structure.

Any volunteers?

Gervas

<<I hope to see the concepts behind space-based computing spreading to
a wider audience.
The "space-based" pattern proposed by GigaSpaces shares some qualities
with some other well-known solutions to scaling but adds some
interesting side-effects.

In my view, Space-based architecture can be compared to other
architectural choices that share some common qualities:

Transparent Partitioning and Co-location of:

    1. Events
    2. Work (logic and effort)
    3. Data

Such a pattern might be dubbed TPC-based architecture. One of the
things I often mention when I speak about using spaces is the
reduction in mapping logic and effort when the space is used to enable
distributed applications.

For instance in many cases databases can be partitioned and can
contain stored procedures, giving them some of the TPC-based
architecture qualities.
In addition, databases are sometimes used as shared memory where the
primary pupose of a particular write to the database is to place some
data into a shared environment as a layer of interoperability between
application constructs.
The resulting mapping code between all the cooperating constructs to
and from the database can be a burden. (not to mention the overhead of
using a database for this purpose)
I have also seen databases used as a checkpoint mechanism for
transient data that has no long-term place in the system.
This use of a database as a state-management solution "guarantees"
reliability of state during a business transaction but at the cost of
extra code and extra connections to perhaps the wrong kind of resource.

When an application leverages a space or similar vehicle as the
state-management and interoperability platform, the constructs
involved are able to share Objects.

This can reduce the mapping issues often associated with other shared
resources. Reducing the lines of code you write.

Behavior exposed through those objects can also be leveraged in terms
of construction of legal instances and even work logic to be performed.

It is these additional things that begin to encompass the totality of
the space-based architecture.

As enabling technologies, our implementation of the TPC-based
architecture utilizes:

     * Mobile code through a code-base enabled master-worker pattern
where tasks containing work can change over time and be routed to the
optimal location based on their state (allowing transparent
co-location and partitioning)
     * Intelligent, Adaptive, Service deployment and runtime management
(allowing transparent yet deliberate co-location through our
declare-able clustering/co-location of managed services [not to be
confused with our space clustering]).
     * An easy to configure and highly abstracted clustered JavaSpaces
implementation. (allowing transparent yet deliberate partitioning and
co-location of state, events and work)

Note the use of "Transparent" seems to focus on the developer role and
to what is visible to the author of the compile-able code artifacts.
"Deliberate" refers to the author of the non-compiled code such as the
various XML descriptors used to wire services together.

Orthogonal to the TPC-based architecture we have additional features
and benefits including:

     * Integration with Spring (allows transparency of implemention)
     * JDBC, MAP, JMS, HttpSession, etc APIs (allows increasing
transparency of implemention)
     * Space API (allows extremely powerful and simple programming model)
     * C++, .NET support (allows increasing transparency of language)
     * policy-driven dynamic service management (allows additional
scaling and fault-tolerance for the entire system)>>

You can read this in full (including his plug for GigaSpaces:) at:

<http://jroller.com/page/owentaylor?entry=space_based_architecture_an_implementa\
tion>

Gervas

Hello,

I am binding (server) to the Jini lookup running on a remote server
which has a valid static IP.

My local IP address is 192.168.x.x and static as 59.x.x.x .
When requesting for the object from other machine,
  the lookup service returns my local IP (192.x) instead of the static
IP (59.x).
  As a result, it throws an IOException.

Please let me know how I can make it work in my LAN.
Does my system need a valid static ip address to bind as a server to a
lookup service running on remote machine with valid IP.

Hello,
I have an application say app1 which binds an objects at the jini
lookup service
running at my server(ip= 72.X.X.X). The interaction between my server
and app1
takes place through this object.
My client connect  from there device to the server. The server picks
the object binded at the  lookup service and call some method on the
app1. The app1
runs at ip(192.X.X.X).

My server is able to pick the object reference from the lookup service
running on its
localhost. But when it is calling some method on app1 it is throughing the
following like
raised remote exception in connect:
connection refust to host 192.168.0.107 nested exception is
java.net.ConnectionException:
connection timed out: connect

Can anybody helpme out why i am getting this error.

Registration is open for the Tenth Jini Community
meeting in Brussels, Belgium from September 13 - 14, 2006.
This meeting is a great opportunity to connect
with interesting people and companies who have
discovered the power of Jini technology to
build dynamic, adaptive systems. This meeting will
run for two full days and be filled with
a variety of technical, business/marketing,
and general sessions. Registration is required.

For details:
http://www.jini.org/

Hi Patrick,

So as part of moving Jini into the Apache Incubator and changing around
of hosting arrangements, Jini.org has been temporarily unavailable.

We were intending to have a smoother changeover but things got
complicated.  Anyways, as of a few hours ago (at least here) the DNS
records have now been updated and Jini.org is now available again.

We've still got content to move over last the material from previous
meetings but that's happening.  You can at least now get details of
JCM10 again.

Note that projects housed on jini.org have in general moved to java.net
- go here for those:

https://jini.dev.java.net/

The plan is to get everything cross-linked as soon as possible to make
navigation easier.  One last thing - whilst we sort out the Incubator
stuff, the starter kit is being house at java.net:

https://starterkit.dev.java.net/

If you want more information, just ask.

Best,

Dan.

P.S.  Probably a better place to ask this question (and others) would be
jini-users:

http://archives.java.sun.com/jini-users.html

As we've been talking about this stuff over there a little bit.

patrickdlogan wrote:
> Looks like jini.org has been down for about 18 hours, based on when I
> was last able to access it.
>
> Does anyone on this list know the scoop?
>
> Thanks,
> Patrick
>
>
>
>
>
>
>
>
>
>
>
>
> Yahoo! Groups Links
>
>
>
>
>
>
>

Is this an advertisement for Jini's inherent resilience? :)

Gervas

Looks like jini.org has been down for about 18 hours, based on when I
was last able to access it.

Does anyone on this list know the scoop?

Thanks,
Patrick

<<The applause that greeted Sun Microsystems officials last week when
they said the company will offer Java to the open-source community
turned to concern as some users fretted over whether the programming
language will split into multiple versions.

Sun executives confirmed the long-anticipated open-source move during
the JavaOne conference here last week, although they said they still
need to devise a detailed plan to ensure that Java isn't put on
diverging paths.

Java consistency is essential to David Holberton, a J2EE developer at
a large aerospace company he asked not be named. Currently, the
versions of the Java Virtual Machine the company's J2EE applications
run on are consistent, Holberton said.

An open-source Java implementation "opens up innovation, but I'm
concerned about fragmentation," he said. Nonetheless, Holberton added
that he's "fairly confident" Sun can avoid any splitting of the code,
citing the company's longtime efforts to ensure a consistent
development environment.

Several other users, including Haroon Rafique, a systems developer at
the University of Toronto, also expressed concern that Java could head
down different paths once developers get access to the source code
under whatever open-source plan Sun devises.

"My concerns would be if they do open-source it -- and don't keep
control over it -- then you are going to have competing
implementations," said Rafique.

"I think the 'how' is going to be very important," said Andrew Smith,
a systems architect at Innovative Software Engineering in Iowa. Smith
wants to know how Sun will preserve compatibility, how testing will be
handled once the code is made open-source, and what will happen if a
variety of distributions emerge as they did with Linux.

Sun has yet to directly respond to such user concerns. The company
didn't provide a plan for preventing multiple Java versions last week,
nor did it disclose a timetable for the open-source effort or any
licensing details at JavaOne.

"There wasn't that much detail to the announcement," said Ari Kaplan,
a senior consultant at Datalink, a consulting firm in Chanhassen,
Minn. Kaplan said that despite the lack of specifics, he expects users
will, for the most part, welcome Sun's plan because of the growing
corporate popularity of open-source software.

However, Kaplan, who is also president of the Independent Oracle Users
Group, added that users often express concern about how well
open-source software is supported by vendors.

"The mainstream is generally positive as long as the quality,
scalability, security and compatibility remain intact," he said.
"Those things still remain to be seen."

At the conference, Sun CEO Jonathan Schwartz said he gave Richard
Green, who heads the company's software division, the go-ahead to
develop a plan for releasing Java's source code. Schwartz said that
nothing will stop the open-source plan, which he contended will
broaden usage of the Java language by developers. He said he also
expects that the move will create new opportunities for the struggling
computer maker.

Mark Driver, an analyst at Gartner, argued that the open-source
statements from Sun executives were made "for effect" and that the
company doesn't necessarily plan to make Java open-source.

"They know they need to open-source Java to fulfill their larger
promise to embrace open-source," Driver said. However, he added, Sun
is fearful that providing open-source access to Java may prompt
Microsoft, The Apache Software Foundation or another vendor to create
implementations that aren't compatible with the current version.

"They think the existing open-source model does not give them the
guarantee of the lack of fragmentation," Driver said. "To their
credit, they understand that Java is a success today because ... they
have this giant stick and they can literally force compliance."

Jeff Kottke, a Java engineer at Dairyland Healthcare Solutions
welcomed the open-source idea. "It seems like open-source groups are
able to put out better code that works faster and cleaner," he said.

Likewise, Chris Fogel, a Java developer at a mobile wireless company
that he asked not be named, predicted that an open-source Java would
lead to wider adoption of the language.

Fogel and others point out that Java already has a community
development process -- the Java Community Proc-ess -- that is overseen
by Sun, which can approve or reject any proposed changes to the code.
But it won't be clear how any open-source move will affect development
"until it's actually out in the [open-source] community," Fogel said.
That's when you really find out, he added.>>

You can read this at:

<http://www.computerworld.com.au/index.php/id;1115830075;fp;4;fpid;611908207>

Gervas

--- In jini_javaspaces@yahoogroups.com, "Gervas Douglas"
<gervasdouglas@...> wrote:
>
> <<Have you heard? Sun Microsystems is open sourcing Java.
>
> "I think it's not a question of whether, it's a question of how," Rich
> Green, Sun's vice president of software, said at last week's 2006
> JavaOne Conference. Cheers all around.
>
> Scratch that. Truthfully, there were no champagne corks popped here at
> the InfoWorld offices following Sun's announcement. This is nothing
> more than the same equivocation we've heard again and again. The
> biggest question of all remains: When will it happen? And to that
> question there is still no answer.
>
> So why does Sun keep dragging its feet? I suspect the answer could be
> in your pocket right now.
>
> Green and others claim compatibility is the foremost concern, but I'm
> skeptical. If Java were fully open sourced, competing Java
> environments could break cross-platform compatibility and lock users
> into a single vendor's implementation. That's exactly what Sun alleges
> Microsoft tried to do back in the 1990s, which became the subject of a
> bitter lawsuit.
>
> But wait a minute. If a programmer writes Java code that accesses Mac
> OS X's Cocoa APIs, that software won't run on any other system but a
> Mac. Similarly, although the Eclipse project's SWT (Standard Widget
> Toolkit) GUI toolkit is cross-platform, it is optimized best for
> Windows. The truth is that developers often write Java code that's
> never meant to be cross-platform. To a certain extent, the
> compatibility argument is something of a red herring.
>
> Meanwhile, every time Sun invites InfoWorld staffers to hear about the
> bright future of Sun's software business, company execs always seem to
> spend a lot of time talking about the cool new games that run on Java
> cell phones. This leaves us scratching our heads somewhat -- we deal
> in enterprise IT, not consumer gadgets. But it's clear that this topic
> is very close to Sun's heart.
>
> And why not? While you and I can download Java for free for our Macs,
> PCs, and Linux boxes, mobile device manufacturers pay a license fee to
> Sun Microsystems for every Java-enabled handset they ship. For Sun it
> is (of all the unheard-of things) a revenue stream.
>
> Now imagine what would happen if Java were truly open source. What if
> Motorola, Nokia, Sony-Ericsson, and all the rest were free to create
> their own custom versions of Java that ran on their mobile handsets
> and other hardware?
>
> Something tells me that the kind of "compatibility" Sun wants to
> preserve in the Java community is the kind that keeps all those mobile
> device licensees compatible with Sun's bottom line -- not to mention
> all its other licensees, such as BEA and IBM. The full scope of the
> fees Sun receives from these has never been disclosed.
>
> It's a shame. Sun has been criticized in the past for not being able
> to make up its mind about Linux, and for not being able to make up its
> mind about open sourcing Java. But the truth may be much more
> problematic. It seems Sun can't make up its mind about what kind of
> company it is. Does it really believe that the future of the software
> business lies in the subscription/support model, as it claims? Does it
> really plan to open source all its software in the next 12 to 18
> months? Or does it want to continue acting like a closed, proprietary
> software company, relying on license fees from partner companies?
>
> Sun claims to want consistency across its software business.
> Unfortunately, it appears the question is not how it wants to do this,
> but whether it really wants to. And as for when it will make up its
> mind, that continues to be anybody's guess.>>
>
> You can find this at:
>
>
<http://ww6.infoworld.com/products/print_friendly.jsp?link=/article/06/05/22/785\
20_21OPopenent_1.html>
>
> Now did you know that the McAllisters are a sept of the Clanranald
> Macdonalds??
>
> Gervas
>

jini_javaspaces@yahoogroups.com wrote:
> Now imagine what would happen if Java were truly open source. What if
> Motorola, Nokia, Sony-Ericsson, and all the rest were free to create
> their own custom versions of Java that ran on their mobile handsets
> and other hardware?
>
> Something tells me that the kind of "compatibility" Sun wants to
> preserve in the Java community is the kind that keeps all those mobile
> device licensees compatible with Sun's bottom line -- not to mention
> all its other licensees, such as BEA and IBM. The full scope of the
> fees Sun receives from these has never been disclosed.

I still find it odd that people who are paid a salary can't seem to understand
how come a company that has employees that need to be paid a salary, are
concerned about how they will continue to make money.

Like it or not, reality is not always easy...

Gregg Wonderly

<<Have you heard? Sun Microsystems is open sourcing Java.

"I think it's not a question of whether, it's a question of how," Rich
Green, Sun's vice president of software, said at last week's 2006
JavaOne Conference. Cheers all around.

Scratch that. Truthfully, there were no champagne corks popped here at
the InfoWorld offices following Sun's announcement. This is nothing
more than the same equivocation we've heard again and again. The
biggest question of all remains: When will it happen? And to that
question there is still no answer.

So why does Sun keep dragging its feet? I suspect the answer could be
in your pocket right now.

Green and others claim compatibility is the foremost concern, but I'm
skeptical. If Java were fully open sourced, competing Java
environments could break cross-platform compatibility and lock users
into a single vendor's implementation. That's exactly what Sun alleges
Microsoft tried to do back in the 1990s, which became the subject of a
bitter lawsuit.

But wait a minute. If a programmer writes Java code that accesses Mac
OS X's Cocoa APIs, that software won't run on any other system but a
Mac. Similarly, although the Eclipse project's SWT (Standard Widget
Toolkit) GUI toolkit is cross-platform, it is optimized best for
Windows. The truth is that developers often write Java code that's
never meant to be cross-platform. To a certain extent, the
compatibility argument is something of a red herring.

Meanwhile, every time Sun invites InfoWorld staffers to hear about the
bright future of Sun's software business, company execs always seem to
spend a lot of time talking about the cool new games that run on Java
cell phones. This leaves us scratching our heads somewhat -- we deal
in enterprise IT, not consumer gadgets. But it's clear that this topic
is very close to Sun's heart.

And why not? While you and I can download Java for free for our Macs,
PCs, and Linux boxes, mobile device manufacturers pay a license fee to
Sun Microsystems for every Java-enabled handset they ship. For Sun it
is (of all the unheard-of things) a revenue stream.

Now imagine what would happen if Java were truly open source. What if
Motorola, Nokia, Sony-Ericsson, and all the rest were free to create
their own custom versions of Java that ran on their mobile handsets
and other hardware?

Something tells me that the kind of "compatibility" Sun wants to
preserve in the Java community is the kind that keeps all those mobile
device licensees compatible with Sun's bottom line -- not to mention
all its other licensees, such as BEA and IBM. The full scope of the
fees Sun receives from these has never been disclosed.

It's a shame. Sun has been criticized in the past for not being able
to make up its mind about Linux, and for not being able to make up its
mind about open sourcing Java. But the truth may be much more
problematic. It seems Sun can't make up its mind about what kind of
company it is. Does it really believe that the future of the software
business lies in the subscription/support model, as it claims? Does it
really plan to open source all its software in the next 12 to 18
months? Or does it want to continue acting like a closed, proprietary
software company, relying on license fees from partner companies?

Sun claims to want consistency across its software business.
Unfortunately, it appears the question is not how it wants to do this,
but whether it really wants to. And as for when it will make up its
mind, that continues to be anybody's guess.>>

You can find this at:

<http://ww6.infoworld.com/products/print_friendly.jsp?link=/article/06/05/22/785\
20_21OPopenent_1.html>

Now did you know that the McAllisters are a sept of the Clanranald
Macdonalds??

Gervas

I received this by e-mail from SD Times.

Gervas
==================================================================
In the excellent political drama "V for Vendetta," the protagonist, V,
blows up the Old Bailey, London's famous criminal court. This act of
defiance lays the groundwork for a popular rebellion against a fascist
regime. The government's PR department spins this disaster as merely
the completion of a long-planned demolition—city engineers, you see,
had long ago determined that the old stone building was structurally
unsound.

Yesterday, Sun announced that its president and COO, Jonathan
Schwartz, had been promoted to CEO, taking that title from founder
Scott McNealy. To quote the company's official statements, this
occurred "as a result of the company's on-going succession planning
process…today's announcement marks the culmination of a carefully
architected succession plan." Yeah, right.

The word on the street has long been that McNealy would be fired this
week due to the company's dreadful financial condition. Sure, the
company just announced a 21 percent revenue increase—largely due to
acquisitions—but even so, the company's losses continue to grow.
Meanwhile, the stock is flat and prospects dim.

What's next for Sun? Schwartz has been driving Sun's vision for
several years now, and I think it's fair to credit him with many of
the company's recent moves, including slashing the cost of software
(making things free, including Solaris), embracing AMD processors,
embracing open-source software, and buying storage and integration
companies StorageTek and SeeBeyond. Those bold moves, however, haven't
stemmed the flow of red ink.

If you think that Schwartz was on the right track, but that McNealy
was a roadblock, then this move heralds an optimistic future for Sun.
With the last of the "old guard" out of the way, then Schwartz is free
to reinvent Sun as he sees fit.

However, if you think that McNealy wasn't a roadblock, then Schwartz's
vision has been guiding the company over the past few years—and hasn't
worked. If the company continues on the same path as before, nothing
will change.

The board didn't merely promote Schwartz—it also left McNealy as
chairman. Perhaps the board thinks that Schwartz still needs adult
supervision. Maybe it means that McNealy won't give up the reins.
Either way, the ambiguity makes it look like the board simply
rearranged the deck chairs. (Of course, it's possible that McNealy's
new role is a temporary face-saving move during a transition period.)

There's a third option, of course: The board wants an exit strategy
and sees Schwartz, not McNealy, as the best man to sell the company.
McNealy, one of Sun's four founders, is emotionally wrapped up in his
company; he wants to save it, needs to save it. Schwartz, on the other
hand, has only been at Sun for a decade—and came there after selling
McNealy his old company, Lighthouse Design.

If you see McNealy leave his chairman position soon, and a sale of Sun
announced, don't be surprised, even if it's positioned as "the
culmination of a carefully architected plan."

Thanks, Dan for putting me right!  This is excellent news as
previously the licence under which Sun released it was seen as a
signficant barrier by some commentators to its adoption.

Gervas

--- In jini_javaspaces@yahoogroups.com, Dan Creswell <dan@...> wrote:
>
> Gervas Douglas wrote:
> > <<As I am sure you have noticed, there has been quite a bit of
> > momentum around LAMP in the industry, ranging from innovators like
> > Google, Yahoo!, and Amazon, to the "Web 2.0" crowd like Friendster,
> > MySpace, and Flickr. In addition, LAMP has increasing usage in the
> > enterprise.
> >
> > The "P" languages in LAMP — PHP, Python, and Perl — are all open
> > source, and each provide their own virtual machine. It would be ideal
> > if the Java JVM was open source so that open source projects like PHP
> > could join up with the Java Virtual Machine. In turn, Java would be
> > much more competitive with .Net, which supports numerous languages out
> > of the box. Initiatives like adding dynamic language support in the
> > JVM will not go far if Java can not meet existing languages on a
> > common ground of open source.
> >
> > What is unfortunate about Sun's open source strategy is that it is
> > very unclear. Can you please answer the following question with a
> > single coherent sentence that people can remember and repeat? If I ask
> > five Sun employees this question, I get five different answers, so
> > having simple answers to these questions will clearly help your own
> > workforce as well as your customers and prospects!
> >
> > "Why is it good to open source OpenSolaris and OpenOffice and bad to
> > open source Java?">>
> >
> > You can read this blog at:
<http://blogs.zdnet.com/BTL/?p='87&tag==nl.e027>
> >
> > No how about Sun opensourcing its neglected Orphan Java Technologies
> > like, J/JS, Mr. Schwartz?  New paradigm shifts in enterprise
>
>
> Errr I think I'm missing something: Jini/JavaSpaces is opensource.
It's
> all released under Apache License v2 and has been for some time:
>
> http://www.sun.com/smi/Press/sunflash/2005-10/sunflash.20051019.5.xml
>
> > architecture such as SOA and composite apps represent a great
> > opportunity for J/JS, if the technology were not tied to Sun's
control...
> >
> > Gervas
> >
> >
>
> Dan
>

Gervas Douglas wrote:
> <<As I am sure you have noticed, there has been quite a bit of
> momentum around LAMP in the industry, ranging from innovators like
> Google, Yahoo!, and Amazon, to the "Web 2.0" crowd like Friendster,
> MySpace, and Flickr. In addition, LAMP has increasing usage in the
> enterprise.
>
> The "P" languages in LAMP — PHP, Python, and Perl — are all open
> source, and each provide their own virtual machine. It would be ideal
> if the Java JVM was open source so that open source projects like PHP
> could join up with the Java Virtual Machine. In turn, Java would be
> much more competitive with .Net, which supports numerous languages out
> of the box. Initiatives like adding dynamic language support in the
> JVM will not go far if Java can not meet existing languages on a
> common ground of open source.
>
> What is unfortunate about Sun's open source strategy is that it is
> very unclear. Can you please answer the following question with a
> single coherent sentence that people can remember and repeat? If I ask
> five Sun employees this question, I get five different answers, so
> having simple answers to these questions will clearly help your own
> workforce as well as your customers and prospects!
>
> "Why is it good to open source OpenSolaris and OpenOffice and bad to
> open source Java?">>
>
> You can read this blog at: <http://blogs.zdnet.com/BTL/?p='87&tag==nl.e027>
>
> No how about Sun opensourcing its neglected Orphan Java Technologies
> like, J/JS, Mr. Schwartz?  New paradigm shifts in enterprise


Errr I think I'm missing something: Jini/JavaSpaces is opensource.  It's
all released under Apache License v2 and has been for some time:

http://www.sun.com/smi/Press/sunflash/2005-10/sunflash.20051019.5.xml

> architecture such as SOA and composite apps represent a great
> opportunity for J/JS, if the technology were not tied to Sun's control...
>
> Gervas
>
>

Dan

<<As I am sure you have noticed, there has been quite a bit of
momentum around LAMP in the industry, ranging from innovators like
Google, Yahoo!, and Amazon, to the "Web 2.0" crowd like Friendster,
MySpace, and Flickr. In addition, LAMP has increasing usage in the
enterprise.

The "P" languages in LAMP — PHP, Python, and Perl — are all open
source, and each provide their own virtual machine. It would be ideal
if the Java JVM was open source so that open source projects like PHP
could join up with the Java Virtual Machine. In turn, Java would be
much more competitive with .Net, which supports numerous languages out
of the box. Initiatives like adding dynamic language support in the
JVM will not go far if Java can not meet existing languages on a
common ground of open source.

What is unfortunate about Sun's open source strategy is that it is
very unclear. Can you please answer the following question with a
single coherent sentence that people can remember and repeat? If I ask
five Sun employees this question, I get five different answers, so
having simple answers to these questions will clearly help your own
workforce as well as your customers and prospects!

"Why is it good to open source OpenSolaris and OpenOffice and bad to
open source Java?">>

You can read this blog at: <http://blogs.zdnet.com/BTL/?p=2787&tag=nl.e027>

No how about Sun opensourcing its neglected Orphan Java Technologies
like, J/JS, Mr. Schwartz?  New paradigm shifts in enterprise
architecture such as SOA and composite apps represent a great
opportunity for J/JS, if the technology were not tied to Sun's control...

Gervas

We are proposing to hold this conference in Andorra in November 2006
or January 2007, probably the latter.  If this interests you, you can
read about it at:



http://groups.yahoo.com/group/service-orientated-architecture/message/3599

Feel free to e-mail me at gervasPOINTdouglasATgmailPOINTcom.

Gervas

A question from my SOA Group:

<<Something else to know would be the rate of adoption
of J/JS.  I have to say I do get the occasional
question about it from customers but outside of this
list I do not hear much about it.

Which products/vendors are offering J/JS support
today?>>

You can find this at:

<http://groups.yahoo.com/group/service-orientated-architecture/message/3504>

Would anyone like to answer this query, please?

Gervas

I have recently started a new Group which has nothing specifically to
do with IT, but is about something that still affects your life:




http://groups.yahoo.com/group/renewable-natural-resources/

At present there are only two members (including myself), so come
along and join us.  Better still, contribute!

Gervas
Moderator

<<Inside the LAN, there are many other alternatives to web services
which may improve our service-oriented environments. They can do this
by increasing network performance through creation of smaller data
sets to transfer, decreasing computational power needed to unmarshall
the data sets, and mobile code in their support of mobile agents and
smart proxies. There are many technology platforms which pose a viable
alternative to web services on the LAN and meet some or all of the
improvements mentioned. One of those technology platforms is Jini.

Jini by itself does not solve the problem but containers built on top
of the Jini platform do. Containers remove some of the Jini
programming complexity by handling codebase downloading and service
deployment. Here are a few example containers:

     * Rio - A dynamic services platform which involves a federation of
container nodes onto which services are deployed. Upon deployment of a
service, the platform identifies nodes which meet the service level
agreement (SLA) declared in the Rio deployment descriptor called an
operational string.

     * Harvester - A container environment for Jini services and
clients. A particularly interesting feature of Harvester is it's
ability to load services and clients written in the Python language.

     * Neon - An agent framework and application grid fabric which
allows your Jini services to be deployed without writing all of the
associated plumbing code. An good introduction to Neon's capabilities
may be found here.

Mobile code is an important reason why Jini is a good alternative to
web services on the LAN. Many Java developers are aware of RMI (remote
method invocation) but have not heard of the Jini RMI impelementation
called JERI (Jini extensible remote invocation). JERI provides
important features over it`s older counterpart: a pluggable transport
layer with security support, an extensible marshalling layer, and
runtime configuration. JERI provides the ability to export your
service proxy for use by a remote service consumer. Your proxy class
may be a "smart" proxy which means that some, if not all, invocation
processing is performed using the consumer`s resources.>>

You can find this blog at:

http://jroller.com/page/csterwa?entry=jini_an_soa_for_the

Gervas

> Is it just me who thinks so, but does anyone else see the constant desire
> to use multiple forms of technologies on the client side (AJAX, etc.) as
a cry for a "universal client"?  Such a client - call it a "browser" for
the common user - should handle HTML, JavaScript, JFC, Java Webstart,
> filesystem browsing, etc.


Me too. It seems to point to a universal OS, one that is very robust and
inherently network-centric. Ie it's only role is to make the device work
and connect to the network, where it can then access apps/data.

The other day I was trying to get a CD based game working for my kid, and
oh boy what a hassle. Wrestling my way through Windows on an older PC was
so slow and so painful, when all I really need is a "KidStation". Ie a
fairly dumb device that can run multimedia programs. A PC is really
overkill for this and even many corporate situations, so it may be that
the red herring in the mix is the PC/Windows component, which is now quite
out of date and a constant source of pain around which everything
revolves. So perhaps it's time to think in terms of a new model for
this....

Regards, Neil.