Semantic Web Interest Group IRC Chat Logs for 2005-01-01

00:00:06 <Arnia> Happy 2005 :)

00:00:33 <dajobe-lap> from UTC+0

00:00:33 <crschmidt> happy 2005, GMT

00:00:47 <dajobe-lap> logger, pointer?

00:00:47 <dajobe-lap> See http://www.ilrt.bris.ac.uk/discovery/chatlogs/swig/2005-01-01#T00-00-47

00:05:26 <Arnia> Woo... the London Eye was impressive

00:11:23 <Arnia> Wow... that was an amazing display

00:51:45 <Talliesin> Happy New Year (UTC) all

01:09:38 * dajobe-lap first post to planetrdf.com

01:21:22 <dajobe-lap> and I fixed a couple of bugs, 2005 (UTC+0) looks good already...

01:21:36 <chrisc> Talliesin: happy new year :-)

03:16:40 <DanC_lap> ooh! I got jabber<->AOL working. using Gush on OS X

03:17:19 <DanC_lap> hmm... no IRC<->Jabber gateway on tipic.com

03:17:34 * DanC_lap should make notes under RemotePresence...

04:15:01 <DanC_lap> Gush is kinda nice... quite friendly... was the first client where I got AIM working

04:15:22 <DanC_lap> it's not open source, though. (creative commons attribution non-commercial, though)

04:15:38 <DanC_lap> tried psi... seems obscure/complex

04:15:43 <DanC_lap> trying Nitro now... like it so far.

04:16:01 <DanC_lap> and this unstable.nl server looks nice http://www.unstable.nl/jabber.html . IRC and AIM transports

04:21:11 <crschmidt> DanC_lap: where are you at? you should be enjoying the new year!

04:21:49 <DanC_lap> America/Chicago timezone. 1:40 to midnight. The family is "camping out" in the family room.

04:21:56 <crschmidt> heh

04:33:58 * DanC_lap tests IRC/jabber gateway...

06:53:43 <DanC_j> whoa!

06:53:58 <DanC_lap> hey! finally got jabber/IRC working!

06:54:07 <crschmidt> happy new year, DanC

06:54:14 <Arnia> Happy new year :)

06:54:27 * Arnia hands out Ferero Rocher

06:54:31 <DanC_lap> recipie: Adium X, connected to irc.unstable.nl

06:54:37 <DanC_lap> happy new year!

06:55:33 <eaon> adium does irc?

06:55:44 <Arnia> *silly 'foreign' accent* With this Ferero Rocher you are really spoiling us

06:56:23 <DanC_j> Adium is a jabber client. irc.unstable.nl bridges jabber/IRC

06:56:57 <eaon> aye - yeah i use adium myself, thats why i was confused for a second

06:57:01 <eaon> and happy new year :)

06:58:11 <DanC_j> hmm... not sure how to do a private message to an IRC peer from here

07:00:30 <DanC_j> hmm... I can receive private messages

07:00:46 <DanC_j> and reply to them

07:01:06 <DanC_j> but I don't see how to initiate them

07:03:54 <DanC_j> my homepage (testing link thingy)

07:04:01 <DanC_j> lose

07:05:46 <DanC_j> 0.73

07:08:18 <eaon> did you try %_adiumversion or whatever it's calledß

07:08:23 <DanC_j> yes

07:08:25 * eaon kicks his shift button

07:09:01 <DanC_j> *wonders if jabber has a concept of /me actions*

07:09:22 <Arnia> Hmm... Right, to make things easier for myself (and others) I'm going to refactor Frege's interfaces to look more like Redland's (except transmitting NTriples across DBUS) with a helper 'GraphChanged' signal and (in the C# bindings at least) a 'Pattern' list that will filter the GraphChanged signal's lists

07:09:36 * DanC_lap sees that if so, the irc.unstable.nl gateway doesn't grok

07:10:16 <eaon> yeah it does Danc_j, but adium doesn't use it

07:10:45 <eaon> it's adiums fault - their message display isn't compatible with the way /me is usually used

07:10:59 <DanC_j> hmm

07:11:27 <DanC_j> jabber clients seem to support a hodgepodge of features

07:11:53 <DanC_j> Gush does a good job with registering AIM gateway peers, but it doesn't do groupchat (as far as I can see)

07:12:18 <DanC_j> Adium's groupchat support seems decent, but I don't see AIM gateway support

07:13:30 <eaon> adium isn't a real jabber client

07:13:52 <DanC_j> no? ah... I guess it's a multi-protocol client

07:14:00 <Arnia> Not sure if I should add support for 'qualities' into the Frege interfaces now... or simply break the interfaces later (I'm going to need the ability to easily annotate statements later to leverage Beagle's stuff properly)

07:14:04 <DanC_j> care to recommend a "real" jabber client for OS X?

07:14:05 <eaon> exactly

07:14:18 <eaon> i wish i could

07:14:33 <Arnia> Hum... Redland really isn't cut out for this :/

07:14:50 <eaon> i find all jabber clients (windows/osx/linux) i know not so good :/

07:15:03 <Arnia> Gaim is ok...

07:15:16 <Arnia> But again its not a real jabber client

07:15:17 <eaon> yeah but does it handle transports properly?

07:15:20 <eaon> right

07:15:28 <eaon> adium uses libgaim

07:15:54 <Arnia> Jabber is a weird protocol...

