General-Purpose Computing on a Semantic Network Substrate

[Marko Rodriguez]

Hello. Please enjoy my latest paper.

LANL is currently building a compiler and virtual machine that is  
compliant with the specification in the paper. If RedFish is  
interested, perhaps in a month or two, I could demo this computing  
paradigm at a Wednesday tech session.


Title: General-Purpose Computing on a Semantic Network Substrate
Authors: Marko A. Rodriguez
Categories: cs.AI cs.PL
Comments: project website: http://neno.lanl.gov
ACM-class: I.2.4; I.2.5; H.3.7; H.3.4

This article presents a model of general-purpose computing on a semantic
network substrate. The concepts presented are applicable to any semantic
network representation. However, due to the standards and technological
infrastructure devoted to the Semantic Web effort, this article is  
presented
from this point of view. In the proposed model of computation, the  
application
programming interface, the run-time program, and the computing  
virtual machine
are all represented in the Resource Description Framework (RDF). The
ramifications of using the same substrate to represent the high and  
low-level
aspects of computing are numerous. The implementation of the concepts  
presented
provides a practical computing paradigm that leverages the highly-
distributed
and standardized representational-layer of the Semantic Web.

http://arxiv.org/abs/0704.3395

Take care,

Marko A. Rodriguez
Los Alamos National Laboratory (P362-proto)
Los Alamos, NM 87545
Phone [phone]
http://www.soe.ucsc.edu/~okram


-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://redfish.com/pipermail/friam_redfish.com/attachments/20070426/316a096f/attachment.html 

[Marcus G. Daniels]

Hi,

Without having to introduce a new virtual machine, how about adding
SPARQL support to LINQ?

Marcus

[Robert Howard-2-3]

Since .NET 2.0 implements covariance, implementing Prolog to traverse these
networks amounts to nesting one YIELD-ing block for each literal in a Horn
Clause.
SEE: http://yieldprolog.sourceforge.net/, which is really all LINQ is doing.
I'd think it would be a natural step from there given the prolog-like syntax
of SPARQL.

Robert Howard
Phoenix, Arizona

 
-----Original Message-----
From: [hidden email] [mailto:[hidden email]] On Behalf
Of Marcus G. Daniels
Sent: Thursday, April 26, 2007 10:37 AM
To: The Friday Morning Applied Complexity Coffee Group
Subject: Re: [FRIAM] General-Purpose Computing on a Semantic
NetworkSubstrate

Hi,

Without having to introduce a new virtual machine, how about adding
SPARQL support to LINQ?

Marcus

============================================================
FRIAM Applied Complexity Group listserv
Meets Fridays 9a-11:30 at cafe at St. John's College
lectures, archives, unsubscribe, maps at http://www.friam.org

[Marcus G. Daniels]

Robert Howard wrote:
> Since .NET 2.0 implements covariance, implementing Prolog to traverse these
> networks amounts to nesting one YIELD-ing block for each literal in a Horn
> Clause.
> SEE: http://yieldprolog.sourceforge.net/, which is really all LINQ is doing.
> I'd think it would be a natural step from there given the prolog-like syntax
> of SPARQL.
>  
Provided there is some fast and reliable way to access and store a
network (a LINQ RDF store or an object database like db4o), and some way
to do queries (nested iterators / yield Prolog), and some way to do
object distribution (I was thinking SOAP), then that's about 90% of the
battle.   They are all well-understood and commercially supported
technologies.

Nice but probably not crucial to have object implementations and queries
all in the same formalism, whether that's Prolog, Lisp, XSLT, etc.  
E.g. the ability to query and program web services without a ad-hoc
interpreter running there.

Incidentally, I noticed the Java wrapper of Cyc has a SOAP service.   It
imagine probably would be possible to do serialization of objects to and
from Cyc.  

[Marko Rodriguez]

Hello,

You mention:

