Plan3 — A Procedural RDF Programming Language

Previous Topic Next Topic
 
classic Classic list List threaded Threaded
6 messages Options
Reply | Threaded
Open this post in threaded view
|

Plan3 — A Procedural RDF Programming Language

Sean B. Palmer
In October 2007 I made a procedural RDF programming language and
implemented it on top of CWM. Today I've released all the code, tests,
and documentation that I could find relating to this project:

http://inamidst.com/sw/plan3/

The main files to look at are:

http://inamidst.com/sw/plan3/plan3.py — the implementation
http://inamidst.com/sw/plan3/tests — a summary of the tests

To make it work, you'll have to hook it up to cwm somehow. I don't
recall how I did this, but I don't think it was more than a few lines
to be changed; I don't have a patch available. I don't have anything
else available relating to this project, that I know of, except what's
in that directory.

The following old Whits post describes some of the rationale of the language:

http://inamidst.com/whits/2007/10#plan3

And, somewhat, how it works. This software is not supported to any
degree, and I don't plan on working on it or developing it any
further. I do not recommend that it be used, but who knows what other
value it might have?

(At the very least, it demonstrates how strange the idea of doing all
Semantic Web programming declaratively really was—though of course all
Semantic Web programming is strange Technobunkum* to a large degree
anyway. This half-baked data-structured mongrel doesn't escape that,
despite its heritage in Pluvo. The idea of having
procedural-imperative accessors to a declarative environment, which is
the direction in which plan3 was heading, may however be nifty to
those who are interested in that sort of thing.)

Thanks,

* http://inamidst.com/whits/2008/technobunkum
— Recommended reading for all Semantic Web engineers.

--
Sean B. Palmer, http://inamidst.com/sbp/
Reply | Threaded
Open this post in threaded view
|

Re: Plan3 — A Procedural RDF Programming Language

Giovanni Tummarello-2

> * http://inamidst.com/whits/2008/technobunkum
> — Recommended reading for all Semantic Web engineers.

Thank you much for putting this into words.
I think however that not all is lost with respect to Web Semantics.
Microformat and (increasingly, for several reasons RDFa) are beginning
to be seen quite a bit out there. (out of the
get-paid-to-work-on-puzzle-with-your-friends as you very appropriately
point out ) .  :-)

So even if this data is broken, very incomplete, difficult to
interlink etc, the fact that it is out there makes it to me so much
more interesting. Driving me out of the addition to the "invent at all
costs" and back into the domain of "comparing and reasoning" (before
inventing ;-) .

Giovanni





On Wed, Sep 24, 2008 at 12:06 PM, Sean B. Palmer <[hidden email]> wrote:

> In October 2007 I made a procedural RDF programming language and
> implemented it on top of CWM. Today I've released all the code, tests,
> and documentation that I could find relating to this project:
>
> http://inamidst.com/sw/plan3/
>
> The main files to look at are:
>
> http://inamidst.com/sw/plan3/plan3.py — the implementation
> http://inamidst.com/sw/plan3/tests — a summary of the tests
>
> To make it work, you'll have to hook it up to cwm somehow. I don't
> recall how I did this, but I don't think it was more than a few lines
> to be changed; I don't have a patch available. I don't have anything
> else available relating to this project, that I know of, except what's
> in that directory.
>
> The following old Whits post describes some of the rationale of the language:
>
> http://inamidst.com/whits/2007/10#plan3
>
> And, somewhat, how it works. This software is not supported to any
> degree, and I don't plan on working on it or developing it any
> further. I do not recommend that it be used, but who knows what other
> value it might have?
>
> (At the very least, it demonstrates how strange the idea of doing all
> Semantic Web programming declaratively really was—though of course all
> Semantic Web programming is strange Technobunkum* to a large degree
> anyway. This half-baked data-structured mongrel doesn't escape that,
> despite its heritage in Pluvo. The idea of having
> procedural-imperative accessors to a declarative environment, which is
> the direction in which plan3 was heading, may however be nifty to
> those who are interested in that sort of thing.)
>
> Thanks,
>
> * http://inamidst.com/whits/2008/technobunkum
> — Recommended reading for all Semantic Web engineers.
>
> --
> Sean B. Palmer, http://inamidst.com/sbp/
>