07:16:26 <Arnia> Hey, has anyone written a q space (or whatever they're called) to transmit RDF?

07:16:51 <DanC_j> q space?

07:17:12 <Arnia> jabber:q elements for sending XML to and fro

07:17:40 <Arnia> I haven't looked at the jabber protocol for a long time so I'm not really sure what they're called :)

07:18:18 <Arnia> Oh... that would be a cool integration with Frege... desktop users able to send bundles of information from machine to machine over jabber

07:19:25 <Arnia> eaon: OSX can run DBUS btw

07:19:42 <eaon> oh

07:19:58 <eaon> but for x11 no?

07:20:05 <Arnia> darwinports

07:20:12 <Arnia>http://dbus.darwinports.com/

07:20:13 <dc_swig> A: http://dbus.darwinports.com/ from Arnia

07:20:29 <eaon> but it doesn't have integration for cocoa apps, right?

07:20:40 <Arnia> I was just about to check for that

07:20:47 <Arnia> (if there were Cocoa bindings)

07:21:02 <DanC_j> wierd... I was able to talk to my hand-held AIM client from Admim _while Gush was running_. replies would go to Gush. When I quit Gush, it no longer works

07:22:17 <Arnia> eaon: Can't see anything... but if there aren't then it shouldn't be too difficult for an OSX system coder to write them

07:22:58 <eaon> would be interesting

07:23:10 <eaon> anyway i need to get some sleep - gnight everyone

07:23:31 <Arnia> night

07:27:31 <DanC_j> ah... gush seems to have explicit support for signing on to a gateway

07:38:12 <Arnia> Another interesting idea (just rambling tonight) is using RDF and ontology to describe data structures on DBUS (to get around the horrible problems DBUS has with complex types atm and provide a more powerful type system that works gracefully with dynamically typed languages in general)

07:38:14 <DanC_j> maybe I'll give Psi another try...

07:47:38 <DanC_j2> aha

07:48:00 * DanC_j2 waves from psi

07:48:02 <Arnia> Is it working now?

07:48:11 * DanC_lap waves from xchat

07:48:22 <DanC_j2> psi seems to grok /me actions better

07:49:05 <DanC_j2> and private chats

07:49:17 <Arnia> cool

07:49:55 <DanC_j2> its "service discovery" is rich too.

07:50:12 <DanC_j2> psi seems quite capable. I had to play with other clients to figure out what was going on.

07:50:22 <DanC_j2> but now that I have a mental model, I think psi is the most capable

08:08:30 <DanC_lap> hmm... /away doesn't seem to map

08:09:09 <DanC_j2> /away testing irc/jabber

08:25:24 <DanC_j2> trying cocinella...

08:38:47 <md-afk> md-afk is now known as M-HappyNewYear

08:38:58 <DanC_lap> can't figure out how to specify the full jabber id of groupchats in cocinella. It seems to assume groupchats are on the same server as your account

08:39:05 <M-HappyNewYear> M-HappyNewYear is now known as M-EveryOne

08:40:06 <M-EveryOne> M-EveryOne is now known as Phurl

08:41:13 <DanC_lap> trying jabberfox...

08:42:22 <Phurl> Jabber For OS X (JabberFoX) is an Objective C-based client for the XML-based Jabber

08:42:22 <Phurl> messaging system for Mac OS X.

08:46:29 <DanC_lap> can't seem to join a groupchat from JabberFoX

08:49:07 <Arnia> Phurl: Turning into a bot now? :)

08:49:23 <Phurl> happy new year Arnia

08:49:42 <Phurl> and DanC_lap

08:49:46 <Phurl> and all of you here

08:50:01 * Arnia boings

08:50:03 <Phurl> Arnia: no, i am becoming awake

09:13:15 <Phurl> i was wondering about this dbus, what purpose does it serv exactly for frege?

09:15:24 <Arnia> Its the IPC layer used to allow every app to use one graph

09:15:45 <Phurl> ahh

09:15:52 <Phurl> ok

09:16:19 <Phurl> but that would be maybe not always needed and therefore optional, theoretically?

09:16:31 <Arnia> Uhh... that's the whole point of Frege

09:16:36 <Phurl> i see

09:16:37 <Arnia> One graph to rule them all

09:16:42 <Phurl> i think that it is good idea

09:16:47 <Phurl> to have a common graph

09:16:52 <Phurl> *GOOD*

09:17:16 <Phurl> something that i have oftened wished for with redland, a graph server in local memory

09:17:29 <Phurl> and dbus has a c interface

09:18:02 <Phurl> i wonder if this would be able to be used for redland on that level

09:18:23 <Phurl> i mean if i have a c app that creates a graph

09:18:38 <Phurl> if it can talk to frege via this dbus?

09:18:43 <Arnia> Uh, yes... it just has to send the appropriate structures over DBUS

09:18:51 <Phurl> redland structures?

09:18:54 <Phurl> or c#

09:19:09 <Arnia> No... arrays of NTriple strings

09:19:13 <Phurl> ahh

09:19:13 <Phurl> ok

09:19:20 <Phurl> gotcha, so c#?

09:19:39 <Arnia> I rely on bindings to change back to more 'normal' structures... but I'm agnostic as to the shape those bindings take

09:19:49 <Phurl> i have seen that

09:19:52 <Arnia> I feel bindings should look like the language they're binding to

