IRC log of swhack on 2002-04-20

Timestamps are in UTC.

00:02:38 [AaronSw]
Ooh, someone has "The Ultimate Experinece" online
00:03:30 [Morbus]
only 3 more hours on these fonts. yay.
00:04:01 [AaronSw]
let me know if you get them to work
00:04:24 [Morbus]
you didn't get any of em working?
00:04:39 [AaronSw]
I sorta stopped after I had that big computer mess.
00:04:42 [AaronSw]
Went to work on other things.
00:04:57 [AaronSw]
became a carpenter
00:05:04 [sbp]
lol
00:05:13 [sbp]
aaah, in-jokes
00:05:20 [AaronSw]
(semi-serious, actually. we're putting shelves in Ben's room today.)
00:05:29 [sbp]
iOoh
00:06:13 [AaronSw]
Heh, iOoh. What happens at Apple conferences.
00:06:43 [sbp]
heh, heh
00:07:49 [sbp]
sbp has changed the topic to: In Japan, they call him Bath-Toy-Morbus-Man
00:08:37 [tomch]
tomch has quit (Read error: 104 (Connection reset by peer))
00:09:01 [sbp]
Hmm... that's one of my crummier topics, but the original joke was just hillarious
00:09:09 [tomch]
tomch (~lambda@modem-2965.monkey.dialup.pol.co.uk) has joined #swhack
00:11:27 [AaronSw]
ooh, Hey Joe is on a weirdal polka session
00:12:34 [sbp]
I like the "Happening for Lulu" version
00:12:57 [sbp]
Hendrix was so sick of playing it by then :-)
00:13:08 [AaronSw]
Weird Al plays it much faster, tho
00:13:11 [AaronSw]
<tav`> remind me never to trust you
00:13:38 [sbp]
heh. not quite sure how you can compare the two...
00:14:37 [walloper]
<lilo> Hi all. Can anyone suggest where a copy of the copyright-expired version of _Robert's Rules of Order_ can be found? The Gutenberg Project does not yet appear to have it. Please /msg lilo. Thanks.
00:14:44 [sbp]
if you really want to listen to a good Hendrix cover...
00:14:52 [sbp]
... try SRV's Little Wing
00:16:01 [AaronSw]
SRV's?
00:16:31 [sbp]
Stevie Ray Vaughan
00:18:04 [sbp]
heh: http://www.esmerel.com/wagons/rob/rules.html
00:20:12 [AaronSw]
ooh, lilo's gonna credit me for finding it
00:20:28 [sbp]
argh, where did you find it?
00:20:48 [Morbus]
* Morbus prints out some gamegrene.com advertisements for a gaming con tomorrow.
00:22:26 [walloper]
<lilo> thanks to aq and AaronSw for coming up with them so swiftly, and CMHunter and aq and sbp and hicham and others for trying so hard :) appreciated everybody
00:22:35 [AaronSw]
Heh, heh.
00:22:58 [sbp]
*chuckle*
00:23:03 [Morbus]
whooo
00:23:14 [sbp]
so come on now, what's the answer? :-)
00:23:33 [AaronSw]
With ads: http://www.bartleby.com/176/
00:23:42 [AaronSw]
sans ads: http://www.constitution.org/rror/rror--00.htm
00:24:10 [sbp]
ah, I gave him the Bartleby one
00:24:21 [AaronSw]
I gave him the constitution.org one
00:24:32 [sbp]
didn't try the c.org one - stupid, stupid, stupid!
00:25:07 [sbp]
ha!: "However, the modifications and enhancements to this work are Copyright © 1996 Constitution Society."
00:25:17 [AaronSw]
but the modifications aren't on that page
00:25:27 [AaronSw]
lilo and i went over this already
00:25:42 [AaronSw]
"Robert's Rules of Order Revised by General Henry M. Robert 1915 Version, Public Domain"
00:25:49 [AaronSw]
i think they're just copying the htmlization
00:26:04 [sbp]
Hmm... but the modifications are in that work, right?
00:27:54 [AaronSw]
* AaronSw plays that vaughn version
00:28:09 [AaronSw]
EOW fast approaches
00:29:02 [AaronSw]
FAQs for my IRC style guide:
00:29:09 [AaronSw]
Q: Isn't this the most pointless document in the world?
00:29:15 [AaronSw]
A: No, that's the N3 style guide.
00:29:23 [AaronSw]
Q: How come you violate these rules?
00:29:40 [AaronSw]
A: When I volate them it's for experimentation and research. When you violate them it's out of ignorance.
00:32:28 [AaronSw]
rules: no channel name in topic. do /me right.
00:32:39 [AaronSw]
name, not :
00:33:06 [AaronSw]
all-caps, colors and bold are <blink><b>ANNOYING</></>
00:34:02 [AaronSw]
bye all
00:34:05 [AaronSw]
[EOW]
00:34:11 [sbp]
c'ya
00:34:48 [sbp]
nice style guide :-)
00:39:22 [GabeW]
GabeW (~Gabe@12-236-237-100.client.attbi.com) has joined #swhack
00:42:58 [Morbus]
2 more hours on the fonts! <G>
00:43:29 [sbp]
heh, heh
00:44:11 [Morbus]
i'm wondering if i should go with suitcase or not.
00:44:11 [Morbus]
i like doing my own handling.
00:44:38 [sbp]
I'm sure that you do
00:44:58 [Ash_]
<Morbus> That way the smallpox viruses get into the plane cabin intact
00:45:04 [Morbus]
i just hope it allows me a decent amount of control.
00:45:44 [sbp]
sbp has changed the topic to: One hour and fifty-eight minutes to go on the fonts!
00:46:26 [Morbus]
one hour and fifty eight minutes?
00:46:26 [Morbus]
oh right. <G>
00:47:25 [Ash_]
AARONSW WHAT DO U MEAN THAT ALL CAPS4%AREC45ANNOYING???
00:47:34 [Ash_]
eheh
00:47:44 [Ash_]
xchat colors suck
00:48:11 [GabeW]
3C4OLORS 8ARE 13COOL
00:48:20 [GabeW]
yeah, kinda of a pain
00:48:45 [Ash_]
mIRC does them so much better.
00:48:59 [Ash_]
3WOO 4HOO
00:49:16 [GabeW]
woowo
00:49:28 [GabeW]
I'm so important
00:52:47 [walloper]
<lilo> Arrgh. On close inspection, every single one of these urls seems to be to the Constitution Society's version, which is under a copyright and a (mildly) restrictive license. 8)
00:53:26 [walloper]
<lilo> If anyone knows where I can find a copy of the 1915 Public Domain version of Robert's Rules of Order, without 'Revised' on it, let me know 8)
00:53:33 [Ash_]
lilo sucks
00:53:37 [Ash_]
die scumbag
00:53:46 [Ash_]
Ash_ has changed the topic to: http://lilofree.net
00:53:49 [walloper]
<lilo> Regardless, thanks to everyone for their help!
00:53:51 [walloper]
<lilo> This is a WALLOPS message for the Open Projects Network. These messages contain non-critical comments and announcements and detailed server admin information. To turn them off, turn off user mode 'w'. On most clients: '/mode <yournick> -w'. Thanks.
00:53:55 [sbp]
heh, I feel a KLINE coming on for Ash...
00:54:14 [sbp]
Hmm... http://www.google.com/search?q=%22Robert%27s+Rules%22+-revised
00:54:36 [Ash_]
Ash_ has changed the topic to: http://lilofree.net/ || <lilo> O NOE I DNOT KNOW HOW TO UES TEH GOOGAL!@%$
00:54:48 [Ash_]
sbp: nope
00:55:22 [sbp]
ooh, that's gonna get #swhack obliterated from TEH face of OPN
00:56:27 [Ash_]
Ash_ has changed the topic to: http://www.lilofree.net/ || <lilo> O NOE I DNOT KNOW HOW TO UES TEH GOOGAL!@%$
00:58:46 [tomch]
Will somebody explain why I actually find that quite amusing?
00:59:20 [Ash_]
tomch: What's quite amusing?
00:59:44 [tomch]
Ash_: Ash_.
00:59:55 [Ash_]
Hmm.
00:59:56 [Ash_]
Dunno.
01:01:11 [Morbus]
[[[
01:01:11 [Morbus]
[8:56] <ply> one more thing.. when i send an email out from my workstation, is there a way to remove the workstation name from the email address?
01:01:11 [Morbus]
[8:56] <ply> ie.. the name is always ply@system1.domain.com.. i want to be ply@domain.com
01:01:12 [Morbus]
[8:58] <Server> ply has left the channel
01:01:12 [Morbus]
[9:00] <Morbus> yeah.
01:01:13 [Morbus]
[9:00] <Morbus> but you were impatient.
01:01:17 [Morbus]
[9:00] <Morbus> bitch.
01:01:17 [Morbus]
[9:00] <Morbus> i got me laundry and me dishes, f00.
01:01:19 [Morbus]
[9:01] <Morbus> woo.
01:01:23 [Morbus]
]]]
01:01:23 [Morbus]
- #sendmail
01:08:41 [oierw`]
oierw` (~mathew@pcp994425pcs.goosck01.sc.comcast.net) has joined #swhack
01:10:10 [Ash_]
Ash_ has quit ("hail satan")
01:10:21 [sbp]
.google "* +"
01:10:21 [xena]
no results found.
01:13:31 [tomch]
hehe
01:15:13 [Morbus]
28.7 of 61.3
01:15:13 [Morbus]
man oh man
01:15:16 [Morbus]
;)
01:15:52 [Morbus]
oierw` (~mathew@pcp994425pcs.goosck01.sc.comcast.net)
01:15:52 [Morbus]
goosck01?
01:15:58 [Morbus]
you mean, there's more than one cock on your goose?
01:16:12 [Morbus]
i didn't think roosters and geese could mate, let alone orgy
01:26:23 [oierw]
oierw has quit (Read error: 110 (Connection timed out))
01:27:08 [oierw`]
oierw` has quit (Read error: 104 (Connection reset by peer))
01:28:15 [oierw`]
oierw` (~mathew@pcp994425pcs.goosck01.sc.comcast.net) has joined #swhack
01:31:05 [Morbus]
half done the fonts. whoo!
01:33:27 [tomch]
:)
01:33:49 [tomch]
*hmm*
01:33:59 [tomch]
9 minuites ahread of schedule
01:34:08 [sbp]
heh, heh
01:34:15 [sbp]
not that he's counting
01:34:20 [tomch]
re-assessment time
01:34:21 [tomch]
:-)
01:41:49 [GabeW]
GabeW has quit ("Client Exiting")
02:08:00 [Morbus]
Morbus has quit (No route to host)
02:09:27 [tomch]
tomch has quit (Read error: 104 (Connection reset by peer))
02:09:52 [tomch]
tomch (~lambda@modem-2965.monkey.dialup.pol.co.uk) has joined #swhack
02:12:35 [oierw`]
wow. these things are loud :p
02:12:42 [oierw`]
* oierw` is in the wrong channel
02:12:45 [oierw`]
*oops*
02:16:37 [sbp]
heh
02:41:18 [sbp]
Gotta run
02:44:22 [tomch]
tomch has quit ("()")
13:58:30 [sbp]
* sbp waves
16:18:55 [tomch]
tomch (~lambda@modem-3736.panther.dialup.pol.co.uk) has joined #swhack
16:52:55 [oierw`]
hello sbp
16:53:55 [oierw`]
how am i mysterious?
17:16:58 [sbp]
You're the mysterious oierw¬
17:17:06 [oierw`]
oierw` is now known as oierw
17:17:12 [sbp]
s/¬/!/
17:17:16 [oierw]
i understand i'm the mysterious oierw
17:17:20 [oierw]
but what makes me mysterious?
17:17:34 [sbp]
your mysteriousness makes you mysterious :-)
17:17:46 [sbp]
heh, actually, I know more about you than most of the other lurkers in here
17:18:08 [oierw]
yes, you do :)
17:18:19 [oierw]
you've seen me think
17:18:29 [sbp]
heh, heh. Quite scary
17:18:59 [sbp]
actually, only deus_x and eikeon are really quiet in here
17:19:20 [sbp]
oh, and tansaku
17:19:41 [sbp]
* sbp wonders why talli has named himself "barstool"
17:19:51 [sbp]
is he waiting for someone to sit on him?
17:19:53 [tomch]
tomch has quit (Killed (NickServ (Ghost: thc!~lambda@modem-3519.porcupine.dialup.pol.co.uk)))
17:20:22 [tomch]
tomch (~lambda@modem-3519.porcupine.dialup.pol.co.uk) has joined #swhack
17:40:36 [Seth]
Seth (~seth@12-230-243-179.client.attbi.com) has joined #swhack
17:41:51 [sbp]
.google Guido Python Style Guide
17:41:52 [xena]
Guido Python Style Guide: http://www.python.org/doc/essays/styleguide.html
17:42:34 [sbp]
Hey Seth. How's the API coming along?
17:44:11 [Seth]
fairly well ... slowley but it's looking good ... has a solid theoritical background
17:44:39 [Seth]
but im still at the 'hello world' level as far as function
17:44:50 [sbp]
cool
17:45:00 [sbp]
will the source be publically available etc.? CVS?
17:45:31 [Seth]
yep ... its will be opensource python code ... ill probably get a sourcefourge .. or what would you recommend?
17:46:25 [sbp]
Hmm... I haven't used CVS personally for any of the APIs that I've worked on, but it's probably a good thing if you can find an account. As for using SF, they've been having a few problems lately, and I don't know if I'd bother with the registration etc. personally
17:47:23 [Seth]
hmmm ... well what would you recommend ... the w3c stuff is not avail to me i dont think
17:47:48 [sbp]
Well, for Eep, I just made the files and a .tar.gz available
17:48:04 [sbp]
i.e. just bunged the whole lot into a publically readable directory
17:48:37 [Seth]
but how can you get others to contribute .. that, of course, is my real motive for publishing the source code
17:48:58 [sbp]
well, you say "yo, Fred, come help me on my code!"
17:49:10 [sbp]
I see your point about CVS making it easier
17:49:18 [Seth]
hmmm... yeah guess that would work
17:49:35 [sbp]
but if you had an SF account, I wouldn't go to the trouble of signing up just to help :-)
17:50:18 [Seth]
is it a whole lot of trouble to sign up at SF ?
17:50:58 [sbp]
dunno; but any trouble is too much trouble, and last time I signed up I wasn't too impressed
17:51:02 [sbp]
things may have changed since then
17:51:18 [sbp]
it wasn't too bad, but I just don't like registration procedures for working on code
17:52:31 [Seth]
i see .. well i would make an exception then and just had deliver the code to your mailbox
17:52:40 [Seth]
had=hand
17:53:05 [sbp]
well, there's nothing to stop you from putting it in SF CVS and on another site, AFAIK
17:53:15 [sbp]
so perhaps that's the best solution - the best of both worlds
17:54:49 [Seth]
the methods are going to be stuff like http://robustai.net/mentography/methods1.html
17:55:43 [Seth]
though for 'gress' im thinking of just calling it 'nextArrow' ... so people dont need to learn my goofy names
17:55:48 [sbp]
heh, this is going to take some reading :-)
17:56:02 [Seth]
sean, it's real dumb simple
17:56:21 [Seth]
ever played with turtle graphics?
17:56:49 [sbp]
yeah, ages and ages ago
17:57:21 [Seth]
so you move a turtle around a space with commands .. go forward 2 .. turn 180 .. stuff like that
17:57:38 [sbp]
yep, I recall
17:57:51 [Seth]
with this api you move a turtle (called the attention pointer) around the fabric of arrows and nodes
17:58:01 [sbp]
ah, neat
17:58:20 [Seth]
on thing about it is that you can never get the turtule off of the graph ... its closed :))
17:58:44 [sbp]
will it be able to do the equivalent of log:semantics to suck in other graphs?
17:59:26 [Seth]
the api will come with the ability to read and write Semenglish and xml\rdf ... thoese make new graphs
17:59:37 [sbp]
actually, apologies, but I have to go. I'll be back in about an hour
17:59:53 [Seth]
well thanks for the interest :))
18:03:45 [tomch]
tomch has quit (Read error: 110 (Connection timed out))
18:28:20 [Seth]
Seth has quit ()
18:35:11 [Seth]
Seth (~seth@12-230-243-179.client.attbi.com) has joined #swhack
19:04:42 [sbp]
* sbp waves
19:05:47 [sbp]
for "first arc", do you mean the first predicate in alphabetical order of the URIs?
19:05:53 [sbp]
and what about bNode labels?
19:06:12 [sbp]
I guess all will be clear when the API's online :-)
19:07:26 [Seth]
actually yes .. but im not sure whether the sequence will be alphabetical ... might just be the order that the predicate labels were defined in the system ... but one could sort those and give them new id, making them almost alphabetic
19:08:19 [sbp]
cool. how many of the jace/vance/gress/sym methods have you currently implemented?
19:08:58 [sbp]
and what other capibilities will it have? will it be able to: read NTriples/Notation3/SemEnglish, XML RDF etc., query, infer, implement builtins, merge documents?
19:09:29 [Seth]
well the implementation of some of these are gonna be but simple ... those you mention are just adding something to the indexes
19:10:10 [Seth]
i keep rewriting the code ... just started again this morning ... my fingers are still very far behind
19:10:36 [Seth]
if you want it to read n3, you might need to implement that yourself
19:10:45 [sbp]
would it be possible to look at what you've done already?
19:10:59 [sbp]
in return, I'll send you another RDF API that I started hacking on this morning (if you like)
19:11:24 [Seth]
maybe tomorrow .. id be embarassed to show it now
19:11:29 [sbp]
:-)
19:12:04 [sbp]
I find that every time I write an RDF API, the design gets better
19:12:28 [Seth]
good .. thats the way its supposed to be
19:12:32 [sbp]
but your approach seems different to the others: somewhat akin to traversing XML documents through the DOM
19:13:01 [Seth]
actually this api is something that i wrote about 20 years ago on the apple-ii in 6502 machine language ...
19:13:22 [Seth]
i just recently convinced myself that it is but simple to do it now in python ... i love python :)
19:13:30 [sbp]
heh, me too :-)
19:13:42 [sbp]
20 years ago? wow, talk about previous art
19:14:07 [sbp]
do you still have the files for the original?
19:14:38 [sbp]
* sbp has heard the old Apple][ mentioned quite a few times
19:14:41 [Seth]
makes it simple ... all the methods still work ... gress,vance, sym, jace, ment, say etc ... i just need to retrieve them from memory and translate them to the new python data structure
19:15:08 [sbp]
right
19:15:21 [Seth]
i got a 5 1/5 floppy that hasnt been read for 20 years and no apple ][ to read it on
19:15:21 [sbp]
I guess that you're storing things as quads?
19:15:28 [sbp]
are you using built in list structures, or some kind of class?
19:15:36 [sbp]
(or both)
19:15:54 [sbp]
ugh
19:16:19 [Seth]
(both)
19:16:27 [Seth]
mostly its all done in lists
19:16:33 [Seth]
and dictionaries
19:16:46 [Seth]
havent totally defined the class structure yet
19:16:53 [sbp]
cool - that's how I've just been doing it (subclassing UserList)
19:17:19 [Seth]
what is your UserList structure?
19:18:01 [sbp]
UserList is defined in the Python stdlib. it's just a wrapper for []
19:18:14 [sbp]
I can send you the code... hang on a sec.
19:18:38 [Seth]
i just go
19:18:43 [Seth]
graph=[]
19:19:03 [Seth]
then graph.append('g0')
19:19:16 [Seth]
graph.append([])
19:19:21 [Seth]
makes my first graph
19:19:45 [sbp]
* sbp sends
19:19:46 [Seth]
the identity of that graph is 'g0'
19:20:07 [Seth]
some day that will be an integer stead of a literal
19:20:22 [sbp]
right, well I subclass UserList, so I have class Store(UserList.UserList)
19:20:36 [sbp]
then I overwrote append so that it doesn't add a triple that's already in the store
19:20:42 [sbp]
and extend to use the new append
19:20:53 [sbp]
and now I'm adding some query and filtering functions
19:20:57 [sbp]
er.. methods, rather
19:21:21 [sbp]
anyway, the test is at the bottom of the code that I just sent you
19:22:11 [sbp]
I'm aiming for a very small but flexible API this time - not dependent on quads or triples
19:22:31 [sbp]
theoretically, Eep was triple oriented but could probably take a quad extension
19:22:46 [sbp]
(Eep was the API that I derived this new code from)
19:23:41 [Seth]
wow .. thanks .. looks like i can learn a lot from this
19:23:51 [sbp]
no problem
19:24:20 [Seth]
my structure might be a little more complex .. its designed to make the nagigating real fast and simple
19:24:24 [sbp]
I'll probably hook up the Yapps Notation3 parser to it...
19:24:50 [sbp]
Hmm... the pointer in your thing reminds me of Befunge :-)
19:25:16 [Seth]
.google Befunge
19:25:17 [xena]
Befunge: http://www.catseye.mb.ca/esoteric/befunge
19:25:20 [sbp]
if befunge was comprised of triples rather than little character functions
19:25:33 [sbp]
befunge is a 2 dimensional obfuscated programming language
19:26:02 [sbp]
that's just what the pointer thing reminds me of... that and the DOM
19:26:07 [sbp]
.google XML DOM
19:26:07 [xena]
XML DOM: http://www.w3.org/DOM
19:26:30 [sbp]
you might want to look at some of the methods in Python's DOM module
19:27:02 [sbp]
.google Python "xml.dom" site:python.org
19:27:02 [xena]
Python "xml.dom" site:python.org: http://www.python.org/doc/current/lib/module-xml.dom.html
19:27:49 [Seth]
i think its different
19:28:09 [sbp]
probably. I'm just engaging in free association :-)
19:28:22 [Seth]
with mentography you got an object called 'attention' that you just move around on a fabric
19:28:42 [Seth]
you dont need to process expressions that are returned by functions
19:29:33 [sbp]
right. in befunge though, you have the file pointer which moves about on the file... so that's a similarity, but of course the similarity ends there since a mentography is a set of triples, not functions :-)
19:29:44 [sbp]
so, what are you going to be doing with the API?
19:29:55 [sbp]
I mean, what taks will it be able to fulfill?
19:30:10 [sbp]
s/taks/tasks/
19:30:23 [Seth]
it can read and write
19:30:34 [sbp]
what file format?
19:30:37 [Seth]
and it displays frames that are user friendly
19:31:22 [Seth]
when you see an instance of something that you want to make another one of,
19:32:04 [Seth]
you see a button where you click on it, the system pops up a questionair with all the fields filled out from the kb
19:32:30 [Seth]
you change the things you want .. and click the thingy into the semantic cloud
19:32:36 [sbp]
a GUI interface? will you be using TKInter for that?
19:32:41 [Seth]
yep
19:32:50 [sbp]
cool
19:33:21 [Seth]
and i want to attach it to some kind of p2p decentralized cloud to distribute stuff to my friends
19:33:38 [sbp]
sounds like semplesh :-)
19:34:05 [Seth]
probably is ... is semplesh got a alpha out yet?
19:34:22 [sbp]
yep; let me get the URI...
19:34:37 [sbp]
http://cvs.plesh.net/semplesh/
19:35:24 [Seth]
so what do i get if i download and install it?
19:36:08 [sbp]
Hmm... do you have a CVS client? if not, you can get the .tar.gz
19:36:17 [sbp]
the tarball: http://cvs.plesh.net/semplesh/semplesh.tar.gz?tarball=1
19:36:41 [Seth]
but what do i get for my effort .. i mean how developed is this now .. and why no action for 6 weeks ?
19:37:21 [sbp]
oops, actually, you want http://cvs.plesh.net/infogami/infogami.tar.gz?tarball=1
19:37:43 [sbp]
well, the RDF API bit of it is practically done and all working
19:37:59 [sbp]
we're just deliberating on the network code, which is very difficult
19:38:01 [Seth]
any gui?
19:38:10 [sbp]
so we have the RDF sorted, and now we're onto the P2P :-)
19:38:14 [sbp]
no GUI, nope
19:38:56 [Seth]
aaron told me he was gonna use stid for the 4th attribute of the tuple
19:39:06 [Seth]
is that still the way?
19:39:32 [sbp]
yeah, I think he still does: class Assertion (_Node):
19:40:15 [Seth]
is the api you just sent the same a infonagi ?
19:40:27 [sbp]
no, the API that I just sent is a derivative of Eep
19:40:40 [sbp]
Eep was something that started independently of infogami
19:40:55 [sbp]
then Aaron merged some of it into infogami, and I'm also trying to develop it further
19:41:21 [sbp]
between us all (i.e. along with mnot et al.) there are quite a few RDF API approached
19:41:27 [sbp]
s/approached/approaches/
19:41:33 [Seth]
but still used the same api
19:41:43 [sbp]
and I presume that we'll do a survival of the fittest thing
19:41:51 [sbp]
who used the same API?
19:42:04 [sbp]
well... Hmm... let me draw an ASCII art diagram
19:43:09 [sbp]
rdfapi(old infogami)----->new infogami
19:43:09 [sbp]
/
19:43:09 [sbp]
Eep-----------\
19:43:09 [sbp]
\-----------------new api(that I just sent to you)
19:43:39 [sbp]
and later, the good bits of the new API that I'm working on will probably get folded info infogami
19:43:55 [Seth]
are they all based on:
19:43:58 [Seth]
SUBJECT, PREDICATE, OBJECT, FORMULA = 0, 1, 2, 3
19:44:04 [Seth]
flat list ?
19:44:13 [sbp]
nope
19:44:18 [sbp]
well, Eep is to some extent
19:44:31 [sbp]
think of Eep as the kind of experimental development branch of infogami
19:44:46 [sbp]
infogami is more object oriented than either Eep or the SWAP stuff
19:45:01 [sbp]
although the new API evolved from Eep is slightly more object oriented, as you've seen for yourself
19:45:20 [sbp]
the point is that they each have different purposes
19:46:01 [sbp]
Eep was just a quick experimental thing that just grew and grew. infogami is stable code for a big P2P project. the new API is a black box thing for a couple of other projects that I hope to be working on (PyB, diff, and annotations)
19:46:09 [Seth]
but they all use a flat list .. is that right? ... i mean this is not a tree of lists ?
19:46:45 [sbp]
well, infogami has nodes, assertions, and stores
19:47:11 [Seth]
three separate lists ?
19:47:18 [sbp]
no, nodes aren't lists
19:47:33 [Seth]
what are nodes?
19:47:40 [sbp]
and neither are assertions or stores, although stores have some of the list methods
19:47:40 [Seth]
data structure wise
19:47:48 [sbp]
for example, you can compare lengths, append, etc.
19:47:51 [sbp]
nodes are classes
19:48:05 [sbp]
they store a symbol, and a type
19:48:25 [sbp]
so the type will be one of URI, EXIVAR, or UNIVAR
19:48:39 [sbp]
and the symbol will be either a URI or a local name
19:48:39 [Seth]
i havent wrapped my mind around the idea that every node in a graph would be a class
19:48:56 [sbp]
well, an instance of the Node class
19:49:06 [sbp]
why wouldn't it be? i.e., what else would it be?
19:49:14 [sbp]
unless you used a kind of (Value, Type) listy
19:49:27 [sbp]
which is what the SWAP stuff uses, and what SWIPT (my first RDF API) used
19:49:33 [Seth]
so every node in your graph is actually an active object .. it would show up in the class browser?
19:49:33 [sbp]
AFAIK
19:49:42 [sbp]
yeah
19:50:01 [sbp]
but () is an instance of a tuple, when you think about it
19:50:02 [Seth]
well that is what i cant wrap my mind around
19:50:10 [sbp]
why not? lists are things too
19:50:19 [sbp]
it's just that we're customizing them
19:50:39 [Seth]
hmmm ...
19:50:43 [Seth]
so when i say
19:50:48 [Seth]
graph=[]
19:51:04 [Seth]
graph is an object
19:51:24 [sbp]
>>> graph = []
19:51:25 [sbp]
>>> type(graph)
19:51:25 [sbp]
<type 'list'>
19:51:25 [sbp]
>>>
19:51:43 [Seth]
well is a list an object?
19:51:49 [sbp]
er, both
19:51:56 [sbp]
er, yes, that is :-)
19:52:06 [sbp]
>>> print graph.__class__
19:52:06 [sbp]
<type 'list'>
19:52:06 [sbp]
>>>
19:52:35 [Seth]
ok, silly me, im new to object programming ... never wrote a whole system in it
19:53:10 [sbp]
so, when you think about it, a "node" in an RDF system is a node. when you use a list for it, you're just adapting a good existing construct
19:53:20 [Seth]
thing is that every node in my system is not an object
19:53:31 [sbp]
what are nodes in your system then?
19:53:43 [sbp]
if they're not objects, how do they exist?
19:54:20 [Seth]
you see them as something like
19:54:28 [Seth]
graph[1][1]
19:54:47 [sbp]
right, so if I did print graph[1][1], what would it give me?
19:55:10 [sbp]
a literal? a tuple? some other instance?
19:55:13 [Seth]
is would list out the entire node
19:55:25 [sbp]
right, but what is that node?
19:55:48 [Seth]
its one level of the tree down from graph
19:57:01 [sbp]
but what *is* it? I mean, if the node is some URI like http://www.w3.org/">http://www.w3.org/">http://www.w3.org/,">http://www.w3.org/, is that the literal "http://www.w3.org/", or a tuple ("http://www.w3.org/", URI), or some other thing like Node("http://www.w3.org/")?
19:57:35 [Seth]
is's a list of lists of identities and tuples
19:58:00 [sbp]
O.K., but what is the identity?
19:58:15 [Seth]
ill send you the code and you can critique it ... it's just not in a good place right now
19:58:17 [sbp]
IOW, what is the nature of the smallest indivisible unit of your API?
19:58:21 [sbp]
cool!
19:58:31 [Seth]
an identity integer
19:58:44 [sbp]
* sbp is rather curious to find out :-)
19:58:47 [Seth]
the high order parts of it give you the type of identity
19:59:06 [Seth]
id=800000000000000
19:59:08 [sbp]
ah, and the integer is mapped to a URI etc. in a dictionary, I suppose?
19:59:18 [Seth]
id=id+1
19:59:25 [Seth]
gives me the next id
19:59:35 [sbp]
you can do id += 1
19:59:54 [Seth]
nid = node id might start at 8000000000000000
20:00:10 [Seth]
pid = property id .. might start at 9000000000000000
20:00:23 [Seth]
so given the id i can tell what kind of object im talking about
20:00:49 [sbp]
aha, like address registers
20:00:53 [Seth]
the db in mysql just has the id .. not the uri .. which i treat as just literals
20:01:22 [Seth]
there like subjective identifiers .. very reliable internally ... meaningless externally
20:02:05 [Seth]
exteranlly i just read and write rdf
20:04:04 [Seth]
so back to your q about alphabetic
20:04:51 [Seth]
if you sort the node id's and property id's by their label literals and rebuild your file, then everything would output in alpha order
20:05:25 [sbp]
but I suppose you'll be stepping through in numerical id order?
20:05:49 [Seth]
yeah why not
20:09:55 [sbp]
so the attention pointer is always pointing at a statement?
20:11:04 [sbp]
Hmm... so if you have some guy :X with two emails and a name, you can gress through the emails, and sym to the name?
20:11:08 [Seth]
yes, it always points to an arrow ... cant't get off an arrow .... the things in it's universe are (graph, node, arrow)
20:11:32 [Seth]
yep .. you got it :)
20:12:12 [Seth]
vance fails if the arrow points out of the graph into the literal space
20:12:24 [sbp]
Hmm... I'm not sure that I get vance yet
20:12:41 [sbp]
so I guess vance would be for if the guy had a cousin, and that cousin had a cousin
20:12:46 [Seth]
vance moves attn from the arrow to the object of the arow
20:12:53 [sbp]
ah, I see
20:13:09 [Seth]
kind of like dereference
20:13:19 [sbp]
so instead of acting upon the nodes with the subject of the current statement, you move to those that have the subject that is the object of the old statement
20:13:26 [sbp]
and jace?
20:13:50 [sbp]
ah, that just steps through all of the nodes
20:13:53 [Seth]
jace moves you to other nodes in the same graph ... fails when there are no more
20:13:58 [sbp]
all of the subject, rather...
20:14:08 [Seth]
yep
20:14:17 [Seth]
bnodes included
20:14:40 [sbp]
what ment and say?
20:14:45 [sbp]
s/what/what about/
20:15:21 [Seth]
say is the output ... usually just says the current arrow in Semenglish
20:15:37 [Seth]
human friendly display
20:15:52 [sbp]
and ment?
20:16:17 [Seth]
ment ... might be renamed 'toGraph' .. goes to the node which contains the graph which the arrow in inside
20:16:29 [Seth]
in=inside
20:16:37 [Seth]
no in=is
20:17:02 [sbp]
* sbp isn't sure that he got that
20:17:42 [Seth]
there is a method called 'toGraph' which moves attn to the node which contains the arrow
20:17:59 [Seth]
in formula talk that would be
20:18:17 [Seth]
move to the node { ..... }
20:18:29 [sbp]
O.K.
20:18:49 [sbp]
Hmm... and you're doing this as lists rather than dictionaries?
20:18:50 [Seth]
if i said
20:19:14 [Seth]
{ A r B } called C.
20:19:23 [Seth]
and attention was on
20:19:26 [Seth]
A r B
20:19:39 [Seth]
toGraph would move attn to C
20:20:00 [Seth]
but there is a problem there between mentography and n3, that would need to be dealt with
20:20:19 [sbp]
ooh, got it
20:20:41 [sbp]
Hmm... I wonder if this could be modelled more efficiently with a Dict. Let's give it a go...
20:21:02 [Seth]
the graph is all contained in the lists .. which is really a 3 level tree of lists
20:21:28 [sbp]
right. Well, Aaron had a similar idea to this
20:21:31 [Seth]
then there are dictionaries to associate the objects in that list to the outside world of literals
20:21:36 [sbp]
i.e. a subject oriented store
20:21:48 [sbp]
so you'd do { 'x': { 'y': ['z'] } }
20:22:20 [sbp]
and then to step through the predicates (arcs) of node 'x', you'd do graph['x'].keys()
20:22:31 [Seth]
no the dictionary out_in would just associate the external name\uri to the internal identity
20:22:48 [Seth]
{'called' : 8000000000000 }
20:23:05 [sbp]
ah, but here I'm using the dictionary for the store too
20:23:25 [Seth]
well i though about that and rejected it .. not sure why
20:24:02 [sbp]
.time EST
20:24:02 [xena]
Apr. 20, 2002 4:24 pm US/Eastern
20:24:05 [Seth]
on thing is that you can't change data in a dictionary without rewriting the whole key\value pair
20:24:18 [Seth]
.time pst
20:24:19 [xena]
Apr. 20, 2002 1:24 pm US/Pacific
20:24:23 [sbp]
good point
20:25:11 [Seth]
also i didnt know u could put a dictionary in a dictionary .. can you?
20:25:19 [sbp]
yep, you sure can
20:25:45 [Seth]
but then can you add to the nested dictioary ?
20:26:44 [sbp]
yep
20:26:55 [sbp]
here's a function I just wrote (haven't tested it yet):-
20:26:59 [sbp]
def add(graph, triple):
20:26:59 [sbp]
s, p, o = triple
20:26:59 [sbp]
if s in graph.keys():
20:26:59 [sbp]
if p in graph[s]: graph[s][p] += o
20:26:59 [sbp]
else: graph[s][p] = [o]
20:26:59 [sbp]
else: graph[s] = { p: [o] }
20:28:49 [Seth]
bet it dont work
20:29:12 [sbp]
ah, it did:-
20:29:13 [sbp]
[[[
20:29:14 [sbp]
graph = {}
20:29:14 [sbp]
triples = [
20:29:14 [sbp]
('x', 'y', 'z'), ('p', 'q', 'r'), ('p', 'q', 's'), ('x', 'z', 'r')
20:29:14 [sbp]
]
20:29:16 [sbp]
for triple in triples: add(graph, triple)
20:29:18 [sbp]
print graph
20:29:20 [sbp]
]]]
20:29:22 [sbp]
gives: {'x': {'y': ['z'], 'z': ['r']}, 'p': {'q': ['r', 's']}}
20:29:41 [sbp]
not bad for a one minute hack :-)
20:30:13 [Seth]
hey, tha's cool!
20:31:32 [sbp]
now, for your program, you'll have to have a pointer for the current subject, and a pointer for the predicate position
20:32:12 [Seth]
there is just one object .. it always points to an arrow
20:33:03 [sbp]
yep, but when you know the arrow, you've also got to know the subject and the object, right? unless you have a different id for each predicate (which in your system you probably do)
20:33:09 [Seth]
but yes it has an index into the (graph, node, predicate, arrow)
20:33:22 [Seth]
index=pointer
20:34:01 [Seth]
yep each predicate has a different id .. but that same predicate in another node would have the same id
20:34:30 [sbp]
O.K., so I've written a combined gress/sym
20:34:36 [sbp]
[[[
20:34:37 [sbp]
subject = 'x'
20:34:37 [sbp]
for predicate in graph[subject].keys():
20:34:37 [sbp]
for object in graph[subject][predicate]:
20:34:37 [sbp]
print subject, predicate, object
20:34:37 [sbp]
]]]
20:34:48 [sbp]
which gives (for the graph above):-
20:34:48 [sbp]
x y z
20:34:48 [sbp]
x z r
20:35:55 [Seth]
at(x) say sym say
20:36:03 [Seth]
that what it looks like to me
20:36:57 [sbp]
ah, pretty much so. I think it's more like at(x), then { gress say } until fail then { sym say } until fail
20:37:04 [sbp]
and loop...
20:37:28 [sbp]
I just need to figure out how to make a pointer
20:37:43 [sbp]
I suppose that a pointer can be the s, p, o signature... ah
20:37:44 [Seth]
at(x) ((say gress ing) sym ing)
20:38:22 [Seth]
ing = repeat then ok
20:38:58 [Seth]
so that operation would output the entire node
20:40:48 [sbp]
repeat then O.K.?
20:41:36 [Seth]
actually ing = then repeat
20:42:07 [Seth]
if logic is fail it repeats ... otherwise it execuites onward in the clause
20:42:56 [Seth]
it implements the 'ing' in English .... like in keep doing something till you can't anymeore
20:43:42 [Seth]
say gress ing
20:43:50 [Seth]
would say all the arrows on a predicate
20:44:33 [Seth]
((say gressing) syming)
20:44:46 [Seth]
says all the arrows on all the predicates on a node
20:45:33 [Seth]
we dont need no stinking loops
20:46:17 [Seth]
actually you dont even need the parenthesis
20:46:25 [Seth]
say gressing syming
20:46:29 [Seth]
works too
20:46:52 [Seth]
but it better to do
20:46:58 [Seth]
say gressing syming ok
20:47:14 [Seth]
cause that will return ok steak of fail
20:50:27 [sbp]
here we go:-
20:50:27 [sbp]
[[[
20:50:27 [sbp]
def at(graph, s):
20:50:27 [sbp]
return s, graph[s].keys()[0], graph[s][graph[s].keys()[0]][0]
20:50:27 [sbp]
def gress(graph, pointer):
20:50:27 [sbp]
s, p, o = pointer
20:50:29 [sbp]
if len(graph[s][p]) == 1: return 0
20:50:31 [sbp]
elif (len(graph[s][p])-1) > graph[s][p].index(o):
20:50:33 [sbp]
return s, p, graph[s][p][graph[s][p].index(o)+1]
20:50:35 [sbp]
else: return 0
20:50:37 [sbp]
def say(pointer):
20:50:39 [sbp]
print pointer
20:50:41 [sbp]
]]]
20:52:05 [sbp]
on the graph above...
20:52:05 [sbp]
{'x': {'y': ['z'], 'z': ['r']}, 'p': {'q': ['r', 's']}}
20:52:05 [sbp]
we run...
20:52:05 [sbp]
pointer = at(graph, 'p')
20:52:05 [sbp]
say(pointer)
20:52:05 [sbp]
if gress(graph, pointer):
20:52:07 [sbp]
pointer = gress(graph, pointer)
20:52:09 [sbp]
say(pointer)
20:52:12 [sbp]
and get...
20:52:13 [sbp]
('p', 'q', 'r')
20:52:15 [sbp]
('p', 'q', 's')
20:52:36 [sbp]
Um...
20:53:08 [sbp]
yeah, but I haven't written a tokenizer for your new language yet :-)
20:53:23 [Seth]
im just using shlex
20:53:33 [sbp]
yet alone an interpreter
20:53:38 [Seth]
hey, sean, your good at this
20:53:57 [sbp]
shlex?
20:54:54 [Seth]
yeah it's in the distribution
20:54:57 [Seth]
from shlex import *
20:55:23 [sbp]
ooh, so it is
20:55:49 [Seth]
x=shlex()
20:55:55 [Seth]
x.getword()
20:56:01 [sbp]
cool, a little simple lexical scanner
20:56:02 [Seth]
works great for tokenizing
20:56:12 [Seth]
look who wrote it
20:56:13 [sbp]
s/little simple/simple little/
20:56:37 [Seth]
woops
20:56:53 [sbp]
ah, Eric Raymond
20:57:00 [Seth]
x.get_token()
20:58:50 [sbp]
here's sym:-
20:58:50 [sbp]
def sym(graph, pointer):
20:58:50 [sbp]
s, p, o = pointer
20:58:50 [sbp]
if len(graph[s]) == 1: return 0
20:58:50 [sbp]
elif (len(graph[s].keys())-1) > graph[s].keys().index(p):
20:58:50 [sbp]
return (s, graph[s].keys()[graph[s].keys().index(p)+1],
20:58:52 [sbp]
graph[s][graph[s].keys()[graph[s].keys().index(p)+1]][0])
20:58:54 [sbp]
else: return 0
20:59:09 [sbp]
running...
20:59:09 [sbp]
pointer = at(graph, 'x')
20:59:10 [sbp]
say(pointer)
20:59:10 [sbp]
while gress(graph, pointer):
20:59:10 [sbp]
pointer = gress(graph, pointer); say(pointer)
20:59:10 [sbp]
while sym(graph, pointer):
20:59:12 [sbp]
pointer = sym(graph, pointer); say(pointer)
20:59:14 [sbp]
while gress(graph, pointer):
20:59:16 [sbp]
pointer = gress(graph, pointer); say(pointer)
20:59:20 [sbp]
gives:-
20:59:22 [sbp]
('x', 'y', 'z')
20:59:24 [sbp]
('x', 'z', 'r')
20:59:26 [sbp]
quite nice, I suppose
20:59:43 [Seth]
i cant believe how fast you are with this
20:59:54 [sbp]
of course, these should be *methods* of a graph class, but oh well
21:00:13 [sbp]
heh, real time programming feedback :-)
21:00:47 [sbp]
oh, and I should be storing more things as variables... "graph[s][graph[s].keys()[graph[s].keys().index(p)+1]][0]" is just a little bit ugly...
21:01:30 [sbp]
actually, let me rewrite those two lines
21:05:36 [sbp]
sorry, bad connection...
21:05:38 [sbp]
O.K.:-
21:05:40 [sbp]
p = graph[s].keys()[graph[s].keys().index(p)+1]
21:05:42 [sbp]
return s, p, graph[s][p][0]
21:05:44 [sbp]
gives the same result, just neater
21:06:10 [Seth]
sean, your running circles aroud me
21:06:22 [sbp]
*chuckle* Just writing vance now
21:07:09 [sbp]
this *should do it:-
21:07:09 [sbp]
def vance(graph, pointer):
21:07:09 [sbp]
s = pointer[2] # new subject is old object
21:07:09 [sbp]
if s not in graph.keys(): return 0
21:07:09 [sbp]
else: return s, graph[s].keys()[0], graph[s][graph[s].keys()[0]][0]
21:07:17 [sbp]
lemme test it
21:07:44 [sbp]
ugh, I'll have to change the test graph a bit
21:09:17 [sbp]
here we go:-
21:09:18 [sbp]
[[[
21:09:18 [sbp]
pointer = at(graph, 'x')
21:09:19 [sbp]
say(pointer)
21:09:19 [sbp]
while vance(graph, pointer):
21:09:19 [sbp]
pointer = vance(graph, pointer); say(pointer)
21:09:20 [sbp]
]]]
21:09:22 [sbp]
prints out:-
21:09:26 [sbp]
{'x': {'y': ['p'], 'z': ['r']}, 'p': {'q': ['r', 's']}}
21:09:27 [sbp]
('x', 'y', 'p')
21:09:28 [sbp]
('p', 'q', 'r')
21:10:28 [sbp]
ah, now jace is a bit different because it's predicate oriented. It can be done by just sorting out all the predicate into one big list or something
21:10:54 [Seth]
jace is node oriented ... moves through all the nodes in a graph
21:10:57 [sbp]
but there you go. that's my little demonstration of how you *could* probably use dictionaries if you wanted to
21:11:06 [sbp]
oh, of course!
21:11:12 [sbp]
sorry, I misread it a little
21:11:18 [sbp]
in that case, jace is pretty simple...
21:11:21 [sbp]
* sbp works on it
21:11:38 [Seth]
do you have all his in a python file? ... dont want to loose it
21:12:01 [sbp]
yep: I'll send it over to you
21:12:13 [Seth]
cool, id like that :)
21:13:06 [Seth]
one good thing about these methods, is that they will end up with exactly the same resust regardless of what kind of data structure you choose to use
21:16:05 [sbp]
makeshift jace:-
21:16:06 [sbp]
def jace(graph, pointer):
21:16:06 [sbp]
s, p, o = pointer
21:16:06 [sbp]
if len(graph.keys()) == 0: return 0
21:16:06 [sbp]
elif (len(graph.keys())-1) > graph.keys().index(s):
21:16:06 [sbp]
return at(graph, graph.keys()[graph.keys().index(s)+1])
21:16:08 [sbp]
else: return 0
21:16:14 [sbp]
code to run it:-0
21:16:18 [sbp]
s/0//
21:16:18 [sbp]
print 'jace test'
21:16:18 [sbp]
pointer = at(graph, 'x')
21:16:20 [sbp]
say(pointer)
21:16:22 [sbp]
while jace(graph, pointer):
21:16:24 [sbp]
pointer = jace(graph, pointer); say(pointer)
21:16:26 [sbp]
result:-
21:16:28 [sbp]
jace test
21:16:30 [sbp]
('x', 'y', 'p')
21:16:32 [sbp]
('p', 'q', 'r')
21:16:34 [sbp]
:-)
21:16:49 [Seth]
wow .. does all you stuff work the first time ?
21:17:02 [sbp]
heh, not always :-)
21:17:07 [sbp]
(if only...)
21:17:31 [sbp]
O.K., that's pretty much done, so I'll send it over to you
21:17:51 [Seth]
great!
21:18:32 [sbp]
sent
21:18:36 [Seth]
got it
21:18:46 [sbp]
wow, that was quick. Ah, technology...
21:19:09 [sbp]
you should be able to just run $ python sethapi.py
21:19:27 [Seth]
now all i got to do is figure out why i had planned on using a more complex structure .. but even so i bet i can use some\most of your code
21:20:07 [sbp]
well, I'm not sure what the best approach would be, but it just struck me that using Aaron's dictionary hierarchy might *work*, and it does seem to have done
21:20:20 [Seth]
yep
21:20:23 [sbp]
whether that's the most efficient route or not is another question...
21:20:37 [Seth]
hey would these methods work on the infonagi api?
21:20:52 [sbp]
nope, since it doesn't use this kind of structure
21:21:21 [sbp]
oh, unless you mean the methods in general...
21:21:22 [Seth]
i dont mean the exact code .. but the methods should still work .. should work regardless of your data structure
21:21:40 [sbp]
right. in which case, yes, it should be possible, but probably more difficult than the scant lines above
21:22:00 [Seth]
yep prolly much more
21:22:44 [Seth]
with the structure im working on .. gress,sym,jace are just an additions to subscripts
21:22:58 [sbp]
BTW, I think guido wrote something about this... Aaron pointed me to it. Something for doing transitive closure, perhaps
21:23:21 [sbp]
aha: http://www.python.org/doc/essays/graphs.html
21:23:49 [sbp]
it's a path finding thing
21:24:02 [Seth]
i saw that ... but its not labeled graphs ... dont think i can use it
21:24:21 [sbp]
well, the thing that I did above is just a slight extension of that
21:25:16 [Seth]
http://www.pythonpros.com/arw/kjbuckets/kjbuckets.html is another .. also cant use cause dont do labels
21:25:27 [sbp]
(BTW, the "give a pointer or 0" thing is a bit tacky: you'll want to re-write that)
21:25:39 [sbp]
ah, DanC showed Tim that
21:26:00 [sbp]
actually, that's an almost perfect module for many RDF APIs :-)
21:26:23 [Seth]
what's 'that' ?
21:26:29 [sbp]
kjBuckets
21:26:55 [Seth]
i couldn figure out how to use it .. but im dumb
21:27:24 [sbp]
I don't think that anyone's actually used it in an RDF API yet...
21:28:56 [Seth]
thing i like about python , is if you get something right, hyou can rewrite the class as a C++ and make it super fast
21:29:29 [sbp]
Hmm... I don't think I've ever rewritten any Python as C++ yet, but I'll take your word for it :-)
21:29:37 [deltab]
have you heard about pyrex?
21:29:43 [Seth]
nope
21:29:45 [sbp]
yeah: good glass
21:30:07 [sbp]
ah, http://www.cosc.canterbury.ac.nz/~greg/python/Pyrex/version/Doc/About.html
21:30:16 [sbp]
cool, deltab
21:32:11 [Seth]
so will pyres write the c++ code, given the python module?
21:32:27 [deltab]
C, not C++
21:34:25 [Seth]
i got to go ... hey sean, thanks a lot :))))))
21:34:34 [sbp]
no problem at all. thanks for chatting
21:34:54 [Seth]
see you soon
21:34:56 [Seth]
Seth has quit ()
22:25:36 [oierw]
oierw has quit ("hmm.")