Reply | Threaded
Open this post in threaded view
|

Re: Plan3 — A Procedural RDF Programming Language

Sandro Hawke
In reply to this post by Sean B. Palmer


> At the very least, it demonstrates how strange the idea of doing all
> Semantic Web programming declaratively really was

Could you explain that point?  (And no, I'm not going to take the time
to study plan3 right now.)  There are certainly serious difficulties
with declarative programming -- in both performance and ease of use --
but what novel "strangeness" have you demonstrated here?

      -- Sandro

Reply | Threaded
Open this post in threaded view
|

Re: Plan3 — A Procedural RDF Programming Language

Sean B. Palmer
On Wed, Sep 24, 2008 at 3:13 PM, Sandro Hawke <[hidden email]> wrote:

> Could you explain that point?

Yep, sure, though this'll probably be a bit of a ramble. In sum, all
of the mainstream bob-a-job programming languages are imperative.
There is lots about RDF that is suited towards declarative
programming, but N3 took it too far.

I haven't done any great survey about this à la my old N3 QNames
survey, but experience tells me that RDF APIs tend to be developed in
imperative languages because that's how people get things done.

It's difficult to tell between trendiness and a good idea. Heck,
sometimes even trendiness quâ trendiness is a good idea.

Paul Graham says somewhere that languages like Java are an
evolutionary dead end. Then again, he also says that the evolutionary
victor will be lisp.

The "novel" strangeness might not be novel from a universal
perspective, and I didn't mean to imply that in my email if I did, but
from a personal perspective it was something that nagged at me all the
time. So I tried it out. Trying things out is what science is founded
on, and computer science is no different.

I've been working with N3 for years. I love N3; I love it dearly. But
it's mad. So I tried plan3 and that was mad too, but in a different
way. Then I tried Trio and Arcs, and that was mad too but in a
*completely* different way.

How can you tell that N3 is good (whatever that means) if you don't
try other things?

At the end of the day, for high-level architectural decisions people
say things bourne out of long experience, and if Paul Graham goes and
says something like "Java is a dead end, lisp is the future!", then
it's an interesting point, and you might not agree, but the truth of a
statement like that isn't the primary thing about it. It makes you
think.

Plan3 made me think; think *practically*. The declarative way of doing
things in N3 really gets on my nerves, so hybridising the two really
made sense. If the Semantic Web is successful on its putated terms,
like if Tabulator and such things become a part of our daily lives as
timbl once said, my bet is that N3 will be an evolutionary dead end,
and that language like plan3 or Niklas's Ardele will be more suitable.

But after all, cum grano salis, because plan3 and Ardele (from what I
can tell from its syntax example; Niklas hasn't fully specified the
design online yet) seem to aim for a 50:50 declarative-imperative
split. Perhaps the sweetspot would be elsewhere, like 30:70.

Note that it doesn't really concern me too much; it's outside of the
realm of my personal interests at the moment. I just gave it as an
example of what might be the primary value of me releasing this. I was
thinking some people might say "what is the point of this?",
otherwise. I think it's a good question to ask.

(Sometimes the benefits of systems can be far off. Prime number
research was just pure maths, pure intellectual fun, until we realised
we could use it as the foundation of public key cryptography.)

Hope that helps,

--
Sean B. Palmer, http://inamidst.com/sbp/
Reply | Threaded
Open this post in threaded view
|

Re: Plan3 — A Procedural RDF Programming Language

adriandwalker
Hi Sean -

You wrote...

In sum, all of the mainstream bob-a-job programming languages are imperative.
There is lots about RDF that is suited towards declarative programming, but N3 took it too far.

Just to be contrarian, one can take declarativeness over RDF much further than N3.  For an example you can run using a browser, please see

  www.reengineeringllc.com/demo_agents/RDFQueryLangComparison1.agent

For background (and why this is highly declarative), please see
   
 www.reengineeringllc.com/A_Wiki_for_Business_Rules_in_Open_Vocabulary_Executable_English.pdf