09:19:55 <Phurl> and the ntriples parser

09:19:59 <Phurl> sure, that is true

09:20:03 <Arnia> I'm going to be writing C# and python bindinsg

09:20:06 <Arnia> bindings

09:20:09 <Phurl> fok

09:20:09 <Phurl> ok

09:20:23 <Phurl> well, i think that this dbus is a real good idea

09:21:09 <Arnia> Its being used in a large amount of new software on linux

09:21:11 <Phurl> it does seem that redland has gotten much better c# interface

09:21:26 <Arnia> Its solving a general issue people have had and is solving it well

09:21:27 <Phurl> but you are right that is needs a native core

09:21:57 <Phurl> the best would be a parallel structure that is compatible with redland

09:22:16 <Phurl> have to think about this some more

09:22:41 <Phurl> at one point i was working on a c# api into the various rdf implementation

09:22:45 <Phurl> sort of a standard

09:22:51 <Phurl> like system.xml

09:23:00 <Phurl> that is independent of the bindings

09:23:17 <Phurl> have to reopen that idea

09:23:40 <Phurl> now that redland is more mature with its c# interface

09:24:03 <Phurl> it could be more easily be modified to be a implmentator of that interface

09:24:43 <Phurl> or it could be used as parser, and another lib as a native c# in memory storage

09:25:06 <Phurl> need the ability to mix and match for the most appripriate things at the time

09:26:31 <Arnia> Hmm... not convinced as to the benefits of that

09:26:36 <Phurl> ok

09:26:53 <Phurl> well, i guess it is what you have done anyway

09:27:02 <Phurl> but that was application specifig

09:27:09 <Phurl> you took parts of redland

09:27:20 <Phurl> and interfaced to another rdf lib, your own

09:27:42 <Phurl> at the time, i was looking into drive and euler and another

09:27:55 <Phurl> it would be nice for example to use redland for eulersharp

09:28:08 <Phurl> or drive with euler

09:28:09 <Phurl> etc

09:28:31 <Phurl> mix and match producers and consumers of rdf

09:28:34 <Arnia> Hum. I don't think its possible to reach a consensus by oneself.

09:28:39 <Phurl> across a standard interface

09:28:48 <Phurl> well, we had a meeting

09:28:53 <Phurl> and agreed on it

09:28:57 <Phurl> this was in 2001

09:29:04 <Arnia> I'm going to put Frege in the wild and see what developers (from many languages and needs) request

09:29:13 <Phurl> yes

09:29:16 <Phurl> that is also good :)

09:29:33 <Phurl> just saying what i was thinking, and telling you what we did in the past

09:30:13 <Phurl> i can tell you that i need to be able to share rdf between various apps

09:30:25 <Phurl> and would like to be able to use this technology

09:30:34 <Phurl> but i am using the redland c interface

09:30:41 <Arnia> Yes, I'll bear it in mind. But Frege is designed to be lightweight and easy to bind to new languages (as long as they have DBUS bindings)

09:30:45 <Phurl> it would be nice to have a dbus storage

09:30:51 <Phurl> for redland

09:30:53 <Phurl> as a backend

09:31:19 <Phurl> so instead of a bdb hash, you just say, connect to this dbus server

09:31:28 <Arnia> I may not be using Redland for very long

09:31:36 <Phurl> then you could use rasqual and rdfproc on the server

09:31:45 <Phurl> well, it is really the question of interface

09:31:53 <Phurl> not of implementation

09:32:03 <Phurl> a server should be able to server many clients

09:32:07 <Arnia> I am targeting a merge with Beagle

09:32:12 <Phurl> dont know

09:32:31 <Phurl> what is that exactly?

09:32:37 <Arnia> (this is after my dissertation hand in)

09:33:09 <Phurl> .g beagle rdf c#

09:33:10 <Arnia> Beagle is an incredibly search-and-indexing system that is used over the session bus

09:33:14 <phenny> beagle rdf c#: http://mail.gnome.org/archives/dashboard-hackers/2004-August/msg00029.html

09:33:15 <Phurl> i see

09:33:18 <Arnia> incredibly advanced

09:33:27 <Phurl> ok

09:33:53 <Phurl> i supposed it is also written in c?

09:34:18 <Arnia> No. C#

09:34:21 <Phurl> ok

09:34:29 <Phurl> well, all very nice stuff

09:34:45 <Phurl> i hope that it is in the end abled to be used

09:34:50 <Phurl> and interfaced with c

09:35:05 <Arnia> Its all part of work on Project Utopia

09:35:08 <Phurl> i can call c# from c

09:35:32 <Phurl> looks like i need to read more about this stuff

09:35:56 <Arnia> Utopia has co-ordinated Beagle, Dashboard, DBUS, HAL, UDev, Galago, inotify, Kernel-Events etc

09:36:03 <Arnia> Its all nice stuff

09:36:26 <Arnia> Anything that can talk to DBUS can talk to Beagle

09:36:49 <Phurl> ok

09:37:10 <Phurl> back to work

09:37:23 <Phurl> thanks for the overview

09:38:45 <Arnia> np

10:08:01 <bijanp> bijanp is now known as bijan

10:49:41 <balbinus_> balbinus_ is now known as balbinus

11:09:44 <Phurl> Phurl is now known as md-afk

13:02:03 <boboss> hello all

14:08:35 <md-afk> md-afk is now known as PhUrl