>
> Nice but probably not crucial to have object implementations and  
> queries
> all in the same formalism, whether that's Prolog, Lisp, XSLT, etc.
> E.g. the ability to query and program web services without a ad-hoc
> interpreter running there.

I reply:

There are two formalisms that I propose using: RDF and SPARQL/Update.  
RDF is to represent your API, runtime program, and virtual machine  
and SPARQL/Update is the protocol for manipulating the network (e.g.  
INSERT, DELETE, SELECT, ASK, etc.). There are many benefits to this  
model. First I will articulate the benefit as realized by our current  
objectives at LANL.

1. We are dealing with a 10 billion triple (edge) semantic network.  
Some analysis can be done by harvesting subsets of the network and  
performing our network analysis algorithms in main memory. However,  
there are some algorithms that are just not possible with a 'main  
memory' approach. Thus, we will move the processor and the algorithm  
to the data. By embedding the processor in the data, we can rely on  
any number of host hardware CPUs to calculate its evolution. As a  
devil's advocate, we could write code that will selectively harvest  
subsets as needed for the 10 billion edge calculation. However, the  
general-purpose processor allows us to do more than just graph  
algorithms.

2. When the virtual machine is represented in RDF, then the virtual  
machine can be queried like any other aspect of the semantic network.  
For instance, it is possible to write code that is interpreted by a  
virtual machine that causes the virtual machine to re-write itself at  
run-time. To my knowledge, no such mechanism exists in other  
programming languages. For instance, the virtual machine of the Java  
programming language is hidden to the programmer. One can not  
manipulate main memory directory nor manipulate the JVM program at  
runtime (the JVM is written in another language). This is not the  
case in my proposed model of computing. The virtual machine is an  
object much like any other object and can be manipulated as such.  
There is much to be said of how this could be used in terms of  
evolutionary algorithms.

3. The Semantic Web is a vision of a semantic network overlaid across  
servers around the world. With the proposed programming paradigm, the  
representation of virtual machines and software is yet another  
component of this distributed semantic network. The Semantic Web  
becomes a computing infrastructure that does not have a sense of its  
underlying hardware support. Because virtual machines are represented  
in the network, they can be evolved by any of underlying hardware  
CPUs. When a hardware CPU leaves the computation, it does not effect  
the state of the virtual machine. The virtual machine simply  
'freezes' and awaits another hardware CPU to continue its evolution.  
In fact, another RDF virtual machine can compute the evolution of the  
'frozen' virtual machine. However, the network will always require a  
grounding in the hardware to evolve. Please read section 4.1 of the  
arXiv preprint for more on this topic.

4. There already exists a host of technologies to support the  
Semantic Web: multi-billion triple triple-store servers, ontology  
development environments, reasoners, etc. The model I proposed  
requires very little investment by the community to use. The Neno  
language that LANL is currently developing looks very similar to  
Java. Once that hurdle is climbed, object-oriented programming is  
possible on the Semantic Web. ... Again, the Semantic Web  
automatically becomes a "SETI at Home". It becomes a decentralized  
computing platform without the standards issues seen by the Grid  
computing community.  There are RDF virtual machines (RVMs) and there  
are RDF programs. If the underlying host machine has the process code  
for the RVM architecture, it can execute it---thats it.

5. The programming language proposed by LANL has constructs that are  
not possible (realistically) with other programming language. This is  
due to the fact that the programming language has an underlying  
network representation. There are some neat constructs that emerge  
when the data structure is a network (e.g. inverse method invocation,  
inverse field referencing, field cardinality, general object query  
(automatic JavaSpaces)). Please refer to section 3 of the arXiv pre-
print.

6. Please refer to section 2 of the paper I submitted to arXiv for a  
list of other benefits of this model.

7. There are still many issues concerning trust and rouge software  
that has not been addressed by my arXiv pre-print. This will be  
addressed in a future paper.

8. Please refer to    http://www.soe.ucsc.edu/~okram/papers/random- 
grammar.pdf      for a specialized random walker RVM architecture.

Thanks for your time,