Apologies if you have seen this before, and thanks for comments.

                                                    -- Adrian
                   
Internet Business Logic
A Wiki and SOA Endpoint for Executable Open Vocabulary English over SQL and RDF
Online at www.reengineeringllc.com    Shared use is free

Adrian Walker
Reengineering                             




On Wed, Sep 24, 2008 at 11:03 AM, Sean B. Palmer <[hidden email]> wrote:
On Wed, Sep 24, 2008 at 3:13 PM, Sandro Hawke <[hidden email]> wrote:

> Could you explain that point?

Yep, sure, though this'll probably be a bit of a ramble. In sum, all
of the mainstream bob-a-job programming languages are imperative.
There is lots about RDF that is suited towards declarative
programming, but N3 took it too far.

I haven't done any great survey about this à la my old N3 QNames
survey, but experience tells me that RDF APIs tend to be developed in
imperative languages because that's how people get things done.

It's difficult to tell between trendiness and a good idea. Heck,
sometimes even trendiness quâ trendiness is a good idea.

Paul Graham says somewhere that languages like Java are an
evolutionary dead end. Then again, he also says that the evolutionary
victor will be lisp.

The "novel" strangeness might not be novel from a universal
perspective, and I didn't mean to imply that in my email if I did, but
from a personal perspective it was something that nagged at me all the
time. So I tried it out. Trying things out is what science is founded
on, and computer science is no different.

I've been working with N3 for years. I love N3; I love it dearly. But
it's mad. So I tried plan3 and that was mad too, but in a different
way. Then I tried Trio and Arcs, and that was mad too but in a
*completely* different way.

How can you tell that N3 is good (whatever that means) if you don't
try other things?

At the end of the day, for high-level architectural decisions people
say things bourne out of long experience, and if Paul Graham goes and
says something like "Java is a dead end, lisp is the future!", then
it's an interesting point, and you might not agree, but the truth of a
statement like that isn't the primary thing about it. It makes you
think.

Plan3 made me think; think *practically*. The declarative way of doing
things in N3 really gets on my nerves, so hybridising the two really
made sense. If the Semantic Web is successful on its putated terms,
like if Tabulator and such things become a part of our daily lives as
timbl once said, my bet is that N3 will be an evolutionary dead end,
and that language like plan3 or Niklas's Ardele will be more suitable.

But after all, cum grano salis, because plan3 and Ardele (from what I
can tell from its syntax example; Niklas hasn't fully specified the
design online yet) seem to aim for a 50:50 declarative-imperative
split. Perhaps the sweetspot would be elsewhere, like 30:70.

Note that it doesn't really concern me too much; it's outside of the
realm of my personal interests at the moment. I just gave it as an
example of what might be the primary value of me releasing this. I was
thinking some people might say "what is the point of this?",
otherwise. I think it's a good question to ask.

(Sometimes the benefits of systems can be far off. Prime number
research was just pure maths, pure intellectual fun, until we realised
we could use it as the foundation of public key cryptography.)

Hope that helps,

--
Sean B. Palmer, http://inamidst.com/sbp/

Reply | Threaded
Open this post in threaded view
|

Re: Plan3 — A Procedural RDF Programming Language

Sean B. Palmer
On Wed, Sep 24, 2008 at 7:43 PM, Adrian Walker wrote:

> one can take declarativeness over RDF much further than N3

Sorry, I didn't understand why your system is more declarative than N3
(really, than CWM/N3), even after reading the PDF. It seemed to use
only very simple rules and some existential quantification, a subset
of CWM/N3's capabilities.

But it did remind me about designing CWM/N3 builtins. I'm not sure
about the details, but I remember a discussion between Tim and Dan
about how to make a property look and behave as declaratively as
possible. The builtins are, to a large extent, just syntactic sugar
for python calls, so there was always the tendency to just use the
python names and behaviours for things which are, of course, under the
imperative mindset.

So I always kinda wondered why not just use the familiar names. No
real point to this anecdote though—you just reminded me of it.

--
Sean B. Palmer, http://inamidst.com/sbp/