--- Day changed Thu Apr 17 2008
00:36 -!- kanzure [n=bryan@cpe-70-113-54-112.austin.res.rr.com] has quit ["Leaving."]
08:05 -!- kanzure [n=bryan@cpe-70-113-54-112.austin.res.rr.com] has joined #hplusroadmap
08:07 -!- Enki-2 [n=weechat@c-71-234-190-248.hsd1.ct.comcast.net] has quit [Read error: 104 (Connection reset by peer)]
08:13 -!- Enki-2 [n=weechat@c-71-234-190-248.hsd1.ct.comcast.net] has joined #hplusroadmap
08:39 -!- kanzure [n=bryan@cpe-70-113-54-112.austin.res.rr.com] has quit ["Leaving."]
10:45 -!- Enki-2 [n=weechat@c-71-234-190-248.hsd1.ct.comcast.net] has quit [Read error: 110 (Connection timed out)]
16:44 < fenn> 80MB movie of a nanomotor.. wtf
16:45 < fenn> havent these guys heard of youtube
18:14 -!- kanzure [n=bryan@cpe-70-113-54-112.austin.res.rr.com] has joined #hplusroadmap
18:14 < kanzure> What happened to everyone?
18:36 [Users #hplusroadmap]
18:36 [ drazak] [ fenn] [ kanzure] [ krebs] 
18:36 -!- Irssi: #hplusroadmap: Total of 4 nicks [0 ops, 0 halfops, 0 voices, 4 normal]
18:37 < fenn> enki appears to be having connection issues, and epitron was being a jerk so i told him to piss off
18:37 < fenn> aside from that, nobody else hangs out here regularly
18:48 < fenn> i think 'you are what you cache' is stupid
18:48 < fenn> it totally ignores generalization/abstraction
18:49 < fenn> most people function on heuristics most of the time
18:49 < fenn> caching is not the same as learning
19:18 < kanzure> you should see my ~/cache/ folder
19:18 < kanzure> btw, I was thinking that I would forward you all of my emails for a single day
19:18 < kanzure> just to catch a glimpse
19:18 < kanzure> today is a great day for this
19:19 < kanzure> I need to go setup a blog
19:19 < kanzure> Andrew is arguing with dad about why he should use blogspot instead of a custom-installed blog
19:19 < kanzure> sigh
19:27 < fenn> i cache things to preserve them for sharing with others or re-evaluation in the future, not because it makes them a part of me
19:27 < fenn> i have some web pages which are total crap, which i preserved on the off-chance that they might be right
19:44 < kanzure> fenn: do you not cache your cells, your food, your thoughts?
19:50 < kanzure>   Domain name    : HEYBRYAN.ORG
19:50 < kanzure>   Created on     : 2005-04-22 01:58:46
19:50 < kanzure>   Expires on     : 2012-04-22 01:58:46
19:50 < kanzure>   Last Updated   : 2008-04-17 23:39:47
19:50 < kanzure>   Years Purchased: 4
19:56 < kanzure> fenn: do you remember "How to make a complete map of everything you think" ? by Lion Kimbro?
19:56 < kanzure> http://www.speakeasy.org/~lion/nb/
19:57 < kanzure> there are also some other items to process through over at http://heybryan.org/mediawiki/index.php/2008-04-17 include coderepos - don't know if that site is legit or not
20:16 < kanzure> fenn: http://heybryan.org/~bbishop/cgi-bin/blosxom.cgi search for 'apropos' on this page. It seems to be a tag-based method of searching for shell commands. This is something that we might want to integrate 
20:16 < kanzure> ... basically we need a streamlined command disambiguation interface so that users can plug simulatable modules together, right? Of course, they have to provide terms, or the autospec error has to provide a context.
20:17 < kanzure> haha, wearable sleeping bag
20:23 < fenn> it's not tag-based, apropos just searches the man-page title
20:25 < fenn> title and description
20:30 < kanzure> blah
20:31 < kanzure> that's not good
20:31 < kanzure> is it bad that I forgot where my blog was for a whole month?
20:31 < kanzure> but it's alright now - I have it updating on rsync from my local cache to the blog directly, so it's all good
20:31 < kanzure> I should probably have it dumping into a wiki
20:33 < fenn> you could have a meta-wiki page that mirrors your blog
20:33 < fenn> ... or not
20:36 < kanzure> mirrors? I'll just dump into it
20:36 < kanzure> because if I'm using rsync, then aren't I just doing what we want to do with ikiwiki anyway?
20:36 < kanzure> it's basically a current versioning system where I assume that all of my files are up to date ;) (all of my files on the laptop, that is)
20:36 < kanzure> which obviously isn't smart :)
20:36 < kanzure> but humorous.
20:37 < fenn> mmm aptera is the first decent car design in a while
20:38 < kanzure> re: car designs; my (completely fun, entertaining, understanding, probably ASD-spectrum) psych teacher drives a box for a car, but she loves it since it gets ~38 mpg. Not aerodynamically feasible + it's fun to laugh at somebody for driving a box.
20:39 < fenn> 38mpg from a box eh?
20:39 < kanzure> a scion, I believe
20:39 < kanzure> but that just means toyota
20:40 < fenn> hmm aptera claims 300mpg?
20:40 < fenn> wtf does that mean
20:40 < kanzure> something in the news recently re: 2200+ mpg from a student team on ~400 kg.
20:41 < kanzure> argh, I hate losing notes
20:41 < kanzure> I accidentally overwrote my 2008-04-17 page on mediawiki today because some guys were talking with me while I was working, I had two windows open I think
20:41 < kanzure> the guys were actually tards, but I decided to entertain them
20:42 < kanzure> 'computer voodoo magic' and such.
20:42 < kanzure> fenn: try:
20:42 < kanzure>     config = yaml.load(file('config.yaml', 'r'))
20:42 < kanzure> except yaml.YAMLError, exc:
20:42 < kanzure>     print "Error in configuration file:", exc
20:42 < kanzure> actually,
20:42 < kanzure> try: yaml.load("!!python/object:__main__.Hero")
20:43 < kanzure> try that, and check the 2nd line (or array index 1) and you'll see a nicely formatted error message
20:43 < fenn> how do you overwrite a page on mediawiki? editing in the form?
20:44 < kanzure> I was typing up an edit on one window, and another in another window
20:44 < kanzure> and I saved on one, closed on another or something
20:44 < kanzure> anyway, it was just that snippit of code there
20:44 < kanzure> found from http://pyyaml.org/wiki/PyYAMLDocumentation
20:44 < kanzure> I was playing around on the laptop with python earlier this morning, I remembered to cache the py-yaml documentation and diveintopython.org's book on to my system
20:44 < kanzure> I think it's ~/cache/skdb/ atm.
20:45 < kanzure> the #yaml guys don't know about parser implementation details
20:45 < kanzure> (ironically, the guy answering in #yaml is a person I found in #math a few weeks ago)
20:45 < fenn> how do i make an error in the config file? it just seems to eat whatever i feed it
20:45 < kanzure> see my 'actually,' message
20:45 < kanzure> try:
20:45 < kanzure> yaml.load("!!python/object:__main__.Hero")
20:46 < kanzure> because you don't have class Hero.
20:46 < kanzure> thus there must be an error
20:46 < kanzure> and this is the exact sort of error that we are interested in
20:46 < kanzure> please don't forget 'import yaml'
20:47 < kanzure> and apt-cache search yaml | grep python
20:47 < fenn> yep
20:48 < kanzure> I had some thoughts on the streamliner-disambiguation program for connecting different programs together or automatically selecting programs to solve autospec problems ... this streamliner should be able to be used automatically or by a user; *this* is what uses the file format IO specs, and it generates something
20:48 < kanzure> it generates either a bash script or python script or something
20:48 < kanzure> and this script would attach/pipeline all of the commands together
20:48 < kanzure> and manage all of the files generated and make sure that they all end up at the same place
20:48 < kanzure> and then *this* script, the one that is generated, is the one that the user ultimately uses
20:49 < fenn> i did some help(exc) stuff and found the __dict__ which contains:
20:49 < fenn> {'note': None, 'problem': "cannot find 'Hero' in the module '__main__'", 'context_mark': <yaml.error.Mark object at 0x84f072c>, 'context': 'while constructing a Python object', 'problem_mark': <yaml.error.Mark object at 0x84f072c>}
20:49 < kanzure> not in all cases does the user have to disambiguate for the program - sometimes it says "well, this last module passed out XYZ and we need TUV, and there's program X that can convert between those two" and do automatic chaining
20:49 < kanzure> hm
20:49 < kanzure> it doesn't have 'Hero' in a variable name though
20:49 < kanzure> and that's unfortunate
20:49 < fenn> no
20:49 < kanzure> but it's easily parseable.
20:49 < kanzure> I guess we can go update the yaml code base if we want
20:49 < kanzure> do I care that much?
20:50 < kanzure> I can at least go suggest to the developers to output errors in yaml :)
20:50 < fenn> i expect the surrounding code is much more general
20:50 < kanzure> hm?
20:50 < fenn> it's probably a string that python interpreter spits out
20:50 < kanzure> ooh
20:50 < kanzure> tokens
20:50 < fenn> eh?
20:50 < kanzure> erm, I'm thinking of something different
20:50 < kanzure> but it might be possible to use the py-yaml parser tokens to find the class name
20:51 < fenn> i mean, its not pyyaml's job to figure out what the problem is
20:51 < kanzure> http://pyyaml.org/wiki/PyYAMLDocumentation#YAMLError
20:51 < fenn> cannot find 'Hero' in the module '__main__'  <- this is a python error
20:51 < kanzure> sure, but it should report the problem
20:51 < kanzure> oh?
20:51 < kanzure> well then.
20:51 < kanzure> then a general underlying debug yaml layer for python would be awesome
20:51 < kanzure> but beyond our scope at the moment
20:52 < fenn> god i dont know how people think pouring unrefined kerosene on ground dead cows is appetizing
20:52 < fenn> but it stinks up the whole neighborhood
20:52 < kanzure> ground dead cows?
20:52 < fenn> hamburger
20:53 < kanzure> from #python - (2008-04-17 19:57:01) bob2: kanzure: well, if you catch ImportError, you can parse the .msg
20:54 < kanzure> try: blah
20:54 < kanzure> except ImportError:
20:54 < kanzure> don't know where the msg var is though
20:54 < fenn> except ImportError, exc:
20:54 < fenn>   print exc.__msg__ probably
20:56 < fenn> exc.message
20:56 < fenn> No module named foo
20:58 < kanzure> apparently it might be straight up msg
20:58 < kanzure> just 'msg', no special namespace or whatever
20:59 < kanzure> http://projecteuler.net/ - math problems for python, it looks like an evaluator server that checks your solutions to number theory problems
21:00 < kanzure> some of the programming competitions out there (the 'official' ones for students etc.) use automatic 'safe-env' evaluator servers
21:00 < kanzure> ex: > If we list all the natural numbers below 10 that are multiples of 3 or
21:00 < kanzure> > 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. Find the
21:00 < kanzure> > sum of all the multiples of 3 or 5 below 1000.  
21:02 < fenn> i dont know where msg is
21:03 < kanzure> re: eye following problems; it occurs to me that this is kind of like my multitasking. But on the other hand, multitasking to this level is common across computer users that know what they are doing.
21:03 < kanzure> but I don't have eye tracking problems
21:04 < kanzure> fenn: e.msg
21:04 < fenn> what is e?
21:04 < kanzure> oops
21:04 < kanzure> (2008-04-17 20:07:46) bob2: kanzure: try: import whatever ; except ImportError, e: print e.msg
21:04 < fenn> AttributeError: 'exceptions.ImportError' object has no attribute 'msg'
21:20 < fenn> some code
21:20 < fenn> module = __import__("package.module", globals(), locals(), ["module"])
21:20 < fenn> members = inspect.getmembers(module)
21:20 < fenn> member = getattr(module, member_name)
21:20 < kanzure> 1) securely?
21:20 < fenn> yep
21:20 < kanzure> 2) import (modulename) ==> means what?
21:20 < fenn> er.. huh?
21:21 < fenn> are you asking about the python statement?
21:21 < fenn> "import module"
21:21 < fenn> loads code from the module "module" into an object named "module"
21:21 < kanzure> so if we were using $ to represent a variable, can we do import $module_name_variable ?
21:22 < fenn> no, but you can do, mymodule = __import__($var)
21:23 < kanzure> in php and perl you can do $$var, where $var might be 'my module name' and $$var refers to the variable named $my_module_name in that case
21:23 < kanzure> can we do something like that with python?
21:23 < fenn> yes, i think it's *var
21:23 < fenn> never used that though, don't you know pointers are evil?
21:23 < kanzure> it's not a pointer, IIRC
21:23 < fenn> reference
21:23 < fenn> whatever
21:23 < kanzure> it's just a way for the parser to expand it
21:23 < kanzure> it's like a search-and-replace deal ;)
21:26 < kanzure> (2008-04-17 20:29:40) Crast: kanzure: you can use eval to access variable variables, but much better is to try to use a dict or reflect an object using getattr (2008-04-17 20:29:48) habnabit: kanzure: getattr. but using a dict is much better most times.kanzure, not exactly like that. if you want references to an object, use an object to store it. it's also common to use a list for this purpose.
21:27 < kanzure> oh
21:27 < kanzure> I see you're already on that
21:27 < kanzure> I don't think we need to have a variable variable in this case though
21:27 < kanzure> because the script would already know of the class name if it wants to use it
21:28 < fenn> eval is really hard to make secure, i gather
21:28 < fenn> but it's useful as a keyword for finding ways to not use eval :)
21:29 < kanzure> hrm
21:29 < kanzure> tell me how this would be secure anyway
21:30 < kanzure> it's not like you can entirely trust APT either..
21:30 < fenn> code modules that you download from us would be signed,  meaning they dont intentionally do bad things to your computer or privacy or whatever
21:31 < kanzure> please explain
21:31 < kanzure> I am not familar with security models, I just assume insecurity and work from there
21:31 < fenn> but anyone could modify code on the wiki, so we'd have to periodically check incoming code to see what it does, and package it into a 'release' to be signed
21:31 < fenn> otherwise we get the 'commit access syndrome'
21:31 < kanzure> what does it mean for it to be signed
21:31 < kanzure> a bit to be checked yes/no?
21:31 < kanzure> key system?
21:32 < fenn> you do a md5sum or SHA and if it matches, it matches
21:32 < kanzure> you would get the md5sum from the server too
21:32 < kanzure> what's the point?
21:32 < kanzure> (the one to check it against)
21:32 < fenn> somehow that gets confounded with your key, so in effect you're saying 'this is what i intend to distribute'
21:33 < kanzure> why can't somebody fake my key?
21:33 < fenn> because it's a key
21:34 < fenn> the client will have your public key, which can tell if the private key (confounded with the signature) is correct
21:34 < kanzure> so if they can tell whether or not it is correct, then why not just bruteforce your private key?
21:34 < kanzure> erm
21:34 < fenn> nice long article, if you really want to know http://en.wikipedia.org/wiki/Public-key_cryptography
21:34 < kanzure> bruteforce somebody else's private key?
21:34 < fenn> because it will take 10^90000 years
21:35 < fenn> depending on how many bits in the key, how many computers bruteforcing, etc
21:35 < fenn> in general, verifying a key takes a lot less time than bruteforcing it
21:35 < fenn> sound familiar?
21:36 < kanzure> yes
21:39 < fenn> i guess someone was making a joke when they said *var
21:40 < fenn> (this is why i hate perl, you cant search for punctuation marks)
21:46 < kanzure> http://heybryan.org/music/radio/ take your pick
21:47 < kanzure> fenn: I never got into the whole pgp thing, mostly because I never bothered to figure out how to
21:48 < kanzure> it looks like we'll want to encrypt all outgoing modules that are picked up or something?
21:49 < kanzure> or store encrypted double versions?
21:49 < kanzure> or just encrypt the hash?
21:49 < kanzure> blah, I don't care
21:49 < kanzure> you can deal with that
21:50 < fenn> i'll delegate it
21:50 < fenn> it doesnt matter at this point anyway
21:50 < kanzure> okay, so, random brainstorming time
21:51 < kanzure> get the module name that makes for the error, then proceed to check the plugin directory for that module
21:51 < kanzure> load it up if we have it
21:51 < fenn> btw, APT handles all this crypto stuff for us, which is part of why i wanted to use it to download software modules
21:51 < kanzure> if we don't have it, start the disambiguation routine
21:51 < fenn> we can just add the plugin directory to $PYTHONPATH
21:51 < fenn> then python will find it
21:51 < kanzure> the disambiguation software would be a way to either (1) automatically download new modules and programs to splice things together or (2) allow the user to select what's the next step (just in time programming, call it)
21:51 < kanzure> yes
21:52 < fenn> if we dont find the module, then we just download it
21:52 < kanzure> but do we want python to load up all modules at once?
21:52 < fenn> it wont load all modules at once?
21:52 < fenn> hrm
21:52 < kanzure> I am wondering if we should conflate mime db == the python plugins
21:52 < kanzure> because the mine db idea was to use file format io specs, i.e. use this program with this input type
21:52 < fenn> we have an 'installation' which is everything the user has and can do
21:52 < kanzure> and clearly here we are using yaml to specify what sort of object the data is
21:52 < kanzure> right
21:53 < kanzure> but the user is not necessarily using everything
21:53 < kanzure> okay, think of it this way
21:53 < fenn> we check the installation against the technology dependency tree to build a sort of customized tree saying what the user can do
21:53 < kanzure> each separate script and program
21:53 < kanzure> has their own data objects
21:53 < kanzure> so these programs are responsible for their modules and objets
21:53 < kanzure> *objects
21:53 < kanzure> but beyond this, they shouldn't really care, and instead call another program
21:53 < kanzure> which is a requirement for the software to run (this would be in the meta data)
21:53 < kanzure> right?
21:53 < kanzure> why do we need this serialization, again?
21:54 < fenn> so people dont have to edit code
21:54 < fenn> its like wiki markup vs html
21:55 < kanzure> okay
21:55 < kanzure> but this is just for one module at a time though
21:55 < kanzure> so each package is independently responsible for this right?
21:55 < fenn> what are you referring to with 'module'?
21:55 < kanzure> one package 
21:55 < fenn> technology package or code to interpret specifications?
21:56 < fenn> i dont want any code in the technology package if i can avoid it
21:57 < kanzure> man, I just lost my train of thought
21:57 < kanzure> WTF are we doing?
21:57 < kanzure> why do we have serialization? the serialization will *only* be for loading up information that the package can interpret itself, right?
21:57 < kanzure> so why *wouldn't* the immediate code specify the classes?
21:58 < fenn> uh.. because people are stupid i guess.. i dont know
21:59 < kanzure> then use a converter
21:59 < fenn> convert what to what?
21:59 < fenn> think of yaml like a sandbox that people can do whatever they want without breaking things
22:00 < fenn> we'll be validating the data structure it creates before running it
22:00 < kanzure> what will this data struct be used for
22:00 < fenn> if people just write raw python instead, they can put whatever they want in there
22:00 < fenn> the data struct will contain specifications about what the technology provides and requries
22:01 < fenn> the specifications need to be compatible for the entire system to be valuable
22:01 < fenn> if everyone writes their own specification class, they cant be compared, it's apples and oranges
22:02 < fenn> if the default level of interaction is writing a yaml file, they have to include one of the provided code modules, and it's harder to make a new code module
22:02 < fenn> so people use an existing specification standard instead of making up a new one for each package
22:02 < fenn> make sense
22:02 < fenn> ^?
22:03 < fenn> the code module also includes some sanity checks and unit tests that get run automatically
22:03 < fenn> believe me, you dont want to sort code
22:04 < fenn> sorting a bunch of yaml files is easier because it's dead data
22:05 < kanzure> oh, right
22:05 < fenn> also, you can present it in different ways, such as with ikiwiki
22:05 < kanzure> we want to use data serialization for a Common Object Library
22:05 < kanzure> there is another aspect of the project, then, that deserves mentioning
22:05 < fenn> this is some microsoft-related concept? i dont know what that really means
22:06 < kanzure> have you ever used aptitude's disambiguation program? it's an ncurses interface that lists potential matching packages
22:06 < kanzure> Common Object Library: 
22:06 < kanzure> there's a set of common objects that you can use
22:06 < kanzure> it's a library
22:06 < kanzure> like sets of header files that you can choose to include
22:06 < kanzure> the python plugins are the header files
22:07 < kanzure> the yaml files contain instances (objects) of the classes in the python plugins / header files
22:07 < fenn> yep
22:07 < kanzure> okay, so the disambiguation program -> you would use this for something else, I was conflating two things together
22:07 < kanzure> my 'file format io specs' is different
22:07 < kanzure> that's where you splice and dice programs together
22:08 < kanzure> where the program can automatically find a path to another format if needed
22:08 < fenn> i was mostly thinking of the file format db for interacting with third party apps
22:08 < kanzure> or the user can sit there and try out a suggested option
22:08 < kanzure> well
22:08 < kanzure> sort of
22:08 < kanzure> think of it this way
22:08 < fenn> which makes it sound more like a traditional plugin API
22:08 < kanzure> many of the scripts added to skdb will sometimes be reworking of the other skdbs
22:08 < kanzure> erm
22:08 < kanzure> sequences of other packages
22:08 < kanzure> sorry
22:08 < kanzure> anyway, these sequences will just direct flow between various modules, yes?
22:08 < kanzure> *various software modules
22:09 < kanzure> this is essentially what the user wants to do for a particular project
22:09 < kanzure> so why not let them choose what to do with output by giving them a list of programs that use that format as input
22:09 < fenn> you cut and stiched those lines so many times i dont know what you just said
22:09 < kanzure> thus the file format io spec metadata (not just package .deb metadata stuff)
22:09 < kanzure> hm
22:09 < kanzure> okay, so imagine it this way
22:10 < kanzure> you just downloaded the CNC lathe tool
22:10 < kanzure> and all of the python modules, .deb packages (except .skdb equivalents), etc.
22:10 < kanzure> your simulated CNC lathe tool is simulated with certain runtime parameters and spits out a file that represents a finished work
22:10 < fenn> agx-get install lathe tool // means i have a cnc lathe
22:10 < kanzure> let's say a chair
22:10 < fenn> agx-make chair
22:10 < kanzure> and so this is yaml instance data
22:11 < kanzure> then you're left sitting there with a theoretical (but fully physically validated, ready to be made exactly to specs) chair
22:11 < kanzure> so now what?
22:11 < kanzure> well, that's where the file format io db disambiguation stuff comes in at
22:11 < kanzure> you would say "what programs can use <this yaml> ?"
22:11 < kanzure> and it would say "well, html2pdf takes HTML yaml, here's its description yadda yadda" and it'd be a selection interface
22:12 < kanzure> now, when I mean to say I was conflating the ideas together
22:12 < kanzure> as in, I was thinking that the yaml object loading stuff from autospec would be associated with the file format io specs
22:12 < fenn> cnc-lathe requires g-code at technology-build-time
22:12 < fenn> er, crap
22:12 < kanzure> yes
22:12 < fenn> chair requires g-code at build-time, cnc-lathe requires g-code at run-time
22:13 < fenn> right? something like that
22:13 < fenn> or maybe chair provides gcode
22:13 < fenn> this is why we write code :)
22:13 < kanzure> you mean: physical expression of 'chair package' requires g-code at cnc-physically-expressed building-time
22:14 < fenn> the word chair can refer to the software describing the chair, the physical chair itself, (others?)
22:14 < fenn> let's conflate the physical chair and the technology package for chair
22:14 < kanzure> simulated chair, g-code for the chair, the physical chair itself (as in, what you are editing in realtime with the CNC lathe spinning around and whatever), the entire 'chair' package and all g-code and software and python plugins and object instances (aka yaml files), ...
22:15 < fenn> so we can say 'chair provides g-code at build-time'
22:15 < kanzure> build-time can mean so many things though
22:15 < kanzure> build-time of the simulation system
22:15 < kanzure> build-time of "chipping and chopping away at wood to make the chair"
22:15 < fenn> terminology.. what's a short name that differentiates between compiling and robotics stuff
22:15 < kanzure> eh
22:16 < fenn> thesaurus time :)
22:16 < fenn> construct, fabricate, manufacture, 
22:17 < kanzure> it's more like
22:17 < kanzure> the problems with talking about cyber->reality borders
22:17 < kanzure> cyber<->physical-materials
22:17 < kanzure> bits<->atoms
22:17 < kanzure> http://cba.mit.edu/ Center for Bits and Atoms
22:17 < fenn> hey isnt that the whole point now :)
22:17 < kanzure> http://digivin.googlepages.com/ aww, Andrew just linked me to his new website
22:18 < fenn> because right now cad-files are so not automated it's sick
22:18 < kanzure> in general
22:18 < fenn> so there's no "source code" to the manufacturing process
22:18 < kanzure> I think that our system idea is going to work
22:18 < kanzure> however, the more we obsess on those details, the less we get done
22:18 < kanzure> I think our system is modular enough that it can be implemented on top of our basic ideas
22:18 < kanzure> yes?
22:18 < kanzure> on top of the basic idea of fetching data types from the web
22:18 < fenn> yep sure
22:18 < kanzure> on top of the basic idea of fetching packages from the web
22:19 < fenn> i wouldnt be doing it if i didnt think it would work
22:19 < fenn> shall we diagram or write code?
22:19 < fenn> top down or bottom up
22:20 < kanzure> you want to stop talking about it and just do it?
22:20 < kanzure> wait
22:20 < kanzure> I should have worded that
22:20 < kanzure> you wanna stop talking and just code?
22:20 < fenn> sometimes i get lost though if there's no diagram
22:20 < kanzure> right
22:21 < kanzure> it's quite a big problem space to contain in the head all at once
22:21  * fenn gets a piece of paper
22:21 < kanzure> and in fact, I am not so sure that other programmers try to cram an entire vision into their head before starting to write code
22:22 < fenn> meh
22:22 < kanzure> btw, I carry stacks of white printer paper with me everywhere I go
22:22 < kanzure> screw lined paper
22:22 < kanzure> I know how to be straight on my own, thanks
22:24  * fenn translates hand-sketched diagram into dia format
22:25 < kanzure> what happened to the UML craze for software engineering?
22:26 < fenn> it turned out you cant automatically turn crappy diagrams into code
22:26 < fenn> else the map is the territory
22:27 < fenn> easier to write code and draw a broad overview, than to make a detailed diagram
22:37 < kanzure> how are the python plugins served?
22:37 < kanzure> are they treated as packages too?
22:37 < kanzure> obviously these are significantly restricted packages in comparison to something like a 'metalcastingtechniques' package
22:37 < kanzure> (which may include exact methodology for making a machine to do metalcasting)
22:38 < kanzure> I suppose the answer is yes
22:38 < kanzure> since the plugins can be of a certain python-class (skdbPythonPluginClass for now)
22:39 < kanzure> so you'd serialize that object to yaml, and then you can load that data up or something
22:39 < kanzure> hrm
22:39 < kanzure> that doesn't make much sense
22:39 < fenn> http://fennetic.net/pub/irc/autogenix.svg (and .dia if you want it)
22:39 < fenn> sry that took so long, is reason i used paper
22:40 < kanzure> if the plugins are a package in skdb, then how are they served? if autospec finds it needs to get a specific plugin, then ... hm. I guess the solution is to have a package that has a type of 'python plugin' which has a common variable specifying the URL to get the plugin source code. Then just make sure your autospec program can use that 'python plugin type'. 
22:40 < fenn> oh ffs the svg is crap
22:41 < kanzure> shit Opera doesn't understand SVG
22:42 < kanzure> have a suggestion for an SVG viewer?
22:42 < kanzure> dia is it?
22:43 < fenn> dia just dropped about 90 geek points
22:43 < fenn> for shitty svg export
22:43 < fenn> http://fennetic.net/pub/irc/autogenix.png
22:44 < drazak> Oh god, geek points!
22:44 < drazak> dia--
22:44 < fenn> dia *= 0.1
22:44 < kanzure> fenn: Paul (OSCOMAK.paul)'s geek points are through the roof. He studied at Caltech in a building called von Neumann Hall.
22:45 < fenn> where they disdained space travel and computer information networks and replicating machines, sure
22:45 < fenn> fuck those assholes
22:45 < fenn> fuck 'em hard! :)
22:46 < fenn> they humor the geeks by promising space travel, when really its just a nuclear arms race
22:46 < kanzure> hah, "so we decided to name this building after von Neumann just in spite"
22:46 < kanzure> cruel
22:46 < kanzure> but really, answer the question
22:47 < kanzure> how are the python plugins served? are they treated as packages in skdb/APT-server-side-equivalent?
22:47 < fenn> we could setup a debian repository and have the autospec download autogenix-$modulename package
22:47 < fenn> or we could do some fancy git stuff?
22:47 < kanzure> and if so, then the meta-data for that package would simply be something standard that all autospec/autogenix things *must* understand from version 1.0 and up
22:47 < kanzure> well
22:47 < kanzure> I think it should be a package
22:48 < kanzure> since it's kinda like a header
22:48 < fenn> dunno, how does gentoo handle this stuff?
22:49 < kanzure> weird, I just had a meta-philosophical insight on the nature of bootstrapping compilers, computational complexity, and well-defined fabrication automation
22:49 < kanzure> it's *fundamentally hard* to describe this sort of system since you have to have such unique vocabulary
22:49 < kanzure> you have to just sit down and *fucking code it*
22:49 < kanzure> you *cannot* verbally detail it, that is implicitly impossible
22:49 < kanzure> but anyway
22:50 < fenn> you mean empirical data is in the loop?
22:50 < kanzure> yes
22:50 < drazak> gentoo handles everything greatly :D
22:50 < fenn> or, build, test, back to the drawing board?
22:50 < drazak> What are you guys trying to do?
22:51 < kanzure> drazak: Wait, haven't we explained yet?
22:51 < drazak> kanzure: which part? and I haven't read a lot of backog, either
22:51 < fenn> drazak: apt-get for rapid prototyping (and related activities) eventually leading to self-replicators
22:51 < kanzure> fenn: Sort of, yes. The only way to 'fully realize it' and 'remember all at once' is to just make it. You can't do a complete description of it, like you said. UML stuff. So therefore.
22:51 < fenn> or, 'emerge' if you prefer
22:52 < kanzure> so that's why I was getting to the "*must* understand from version 1.0 and up"
22:52 < kanzure> you have to have the bootstrap stuff in there
22:52 < kanzure> luckily our gcc friends boostrapped the compilers for us (hehe)
22:52 < kanzure> and bootstrapped operating systems for us
22:52 < fenn> we have no bootstrapped rapid prototyper
22:52 < kanzure> which is of course what we're doing here
22:53 < kanzure> bruteforced boostrapping ;)
22:53 < fenn> no, we're writing the OS for a rapid prototyper, basically
22:53 < kanzure> werm
22:53 < kanzure> bootstrapping
22:53 < kanzure> hm
22:53 < kanzure> perhaps
22:53 < kanzure> the analogy doesn't completely hold of course
22:53 < kanzure> because if you downloaded and installed and configured all skdb software into the prototyper,
22:53 < kanzure> that would be lots of waste methinks
22:53 < fenn> but some of the code can be applied to regular humans in the meanwhile, like von nuemann running his cellular automata on paper
22:53 < fenn> or turing running a LCM on paper
22:54 < kanzure> was he really doing 60x60 cell states on paper? by hand?
22:54 < fenn> dunno
22:54  * fenn points at the mythos
22:54 < kanzure> that's ... sick.
22:54 < fenn> its not hard actually
22:54 < fenn> just repetetive
22:54 < kanzure> :)
22:54 < fenn> repetetetititive
22:54 < kanzure> hehe, I find myself saying that sometimes
22:55 < fenn> so, the hard part will be convincing people without a rapid prototyper that this is worthwhile, rather than just googling for 'fart catcher' or whatever they're making
22:56 < kanzure> nah
22:56 < kanzure> that will not be too hard
22:56 < kanzure> basically what we do is formalize a few projects 
22:57 < kanzure> something appealing
22:57 < fenn> b/c rapid prototypers are more or less useless if you have to do everything by hand, and nobody is interested until they have a rapid prototyper laying around (idle)
22:57 < kanzure> and start attracting attention in that way
22:57 < drazak> (rapid prototyper? :P)
22:57 < fenn> see how reprap is floundering, despite massive hype
22:57 < kanzure> drazak: 3D printer 
22:57 < kanzure> think of that
22:57 < kanzure> fenn: yes
22:57 < drazak> ohhhhhh
22:57 < drazak> yeah, seen those
22:57 < kanzure> fenn: I am amazed at reprap. it's a self-replicating viral meme, that's sure enough
22:57 < fenn> the meme was around before the reprap
22:57 < drazak> the college around here has one
22:58 < fenn> drazak: did they make anything with it?
22:58 < kanzure> http://www.last.fm/user/superkuh "I enjoy recursion, dissipating local energy gradients, lipid bilayers, and biophysics in general."
22:58 < drazak> fenn: they've done a few things
22:58 < drazak> fenn: one of my teachers at the middle school was looking to get one for the school
22:58 < fenn> did they make parts for another reprap!!!!!
22:58 < kanzure> "I enjoy recursion" <-- a good line to copy around the web
22:58 < drazak> for our science olypiad team
22:58 < fenn> nobody seems to be doing that, which is the stated goal, fuckers
22:58 < kanzure> isn't it olympiad?
22:58 < drazak> yeah, missed a letter
22:59 < kanzure> but you've done so consistently
22:59 < fenn> you dont 'get one' you have to make it, because nobody is making parts with their repraps (because the overall design sucks (not the implementation))
23:00 < kanzure> hrm, re-order: but you've consistently done so
23:00 < fenn> spelling is arbitrary
23:01 < kanzure> 'do what I mean, not what I say'
23:01 < fenn> nonetheless, people who write 'hi how r u 2day' are fucking idiots
23:01 < fenn> i need to go dissipate some local energy gradients, bbiab
23:02 < drazak> I agree
23:04 < kanzure> hm
23:04 < kanzure> I have an idea
23:04 < kanzure> let's call these "stoppers" in the netwrok
23:04 < kanzure> *network
23:04 < kanzure> basically, I was considering the case where we have a python-plugin package with metadata
23:04 < kanzure> the user progs would have to be able to interpret the metadata
23:04 < kanzure> but this metadata might require another package
23:04 < kanzure> and then another and another
23:04 < kanzure> it's obviously recursive and that's fine, sure
23:05 < kanzure> but at some point you have to just *stop* and download some final code
23:05 < kanzure> I propose we call this a 'stopper'
23:05 < kanzure> this is a type of meta-data file that is the most ridiculously basic file ever
23:05 < kanzure> this is the one that points to one URL and has no other data what's so other
23:05 < kanzure> just file.txt: http://heybryan.org/code.py
23:05 < kanzure> that's all it has
23:05 < kanzure> then, the user-progs download that code and run it
23:06 < kanzure> this is the way to terminate the endless chain of program requests and requirements upon requirements
23:09 < kanzure> I also propose two layers for skdb servers (not the ikiwiki software stuff)
23:09 < kanzure> skdb layer 1 -- *raw* data, this is the .py files and the .yaml files and even zip files of HTML and PDFs for human processing
23:10 < kanzure> in the ideal situation, those would be assembled into zip files and stored locally on our servers
23:10 < kanzure> skdb layer 2 - the metadata files. These would be cached by all users. They point to the resouces in layer 1.
23:10 < kanzure> and also specify the hell out of other stuff and so on :)
23:14 < kanzure> there is a core set of functionality that autogenix and other related tools *must* have in order to bootstrap the system
23:14 < kanzure> the server-side stuff doesn't have to be bootstrapped, it's pretty easy really
23:15 < fenn> back. one problem with apt is it requires superuser access
23:16 < kanzure> don't see why that would be required here
23:16 < kanzure> I also think we can pretty easily do away with apt as the frontend
23:16 < kanzure> I mean, the frontend stuff sounds simple to me - as far as APT goes
23:17 < fenn> it shouldnt be required, but that's how it works (because 99% of packages modify the installed system)
23:17 < kanzure> as for the extra stuff - like being able to interpret the metafiles and being able to update (by reading the 'stoppers' on skdb)  - that's a bit more tricky
23:17 < fenn> we wouldnt use apt for _our_ frontend, but for installing software (deal with key signing and software depenency resolution)
23:19 < kanzure> ooh
23:19 < kanzure> here's a tricky loop
23:19 < kanzure> program io specs (like what file formats the program accepts as input for what parameters) can be in yaml
23:19 < kanzure> *but* py-plugins (that provide the tools to interpret yaml) have yaml metadata
23:20 < kanzure> and pyplugins help to interpret prog io specs (loop back to square one)
23:20 < kanzure> thus I think I have proven the need for bootstrapping
23:21 < fenn> uh, this is no big deal, you just download all the software for the base system in one go
23:24 < kanzure> correct
23:24 < fenn> re: layer 1/2; do you need the data (layer 2) to make a dependency tree? if not, how do simulators fit into the picture?
23:25 < fenn> i guess simulators could get run by the package developer, to automatically generate metadata
23:26 < fenn> so the metadata files wouldnt be the exact same files as the source yaml on the wiki, but would be derived from them
23:27 < kanzure> huh? hold on
23:27 < kanzure> you need layer 2 to make the dependency tree
23:27 < kanzure> layer 2 includes all of the yaml, I would think
23:27 < kanzure> on the other hand
23:27 < kanzure> on layer 1 there would include yaml for other things wouldn't it?
23:28 < kanzure> that could be a different dependency tree, perhaps?
23:28 < kanzure> I thought that simulators would be ran at user-end?
23:28 < fenn> why would the user run simulations?
23:28 < kanzure> the metadata files should be on the wiki
23:28 < kanzure> fenn: ex: mission optimization?
23:29 < kanzure> feasability simulations?
23:29 < fenn> autogenix already says 'its feasible'
23:29 < fenn> autospec
23:29 < fenn> bah
23:29 < kanzure> are you sure?
23:29 < fenn> they could doublecheck
23:29 < kanzure> autospec does that for file formatting
23:29 < kanzure> and yaml and so on and making sure you have the available modules
23:30 < kanzure> but then this does not tell you whether or not you can provide enough 'juice' or other various characteristics
23:30 < kanzure> right?
23:30 < fenn> no, autospec reads the metadata and builds a dependency tree, in order to say whether something is feasible or not
23:30 < kanzure> oh
23:30 < fenn> it determines if there's enough juice
23:30 < fenn> what else would it do?
23:30 < kanzure> check if the yaml file parses and whether or not it needs to go get more python plugins from the repository
23:30 < fenn> file format is something else, interfacing with simulators and crap
23:31 < fenn> yes, it needs to get updated plugins, correct
23:32 < kanzure> somehow saying that no end-user does simulations sounds fishy/wrong
23:32 < kanzure> not to mention the new issues as to how autospec would do a full feasability check ... that's just doing metadata dependencies; you'd have to encode "I need 20 amps" as an object ... which seems nasty.
23:33 < fenn> yes, you have to encode 'i need 20 amps'
23:34 < fenn> otherwise you can only say 'i need powersupply xyz20'
23:35 < kanzure> so it would be through the python plugins that autospec would learn how to check specs for amperage and so on?
23:35 < kanzure> 'learn'
23:35 < kanzure> ouch
23:35 < kanzure> I don't mean to use the word learn
23:35 < kanzure> if epitron was here he'd say something about brains
23:35 < fenn> heh
23:35 < fenn> yes autospec needs plugins to understand what '20 amps' means
23:36 < fenn> also what 'i need' means
23:36 < fenn> probably expressed something like peak or continuous
23:37 < kanzure> soo
23:37 < kanzure> in other words
23:38 < kanzure> autospec needs to have a standard library of simulation tools to work with those spec-params or whatever
23:38 < kanzure> in other words
23:38 < kanzure> a simulator
23:38 < kanzure> but this is a global simulator, it seems, all in one place
23:38 < kanzure> which is different (+better) from my original idea of encoding the simulators into the chair.py code itself
23:38 < kanzure> this way, the python plugins provide ways to 'deal individually' with aspects of a part
23:38 < kanzure> and it could be a graph-based traversal or something
23:38 < kanzure> where it just satisfies a certain region of the graph/tree
23:38 < kanzure> and then moves on to another part
23:39 < kanzure> but of course, doing a very deep search through possibility space would be more intense
23:39 < kanzure> and I don't know how to make a common interface for doing *all* types of walks through the possibility space of verification or whatever
23:39 < fenn> i'm not sure graph traversal is really the best way to imagine it
23:39 < kanzure> know what I mean?
23:39 < kanzure> it has to meet requirements, right? so when you meet one requirement, you have to make sure you can meet the others at the same time
23:40 < kanzure> kind of like balancing a chemical equation 
23:40 < fenn> sure, and also find the shortest distance
23:41 < kanzure> uh
23:41 < kanzure> so what are you proposing
23:41 < kanzure> I mean, it sounds like you've completely made the entire skdb project sound pointless
23:41 < kanzure> and made autospec do all of the effort
23:42 < kanzure> while not specifying how it could *possibly* work with all sorts of varied packages and so on
23:42 < kanzure> I guess the 'units' stuff can be encoded in yaml and python plugins and the packages in skdb
23:42 < kanzure> and then you just try to find ways to disambiguate the units
23:42 < kanzure> into common expressions of the same exact things
23:42 < kanzure> kind of like finding the greatest common denominator
23:42 < kanzure> and then factoring it out of the entire picture
23:43 < fenn> there are base units that can't be factored out
23:44 < fenn> believe it or not, there is no difference between a joule and a  kg*m^2/s^2
23:44 < fenn> i dont see how it's pointless to boil down equivalent things
23:45 < fenn> and then say 'feasible' if they're equivalent (or satisfied conditions)
23:45 < fenn> like, power provided must be greater than power required
23:46 < fenn> error provided must be less than tolerance required
23:46 < kanzure> okay
23:46 < kanzure> makes sense now
23:48 < kanzure> http://heybryan.org/docs/cache-index.txt
23:48 < kanzure> my ~/cache/
23:49 < kanzure> does not include my 30 GB of texts
23:52 < fenn> just looks like bad organization? i dont get it
23:52 < fenn> obviously these are more important than the other 30GB
23:53 < fenn> some of them are just trash though, waiting to be cleared out
23:56 < fenn> you could sort a database chronologically and by importance at the same time, with a 3d view or by changing font size