14:10:01 <PhUrl>http://www.informationweek.com/story/showArticle.jhtml?articleID=56900091

14:10:01 <dc_swig> B: http://www.informationweek.com/story/showArticle.jhtml?articleID=56900091 from PhUrl

14:10:10 <PhUrl> B:Netcraft Debuts Anti-Phishing Toolbar For IE

14:10:10 <dc_swig> Added comment B1.

14:10:13 <PhUrl> B:|Netcraft Debuts Anti-Phishing Toolbar For IE

14:10:14 <dc_swig> Titled item B.

14:10:47 <PhUrl> B1:When will rdf apply a weight attribute for each site?

14:10:47 <dc_swig> Replaced comment B1.

14:11:11 <PhUrl> B1:Could be an application for the semantic web to give weight attribute for each uri

14:11:12 <dc_swig> Replaced comment B1.

14:11:41 <PhUrl> B:Attaching a spam semantic to uri

14:11:42 <dc_swig> Added comment B2.

14:12:04 <JibberJim> B:Windows XP2 says "The file was restricted because the content doesn't match its security information"...

14:12:04 <dc_swig> Added comment B3.

14:12:58 <JibberJim> B: An window Installer file sent with mime-type text/plain, great work once again from a security company!

14:12:58 <dc_swig> Added comment B4.

14:13:44 <JibberJim> B2:When trying to download it IE6 on Windows XP2 says "The file was restricted because the content doesn't match its security information"...

14:13:44 <dc_swig> Replaced comment B2.

14:13:52 <JibberJim> B3:When trying to download it IE6 on Windows XP2 says "The file was restricted because the content doesn't match its security information"...

14:13:52 <dc_swig> Replaced comment B3.

14:13:57 <PhUrl> happy new year Jibb

14:14:04 <JibberJim> B2:Attaching a spam semantic to uri

14:14:04 <dc_swig> Replaced comment B2.

14:14:15 <JibberJim> Happy New Year PhUrl!

14:14:42 <PhUrl> if that is not semantic, i dont know what is

14:16:47 <PhUrl> B:if the semantic web will not be able to help identify and communicate the semantics of spam, then what semantics will be communicated?

14:16:47 <dc_swig> Added comment B5.

14:20:52 <PhUrl> B:That makes me also wonder if the semantic web will allow me to find a real "free" p0rn site? :) I mean p0rn is one of the few money makers on the web, thus will have to be well supported by the semantic web for it to be accepted.

14:20:52 <dc_swig> Added comment B6.

14:21:30 * PhUrl imagines the ontology of sexual perversion expressed in owl.

14:22:40 <PhUrl> B:This is all predicated in the root question of credibility

14:22:40 <dc_swig> Added comment B7.