Marko A. Rodriguez
Los Alamos National Laboratory (P362-proto)
Los Alamos, NM 87545
Phone [phone]
http://www.soe.ucsc.edu/~okram


-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://redfish.com/pipermail/friam_redfish.com/attachments/20070429/f42c4432/attachment.html 

[Marcus G. Daniels]

Howdy,
> RDF is to represent your API, runtime program, and virtual machine and
> SPARQL/Update is the protocol for manipulating the network (e.g.
> INSERT, DELETE, SELECT, ASK, etc.).
> 1. We are dealing with a 10 billion triple (edge) semantic network.
> Some analysis can be done by harvesting subsets of the network and
> performing our network analysis algorithms in main memory. However,
> there are some algorithms that are just not possible with a 'main
> memory' approach.
Sandia has a multithreaded graph library project intended for very large
semantic networks called Eldorado MTGL.  It is a `in core' or `main
memory' approach.   They are targeting XT3-based systems where some of
the Torrenza friendly CPUs are Cray's massively multithreaded XMT
processors.  Like any big computer, it will have terabytes of RAM, but
unlike a typical cluster type system, the XMT processors will be able to
see it all.   The supercomputer interconnect has variable latency
depending on the distance of memory (# of routed hops or page-in -- the
latter it won't by have by design), but the fact there are thousands of
threads at once traversing the network is analogous to a grocery store
with dozens of lanes instead of just one.   In contrast I understood a
big bottleneck was just loading it from their clients' relational
database.

While `load' and `store' CPU instructions act against a non-persistent
contiguous array of virtual memory, it is an easy constraint to get
around.   One way is by using some of the most significant bits of the
address space for type information and the lower bits for the object
offsets or numeric values (or in this case maybe an encoding like
type+context+{noun,verb,noun} where `noun' and `verb' were indexes into
a `context' object that boxed the UUIDs).  For example, Opteron's have a
48 bit virtual address space, so a split of 16 bits for type info and 48
for data would make sense, giving 281475 billion addressable objects.    
With POSIX, the mmap system call can be used to set up these regions in
an efficient way, and/or make them persistent to a file.   Named objects
or UUIDs can be swizzled to container data structures in persistent
virtual memory (application-specific swap files, basically).   Some
persistent object stores like [1]  literally do this.  At the end of the
day, there's some data you want and whether you have a triple store
server that reads the data from various sources and then sends it over a
stream to you, or you rely on the MMU of the machine to page it in from
a local disk sector or external pager, the issue of `main memory' or not
seems like a red herring.

> 2. When the virtual machine is represented in RDF, then the virtual
> machine can be queried like any other aspect of the semantic network.
> For instance, it is possible to write code that is interpreted by a
> virtual machine that causes the virtual machine to re-write itself at
> run-time. To my knowledge, no such mechanism exists in other
> programming languages. For instance, the virtual machine of the Java
> programming language is hidden to the programmer. One can not
> manipulate main memory directory nor manipulate the JVM program at
> runtime (the JVM is written in another language). This is not the case
> in my proposed model of computing.

Well, new objects can be described and byte coded, using libraries like:

  http://www.gnu.org/software/kawa/api/gnu/bytecode/package-summary.html

For example, the Kawa language framework implements Scheme on it.

  http://www.gnu.org/software/kawa/index.html
> The virtual machine is an object much like any other object and can be
> manipulated as such. There is much to be said of how this could be
> used in terms of evolutionary algorithms.
Any language that has an `eval' or dynamic binding can do this (Python,
Perl, Ruby, Lisp, JavaScript, Objective C).   For example, in Common
Lisp to brutally change all addition into multiplication (yes it can
also be done with lexical or dynamic scope):

(setf (symbol-function '+) #'*)
(+ 3 4)
12

As far as I can tell manipulating the `virtual machine' is mostly just a
question of what bindings are between names and actions.  
System level features (like whether physical threads or I/O features are
available) you either have or don't.

Java is a bit confusing here because there is has infix syntax without
operator overloading and because it isn't a dynamically typed language.  
> 4. There already exists a host of technologies to support the Semantic
> Web: multi-billion triple triple-store servers, ontology development
> environments, reasoners, etc. The model I proposed requires very
> little investment by the community to use. The Neno language that LANL
> is currently developing looks very similar to Java.
Like with inverse field referencing or method invocations that would
still be concise in C# with a LINQ interface to SPARQL.  Dynamic
bindings can be implemented using a dictionary class that can be loaded
and modified using reflection, and has a method for callout.  Field
cardinality -- a fixed size array of objects, where some can be null, no?  
> 5. The programming language proposed by LANL has constructs that are
> not possible (realistically) with other programming language. This is
> due to the fact that the programming language has an underlying
> network representation. There are some neat constructs that emerge
> when the data structure is a network (e.g. inverse method invocation,
> inverse field referencing, field cardinality, general object query
> (automatic JavaSpaces)). Please refer to section 3 of the arXiv
> pre-print.
I guess it depends how concise you want these to be.   If you really
want it concise, then I wonder why use Java and not something like
Prolog?  I mentioned LINQ because it is an evolutionary addition to an
established popular environment (C# and .NET).  Inverse method/field
invocation/references are just matters of collecting a set things and
then apply a function to them.   And going back to the load/store
analogy of a CPU, the notion of a distributed space is really not much
more than adding more bits to the address or a `who' argument:

load(who,where) or who.load(where)
store(who,where,what) or who.store(where,what)

(And implementing that's just a matter of RMI, SOAP, MPI, or pick you're
favorite.)

cheers,

Marcus

[1] http://www.rscheme.org/rs/a/2005/persistence

[Joshua Thorp]

Marko,

Redfish is very interested in this.  I especially like this line of  
thinking:

 From 4.9:

...Once the Fhat RVM has
completed computing that particular RDF sub-network, it can halt and  
another CPU can
pick up the process on a yet another area of the RDF network that  
needs computing by the
RDF software. In this model of computing, data doesn?t move to the  
process, the process
moves to the data.


We are interested in models for distributed computing that can easily  
exist in very heterogeneous environments such as high performance  
computers/web service servers/desktop PCs down to phones and other  
specialized network devices with low levels of resources,  but  
interestingly also lowest latency with regard to the so called 'user'.

Would this new language make managing data and process on multiple  
computers easier to program for in a more general sense?  How do we  
make a network based computer that gets us away from having to worry  
about where a particular data set is -- or where a particular process  
is running?  I know this is focused on the semantic web but can this  
help me deal with manageing my many overlapping data streams that I  
want available on any computer I come in contact with -- such as  
model output or more importantly digital photos,  mp3s,  and videos?

I think a wed-tech talk would be very welcome.

--joshua

---
Joshua Thorp
Redfish Group
624 Agua Fria, Santa Fe, NM




On Apr 26, 2007, at 8:01 AM, Marko A. Rodriguez wrote:

>
> LANL is currently building a compiler and virtual machine that is  
> compliant with the specification in the paper. If RedFish is  
> interested, perhaps in a month or two, I could demo this computing  
> paradigm at a Wednesday tech session.
>

-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://redfish.com/pipermail/friam_redfish.com/attachments/20070429/dd60a1cd/attachment.html 

[Carl Tollander]

Joshua,

Along these lines -- just noticed this tonight on java.net --  
https://cajo.dev.java.net/ -- I haven't gone through it in detail so
can't even begin to compare it to the RVM features of interest yet but
it looks mighty interesting.

Carl

Joshua Thorp wrote:

> Marko,
>
> Redfish is very interested in this.  I especially like this line of
> thinking:
>
> From 4.9:
>
> ...Once the Fhat RVM has  
> completed computing that particular RDF sub-network, it can halt and
> another CPU can  
> pick up the process on a yet another area of the RDF network that
> needs computing by the  
> RDF software. *In this model of computing, data doesn?t move to the
> process, the process* * *
> *moves to the data.*  
>
>
> We are interested in models for distributed computing that can easily
> exist in very heterogeneous environments such as high performance
> computers/web service servers/desktop PCs down to phones and other
> specialized network devices with low levels of resources,  but
> interestingly also lowest latency with regard to the so called 'user'.  
>
> Would this new language make managing data and process on multiple
> computers easier to program for in a more general sense?  How do we
> make a network based computer that gets us away from having to worry  
> about where a particular data set is -- or where a particular process
> is running?  I know this is focused on the semantic web but can this
> help me deal with manageing my many overlapping data streams that I
> want available on any computer I come in contact with -- such as model
> output or more importantly digital photos,  mp3s,  and videos?
>
> I think a wed-tech talk would be very welcome.
>
> --joshua  
>
> ---
> Joshua Thorp
> Redfish Group
> 624 Agua Fria, Santa Fe, NM
>
>
>
>
> On Apr 26, 2007, at 8:01 AM, Marko A. Rodriguez wrote:
>
>>
>> LANL is currently building a compiler and virtual machine that is
>> compliant with the specification in the paper. If RedFish is
>> interested, perhaps in a month or two, I could demo this computing
>> paradigm at a Wednesday tech session.
>>
>
> ------------------------------------------------------------------------
>
> ============================================================
> FRIAM Applied Complexity Group listserv
> Meets Fridays 9a-11:30 at cafe at St. John's College
> lectures, archives, unsubscribe, maps at http://www.friam.org

[Marko Rodriguez]

Hi Josh.

>
> We are interested in models for distributed computing that can  
> easily exist in very heterogeneous environments such as high  
> performance computers/web service servers/desktop PCs down to  
> phones and other specialized network devices with low levels of  
> resources,  but interestingly also lowest latency with regard to  
> the so called 'user'.
>

We are currently developing the Fhat processor in Java and for  
various triple-store interfaces. What this means is that nothing will  
run faster than Java and on top of that, it will always be  
constrained by the read/write speed of the triple-store. For triple-
stores like AllegroGraph, this is fast, for stores like Kowari..... i  
dunno---we will see when we benchmark the prototype ... This is not a  
high-performance computing paradigm as much as its a distributed  
computing (internet computing) paradigm. Let me point you to this  
article by some Carnegie-Mellon people that is related in thought:

http://isr.cmu.edu/doc/isr-ieee-march-2007.pdf


> Would this new language make managing data and process on multiple  
> computers easier to program for in a more general sense?  How do we  
> make a network based computer that gets us away from having to  
> worry  about where a particular data set is -- or where a  
> particular process is running?  I know this is focused on the  
> semantic web but can this help me deal with manageing my many  
> overlapping data streams that I want available on any computer I  
> come in contact with -- such as model output or more importantly  
> digital photos,  mp3s,  and videos?

If you do represent your data in RDF (which could be a resolvable URI  
to some byte-stream---e.g. music, movies, images, etc.)  then your  
data is always present/accessible on the "Semantic Web" (in a triple-
store repository or pointed to by a URI in the RDF network that can  
be resolved to a "physical" file). Furthermore, the execution of that  
data is also on the Semantic Web (the RVM state is represented in  
RDF). Lets say you want to move to computer B but you have something  
executing on your current computer A. Well you just halt the RVM and  
its stored frozen in the Semantic Web (you can halt at the  
instruction level--meaning, in mid-method...). Then you just move to  
computer B and start the RVM process up again. It continues at the  
last instruction you halted it at. To the RVM time didn't stop. You  
can move to different computers and always have the same applications  
running where you left off---no sleeping or shutting down.

Again, your data, your computing machine (RVM), and your software  
(triple-code) is all in the Semantic Web. It doesn't matter which  
hardware device you are running the RVM process on (as a long as the  
RVM process code is written for that machine---thats why we are  
building the Fhat process code in Java). Also, check this out. Assume  
that your hardware CPU is VERY slow (lets say a mobile device). Well,  
you need not use the mobile device's CPU to execute the RVM process.  
You can leverage another CPU in the pool of Semantic Web hardware  
devices to execute the code while the state changes are read by your  
mobile device. Your mobil device is only an I/O device, not a "number  
cruncher". You can have your home computer doing all the RVM process  
code while your mobile device controls that flow of execution. Your  
mobile device leverages the computer power of the desktop machine.

However, there is a great price to pay for all this. Because  
EVERYTHING is represented internal to the triple-store, there is a  
great deal of read/writes. The triple-store is the bottle-neck. While  
you can federate triple-stores (which is blind to the end  
applications), this is still the limiting factor. However, we are not  
only developing Fhat, but r-Fhat (reduced Fhat) which is an RVM whose  
state is not represented in RDF. This does not provide the nice  
portability seen with Fhat, but does greatly reduce the number of  
read/writes to the triple-store. For this reason, I wouldn't pose  
this as a "high-performance" computing paradigm.

(I haven't thought much about multi-threading where you can have  
multiple RVM processes executing a single RDF program, but I know its  
possible and will write something up about it as the logistics of it  
solidify in my mind... In such cases you would want your RDF software  
distributed across multiple triple-stores so as to avoid the read/
write bottle neck.)

Finally, because everything in the Semantic Web is a URI (for which a  
URL is a sub-class of), the software you write it at the world stage.  
This gets into the whole Semantic Web Services concept. You can have  
instantiated objects or APIs (objects that need instantiating) that  
just exist and can be leveraged by your software. There is no  
downloading of .jars and classpathing stuff. Its all in one large  
software repository called the Semantic Web.

Hope this clears things up... Please ask more questions. It helps me  
to clear up my thoughts (again, this is all very new to me too :).

Take care,
Marko.

> I think a wed-tech talk would be very welcome.
>
> --joshua
>
> ---
> Joshua Thorp
> Redfish Group
> 624 Agua Fria, Santa Fe, NM
>
>
>
>
> On Apr 26, 2007, at 8:01 AM, Marko A. Rodriguez wrote:
>
>>
>> LANL is currently building a compiler and virtual machine that is  
>> compliant with the specification in the paper. If RedFish is  
>> interested, perhaps in a month or two, I could demo this computing  
>> paradigm at a Wednesday tech session.
>>
>
> ============================================================
> FRIAM Applied Complexity Group listserv
> Meets Fridays 9a-11:30 at cafe at St. John's College
> lectures, archives, unsubscribe, maps at http://www.friam.org

Marko A. Rodriguez
Los Alamos National Laboratory (P362-proto)
Los Alamos, NM 87545
Phone [phone]
http://www.soe.ucsc.edu/~okram


-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://redfish.com/pipermail/friam_redfish.com/attachments/20070430/fd36de4d/attachment.html 

[Joshua Thorp]

Hi Marko,

Sorry it seemed like I was asking for High Performance computing...  
We've had plenty of discussion on this list about that topic to point  
to the many contortions and specialized software that one has to  
utilize when speed is at the top of the list.  I meant more how to  
put a control layer on top of a high-performance computer system that  
let me manage streams of data and processes either migrating to the  
high-performance platform or resulting streams off the plat-form and  
closer to my eyes/hands...  As Marcus points out there are already  
tons of ways to work with the semantic web and like wise if I were to  
better formulate my problem there are probably plenty of simple  
python scripts or Java libraries to apprach these problems.

However what I take from your paper is an interest in the creation of  
a new language that naturally fits the problem.  Your problem of  
analyzing triple store data for the citation metrics problem seems  
perfectly fit for your new language.  I am not so concerned with  
speed of execution as I am with ease of programming and thinking  
about a problem.  Python isn't a fast enough language to do the heavy  
computing in a situation where speed is the paramount requirement  
i.e. interactive ABM visualization.  However for transforming sets of  
data from one into other sets of data it is very natural and this can  
partially be attributed to its use of lists and dictionaries as built  
in data types.

Ideally each part of the problem would be solved in a language well  
suited to that problem -- i.e. put the graphics intensive bit on the  
graphics processor,  the network intensive stuff on a high bandwidth  
machine etc.  But some distributed OS type code would be necessary to  
manage these processes and data streams,  what sorts of constructs  
would be most natural in a language that solved such a set of problems?

--joshua

[Joshua Thorp]

Carl,

Very cool,  I'll have to check it out.

--joshua

---
Joshua Thorp
Redfish Group
624 Agua Fria, Santa Fe, NM




On Apr 29, 2007, at 11:00 PM, Carl Tollander wrote:

> Joshua,
>
> Along these lines -- just noticed this tonight on java.net --
> https://cajo.dev.java.net/ -- I haven't gone through it in detail so
> can't even begin to compare it to the RVM features of interest yet but
> it looks mighty interesting.
>
> Carl
>
> Joshua Thorp wrote:
>> Marko,
>>
>> Redfish is very interested in this.  I especially like this line of
>> thinking:
>>
>> From 4.9:
>>
>> ...Once the Fhat RVM has
>> completed computing that particular RDF sub-network, it can halt and
>> another CPU can
>> pick up the process on a yet another area of the RDF network that
>> needs computing by the
>> RDF software. *In this model of computing, data doesn?t move to the
>> process, the process* * *
>> *moves to the data.*
>>
>>
>> We are interested in models for distributed computing that can easily
>> exist in very heterogeneous environments such as high performance
>> computers/web service servers/desktop PCs down to phones and other
>> specialized network devices with low levels of resources,  but
>> interestingly also lowest latency with regard to the so called  
>> 'user'.
>>
>> Would this new language make managing data and process on multiple
>> computers easier to program for in a more general sense?  How do we
>> make a network based computer that gets us away from having to worry
>> about where a particular data set is -- or where a particular process
>> is running?  I know this is focused on the semantic web but can this
>> help me deal with manageing my many overlapping data streams that I
>> want available on any computer I come in contact with -- such as  
>> model
>> output or more importantly digital photos,  mp3s,  and videos?
>>
>> I think a wed-tech talk would be very welcome.
>>
>> --joshua
>>
>> ---
>> Joshua Thorp
>> Redfish Group
>> 624 Agua Fria, Santa Fe, NM
>>
>>
>>
>>
>> On Apr 26, 2007, at 8:01 AM, Marko A. Rodriguez wrote:
>>
>>>
>>> LANL is currently building a compiler and virtual machine that is
>>> compliant with the specification in the paper. If RedFish is
>>> interested, perhaps in a month or two, I could demo this computing
>>> paradigm at a Wednesday tech session.
>>>
>>
>> ---------------------------------------------------------------------
>> ---
>>
>> ============================================================
>> FRIAM Applied Complexity Group listserv
>> Meets Fridays 9a-11:30 at cafe at St. John's College
>> lectures, archives, unsubscribe, maps at http://www.friam.org
>
> ============================================================
> FRIAM Applied Complexity Group listserv
> Meets Fridays 9a-11:30 at cafe at St. John's College
> lectures, archives, unsubscribe, maps at http://www.friam.org

[Marko Rodriguez]

Hi Josh.

Yes. It depends on your problem scenario. Any computing platform can  
do anything you need. Anything you can do in one language you can do  
in another (of course, at different levels of headache).

For the Semantic Web, there is very limited support or very awkward  
support for object-oriented programming. Furthermore, there are no  
triple-store platforms that support what we want to do. Jena, Kowari,  
etc. are all too slow and don't support the billion triple scale.  
Therefore, we use AllegroGraph. Our code to manipulate the triple-
store is written in Lisp. However, the Lisp perspective on  
AllegroGraph is very low-level as well (Prolog statements and  
individual URIs). To give us a higher-level of abstraction on the  
endless pool of triples, we are developing Neno. Neno provides us  
object-oriented control of low-level triples (more "Javaish", than  
"Prolog/Lispish"). We don't want to think in terms URIs and SELECT/
INSERT statements. We want to think in terms of instantiating objects  
and executing methods. There are similar solutions like SWCLOS, but  
these don't have some of the other benefits like RVM representation  
in the Semantic Network, self-modifying code, etc. While we currently  
don't have great use cases for this functionality, its head-candy to  
say the least :).

Your questions concerning mobile computing stimulated some ideas in  
me. The idea of a personal pervasive CPU (RVM) is very interesting to  
me and very simple with the Neno platform.

As we play more, more application scenarios will pop out and we will  
add more to the Neno API to support these application scenarios. So  
please, keep the ideas flowing.

Take care,
Marko.


On Apr 30, 2007, at 11:27 AM, Joshua Thorp wrote:

> Hi Marko,
>
> Sorry it seemed like I was asking for High Performance computing...
> We've had plenty of discussion on this list about that topic to point
> to the many contortions and specialized software that one has to
> utilize when speed is at the top of the list.  I meant more how to
> put a control layer on top of a high-performance computer system that
> let me manage streams of data and processes either migrating to the
> high-performance platform or resulting streams off the plat-form and
> closer to my eyes/hands...  As Marcus points out there are already
> tons of ways to work with the semantic web and like wise if I were to
> better formulate my problem there are probably plenty of simple
> python scripts or Java libraries to apprach these problems.
>
> However what I take from your paper is an interest in the creation of
> a new language that naturally fits the problem.  Your problem of
> analyzing triple store data for the citation metrics problem seems
> perfectly fit for your new language.  I am not so concerned with
> speed of execution as I am with ease of programming and thinking
> about a problem.  Python isn't a fast enough language to do the heavy
> computing in a situation where speed is the paramount requirement
> i.e. interactive ABM visualization.  However for transforming sets of
> data from one into other sets of data it is very natural and this can
> partially be attributed to its use of lists and dictionaries as built
> in data types.
>
> Ideally each part of the problem would be solved in a language well
> suited to that problem -- i.e. put the graphics intensive bit on the
> graphics processor,  the network intensive stuff on a high bandwidth
> machine etc.  But some distributed OS type code would be necessary to
> manage these processes and data streams,  what sorts of constructs
> would be most natural in a language that solved such a set of  
> problems?
>
> --joshua
>
>
>
> ============================================================
> FRIAM Applied Complexity Group listserv
> Meets Fridays 9a-11:30 at cafe at St. John's College
> lectures, archives, unsubscribe, maps at http://www.friam.org

Marko A. Rodriguez
Los Alamos National Laboratory (P362-proto)
Los Alamos, NM 87545
Phone [phone]
http://www.soe.ucsc.edu/~okram


-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://redfish.com/pipermail/friam_redfish.com/attachments/20070430/fd9470bc/attachment.html 

[Marcus G. Daniels]

Hi,

Another question:   Are you at liberty to reveal the source of the 10
billion triples?   Do have the the research library basement filled with
an army of ontology coders?   ;-)

[Marko Rodriguez]

Hi Marcus,

http://www.mesur.org.

See ya,
Marko.

On Apr 30, 2007, at 1:10 PM, Marcus G. Daniels wrote:

> Hi,
>
> Another question:   Are you at liberty to reveal the source of the 10
> billion triples?   Do have the the research library basement filled  
> with
> an army of ontology coders?   ;-)
>
> ============================================================
> FRIAM Applied Complexity Group listserv
> Meets Fridays 9a-11:30 at cafe at St. John's College
> lectures, archives, unsubscribe, maps at http://www.friam.org

Marko A. Rodriguez
Los Alamos National Laboratory (P362-proto)
Los Alamos, NM 87545
Phone [phone]
http://www.soe.ucsc.edu/~okram


-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://redfish.com/pipermail/friam_redfish.com/attachments/20070430/4d13a220/attachment.html