14:33:03 <PhUrl> B:see also [http://credibility.stanford.edu/|Web Credibility Project]

14:33:03 <dc_swig> Added comment B8.

14:38:23 <PhUrl> B:see also [http://www.pacificavc.com/blog/2003/02/10.html|Bayesian Nets, Latent Semantics, Despamming and other speculations]

14:38:23 <dc_swig> Added comment B9.

14:38:55 <PhUrl> B9:see also [http://www.pacificavc.com/blog/2003/02/10.html#a78|Bayesian Nets, Latent Semantics, Despamming and other speculations]

14:38:56 <dc_swig> Replaced comment B9.

14:41:34 <PhUrl> B:see also [http://www.hpl.hp.com/semweb/sw-technology.htm#Proof,%20trust%20and%20security|Hp's Introduction to Semantic Web Technologies : Proof, trust and security]

14:41:34 <dc_swig> Added comment B10.

14:42:13 <PhUrl> B:see also [http://russell.rucus.net/masters/writings/conferences/satnac2004Cloran|Trust on the Semantic Web] from Russell Cloran, Barry Irwin

14:42:13 <dc_swig> Added comment B11.

14:43:36 <PhUrl> B:see also [http://www.advogato.org/trust-metric.html|Advogato's Trust metric] referenced wrongly from above link

14:43:37 <dc_swig> Added comment B12.

14:50:26 <bballizlife_> bballizlife_ is now known as bballizlife

15:15:02 * PhUrl needs more speed, 10 minutes and waiting for cwm, gets pychinko

15:15:52 <timbl> :)

15:16:46 * timbl was putting links to pychinko on cwm page, got distracted by tryingto get BBC news video feed.

15:18:45 <timbl> Sheesh. "This service has not been designed for use on a Macintosh." -- http://asia-en.sg.real.com/partners/bbcnews/ifs/?x=y&pcode=bbcnews-i&cpath=R1R&rsrc=ifscons

15:19:52 <PhUrl> timbl: i just had a major realization for my project, for past years i have been numbering my nodes in my document like file:doc#:id-NNN, now if i replace them with _:aNNNN all of a sudden, cwm can deal with my data much better!

15:20:08 <PhUrl> it is perfect

15:20:29 <timbl> Why not use the first, though?

15:20:36 <timbl> Why can't cwm deal with that?

15:20:41 <PhUrl> first?

15:20:57 <timbl> <doc>#id_NNNN

15:21:15 <PhUrl> i wonder if there is a way to say that the id-NNNN is equivalent to _:aNNN

15:21:38 <PhUrl> well, let me see.

15:21:51 <timbl> You can't. One is a URI, the other is a bnode, an identifier which will be thrown away and has no meaning outside the input stream.

15:22:23 <PhUrl> i see

15:22:34 <PhUrl> i would like to use the bnode i think

15:22:57 <PhUrl> beccause the ID is just a node created by graph traversal of the AST from the compiler

15:23:06 <PhUrl> and has no meaning outside of the document

15:23:40 <timbl> Ok, that makes sense.

15:23:55 <timbl> But I don't see why cwm wouldn't work if you gave it a URI.

15:23:59 <PhUrl> i want to throw away the id-NNNN nodes, and treat them as [ :predicate :object] like objects

15:24:07 <PhUrl> let me make a simple test

15:24:43 <timbl> Ok

15:26:48 <PhUrl> @prefix : <#> .:id-1 :next :id-2.:id-2 :next :id-3. # bad

15:26:48 <PhUrl> _:id-1 :next _:id-2._:id-2 :next _:id-3. # good

15:26:56 <PhUrl> i guess it is just the _ in front

15:27:02 <PhUrl> that makes it work

15:27:29 <PhUrl> "[ :next [ :next [ ] ] ]. " is produced on the second line

15:27:44 <PhUrl> by the second line marked as # good

15:27:47 <PhUrl> that is what i want

15:28:05 <PhUrl> so, now i just have to figure out how to emit objects like that from redland

15:28:12 <PhUrl> via the c interface

15:33:54 <PhUrl> rapper accepts _:aaid_1 but not _:aid_1 or _:aid-2, cwm -ntriples takes all of them

15:34:00 <PhUrl> happy new year dajobe

15:34:15 <PhUrl> err

15:34:29 <PhUrl> rapper accepts _:genid2

15:34:35 <PhUrl> as ntriples

15:34:43 <timbl> but not?

15:34:52 <dajobe> hello

15:35:27 <PhUrl> rapper accepts _:genid1 but not _:aid_1 or _:aid-2, cwm -ntriples takes all of them

15:35:39 <dajobe> ntriples doesn't allow - since cwm doe different things with -, depending on some things I forget

15:35:51 <PhUrl> but even _

15:36:12 <dajobe> just don't use it, move on, maybe?

15:36:28 <timbl> I thought everything accepts _

15:36:36 <timbl> in a name

15:37:03 <dajobe> _:aid_1 should be ok

15:37:22 <crschmidt> rapper: Error - URI http://crschmidt.net/:1 column 6 - Missing whitespace after term 'aaid'

15:37:44 <dajobe> hey, a bug

15:38:30 <PhUrl> ok, so i wonder how to create such objects via the redland c interface?

15:39:09 <dajobe> ask again after you've read the documentation and examples

15:39:17 <PhUrl> rtfm, fair enough

15:39:53 <sbp> [[[

15:39:58 <sbp> nodeID ::= '_:' name

15:40:02 <sbp> name ::= [A-Za-z][A-Za-z0-9]*

15:40:07 <sbp> ]]] - http://www.w3.org/TR/rdf-testcases/#ntrip_grammar

15:40:19 <sbp> so you can use neither - nor _ as nodeID labels in N-Triples

15:40:27 <PhUrl> ahh

15:41:01 <PhUrl> _:aid1 <file:test-cwm.n3#next> _:aid2 . works

15:41:05 <PhUrl> great

15:41:50 <dajobe> turtle allows more

15:42:22 <sbp> of course

15:43:36 <PhUrl> librdf_new_node_from_blank_identifier

15:43:52 <PhUrl> ahh, that is what a bnode is, a blank node! doh

15:43:56 <crschmidt> aka RDF.Node(blank="")

15:44:27 * crschmidt pets his pretty Python

15:44:33 <PhUrl> well, i am using the c interface

15:44:41 <PhUrl> but great

15:44:48 <PhUrl> thanks all for the help

15:46:21 <PhUrl> now, let me see what happens when i feed pychinko 13 megs of n3 to chew on

15:55:17 <Arnia> crschmidt: For a perl guy, you've taken to python well :)

16:03:01 <PhUrl> i am agnostic

16:03:16 <PhUrl> the best tools are to be used for the job

16:04:36 <Arnia> You seem pretty religious about C

16:05:03 <PhUrl> i am not religious at all. i dont believe in anything execpt to question beliefs.

16:05:32 <PhUrl> but c is very pratical. It is just the question of ROI

16:05:40 <PhUrl> how can I gain access to the resources i need

16:06:00 <PhUrl> most programming resources are predicated on c

16:06:18 <PhUrl> so if you can master c, you can use them.

16:06:43 <PhUrl> even mono is written in c in the core, python and perl as well

16:07:01 <PhUrl> so even if you have a bootstrap, the first level will be something portable

16:07:18 <PhUrl> and the compiler is the first thing to be ported to a new platform

16:07:23 <PhUrl> the c compiler

16:09:07 <Arnia> Hm... I find C tedious :)

16:09:09 <PhUrl> Arnia: I think that if you get to know me better, you will find that I am quite rational and reasonable.

16:09:17 <PhUrl> yes, it is very tedious

16:09:22 <PhUrl> if you program it normally

16:09:39 <PhUrl> but that is why i want to have the introspector

16:09:57 <PhUrl> so that i can automatically read and write c via nice high level macros

16:10:09 <PhUrl> without being bound to a platform

16:10:18 <PhUrl> or losing in flexibility

16:10:39 <PhUrl> if you can process and reason about c in any rdf enabled tool,

16:10:48 <PhUrl> then you can eliminate the tediousness

16:10:56 <PhUrl> using the tools of your choice

16:11:39 <PhUrl> what is perl but a collection of c routines and some sytax sugar on top?

16:11:50 <PhUrl> syntax

16:11:55 <bparsia> 13 megs. Hmm.

16:11:57 <Arnia> So, what you're looking to do is model a turing machine? :p

16:12:02 <PhUrl> no

16:12:10 <Arnia> A bit computationally expensive is it not

16:12:24 <PhUrl> i want to reason about the program

16:12:25 <Arnia> bparsia: 13 megs?

16:12:44 <bparsia> <PhUrl>now, let me see what happens when i feed pychinko 13 megs of n3 to chew on

16:12:45 <PhUrl> i have extract 13 megs of n3 from the pnet

16:12:45 <Arnia> PhUrl: Which is how expensive?

16:12:58 <PhUrl> well it depends

16:13:09 <PhUrl> lets say you want to find all the users of the function

16:13:17 <bparsia> PhUrl...how many triples?

16:13:23 <PhUrl> hold

16:13:28 <bparsia> Roughly?

16:14:02 <PhUrl> wc : 321970 636028 12508857 cwm2.n3

16:14:11 <PhUrl> 300k

16:14:15 <bparsia> Oh

16:14:27 <bparsia> Should be ok

16:14:28 <PhUrl> that is just one file

16:14:30 <bparsia> Depending ont eh rules

16:14:41 <bparsia> I.e., how well distributed they are.

16:14:44 <PhUrl> well, i just want to have a cwm like pretty output

16:14:46 <PhUrl> no rules

16:14:54 <bparsia> Ah.

16:15:02 <bparsia> Then you aren't really usign pychinko, but rdflib?

16:15:04 <PhUrl> i have lots of statements like _:a :goo _:b

16:15:22 <PhUrl> and then _:b :hoo _:c

16:15:47 <PhUrl> i want to resolve that to [ :goo [ :hoo [] ] ]

16:16:04 <PhUrl> well, if it can to that, i have lots of rules

16:16:09 <bparsia> You mean serialize it?

16:16:21 <PhUrl> serialize it, but in a pretty way

16:16:27 <bparsia> Hmm.

16:16:35 <PhUrl> like cwm

16:16:47 <bparsia> WEll, pychinko proper is the rete engine,s o doesn't have a serializer

16:16:51 <PhUrl> ok

16:16:53 <bparsia> rdflib has some serializers

16:16:58 <PhUrl> well,find

16:16:59 <PhUrl> fine

16:17:08 <PhUrl> i have lots of rules written for cwm

16:17:11 <PhUrl> that i can port and test

16:17:14 <bparsia> But they got a bit flaky in the last version. A more recent one might work

16:17:19 <PhUrl> i just need something that is effienct

16:17:21 <dajobe> this is a lot of work for a pretty printer...

16:17:25 <bparsia> bparsia is now known as bijan

16:17:28 <bijan> Yes

16:17:39 <PhUrl> when i traced cwm, it spent lots of time parsing

16:17:51 <timbl> cwm's pretty serializer is designed to be pretty, but i s*not* designed for large quantitites ... may not be anything like linear in store size.

16:17:53 <PhUrl> it would be great to just not have to parse the document over and over

16:18:06 <PhUrl> i understand

16:18:23 <bijan> Er...if you have it in ntriples...that's likely to be the best for parsing and serializing :)

16:18:29 <bijan> Doesn't get much easier than that!

16:18:33 <PhUrl> i have it in redland db

16:18:41 <PhUrl> in a redland db

16:18:48 <crschmidt> why do you want it pretty printed, exactly?

16:18:50 * bijan off

16:19:25 <PhUrl> crschmidt: because the pretty format contains the structure of the c program

16:19:39 * sbp wonders how much faster, if at all, an N-Triples parser would be bolted onto CWM instead of the N3 parser

16:19:48 <sbp> then you could do cwm --nt input.nt --n3

16:19:57 <PhUrl> i just want cwm to use redland db via redland python

16:20:15 <PhUrl> or pychinko for that matter

16:20:16 <crschmidt> PhUrl: Well, the way it's printed doesn't matter though, right?

16:20:17 <timbl> Yosi has been hacking a the parsing inefficiencies .. but as a lot of them were python doing things with sequences which should logically have been sets, we didn't push it till after 1.0 (ie now) when we will assume python2.3 and set support

16:20:52 <sbp> don't forget that builtin sets are much faster

16:21:05 <PhUrl> I dont just want to serialize

16:21:12 <PhUrl> but that is the first thing i do

16:21:17 <PhUrl> i extract from c to redland

16:21:30 <PhUrl> redland to ntriples via rdfproc

16:21:39 <PhUrl> and then into something readable via cwm

16:21:46 <crschmidt> why does it need to be readable?

16:21:50 <PhUrl> now that i have figured out these bnodes

16:22:02 <PhUrl> the cwm output it really really nice

16:22:08 <PhUrl> crschmidt: let me show you

16:22:25 <crschmidt> I understand the difference between what pretty looks like and what not pretty looks like.

16:22:26 <sbp> crschmidt: I often pass documents of all kinds (N-Triples, RDF/XML, and duff N3) through CWM to get a readable serialisation

16:22:52 <crschmidt> sbp: I do that for testing, and for getting it straight in my head, but i can't keep 13 meg of ntriples straight in my head anyway :)

16:23:09 <sbp> yeah. I'd probably try to --filter the bits out thaht I want to read first

16:23:16 <PhUrl> crschmidt: let be put it this way

16:23:25 <crschmidt> also, it seems like PhUrl wants something that is "more pretty" than cwm...

16:23:31 <PhUrl> no

16:23:32 <crschmidt> Or am I misunderstanding, phurl?

16:23:39 <PhUrl> i just want cwm to use redland db

16:23:40 <crschmidt> Oh, you just want something that can pretty print quicker?

16:23:42 <PhUrl> and be faster

16:23:46 <PhUrl> no

16:23:49 <PhUrl> cwm is fine

16:23:54 <PhUrl> just a bit to slow

16:23:55 <PhUrl> that is all

16:23:57 <crschmidt> Ah

16:24:06 <crschmidt> i'll drink to that :)

16:24:07 <PhUrl> i have rules and filters for cwm

16:24:16 <PhUrl> and it is easy to use

16:24:17 <timbl> I see we have a need for some integration work.

16:24:19 <PhUrl> and works

16:24:19 * crschmidt spent 137 hours pretty printing an rdf/xml serialization at one point

16:24:32 <PhUrl> i dont want to learn new tools

16:24:41 <PhUrl> and figure out how to install new libs

16:25:05 <PhUrl> you may ask why i look at these 13 mbs?

16:25:14 <crschmidt> nah

16:25:17 <PhUrl> normally i write my queries by hand

16:25:19 <crschmidt> i understand that.

16:25:28 <PhUrl> so i extract the needed data manually

16:25:35 <PhUrl> then generalize it into a rule

16:26:37 <PhUrl> what i think is great is this dbus idea

16:26:47 <PhUrl> i would buy 1gb of ram

16:26:50 <PhUrl> more

16:26:59 <PhUrl> if i could store the entire doc in an array

16:27:08 <PhUrl> and have cwm operate on that

16:27:21 <PhUrl> without have to re-read the darn thing

16:27:44 <PhUrl> an in-memory db with a server like interface would be great

16:27:53 <PhUrl> and if i could interface to it via redland

16:27:55 <PhUrl> even better

16:28:14 <PhUrl> i was thinking about a DBUS storage backend for redland

16:28:25 <PhUrl> that you would just attach to some service point

16:28:34 <PhUrl> and load it up

16:30:21 <Arnia> PhUrl: I think you've misunderstood me

16:31:05 <PhUrl> Arnia: that is possible :)

16:31:13 <PhUrl> very very likely

16:31:46 <PhUrl> but i know that i have wanted a shared memory interface to redland

16:31:54 <PhUrl> for a long time

16:32:26 <Arnia> PhUrl: First of all, DBUS is not a novel idea. Its already used a lot by various applications. Secondly, the idea is to expose a graph over DBUS rather than allow redland to use DBUS as a backing store. Thirdly, DBUS isn't about shared memory

16:33:19 <PhUrl> well, redland provides an interface

16:33:27 <PhUrl> you could have two instances of redland :

16:33:35 <PhUrl> a client and server

16:33:50 <PhUrl> the client would have a dbus storeage that connects to the server

16:33:52 <dajobe> that's not what dbus is primarily for

16:33:58 <PhUrl> the server would use another storage

16:34:03 <PhUrl> to hold the data

16:34:12 <Arnia> I'm using DBUS to provide an exceptionally lightweight system

16:34:16 <PhUrl> ok, maybe i have not understood dbus

16:34:21 <PhUrl> i just want

16:34:22 <Arnia> That is a very important design requirement

16:34:29 <PhUrl> 1. to not have to change my code

16:34:45 <PhUrl> 2. to be able to keep a rdf store in memory

16:35:07 <dajobe> you seem to have lots of wants

16:35:09 <PhUrl> 3. to be able to connect to that store via an addressing system

16:35:23 <PhUrl> dajobe: yes, and i will implement them when i get around to it

16:35:37 <PhUrl> i have built multi processing stuff before

16:35:52 <PhUrl> and a shared memory storage backend would be easy

16:40:46 <Arnia> PhUrl: Are these wants motivated by a common set of use-cases?

16:41:26 <PhUrl> it is important to have a vision, in the end a graph can be represented as a matrix. if you look at high performance matrixs, you will find ScaLAPACK. If you had a salapack backend for redland, then you would have a distributed and high perfomance storage.

16:42:01 <PhUrl> arnia, the use case is the semantic web, making tools that just work

16:42:02 <Arnia> Can that cope with a matrix that changes size many many many times?

16:42:23 <PhUrl> i dont care about changes in size after a certain point

16:42:42 <PhUrl> i want to be able to freeze an graph into an ICE CUBE

16:42:54 <Arnia> PhUrl: Ah forgive me, my lack of vision must be stopping me see how these ideas fit together with that goal

16:42:55 <PhUrl> i have a protoype of that already

16:43:06 <PhUrl> the goal is just to make cwm scalable

16:43:09 <Arnia> Why on earth do you wish to remove the dynamism from a graph

16:43:20 <PhUrl> for some documents, they done change

16:43:23 <Arnia> That's hardly a semwebby thing to do, is it?

16:43:27 <PhUrl> they can be cached

16:43:45 <PhUrl> an optimizer needs to know what data is changable

16:43:49 <PhUrl> and what can be optimized

16:44:02 <PhUrl> some data is constant

16:44:08 <Arnia> So you want a graph that is huge, frozen and dynamic all at the same time?

16:44:16 <PhUrl> or read only for a context

16:44:18 <PhUrl> no

16:44:27 <PhUrl> i want to be able to freeze a graph

16:44:35 <PhUrl> and make read access to it fast

16:44:45 <Arnia> And when the graph changes?

16:44:54 <Arnia> As it will do fairly rapidly I believe

16:45:04 <PhUrl> then i have a standard graph

16:45:12 <PhUrl> that has to be frozen again

16:45:48 <PhUrl> that is why redland has different storages

16:46:16 <PhUrl> i can imagine a redland storage called freezer that is write once read many

16:46:30 <PhUrl> you could burn a snapshot of the semweb to a dvd

16:46:41 * Arnia blinks thrice fast

16:47:06 <PhUrl> a snapshot of lets say 4 gb of red

16:47:07 <PhUrl> rdf

16:47:11 <PhUrl> to a dvd

16:47:25 <PhUrl> and then distribute that for processing to many computers

16:47:36 <PhUrl> i am assuming that some processing will need to be distributed

16:47:42 <Arnia> Yes, I know what you mean. I'm just not seeing its practicality -- a solution looking for a problem as they say

16:47:45 <PhUrl> i know that my app needs that

16:48:11 <PhUrl> Arnia: well, you lack my experience in dealning with huge datasets

16:48:32 <PhUrl> when i was working for worldcom for 7 years, building billing and telcoms apps

16:48:40 <PhUrl> i had datasets of massive size

16:49:07 <PhUrl> they would be however good applications of the tools for the semantic web

16:49:19 <PhUrl> but you need to have tools that can deal with GBs of data

16:49:23 <PhUrl> it is that simple

16:49:37 <Arnia> yes, but not EVERY tool needs to deal with GBs of data

16:49:39 <PhUrl> and large data sets need to consider things like caches, distribution

16:49:52 <PhUrl> well, i specialize in large data sets

16:50:08 <Arnia> In fact, for most use cases a frozen graph is bad... because people want dynamism

16:50:08 <PhUrl> and want to push the limits of the semantic web to handle them

16:50:26 <PhUrl> right now, i see that we have google indexing 8 billion pages

16:50:50 <PhUrl> and we have a web that is expanding faster than can be indexed

16:51:07 <PhUrl> if you just look at the 10x expansion in size of the introspector data

16:51:21 <PhUrl> from source code to rdf graph, the size goes up 40x

16:51:32 <PhUrl> so, i need tools that will be able to deal with that much data

16:51:39 <PhUrl> to make the introspector feasable

16:51:45 <PhUrl> so do the bioinformatics people

16:51:58 <PhUrl> and so would a anti spam database

16:52:07 <PhUrl> or a web of trust

16:52:13 <PhUrl> or any real application

16:52:13 <Arnia> Ok... so remind me, what project are you working on? Can you express your goals as a pithy 'mission statement'

16:52:17 <PhUrl> of any size

16:52:28 <Arnia> I don't think 'any' real application needs frozen graphs etc

16:52:36 <PhUrl> Arnia: i don give a **** if you understand it or not

16:52:43 <Arnia> That is overstating your case

16:52:46 <PhUrl> we keep on going over the same ground

16:52:51 <PhUrl> and wasting time

16:52:56 <PhUrl> PhUrl is now known as md-afk

16:56:44 <kao_home_> kao_home_ is now known as kao_home

20:08:07 <bballizlife_> bballizlife_ is now known as bballizlife

21:47:19 <DanC> trying to organize some videos...

21:47:27 <DanC> scanned a few UPC codes with cuecat...

21:47:37 <DanC> tried to map to title, year-of-release

21:47:42 <DanC> turns out to be messy

21:50:15 <JibberJim> Have you got the UPC codes there?

21:50:27 <JibberJim> I have a large DB of them locally...

22:08:48 * DanC is making progress, using a combination of http://www.upcdatabase.com/item.pl?upc=085391257134 and imdb

22:09:08 <DanC> and some a *really* q&n xml/xpath implementation

22:09:12 <DanC> q&d

22:10:20 <DanC> aha! I'm winning.

22:10:36 <dajobe> q&n?

22:10:53 <DanC> quick n dirty

22:11:00 <DanC> def tags(markup):

22:11:00 <DanC> """quick-n-dirty XML parser

22:11:00 <DanC> """

22:11:00 <DanC> for tag in markup.split(">"):

22:11:00 <DanC> yield tag

22:11:28 <dajobe> I wonder how long it takes to write a complete xml parser. I'd say a few years...

22:11:44 <DanC> I could import libxml2

22:12:04 <DanC> but that 2 line xml parser actually works for this app, and it's quicker than looking up the libxml2 api docs

22:20:14 * DanC must dash... darn; just when I was winning...

22:22:24 <sbp> I wrote a really small non-validating XML parser once

22:23:21 <sbp> http://infomesh.net/200X/xmlsimple.py.txt

22:23:31 <sbp> it would indeed take years to make a good validating one