--- Day changed Sat Apr 19 2008
00:56 -!- Splicer2 [n=p@h174n1c1o261.bredband.skanova.com] has joined #hplusroadmap
01:01 < kanzure> fenn: I wonder if agx-make directly generates CAM or not. I suspect not. agx-make would be more like the API layer to /dev/ more than anything else.
01:01 < kanzure> yes?
01:01 < kanzure> it would aggregate all of the information relevant as inputs to the machinery in your local fab-lab-configuration
01:08 < fenn> agx-make is a compiler that can call many different 'backend' CAM tools
01:08 < kanzure> can we hack gcc for this purpose?
01:08 < kanzure> port gcc to a new 'isa' 
01:08 < kanzure> where this 'isa' is the fablab instruments?
01:08 < fenn> dunno, gcc is a C compiler mostly
01:09 < fenn> using make might make sense
01:09 < fenn> gnu make
01:10 < kanzure> I'm just wondering to what extent we can consider it a compiler
01:10 < kanzure> since technically gnu make is not a compiler in the truest sense, last I checked
01:10 < fenn> ok, it's not a compiler, its a "make" whatever you call that
01:10 < kanzure> plus we don't have to compile the firmware for each new package physical implementation
01:10 < kanzure> ok
01:10 -!- Splicer [n=p@h238n1c1o261.bredband.skanova.com] has quit [Read error: 110 (Connection timed out)]
01:11 -!- Splicer [n=p@h174n1c1o261.bredband.skanova.com] has joined #hplusroadmap
01:11 < fenn> its a frontend that causes software files for performing a particular physical operation to be compiled
01:12 < fenn> where said physical operation is one that's been verified to be feasible with the current infrastructure/inventory
01:12 < kanzure> yes
01:13 < kanzure> my thoughts were that the skdb packages would generate yaml serialized data structs
01:13 < kanzure> these structs would be the files that the tools are programmed to physically follow and/or implement
01:13 < kanzure> simple enough, no?
01:14 < fenn> yeah, the yaml will get boiled down into longer and longer sequences of lower level data, until it reaches basic 'move motor' type information
01:14 < kanzure> or "move your ass, human!"
01:14 < fenn> well, you'd want to give the human higher level data
01:14 < fenn> depending on their skill level, of course
01:15 < fenn> you can say 'now solder r1. now solder r2' to an electronics pro
01:15 < kanzure> I was thinking something more subtle; electric shocks? joking aside, yes
01:15 < fenn> er, can't
01:15 < fenn> http://ladyada.net/make/usbtinyisp/solder.html
01:16 < fenn> it would be neat if we could automatically generate instructions like that
01:17 < kanzure> she's a classic
01:17 < kanzure> how many times has she been on Slashdot now? three? four?
01:17 < fenn> dunno, slashdot is so crap anymore i dont read it
01:17 < kanzure> especially after the electronics "SHE'S A WOMAN WITH ELECTRONS BUZZING AROUND, A TERRORIST! JUMP HER!" scare
01:18 -!- Splicer2 [n=p@h174n1c1o261.bredband.skanova.com] has quit [Read error: 110 (Connection timed out)]
01:21 < fenn> could you explain what this line means? To continue: just as you cannot search for software based on functionality, you cannot search for other tools based on functionality, except in as much as the language and social context allows you to express similar ideas that others have had before (natural languages have allowed this to some extent)
01:22 < kanzure> yes
01:22 < kanzure> suppose you 'know' that something must exist out there in the world
01:22 < kanzure> try to find it on Google without having verbal grounding in reality
01:22 < kanzure> knowing how other people would word it.
01:22 < fenn> sure i had that problem the other day with eval()
01:22 < kanzure> same thing with software ... you don't search for "if then if then if then" (since that'd be programming the thing you want!)
01:23 < kanzure> you search for tags and descriptions etc., there is a lot of social context that programmers usually tend to forget ... they are not intuiting their programs from out of the blue :)
01:23 < kanzure> as much as I'd like to think I am ...
01:23 < fenn> you read too much for that to be true
01:24 < kanzure> <-- tainted
01:24 < kanzure> but I started off a total moron, so perhaps not?
01:24 < fenn> back before the internet, i came up with the idea that we only really have three or four original thoughts in a year (actually i was a bit more harsh, saying all thoughts were derived from someone else)
01:25 < kanzure> sure, aggregation
01:25 < fenn> but see, we dont realize it, we think they're all new ideas and belong to us
01:25 < kanzure> permutation/mutation/insight v. recombination
01:25 < kanzure> s/recombination/recombination+aggregation/
01:26 < kanzure> perhaps permutation and mutation would go along with refactoring and documenting
01:26 < fenn> no, refactoring is generalizing
01:26 < fenn> or categorizing sometimes
01:26 < kanzure> hm.
01:27 < fenn> the point of refactoring is that it's not a creative act
01:27 < fenn> you keep the same functionality but make a program easier to modify or improve upon
01:27 < kanzure> hm, yes, so therefore it doesn't fit on that spectrum I was using above
01:27 < fenn> epicycles -> kepler's law
01:28 < fenn> can you imagine epicycles with relativity thrown in?
01:28 < kanzure> epicycles were simply the rotations around celestial bodies, right?
01:28 < kanzure> relativity is then just observer bias factored in, yes?
01:29 < fenn> sorta. they said spheres are perfect so therefore planets must move in circles, or at least circles on circles
01:29 < fenn> then they had circles on circles on circles to make it fit the data
01:29 < fenn> so kepler came along and refactored it, 'its an ellipse you dummies'
01:29 < kanzure> I am impressed + baffled by astronomers
01:29 < kanzure> I keep on looking at star charts and so on
01:29 < kanzure> and I have *NO* clue how these things work
01:29 < kanzure> the planet is freaking *rotating*
01:30 < kanzure> and all of the star charts don't seem to take that into account
01:30 < kanzure> how the hell can they predict where the stars will be no matter where you are in the world?
01:30 < fenn> oh, you can 'factor out' the planets rotation by taking an observation at the same time each day
01:30 < kanzure> doesn't it depend on your location of observin?
01:30 < fenn> or you can generalize the relationship between time and rotation of the sky
01:30 < kanzure> altitude, direction, coordinates, etc.?
01:31 < kanzure> angle of inclination, ...
01:31 < fenn> well, most observatories dont travel around :)
01:31 < kanzure> ah
01:31 < fenn> angle of inclination is what you're measuring
01:31 < kanzure> but wouldn't that depend on your xyz coords on the surface topology of the planet manifold?
01:31 < kanzure> remove the word 'manifold' from that sentence
01:32 < fenn> er.. angle of inclination relative to the horizon depends on the local topology, yes
01:32 < fenn> so usually they fix on the north star or something (i'm not an astronomer)
01:33 < kanzure> ohh
01:33 < kanzure> and then they can use time synchronization via watches and clocks
01:33 < kanzure> thus you should be able to determine what's going on based off of your watch
01:33 < kanzure> and the location of some main orienting ref object
01:33 < kanzure> and then extract your relative differences or something
01:33 < fenn> yep
01:33 < kanzure> never heard any talk of that, though
01:34 < fenn> the other half of astronomy is emission spectrography (or absorption if its a planet)
01:35 < kanzure> right, I can understand that
01:35 < kanzure> easy stuff, that's just astrophysics, photons and red shifts and shifts due to movements etc.
01:35 < fenn> oh, sure, easy
01:35 < fenn> ;)
01:35 < kanzure> much easier when you can do it from orbit
01:36 < fenn> nevermind that it's all LIES
01:36 < kanzure> without atmospheric interference
01:36 < kanzure> is it?
01:36 < fenn> it all seems rather tenuous to me
01:36 < fenn> this has redshift, therefore it must be moving away from us .. well, what if space is non-uniform?
01:37 < kanzure> 'space' itself is tricky stuff
01:37 < fenn> ok, i'll state it differently. what if the speed of light changes depending on where you are
01:38 < kanzure> while I'm not about to suggest the ancient aether theories, I'm not about to suggest that the 'vacuum of space' is a vacuum ... not with the nonzero energy content of the vacuum of space. It's 4 K.
01:38 < kanzure> sure, if it's not truly a vacuum then the speed of light is relative to the environment
01:38 < kanzure> just like we can 'slow' light down in ultracold environments
01:41 < fenn> well, i dont have a telescope so i basically have to take these peoples' word for it
01:42 < kanzure> launching a satellite is peanuts in comparison to most of my ideas, eh?
01:42 < kanzure> the guys in #space are building one
01:42 < kanzure> or maybe it's #astronomy
01:42 < fenn> launching a satellite is 1957 technology
01:42 < kanzure> then why the hell do people complain so much about doingi t
01:42 < kanzure> jackasses
01:43 < fenn> because they dont have the funding of the entire post-war soviet union
01:44 < kanzure> please, with your interest in gingery?
01:44 < kanzure> many rocket enthusiasts do metal shopping and make their own damn rockets by hand
01:44 < fenn> many rocket enthusiasts dont understand the extreme differences between a sounding rocket and an orbital rocket
01:45 < fenn> sure, what's another few decimal places
01:45 < kanzure> heh
01:45 < fenn> and its not just quantitative, it's qualitative because the costs go up exponentially
01:45 < kanzure> costs? 
01:46 < fenn> yes, costs: time, energy, motivation
01:46 < kanzure> motivation ... should never cost.
01:46 < fenn> bah you can say that about anything
01:46 < kanzure> "As I move, so I move the universe." - Danlo
01:46 < kanzure> it's up on my whiteboard
01:47 < fenn> time is nature's way of making sure everything doesn't happen at once - what is motivation for then?
01:47 < kanzure> Lion Kimbro would argue time is bullshit
01:47 < kanzure> http://www.speakeasy.org/~lion/
01:48 < fenn> ask him what we should do next :)
01:48 < kanzure> shit shit shit shit shit
01:48 < kanzure> http://www.davidzindell.com/
01:49 < fenn> Time is an Invention of Awareness
01:49 < fenn> sounds like it exists then?
01:49 < kanzure> but I was looking for http://hometown.aol.com/pylebc/zindell.htm
01:49 < kanzure> actually another page
01:50 < fenn> bleh.. that pseudo-spiritual stuff doesnt motivate me, unfortunately
01:51 < kanzure> ignore it
01:51 < kanzure> he's otherwise a high signal to noise author
01:51 < kanzure> on which Orion's Arm is mostly based
01:53 < kanzure> ah, here we go
01:53 < kanzure> http://home.austin.rr.com/lperson/fireser.html
01:58 < fenn> oh well, at least he doesnt trivialize a post-human intelligence the way charles stross does in accelerando
01:58 < kanzure> heh
01:58 < fenn> "look its a girl in a box"
01:58 < kanzure> hurray
01:58 < kanzure> hehe
01:58 < kanzure> yeah, I wouldn't mind writing some intense scifi
01:59 < kanzure> I certainly know I can read enough and do a massive review to aggregate enough future tech and philosophy in one gulp
01:59 < fenn> writing is hard, really
01:59 < fenn> not worth it
01:59 < fenn> why do you think there's so much crap on TV
02:00 < kanzure> I find writing to be easy.
02:00 < kanzure> refactoring is what's hard
02:01 < kanzure> and I much rather prefer my stories be told in physical constructions (==> skdb) or functionality rather than empty promises
02:04 < fenn> "IMPRINTING - Changing the metabolic pathways and neural network; redefining the synapses of the brain"  this one happens to be more real than most people know
02:04 < kanzure> location?
02:04 < fenn> http://hometown.aol.com/pylebc/zgloss.htm
02:04 < kanzure> just seems to be out of the blue-- ah
02:04 < kanzure> yep
02:04 < kanzure> your thoughts are changing metabolism, technically
02:05 < kanzure> because your thoughts require energy, no?
02:05 < kanzure> the mapping between thoughts and precise, discrete changes in cellular metabolism is interesting
02:05 < kanzure> I think this is where Gary Lynch did his LTP studies, but it wasn't from a subjective POV of thinking of course
02:05 < kanzure> (it was rat training + mem engrams)
02:06 < fenn> its not so much a change in the neural network as a change in the weight-assigning/backpropagation algorithm
02:07 < fenn> they never should have changed it from 'long lasting potentiation'
02:08 < fenn> one of these years i'll learn all the silly neuro jargon
02:11 -!- Splicer2 [n=p@h174n1c1o261.bredband.skanova.com] has joined #hplusroadmap
02:12 < kanzure> fenn: I'll write up that list of progs for skdb and so on tomorrow; I've been toying around with ikiwiki tonight and will be getting to work in the morning
02:13 < kanzure> tonight officially has sucked - inattentive + hyperaction => circles
02:16 < fenn> i'm processing the skdb article into something resembling prose
02:20 < kanzure> thank you
02:20 < kanzure> I'll probably join you on that sometime tomorrow
02:21 -!- kanzure [n=bryan@cpe-70-113-54-112.austin.res.rr.com] has quit ["Leaving."]
02:25 -!- Splicer [n=p@h174n1c1o261.bredband.skanova.com] has quit [Read error: 110 (Connection timed out)]
03:21 -!- Splicer2 [n=p@h174n1c1o261.bredband.skanova.com] has quit [Read error: 110 (Connection timed out)]
03:21 -!- Splicer2 [n=p@h210n2c1o261.bredband.skanova.com] has joined #hplusroadmap
03:42 -!- Splicer [n=p@h210n2c1o261.bredband.skanova.com] has joined #hplusroadmap
04:01 -!- Splicer2 [n=p@h210n2c1o261.bredband.skanova.com] has quit [Read error: 110 (Connection timed out)]
04:26 -!- Splicer2 [n=p@h210n2c1o261.bredband.skanova.com] has joined #hplusroadmap
04:28 -!- Netsplit leguin.freenode.net <-> irc.freenode.net quits: Splicer
05:40 -!- Splicer [n=p@h210n2c1o261.bredband.skanova.com] has joined #hplusroadmap
05:55 -!- Splicer2 [n=p@h210n2c1o261.bredband.skanova.com] has quit [Read error: 110 (Connection timed out)]
05:55 -!- Splicer2 [n=p@h70n2c1o261.bredband.skanova.com] has joined #hplusroadmap
06:05 -!- Splicer [n=p@h210n2c1o261.bredband.skanova.com] has quit [Read error: 110 (Connection timed out)]
06:51 -!- Splicer [n=p@h62n3c1o261.bredband.skanova.com] has joined #hplusroadmap
07:06 -!- Splicer2 [n=p@h70n2c1o261.bredband.skanova.com] has quit [Read error: 110 (Connection timed out)]
10:07 -!- Splicer2 [n=p@h28n2c1o261.bredband.skanova.com] has joined #hplusroadmap
10:19 -!- Splicer [n=p@h62n3c1o261.bredband.skanova.com] has quit [Read error: 110 (Connection timed out)]
10:29 -!- Splicer [n=p@h104n2c1o261.bredband.skanova.com] has joined #hplusroadmap
10:41 -!- Splicer2 [n=p@h28n2c1o261.bredband.skanova.com] has quit [Read error: 110 (Connection timed out)]
10:44 -!- kanzure [n=bryan@cpe-70-113-54-112.austin.res.rr.com] has joined #hplusroadmap
10:57 < kanzure> http://www.facebook.com/event.php?eid=17728995118 <-- Austin RepRap group with a n
10:57 < kanzure> http://www.actlab.utexas.edu/
11:00 < kanzure> Okay. Back to work.
11:11 < kanzure> http://math.utexas.edu/users/henrys/waystogowrong.html <-- depressing
11:15 < kanzure> http://heybryan.org/mediawiki/index.php/Societal_engineering_knowledge_database#todo
11:33 -!- Splicer2 [n=p@h104n2c1o261.bredband.skanova.com] has joined #hplusroadmap
11:44 < kanzure> Hey Splicer2.
11:45 -!- Splicer [n=p@h104n2c1o261.bredband.skanova.com] has quit [Read error: 110 (Connection timed out)]
11:53 < kanzure> fenn: I think we need to split agx-make into some subprograms.
12:19 < kanzure> fenn: agx-make is going to be somewhat of a nightmare. Do we want scripts to do API calls that would interface with the machinery? Or do we want to compile a final script/program to be executed over the particular fablab machinery network?
12:20 < kanzure> the compilation case does not allow the 'human readable output' alternatives (except if there's a terminal/printer that could be programmed to spit out the instructions ... hrm.)
13:31 < kanzure> I asked in #robotics for some help with the ideas of configuration of a local setup ... yeah. They just went off on random rants. 
13:37 < kanzure> I guess we can enforce configurations upon users. "To execute this script, the lab has to be moved to position-style-31410, proceed? WARNING: THIS WILL MAKE YOUR MACHINERY MOVE!". And then if they are motor-powered, they will wheel around into a particular config.
13:39 < kanzure> As for the API calls. The 'api layer' thing. Conveniently, all of your drivers *should* be up on skdb for others to download, or to at least include in revisions of the 'api layer' software for interfacing with the physical network. How would it work? How does the printing server usually work? 
13:42 < kanzure> http://cups.org/
13:42 < kanzure> 'CUPS uses the Internet Printing Protocol ("IPP") as the basis for managing print jobs and queues and adds network printer browsing and PostScript Printer Description ("PPD") based printing options to support real-world printing.'
13:42 < kanzure> heh, they describe it as real-world printing.
13:44 < kanzure> http://www.cups.org/documentation.php/overview.html
13:45 < kanzure> http://www.cups.org/documentation.php/spec-design.html even better
13:49 < kanzure> hm, ##cups is a pretty small group.
13:55 < kanzure> How does cups interface with drivers?
14:05 < kanzure> Linux kernel 2.6 added 'Vendor neutral virtualisation API' - what does this mean?
14:06 < kanzure> and why did bluetooth support have to be released with an entirely new version of the kernel (2.4)? that doesn't sound right
14:08 < kanzure> `Every version of a device, such as a printer, requires its own specialized commands. In contrast, most applications access devices (such as sending a file to a printer) by using high-level, generic commands, such as PRINTLN. The driver accepts these generic statements and converts them into the low-level commands required by the device.`
14:15 < kanzure> http://devresources.linux-foundation.org/dev/opendrivers/wiki/index.php/Documentation
14:21 < kanzure> "During startup, a driver registers with its bus, and the bus inserts the driver
14:21 < kanzure> into its internal list of drivers. The bus then attempts to bind the driver to the
14:21 < kanzure> bus's list of devices. A bus compares a list of bus-specific device ID numbers that it supports with the ID numbers
14:21 < kanzure> of the devices on the bus. If a match is made, the device is 'attached' to the driver. The driver allocates a driver-specific
14:21 < kanzure> object to describe the device. This usually includes a class-specific object as well,
14:21 < kanzure> which the driver uses to register the device with it's class"
14:23 < kanzure> http://wiki.kernelnewbies.org/KernelMentors
15:10 < kanzure> the guys in #kernelnewbies on oftc recommended http://www.lantronix.com/device-networking/embedded-device-servers/xport.html
15:10 < kanzure> but otherwise sat quietly.
15:11 < kanzure> how do you interface with the hardware? let's say a driver is written, then what? do you sit on /dev/ and listen with a pipeline?
15:13 < kanzure> looks like cupsd is based around the idea of maintaining the status quo of functionality (I am not using 'status quo' in the negative connotation here)
15:19 < kanzure> huh, looks like you just echo > /dev/you and cat /dev/you to get information. http://www.freesoftwaremagazine.com/articles/drivers_linux?page=0%2C6
15:20 < kanzure> I guess you can then have a message passing protocol to be implemented
15:26 < kanzure> userpsace example - http://www.freesoftwaremagazine.com/articles/drivers_linux?page=0%2C10
15:26 < kanzure> yep, just reading back and forth from /dev/deviceshere
15:26 < kanzure> hm
15:27 < kanzure> (the guys in #kernelnewbies suggested that it be all done over ethernet or usb, so that it's already in userspace -a  fine idea - but it needs to be generally extensible)
15:28 < kanzure> so I think it might be a good idea to go back to the 'API layer' idea, having a 'cupsd' equivalent to run things, with extendibility such that new 'protocols' can be implemented when necessary, and then we just hold general tools to a standard with an iron fist
15:30 < kanzure> On Saturday 19 April 2008, Stefano Vaj wrote:
15:30 < kanzure> > While I may have no final view on the subject, it should be
15:30 < kanzure> > underlined that *both* points of view are equally  "eugenetic". That
15:30 < kanzure> > of the deaf community and parents who want to ensure conformity of
15:30 < kanzure> > their offspring to their own Idealtypus, and that of the broader
15:30 < kanzure> > community who feels that would rather have it conform with a norm
15:30 < kanzure> > where deafness is fundamentally a disability, and little else. And I
15:30 < kanzure> > do not believe that a *political* and *aesthetic* choice between
15:30 < kanzure> > these two conflicting views can really be avoided through reference
15:30 < kanzure> > to some general governing principles.
15:33 < kanzure> re: the iron fist; protocol-software can be stored in skdb as packages themselves (just no physical expression). I wonder, to what extent do the tools get to control their own state, versus management of state on the server? Part and part? Not all tools are going to manage their state, and likewise some tools will manage their state more thoroughly than others; so cupsd has to take this into account.
15:34 < kanzure> the abstraction that cupsd facilitates is very nifty - you just press the 'print' button and it takes care of everything else. 
15:39 < kanzure> kind of hard to imagine how the /dev interface is supposed to work when I don't have any tools off the top of my head
15:39 < kanzure> and we get to design the tools too, that's always useful
15:39 < kanzure> but on the other hand, interfacing with other, older machinery would be useful as well
15:40 < kanzure> this isn't exactly the most standardized project though - many factories have completely custom-made solutions
15:44 < kanzure> ah, the drivers manage the state information
15:44 < kanzure> and then the userspace programs just get data back and forth
15:44 < kanzure> maybe. distinction of where to put what for userspace/kernelspace there is hazy.
15:46 < kanzure> okay, so we'd have code in skdb that could be used to interact with particular machines, or the user can code up his own driver and userspace program that can be interfaced with the 'cupsd equivalent'
15:46 < kanzure> now, agx-make and cupsd have to know about the local configuration - what machinery is connected related to the fablab, and what isn't? When there isn't something available, known to it, then it should default to 'human instruction mode' - where should it dump the instructions? Should agx-make dump the instructions state to the terminal screen?
15:52 < fenn> hi. still reading backlog
15:54 < fenn> printer analogy can only go so far. a printer will always use ink cartridges, will always print on paper, will always print 2d documents that eventually end up as a high-res bitmap
15:54 < fenn> all printers do this
15:55 < fenn> manufacturing technology is a lot more complex
15:55 < fenn> it might work for DNA reader/writer hardware
15:56 < fenn> i dont want to require any specific hardware like xport or even x86 processors
15:56 < fenn> that's part of the hardware 'infrastructure' that is unique to each user
15:57 < kanzure> sure
15:58 < fenn> state changes have an associated cost, which influences the optimization path
15:59 < fenn> buying a new machine is a change in state
15:59 < kanzure> no, I was talking about 'state change' in terms of what the server knows about the hardware, and what the hardware knows about itself (what position it is, for example)
15:59 < fenn> you might be able to hack the drill press into a milling machine, but you could also just buy a milling machine
15:59 < kanzure> or like the linux device drivers - the driver can maintain an internal state so that it knows what to expect from the port on the next interrupt or whatever
16:00 < fenn> oh, some printers are smarter than others, lets leave it at that
16:01 < kanzure> I see, so how does cupsd manage that?
16:01 < kanzure> I guess each new driver module just hides that 'smartness' away and lets cupsd work with it like any other driver
16:01 < fenn> judging by the vast array of printer drivers, each printer has its own driver
16:01 < kanzure> so it might be hiding or adding fake functionality
16:01 < fenn> right
16:02 < fenn> not necessarily fake functionality, just an abstraction layer
16:02 < fenn> wherever you have an interface there's an abstraction layer associated with it
16:02 < fenn> this applies to physical objects too?
16:02 < kanzure> eh?
16:03 < fenn> nevermind, too philosophical for me
16:03 < kanzure> okay, so when I was talking about my 'api layer' earlier, I guess I can convert that stuff into saying that it is the job of the driver to meet the standard specs for cupsd to work with ... then, all skdb scripts just implement one unified language for manufacturing
16:03 < kanzure> 'one unified language for manufacturing' or api calls
16:03 < kanzure> somebody suggested
16:03 < kanzure> tool.arm.moveLeft(90)
16:03 < kanzure> but that doesn't sound like a smart idea
16:03 < kanzure> that's very very messy
16:04 < fenn> no, that doesnt work, you try to make 'one unified language for manufacturing' and end up with a monster that nobody can use
16:04 < kanzure> (also, 3D object interpretation programs should be able to generate a list of movements or whatever)
16:04 < kanzure> right
16:04 < kanzure> so it has to be something else
16:04 < kanzure> you have much more experience in this area
16:04 < fenn> the STEP file format is a real-world example of trying to make one unified language for manufacturing
16:05 < fenn> i like the 'rhizopod' idea
16:05 < fenn> http://www.lantronix.com/device-networki
16:06 < fenn> not that
16:06 < fenn> http://scratchcomputing.com/projects/vectorsection/
16:06 < fenn> another graph :)
16:07 < kanzure> hm
16:07 < kanzure> I see many ways that we can implement reprogrammable factories
16:07 < kanzure> most of the tools will have microcontrollers, thus we can do a massive recompiling of everything down to that code, from parallel code down to the physical substrates
16:07 < kanzure> well
16:08 < kanzure> screw it, I guess we're going to have to demand standardization of shop setups
16:08 < kanzure> just like the 'debian definition' is very specific
16:08 < kanzure> I'd like to avoid that ... but I don't see another way.
16:08 < fenn> there is a subset of g-code that is conserved across all industry, that's the g1 command (and possibly g2/g3)
16:09 < kanzure> this means that "you *must* have an arm that passes these standardization codes, and it *must* be in this location, and it must be able to move at this rate and with this precision, etc."
16:09 < fenn> G1 X0 F60 means goto x 0 at 60 inches or mm per minute
16:09 < kanzure> uh-huh
16:10 < fenn> thats a lot of musts.. i only know one person with a functioning robot arm
16:10 < kanzure> oh, I mean a general arm
16:10 < kanzure> like the ones we see in many industrial manufacturing operations, esp. automobile industry
16:11 < fenn> yea, a robot arm
16:11 < fenn> oh wait, two
16:11 < fenn> they would both laugh at our idea, so you see, um.. i dont know what i'm saying
16:12 < fenn> industry is very conservative
16:12 < fenn> it's why people still use g-code
16:12 < kanzure> I'm guessing the real reason is because they don't have young kids coming in to redesign the factories
16:12 < kanzure> I bet they think it's impossible
16:12 < kanzure> + there's not enough people wanting completely new factories from the ground up
16:13 < fenn> the reason japan and germany are so successful is because we bombed the shit out of all their old factories and they were forced to build new ones
16:13 < kanzure> and open source solutions are long-term, reconfiguration being needed for updates
16:14 < kanzure> FPGAs for factories
16:14 < fenn> indeed
16:15 < kanzure> so.
16:15 < kanzure> consensus?
16:15 < kanzure> oh
16:16 < fenn> its not going to be a viral meme that spreads through industry, they're going to laugh at the whole idea of autogenix until they're forced to scramble and catch up
16:16 < kanzure> sure
16:16 < kanzure> I don't care about industry
16:16 < fenn> ok, good
16:16 < kanzure> (I mean, it would be great if they did want to contribute, of course)
16:17 < kanzure> but I was asking for a consensus on what to do with our cupsd clone/hack
16:17 < fenn> consensus means everyone agrees
16:17 < kanzure> do we want to force 'standardization' (with all of those musts) to make distribution variants for shops? "Yep, I'm running an xyz flavor of shop."
16:18 < kanzure> else, how do we make this reconfigurable such that any package could specify instructions for no particular implementation
16:18 < fenn> standardization is just another word for black box
16:18 < kanzure> distributions would have very specific rules
16:19 < kanzure> "there is always a type-354r14 class 1294 arm at coordinates 341, 414"
16:19 < fenn> that sounds too fragile, all DLL-hell and no duck-typing
16:19 < kanzure> right, but I don't know how to do the alternative quite yet
16:19 < kanzure> oh
16:19 < kanzure> I guess any machinery that you *do* add, must be in skdb and fully specced out
16:19 < fenn> first of all, why does the arm have to be at 341,414
16:20 < kanzure> needs to be out of the way and have its own spot
16:20 < kanzure> then the skdb program would run
16:20 < kanzure> and move it around to do its thing for that particular project
16:20 < kanzure> *particular package
16:20 < kanzure> (I don't like it either.)
16:20 < fenn> neither of those things have anything to do with the function of an arm, which is to position objects
16:21 < fenn> the arm has to be relative to something else, (or be not in the way, relative to seomething else)
16:21 < kanzure> right, ideally that would be a movable arm, so that you could get cargo and move it from one area to the next
16:21 < kanzure> wheels or something, I don't care
16:21 < fenn> that's more than an arm
16:21 < kanzure> anyway, we both know we hate this implementation
16:21 < kanzure> so back to the reconfigurable one
16:22 < kanzure> like I said - any machine you do add to your setup, you have to add an entry into skdb and also tell cupsd that you have it (part of the install / setup process, easy)
16:22 < kanzure> then, you have to find a 'close enough class' that is already implemented
16:22 < fenn> skdb is social knowledge, so you'd only add an entry if nobody else had one quite like it
16:22 < kanzure> correct
16:22 < kanzure> if it's already there, you'd take it
16:22 < fenn> ok
16:23 < kanzure> which would download a driver for you
16:23 < kanzure> but if you have a proprietary instrument, though
16:23 < kanzure> things are going to be different
16:23 < fenn> define proprietary
16:23 < kanzure> not open source, you have to consider the driver a blackbox
16:23 < fenn> it does have some specifications though
16:23 < kanzure> how so?
16:24 < fenn> you know, 50 pages/min, 600dpi, requires 110VAC, etc
16:24 < fenn> and presumably the company provides instrutions for how to use the software
16:24 < fenn> (or else we're in an nvidia mess)
16:26 < kanzure> if you get those specs from the company, then you have to hack together the interface with cupsd to that driver
16:26 < kanzure> now, there's one part missing I think
16:26 < fenn> ok, so besides not knowing how to build the thing, what else do we have to worry about?
16:27 < kanzure> you have to be able to interpret the code in (skdb) relative to the new tool you have
16:27 < kanzure> this would be a plugin to agx-make, right?
16:27 < kanzure> erm
16:27 < kanzure> your new tool exposures some general functionality
16:27 < kanzure> once you tell agx-make how to access that functionality,
16:28 < kanzure> you need to tell your computer how to interpret requests for that functionality from (.skdb) packages that are running their code
16:28 < kanzure> does that make sense?
16:28 < fenn> there would be some server running, listening for requests to make stuff
16:29 < fenn> not sure i see the problem?
16:29 < fenn> you to describe the capabilities of the machine?
16:29 < fenn> s/you/how/
16:29 < kanzure> sigh
16:30 < kanzure> example: skdb package chair
16:30 < kanzure> chair has some standardized code to make this chair, it's in the file make_chair.py or something
16:30 < kanzure> (the file name was mentioned in the metadata file / skdb file or whatever)
16:30 < kanzure> make_chair.py has to tell it how to make the chair - it can say "here's this 3D file, make this"
16:30 < kanzure> or it can say other things too like "here's how to specifically maneuver about to make this"
16:31 < kanzure> now, the specific maneuvering is *general* and *abstract* since it shouldn't ever assume you have specific hardware
16:31 < fenn> 3d file = cad, specific maneuvers = cam output
16:31 < kanzure> yeah, but what about the overall manufacturing circuit?
16:31 < fenn> cam is the process of taking a cad file, looking at the machine you have, and making specific maneuvers
16:32 < fenn> traditional cam software is very very stupid
16:32 < kanzure> okay, so cam would part of cupsd
16:32 < kanzure> *would be part of
16:32 < kanzure> also, it has to know what the current state of the manufacturing process is at
16:32 < fenn> it usually doesnt know *anything* and you have to tell it how to do everything, one step at a time
16:32 < kanzure> so it would have to know that 'we have a partial chair sitting on platform A223'
16:32 < kanzure> but you can't do that though
16:32 < kanzure> you have various hardware implementations
16:32 < kanzure> otherwise we get to those 'too many musts'
16:33 < fenn> why would it have to know we have a partial chair? cant it just know that there was a job running and got interrupted?
16:36 < kanzure> sure
16:36 < fenn> traditional robots are blind and forgetful
16:36 < kanzure> sigh
16:36 < kanzure> you dont' seem to get it thoguh
16:36 < fenn> you're right
16:36 < kanzure> you keep on saying that they are blind and stupid and that is true
16:36 < kanzure> but the issue is that the hardware is different
16:37 < kanzure> my setup is not necessarily the same as your setup (we have established this -- otherwise "too many musts" etc)
16:37 < fenn> the reason they are blind and stupid is that the software to make them otherwise is hard to write
16:37 < kanzure> so the hardware implementation of all of the tools and machinery has different protocols
16:37 < kanzure> and the simplification layer doesnt' necessarily know how to connect the (skdb) calls to the driver calls for the machinery
16:37 < fenn> it doesnt?
16:38 < kanzure> no, how would it?
16:38 < fenn> simplification is 3d file => sequence of movements, right?
16:38 < fenn> yes/no?
16:39 < fenn> assuming it is, then each piece of hardware has some metadata provided by a skdb package that is installed on the user's system
16:39 < fenn> and that metadata describes the functionality of each machine
16:40 < fenn> so there are rules coded in other skdb packages explaining how to go from raw lumber to radially symmetrical objects such as chair legs
16:40 < fenn> and other rules explaining assembly of chair legs into chairs
16:41 < fenn> you dont necessarily need a lathe to make a chair leg, but it's the most efficient method (in terms of time, cutter wear, surface finish)
16:42 < fenn> say you had a cnc milling machine, you could mill a bas-relief chair leg into a block of wood, then flip it over and do the other side
16:42 < fenn> net result: radially symmetric object
16:43 < fenn> clamping a round shape is a little tricky but it will work
16:44 < fenn> figuring out the clamping is usually the most costly and time-consuming part of a cnc job
16:44 < fenn> so its really strange that there is no automated software for it
16:52 < fenn> mental map of workpiece holding systems: http://www.emeraldinsight.com/fig/0330220201017.png
16:53 < kanzure> "and that metadata describes the functionality of each machine"
16:53 < kanzure> huh
16:53 < kanzure> I thought we agreed that you can't formally describe functionality
16:56 < fenn> i never said that, you keep saying it and i disagree
16:56 < fenn> that's why i say each package has a provides: section
16:58 < kanzure> how would that be possible
16:58 < kanzure> klfajsfdkjasl;fjmal;dkfjaskj
16:58 < kanzure> provides is not the same thing as functionality
16:58 < kanzure> the program itself is the functionality
16:58 < kanzure> and is explicitly defined by the code
16:59 < kanzure> you have never disagreed with me on the inability to search for software except by natural languages
16:59 < fenn> there's no classification system for software functionality
17:00 < fenn> however, there are classification systems for physical functionality
17:00 < fenn> example: transportation
17:00 < fenn> if there were no classification, you'd have to say, "find me a thing.. that can move stuff from one location to another"
17:01 < fenn> then you'd have to go through all the ambiguities of that statement
17:01 < fenn> define 'stuff' and 'one location' etc
17:01 < kanzure> I don't understand how that helps the situation
17:01 < fenn> because cars and trains and airplanes are classified as transportation
17:02 < kanzure> so what?
17:02 < fenn> so you can search for transportation
17:02 < kanzure> that's social knowledge
17:02 < fenn> yes
17:02 < kanzure> that's the other part of skdb
17:02 < kanzure> we're discussing the manufacturing code
17:02 < fenn> ok, there's also "3 axis subtractive machining"
17:03 < fenn> is that not a functionality?
17:04 < fenn> a lathe is 2-axis machining, or single-point turning
17:04 < kanzure> you are hurting me :(
17:04 < kanzure> please explain what the .skdb files would have for their manufacturing code in that scenario
17:04 < kanzure> and how would that interface with the random-ass hardware that you happen to have in your shop environment
17:06 < fenn> chair would have 3d cad files showing a radially symmetrical object and describing its material (wood)
17:07 < fenn> algorithm sees that you have lathe installed, which provides 2-axis-machining, it consults the libmachining to find that yes, you can make radially symmetrical objects from wood with 2-axis-machining
17:08 < fenn> algorithm also sees that you have mill installed, with provides 3-axis-machining
17:08 < fenn> this can also make radially symmetrical objects, but the cost is higher
17:09 < kanzure> what is 'algorithm' - is it agx-make? the python scripts for that particular skdb package?
17:09 < fenn> so the algorithm chooses lathe and invokes CAM routines to cut the part on a lathe, then passes the job off to the cupsd layer
17:09 < kanzure> wait, what?
17:09 < fenn> its the program that traverses the big dependency tree describing everything
17:09 < kanzure> okay, so this is 'job-creation routine'
17:10 < kanzure> so agx-make has two parts: (1) job maker/builder, and (2) the scheduler/head-of-the-octopus
17:11 < fenn> you have to pretend to build the job before you can decide if it's worth making (unless there are heuristics available)
17:11 < fenn> for all intents and purposes pretending to build it is the same as building it
17:11 < kanzure> pretending to build == simulation?
17:11 < fenn> yes
17:11 < kanzure> or do you mean 'in your head, does it make sense'?
17:11 < kanzure> okay
17:12 < kanzure> so
17:12 < fenn> i mean, you'd invoke cam routines, see how long it takes by adding up all the movements and feed rates
17:12 < kanzure> how would the algorithm see that you have lathe installed? you need a local description of everything you have in your shop, obviously, and then cross-referenced to skdb out on the internet?
17:13 < fenn> yes, except for the internet part
17:13 < fenn> its a local 'installation'
17:13 < fenn> metadata for every piece of hardware in your shop
17:14 < fenn> maybe you need cad schematics too
17:14 < fenn> models, not schematics
17:15 < kanzure> it's a local installation, but ideally your parts are described on the internet, no? the only reason they would not be would be if (1) they are proprietary and to some extent closed, or (2) you haven't gotten around to doing a writeup ;)
17:15 < fenn> its not as hard as it sounds, most lathes are more or less identical, but with a few dimensions different
17:15 < fenn> the same with drill bits, bolts, etc
17:16 < fenn> sometimes it can cost less to buy something standardized than to try to model some old piece of junk
17:17 < fenn> but if people want to model junk, that's fine too
17:17 < fenn> depends on how much you value your time
17:18 < fenn> so, do you agree that it's possible to describe functionality?
17:19 < kanzure> the description is only 'social' in nature
17:19 < kanzure> and I'm fine with that, as long as we keep that straight
17:20 < kanzure> it's just kind of unfortunate
17:20 < kanzure> oh, I get it now
17:20 < kanzure> you have to know what you have built
17:20 < kanzure> heh
17:20 < fenn> the description '2 axis machining' is a kind of black-box
17:20 < kanzure> in terms of what others have previously built (so that you can classify it properly)
17:20 < kanzure> yeah, if you built a '2 axis machining' thing and didn't know it, good luck trying to hook up with the general api or whatever
17:20 < kanzure> although you seem to be arguing that skdb packages would not specify their own 'agx-make' code
17:21 < fenn> you can build a physics simulation of the cutting process, but it would take huge amounts of computer power to run that on every package
17:21 < fenn> there's got to be some way to automatically generalize, but i dont know how to do it
17:22 < fenn> some skdb packages would be processes only, not physical objects
17:22 < fenn> these would be mostly code
17:23 < fenn> so the chair package could specify 2-axis-machining, or they might be lazy and let the computer figure it out
17:24 < fenn> i think i'd prefer the lazy route since it should reveal the most optimal path
17:24 < fenn> you dont _need_ a lathe to make a chair
17:25 < fenn> there are a lot of inflexible ways of thought.. we call them culture :)
17:25 < kanzure> huh?
17:26 < fenn> "everyone knows that chair legs are made on a lathe"
17:26 < fenn> then you look at my extruded plastic thing and dont know what it is
17:27 < fenn> or something like this http://www.n55.dk/MANUALS/DYNAMIC_CHAIR/CHAIR.html
17:28 < fenn> the dynamic chair is very efficient in its manufacturing process because it uses the same tools they use to build everything else
17:28 < fenn> it's probably not a good choice if you dont have access to a sheet metal brake
17:30 < fenn> now, i'm not saying the computer will know how to come up with this innovative way of making a chair, because that requires generalizing the concept of what a chair does
17:31 < fenn> but you could program a 'fitness function' for 'chairness' and let a genetic algorithm pull bits and pieces from skdb
17:32 < kanzure> huh??
17:32 < fenn> have you seen this page? http://ccsl.mae.cornell.edu/
17:33 < kanzure> so
17:33 < kanzure> even though we have an exact chair description and so on
17:33 < kanzure> we still use a genetic algo??
17:34 < fenn> an exact chair description is brittle
17:34 < fenn> if you dont have all the pieces required for building the chair exactly the way it's specified, you're stuck
17:35 < kanzure> why do you need a genetic algorithm though
17:35 < fenn> if you have a genetic algo for building chairs, you can automatically make the chair out of whatever you have (maybe)
17:35 < kanzure> you've completed destroyed my entire concept of wtf this thing is going to be doing
17:35 < kanzure> :)
17:35 < fenn> i know :(
17:35 < kanzure> let's just assume that you have the right materials
17:36 < fenn> if you have the exact tools and the exact materials you can make the exact replica
17:36 < fenn> i just dont think black boxing is all that useful
17:36 < fenn> it leads to DLL-hell
17:36 < fenn> it leads to everything we associate with computers
17:37 < kanzure> so I don't know what's going on now
17:37 < kanzure> what's the point of adding .skdb packages if they don't tell you anything
17:37 < fenn> but they do tell you things
17:38 < fenn> say we have a package gen-chair
17:38 < fenn> gen could stand for generic or genetic algorithm
17:38 < fenn> it's a generalized chair
17:38 < kanzure> right?
17:39 < kanzure> so it has to tell you how to make it still
17:39 < fenn> you feed it _specific_ things you have, it pieces them together in random ways and tries to improve on its design, where improve is based on the fitness function
17:39 < fenn> then it dumps its generated model into some manufacturable format
17:39 < kanzure> oh, right
17:39 < kanzure> because the items in skdb aren't necessarily the ones you locally have
17:39 < fenn> the manufacturability would be part of the fitness function i guess
17:39 < kanzure> so the piecing-together and scoring function would involve autospec again
17:40 < kanzure> to make sure the units resolve
17:40 < kanzure> and that you have the local resources etc.
17:40 < kanzure> (inventory)
17:40 < kanzure> then the manufacturing format - this still needs some work though ... 
17:40 < fenn> yep
17:41 < fenn> i'm sure there's a manufacturing ontology out there already
17:41 < fenn> like http://efunda.com/
17:43 < fenn> unfortunately they have no quantitative analysis of each process
17:44 < kanzure> the manufacturing format would the 'job'
17:45 < kanzure> which cupsd/equivalent would schedule, queue up and execute
17:45 < fenn> cups has it easy for printing because there's no optimization possible
17:46 < fenn> its the same thing every time
17:46 < kanzure> all optimization is done during the job-production step
17:46 < kanzure> so by the time it gets to cupsd, no optimization is needed
17:46 < fenn> yeah but there is inter-job optimization too
17:46 < kanzure> hm
17:46 < kanzure> oh, that's true
17:46 < fenn> like, while the furnace is still hot, lets do these other castings quick
17:46 < kanzure> okay, so the manufacturing-format has what optimized?
17:46 < kanzure> it's optimized to local tools, machinery, etc., right?
17:46 < fenn> optimized to the end user
17:47 < kanzure> 'tailored' for the end user
17:47 < kanzure> is more like ti
17:47 < kanzure> and then cupsd would do job-optimization, then job-scheduling/queuing.
17:47 < kanzure> job optimization sounds kind of hard
17:47 < kanzure> I am imagining a yaml format for graphing it out physically
17:47 < kanzure> where nodes are processes in the manufacturing steps
17:47 < kanzure> or something?
17:47 < kanzure> and then it would optimize the movement of the object from one place to another?
17:47 < kanzure> does that fit what you were thinking?
17:48 < fenn> optimization would occur at each level of blackboxing (abstraction)
17:48 < kanzure> http://www.bathsheba.com/ artist doing 3d metal printing
17:48 < kanzure> what does that mena
17:48 < kanzure> *mean
17:48 < kanzure> you said basically nothing to me there :)
17:48 < fenn> so as you get closer to sequences of movements, you shuffle things around after each expansion step
17:49 < fenn> first you knead the bread, then you bake the bread, then you eat the bread
17:49 < kanzure> oh, so you mean 'optimize the kneading process' ?
17:49 < kanzure> how do you know that it does not violate something that has to occur during the kneading?
17:49 < kanzure> http://www.bathsheba.com/sculpt/process/index.html#3dprint
17:50 < fenn> there are rules explaining what you can and cant do
17:51 < fenn> or, you could define a fitness function for 'kneaded bread' and let it try all the permutations :P
17:51 < Splicer2> i'm guessing you've seen the open source CAM portion of this: http://www.editthis.info/opencam/Main_Page
17:52 -!- Splicer2 is now known as Splicer
17:52 < fenn> yes i wrote half of that
17:52 < Splicer> hehe
17:52 < kanzure> fenn: how depressing (re: last msg)
17:53 < kanzure> I mean, that it's such a small number of people that might have a clue of what's going on 
17:54 < kanzure> fenn: how would you describe the rules for allowed/unallowed edits to the process? I guess you can have a 'no rewrite zone' and then stuff that you don't care about, but ...
17:54 < kanzure> give me a reason why we want 'job optimization' and evidence that it is possible
17:54 < fenn> uhhh.. what?
17:54 < kanzure> it's already tailored to your machines, your layout, your resources, ... (from the other stage)
17:55 < kanzure> (from the manufacturing-format generator)
17:55 < fenn> because otherwise the computer will do things in what appears to be the stupidest order possible
17:55 < kanzure> wasn't that programmed originally by the skdb package maintainer?
17:57 < kanzure> oh
17:57 < kanzure> no, I suppose not
17:57 < kanzure> since your configuration/layout for your machines is different
17:57 < fenn> what OS are you running, debian or ubuntu?
17:57 < kanzure> deb
17:57 < kanzure> so you said to blackbox it all, and then just optimize each step really
17:57 < kanzure> so I'd call this layout optimization
17:57 < fenn> would you mind installing emc2-sim so i can demonstrate some stuff?
17:57 < kanzure> or optimization due to layout
17:58 < kanzure> let me check
17:58 < fenn> its not in the repo's you have to add a repo to /etc/apt/sources.list
17:58 < kanzure> ugh
17:58 < kanzure> can we do it later? I'm completely willing, but going off to do some random stuff in a few moments
17:59 < kanzure> re: optimization at the cupsd stage - what is there beyond 'layout optimization' (obviously you want to choose the shortest possible path, don't be criss-crossing all over the shop)
17:59 < kanzure> and I'm gone for a while or something
18:00 < fenn> ok, emc stuff later
18:00 < fenn> layout optimization is really about conserving time and energy
18:01 < fenn> keeping the oven warm for the next batch is conserving energy
18:01 < fenn> but if you try to do everything in one big batch, you might end up missing some deadline (or just take 'too long')
18:02 < kanzure> huh?
18:04 < fenn> you can boil time and energy and materials down into dollars, and then just optimize for dollars
18:04 < fenn> but there are constraints, you might not have enough (time energy materials)
18:04 < fenn> there may be no solution
18:05 < fenn> usually though, there are too many solutions
18:05 < kanzure> so it's another GA layer of optimization?
18:05 < kanzure> what are the ways of permutation and combination for this layer of GAs?
18:05 < kanzure> obviously it's not manufacturing-formt
18:05 < kanzure> *format
18:05 < kanzure> but instead it's the options specific to using the machines
18:05 < kanzure> or something like that?
18:05 < kanzure> you mentioned 'culture' earlier
18:05 < fenn> i was imagining it as a highly structured yaml file that gets boiled down into a flat sequence of movements
18:06 < fenn> and at each stage of 'boiling' you rearrange the pieces
18:06 < fenn> you could put multiple jobs into the same big yaml file at the start
18:07 < fenn> or maybe just keep dumping them in at the bottom of the file, like a queue
18:09 < fenn> i like files because i can interrupt the system and easily see what is going on
18:10 < fenn> there are lots of tools for inspecting and manipulating files and i already know how to use them
18:11 < fenn> anyway, 'culture' is not just what you have, its what you have to think with
18:11 < fenn> you can build a new machine if you can think it
18:26 < Splicer> I was thinking about that today... concerning this bioDIY thing, I think people view it differently in different countries.  
18:28 < Splicer> I think it doesn´t feel as threatening in Canada for instance, that it lacks that tint.
18:29 < fenn> sure, they didnt have to listen to endless news stories about anthrax
18:29 < fenn> and a 'diy chemist' is not necessarily someone making bombs or drugs
18:30 < fenn> (if you're canadian)
18:30 < fenn> that's not what i mean by culture though
18:30 < Splicer> people should probably be more concerned with a computer somewhere accidentally doing something.. but people are used to those now
18:31 < fenn> i want you to worry less, live more
18:31 < fenn> srsly.. you're more likely to die in a car wreck
18:32 < Splicer> yeah
18:33 < Splicer> it puts a cap on things
18:35 < kanzure> fenn: so, split it up into microjobs, and then optimize each of the microjobs so that you don't unheat the oven and other stuff like that
18:35 < kanzure> it would be something like 'trend analysis' across the microjobs perhaps
18:42 < Splicer> you´re talking about building a unified CAM process and manufacturing format right? Which would take a recepie as input and optimize itself to te tools at hand? 
18:43 < fenn> yep
18:43 < fenn> Splicer: congratulations on actually 'getting it' unlike epitron :)
18:44 < fenn> Splicer: here's a pretty picture i drew showing the overall structure: http://heybryan.org/mediawiki/index.php/skdb
18:49 < kanzure> fenn: worst case scenario: it doesn't auto-optimize. fix: somebody adds it in. I think that if it just *flat out works* in the first place, then that's fine. So let's just code in an optimize() method (for this job-optimization, not manufacturing-format optimization (where we do the GA re: local tools and resources)
19:02 < Splicer> because the skdb knows everything it's ideal to automatically optimize the solution. If it is fed a welldefined problem, that's the purpose of the system?
19:03 < fenn> it's also useful for determining what to do next
19:03 < fenn> say you have a goal in mind, if you can define what your present capabilities are it can find the best path ( i guess that's the same as optimizing)
19:04 < Splicer> yeah
19:05 < Splicer> it's a very cool idea... but huge
19:06 < fenn> i expect it to take a long time to get to that point, so we'll be making useful tools in the meanwhile
19:12 < fenn> non-optimized is fine i guess, just frustrating to watch: http://video.google.com/videoplay?docid=5506285167473738661&q=&hl=en
19:12 < fenn> same brazilian guys
19:20 < kanzure> fenn: so you agree it's okay if we ignore that 2nd layer of optimization for now? otherwise I think the architecture is good to go
19:37 < kanzure> Splicer: it's actually quite small
19:37 < kanzure> the infrastructure/architecture is pretty simple
19:37 < kanzure> now that we know what it is ;)
20:24 < Splicer> I don´t know, the more one thinks about it the bigger it gets don´t you find?
20:30 < Splicer> When I look at your pic, I can´t even figure out what a question would look like that would optimize the connectors in it... it sounds like the kind of problem people have been struggling with for a long time, and the answer would border to somekind of general intelligence.
20:30 < Splicer> "Build me a radio"
20:32 < fenn> Splicer: two two hexagons are nodes in the tree, you want to find the optimum path by hopping from hexagon to hexagon
20:33 < Splicer> what?
20:34 < fenn> the top to bottom stuff happens more or less automatically
20:34 < fenn> going from start to finish is left to right though
20:36 < Splicer> you´re saying; everything is already defined and because of the structure it's defined in, the solution is just following a straight path?
20:39 < fenn> the solution is finding the shortest path
20:42 < Splicer> it sounds a bit like the problem of trying to get a computer to understand natural language, it's not as trivial as it sounds.
20:44 < kanzure> haha
20:44 < kanzure> that's why it's not natural language
20:45 < fenn> fortunately most engineering languages are formal notations
20:46 < fenn> there is a lot of 'common sense' to be dealt with though
20:46 < kanzure> it would suck if you had to speak to your mechanical conveyor belt instead of formal specs
20:46 < kanzure> or formal voltages
20:46 < fenn> transformal voltages? :)
20:47 < kanzure> <-- clueless
20:48 < Splicer> ambiguities aside, formal language is also jumping between hexagons and evaluating paths.
20:48 < kanzure> huh?
20:48 < kanzure> 'jumping' makes your sentence not compile in my brain
20:49 < fenn> traversing trees
20:49 < Splicer> yeah
20:53 < kanzure> Splicer: so do you see how it's not like trying to get a computer to parse natural language?
20:56 < kanzure> How weird. A while ago I was clicking through some facebook pages (repetitions ... clicked through 40 pages because their interface sucks; I probably should have gone installed a userscript for facebook to autoload the next page and attach to the end of the screen, but whatever),
20:56 < kanzure>  and at one point I got an idea for a next step in one fo the tasks I was working on, but I didn't do it *because I was not sure which xterm session was the one I wanted*. How weird is that.
20:57 < Splicer> I don´t know if I understood everyting.. but isn´t it almost exactly the same? The languagespace is defined in the skdb in some formal notation and getting an answer to a question is just traversing the tree?
20:57 < kanzure> what question?
20:57 < kanzure> yeah, okay, I see what you mean
20:57 < kanzure> the thing is that we can only ask very exact questions
20:57 < Splicer> "using this input, optimize it"
20:57 < kanzure> in the case of a self-replicating machine, we hypothesize that it's simply where all of the packages completely loop together
20:58 < kanzure> ah, well, the optimization stuff is two-fold
20:58 < fenn> the idea is to 'make no assumptions'
20:58 < kanzure> it's all on the userend
20:58 < kanzure> (1) optimize it to the materials and resources available, plus the tools available - this is just a GA and is simple, plus a scoring function
20:58 < kanzure> (2) possibly optimize it to the microjobs or whatever, so that you conserve power and don't waste heat, or don't go in a zigzag when a line would work
20:58 < fenn> sloppy questions are fine, and preferred if they reveal a better solution that a more strict question might have prevented (inadvertently)
20:58 < kanzure> so the optimization is well-defined
20:59 < kanzure> and more optimization algos can be added of course, and users can download 'em to run them
20:59 < kanzure> hm, sloppy questions might be harder to ask though
20:59 < kanzure> you can't just search for the d-loops
20:59 < kanzure> I guess I need an example of a sloppy question
20:59 < kanzure> "find me a toaster" - that's sloppy, right? you would get everything tagged/described-as toaster
20:59 < kanzure> or any aliased with the word toaster
20:59 < fenn> yes, its hard for humans to make just the right amount of uncertainty
20:59 < kanzure> *anything
21:00 < Splicer> those are the oldest games in computer science i think
21:00 < fenn> we want to run our neural nets in reverse and generate a plausible situation, then ask the machine to do it
21:00 < kanzure> yes, they are the oldest games - and we are damn good at them too
21:01 < kanzure> fenn: huh?
21:01 < kanzure> I don't think that's an accurate description really
21:01 < fenn> that's what people want to do
21:01 < Splicer> the best example i know is the google translator
21:01 < kanzure> oh
21:01 < kanzure> fenn: yes
21:01 < kanzure> Splicer: how is that an example of what we are describing?
21:01 < kanzure> Google Translator is natural language processing (actually, it's a lot of lookups and replaces, plus grammar rules and so on)
21:02 < kanzure> actually, Google search fails in the multilingual domains, eh?
21:02 < fenn> google translator sucks, it has no sense of context
21:02 < kanzure> I was suggesting to Jimmy Wales something called MPOV search.
21:02 < kanzure> Jimmy was being bashed to death in the news a few months ago
21:02 < kanzure> he released Wikia Search, and had barely crawled a few hundred thousand sites
21:03 < kanzure> so everybody was very bitter at him
21:03 < kanzure> I jumped on the opportunity and started corresponding with him
21:03 < kanzure> Wikia Search is basically built on lucene, nutch, and a few social networking + wiki frontends for their website (yikes!)
21:03 < kanzure> all open source, so I started thinking about that
21:04 < kanzure> and one of the ideas that I came up with, along with the help of a few others on the search-l mailing list over at wikia.com, was the idea of MPOV search, or the concept that people are searching from a certain context
21:04 < kanzure> he hated it because it was point of view search
21:04 < kanzure> and he wants to be "Objective"
21:04 < kanzure> can anybody spot anything wrong with that when it comes to searching? ;)
21:05 < kanzure> the user is the ultimate evaluator in terms of search result quality -- attention is the primary scarcity, and they have a point of view within which they are searching. So if you could load up a specialized "ranking algorithm" for certain specialized searches, you'd sure as hell use it.
21:05 < kanzure> which fits into the Wikia/ATLAS-L architecture of the internet
21:05 < fenn> there's no such thing as NPOV
21:05 < kanzure> producers, aggregators, brokers of 'information nuggets'
21:05 < kanzure> fenn: correct
21:06 < fenn> language automatically induces a bias, you're imposing your ontology on the undescribable 'objective reality'
21:06 < kanzure> neat, Machinae supremacy just clicked on for demoscene radio. ('Gianna sisters'). Been forever since I've heard these guys. They had good web presence back in the day.
21:06 < kanzure> fenn: seems obvious to us, but Jimmy was probably feeling attacked
21:06 < kanzure> since he upholds his Wikipedia editing policies as the highest morality or something
21:07 < fenn> sure, NPOV is how you keep people from fighting
21:07 < kanzure> heh - how's that working out for them? (edit wars ...)
21:07 < fenn> take a little from here, and a little from here, and everyone gets their say in
21:07 < fenn> well, arbitration does .. something
21:07 < fenn> i dont pay much attention to wikipedia politics (maybe i should)
21:08 < kanzure> don't know if you should
21:08 < kanzure> I certainly don't, except what I get in my inbox or see in the news
21:08 < fenn> they generate a crapload of text to sift through
21:08 < kanzure> or when I try to edit an article
21:08 < kanzure> yes
21:08 < fenn> and all the silly arguments are archived because nobody can come up with a consensus statement
21:08 < kanzure> have I told you about ##wikipeding ?
21:08 < kanzure> the idea is to do community depth-N reads of wikipedia in realtime
21:08 < fenn> http://fennetic.net/milesaway/decision_making
21:09 < fenn> ^^consensus appeals to people but it doesn't work in groups > 3
21:09 < kanzure> I wonder what would happen if I tried pathologically avoiding decisions
21:09 < kanzure> either I blank everything out and claim it's not a decision
21:10 < kanzure> or I'd retreat and be doing nothing (but isn't that a decision itself?)
21:10 < kanzure> hehe
21:10 < fenn> you'd get paralyzed and accomplish nothing
21:10 < kanzure> perhaps
21:10 < fenn> trying to follow too many paths at once
21:10 < kanzure> which is the core problem of ADHD
21:10 < fenn> yes
21:10 < fenn> limited bandwidth
21:10 < kanzure> wild, disruptive microcolumns that have to be locked down by avoiding stimulation
21:11 < fenn> oh, if you think the bandwidth is "just the way things are" then the problem is you
21:11 < fenn> i'm an unreasonable person though
21:11 < kanzure> 'We discuss how excessive neuronal processing may render the world painfully intense when the neocortex is affected and even aversive when the amygdala is affected, leading to social and environmental withdrawal. Excessive neuronal learning is also hypothesized to rapidly lock down the individual into a small repertoire of secure behavioral routines that are obsessively repeated.'
21:11 < kanzure> what? (re: your oh line)
21:12 < fenn> wild disruptive microcolumns is ok if you can do something with their output (it is useful, in the proper context)
21:12 < fenn> but if there's too much output fighting over the same limited i/o device (eyes ears mouth) then none of them are happy
21:12 < Splicer> like the mad stock guy?
21:13 < kanzure> fenn: output is constrained though, only so many fingers and toes
21:13 < kanzure> only so many wpm typed/spoken
21:13 < fenn> well, fix it :)
21:13 < kanzure> and I tend to do 150 wpm typed when really hyperactive and on a roll, it's so that I can try to record each thought as it occurs, but I still lose so much information ... 
21:13 < kanzure> right
21:13 < kanzure> thus my projects
21:14 < kanzure> ah, we were going to do something with emc weren't we?
21:15 < fenn> i was going to show you the difference between optimized and unoptimized paths
21:16 < fenn> if i can figure out how to do that
21:16 < kanzure> paths would be ways of editing the object?
21:16 < fenn> machining the object
21:16 < kanzure> hunk of metal -> tool to drill all over it or whatever -> yeah
21:16 < kanzure> okay
21:16 < kanzure> so some motions would be optimal, others would be stupid for a certain form
21:16 < kanzure> it's certainly an art, but also an art that gets to be automated for obvious reasons (the computer precision)
21:17 < fenn> so, this script will do stuff to download the simulator: http://www.linuxcnc.org/dapper/emc2-install-sim.sh
21:18 < fenn> you can look and see what its doing of course
21:18 < fenn> um, i think it will work. there was an issue with libpth2 vs libpth20 yadda yadda
21:18 < Splicer> time to sleep.. cu
21:19 -!- Splicer [n=p@h104n2c1o261.bredband.skanova.com] has quit []
21:19 < kanzure> fenn: please go on - I'm doing a few things at the moment but am following and see the script, yes
21:19 < kanzure> also, what's with the pgp stuff? 
21:19 < kanzure> I recently noticed that APT has been asking me to continue without signatures, but I didn't make much of it
21:19 < fenn> its because it's a different repository that is signed by an independent developer
21:19 < kanzure> (don't know why - wasn't thinking)
21:20 < fenn> so you have to say 'i trust this developer'
21:20 < kanzure> well yeah, but apt has been doing it just in general even when downloading from kernel.org
21:20 < fenn> hmm.. debian etch shipped with some outdated keys i think..
21:20 < kanzure> weird
21:21 < kanzure> the fact that security contexts are socially diffused illustrates a good reason for skdb, for example
21:21 < kanzure> the whole 'reason why circuit ideas are hidden'
21:21 < kanzure> (it's not that they are hidden, but that they are social knowledge and contextual, etc. etc.)
21:21 < kanzure> erm. I have concluded that I suck at verbalizing.
21:22 < kanzure> hrm, my ~/cache/ is 7 GB.
21:23 < kanzure> 3.6 GB of CFD software.
21:30 < kanzure> http://heybryan.org/wiki/ ikiwiki works
21:30 < kanzure> but it does not look like it allows editing from the web
21:30 < kanzure> is this a problem?
21:31 < kanzure> adding a few scripts to allow editing of the flatfiles is easy, but how would this be interfaced to the versioning system?
21:32 < kanzure> would I be able to just dump the new edit of a page into the repository (dump it into git, actively), if I do this, would git know to check for updates and so on?
21:32 < kanzure> (so it'd be a web frontend to sending updates to the git repository  and 'commiting' them)
21:32 < kanzure> doesn't sound too safe ... hrm.
21:33 < fenn> duh.. what? ikiwiki is supposed to commit to its own git repository whenever a web edit is made
21:34 < kanzure> ah, nevermind
21:34 < kanzure> it's extra config options that I need.
21:34 < kanzure> sorry, didn't read far enough
21:34 < kanzure> over at http://ikiwiki.info/setup/
21:38 < fenn> i dont really get what srcdir is
21:39 < kanzure> the files?
21:39 < kanzure> it's a wiki compiler, not a straight up wiki
21:39 < kanzure> so /var/www/wiki/ is the presentable files, while wikiwc are the plaintext contents
21:39 < kanzure> or the 'working copy'
21:39 < kanzure> dunno
21:39 < kanzure> nevermind
21:40 < fenn> oh i see
21:41 < fenn> woah, interesting collapsible text on the ikiwik setup page (click on Git)
21:46 < kanzure> yep
21:46 < kanzure> it's probably just a div visibility=hidden 
21:47 < kanzure> div id=5 onmousedown="javascript:document.getElementByID(5).visibility=show;" style="visibility:hidden;"
21:47 < kanzure> oh, well, the onmousedown is on the link obviously
21:47 < kanzure> and it'd be a toggle instead of a straight up 'only show it' method
21:48 < kanzure> http://heybryan.org/wiki/ adding git at the moment
21:50 < kanzure> gah, ikiwiki-makerepo does not exist
21:50 < fenn> /usr/bin/ikiwiki-makerepo ?
21:51 < kanzure> nope
21:51 < kanzure> only ikiwiki and ikiwiki-mass-rebuild
21:51 < kanzure> http://ikiwiki.info/plugins/ awesome, they have an hnb plugin (hnb is what I used to make http://heybryan.org/todo.html back in the day)
21:53 < kanzure> so in 2007-12 ikiwiki-makerepo was announced on the debian developer mailing list - http://lists.debian.org/debian-devel-changes/2007/12/msg00054.html
21:53 < kanzure> so.
21:54 < fenn> i have ikiwiki        2.41
21:55 < fenn> how did you get the edit buttons?
21:55 < kanzure> 1.33 wtf
21:55 < kanzure> fenn: have to enable cgi 
21:55 < kanzure> 1.33.3 in particular
21:55 < kanzure> this sucks.
21:55 < kanzure> are my sources old?
21:56 < fenn> i'm using etch/testing
21:56 < kanzure> apt-get update; now I got 1.33.4 ...
21:56 < fenn> oh wait, theres an unstable so i guess not
21:56 < kanzure> I thought I installed testing back in February.
21:58 < kanzure> I'm using etch.
22:00 < kanzure> added to my sources.list: deb http://mirrors.kernel.org/debian/ etch main contrib non-free
22:00 < kanzure> deb-src http://mirrors.kernel.org/debian/ etch main contrib non-free
22:01 < kanzure> apt-get update
22:01 < kanzure> 1.33.4 is still the latest.
22:01 < kanzure> did you install by hand?
22:03 < kanzure> ah, unstable
22:03 < kanzure> do I dare go unstable.
22:09 < kanzure> something must be wrong- "make: command not found"
22:09 < fenn> that's definitely not right
22:17 < fenn> oh joy how i missed perl CGI errors
22:20 < kanzure> http://www.google.com/codesearch?client=opera&rls=en&q=msgfmt&sourceid=opera&ie=UTF-8&oe=utf-8&um=1&sa=X&oi=codesearch_group&resnum=4&ct=title
22:20 < kanzure> got my first 'Google Code' result in my web search results
22:20 < kanzure> hm
22:21 < fenn> ffs
22:21 < fenn> i think ikiwiki doesnt have all the dependencies in its debian package
22:22 < kanzure> msgfmt is in package 'gettext'
22:28 < kanzure> http://en.wikipedia.org/wiki/SPARQL thoughts? 
22:28 < kanzure> it looks like a way to work with structured documents (RDFs)
22:30 < kanzure> I think the yaml equivalent is http://yaml.kwiki.org/index.cgi?YPathBrainstorm 'ypath'
22:31 < kanzure> so is SPARQL to RDF as xpath is to XML?
22:35 < fenn> cool it works
22:35 < fenn> um, i dont know how exactly :(
22:45 < kanzure> git: 'init' is not a git command
22:45 < kanzure> hrm
22:45 < fenn> here's what i did: http://fennetic.net/pub/irc/ikiwiki
22:45 < fenn> git init works here
22:46 < fenn> git-core  1:1.5.3.7-1
22:47 < kanzure> 1:1.4.4.4-2 -- it keeps on talking about how I should port over to gitfm, but then gitfm isn't used by ikiwiki, now is it?
22:47 < fenn> the package 'git' is the wrong git, that's some other bullshit that happens to have the same name
22:48 < fenn> apt-get remove git; apt-get install git-core
22:49 < kanzure> usr/bin/git: no such file or directory
22:49 < kanzure> so.
22:49 < fenn> zowee, there are 138 git-* commands
22:49 < kanzure> git-core - content addressable filesystem
22:50 < kanzure> git-cvs - content addressable fs (cvs interoperability)
22:50 < kanzure> but I have git-core installed, but still no git command
22:50 < fenn> dpkg -S /usr/bin/git
22:50 < fenn> git-core: /usr/bin/git
22:50 < kanzure> not found 
22:50 < fenn> wtf
22:50 < kanzure> git-core version 1:1.4.4.4-2
22:50 < kanzure> replaces: cogito
22:52 < kanzure> so, what's going on?
22:54 < fenn> this is what dpkg -L git-core shows: http://pastebin.ca/990350
22:55 < fenn> are you getting something similar?
22:56 < fenn> i see this in the changelog (git-core 1.5.2.1-1) debian/control: git-core: Conflicts: git (<< 4.3.20-11) (/usr/bin/git transition).
22:57 < fenn> so looks like the package 'git' had /usr/bin/git and they switched it around so git-core was the 'real' git
22:57 < fenn> what a fubar
22:57 < kanzure> I don't have git-submodule, among others like 'git'
22:57 < kanzure> hm?
22:57 < kanzure> so then what am I to do?
22:59 < fenn> /usr/bin/git-scm
22:59 < fenn> i think that provides the same funcitonality as /usr/bin/git
23:00 < kanzure> I'll ln it then.
23:00 < fenn> or  /usr/bin/git.transition
23:01 < kanzure> no such file
23:03 < kanzure> git-scm
23:03 < kanzure> fatal: cannot handle scm internally
23:06 < fenn> ./usr/bin/git-scm link to ./usr/bin/git-format-patch
23:06 < fenn> looks like its just a link
23:06 < kanzure> so should we go for svn?
23:06 < fenn> ugh no
23:06 < kanzure> cvs?
23:06 < fenn> nooooo!!
23:06 < fenn> this is a debian etch problem
23:06 < kanzure> fenn, your precious git package does not exist
23:06 < kanzure> eh
23:08 < fenn> GIT Transition Plans. Ian Beckwith explained that /usr/bin/git will be maintained via alternatives. Both GNU Interactive Tools and Linus Torvalds' source code management system git provide the same program name. The GNU interactive tools have been renamed into gitfm to resolve this conflict and in etch will contain a wrapper that is able to execute the other program.
23:08 < kanzure> hm
23:09 < fenn> from http://lists.debian.org/debian-release/2006/08/msg00351.html
23:09 < kanzure> how does that resolve the conflict
23:09 < kanzure> update-alternatives --config git
23:10 < kanzure> There is only 1 program which provides git \n (/usr/bin/git-scm). Nothing to configure.
23:10 < fenn> you have no file /usr/bin/git-scm?
23:10 < kanzure> fatal: cannot handle scm internally
23:13 < fenn> the fatal: is at least a git error :)
23:15 < fenn> i think git 1.5 is a lot different from 1.4
23:16 < kanzure> there is a way to specify which version to get via apt
23:16 < kanzure> apt-get install git-core <something here>
23:16 < fenn> git-core=1.5.123123123
23:16 < fenn> but its not in the etch repo's
23:16 < fenn> because etch is old
23:16 < kanzure> so, should I try apt-get dist-upgrade?
23:16 < fenn> if you dont mind things being broken for a while :)
23:17 < kanzure> eh, but I do
23:17 < kanzure> can I install it by hand?
23:17 < fenn> yes
23:18 < kanzure> you recommend 1.4?
23:19 < fenn> no, 1.5
23:19 < fenn> http://packages.debian.org/testing/devel/git-core
23:20 < fenn> or from source: http://kernel.org/pub/software/scm/git/git-1.5.5.tar.bz2
23:23 < kanzure> ./configure was successful
23:23 < kanzure> make
23:23 < kanzure> in file included from daemon.c:1, cache.h:9:18: error: zlib.h: No such file or directory
23:23 < kanzure> hrm
23:26 < fenn> sudo apt-get build-dep git-core
23:26 < fenn> should get a lot of -dev packages
23:27 < fenn> hrm no source package.. lame
23:27 < kanzure> I got the dependencies from http://ftp.de.debian.org/debian/pool/main/g/git-core/git-core_1.5.5-1.dsc
23:28 < fenn> ok
23:32 < kanzure> "Yes, and how do you envision that working? I think a great deal of time and effort would need to be given to societal structure on Mars. Dare I say that it would be much more useful for a Virgle colony to leave social planning to social scholars... I would much rather live in a Paul Fernhout society than a Bryan Bishop society. Stick to engineering or physics, Bryan, haha." - some random guy from the Virgle mailing list re: 'some
23:32 < kanzure> sigh
23:34 < fenn> fernhout is a social scholar now?
23:35 < fenn> cant we all just get a long
23:35 < kanzure> the virgle group is a big source of hostility
23:35 < kanzure> it's really weird
23:35 < kanzure> I think it's attracted the wrong people or something
23:35 < kanzure> very angry people
23:36 < kanzure> make, make install
23:36 < kanzure> git - still no such file
23:36 < kanzure> this was with 1.5.5
23:36 < kanzure> (git-core)
23:38 < fenn> /usr/local/bin/git?
23:39 < kanzure> exists
23:39 < fenn> \o/
23:40 < fenn> so.. does it work?
23:41 < fenn> mkdir testgit; cd testgit; /usr/local/bin/git init
23:41 < kanzure> yes
23:41 < kanzure> but uhh, how do I create the link?
23:41 < kanzure> ln /usr/bin/git /usr/local/bin/git does not work
23:41 < fenn> other way around
23:41 < fenn> ln -s /usr/local/bin/git /usr/bin/git
23:42 < fenn> but it should find /usr/local/bin/git if the command is being called in a halfway decent manner
23:42 < kanzure> 'ln creating symbolic link blah to blah2 : file exists'
23:42 < kanzure> git still does 'no such file or directory' though (for /usr/bin/git)
23:42 < fenn> hmm i thought you just said /usr/bin/git didnt exist
23:42 < kanzure> hm
23:42 < kanzure> right
23:42 < kanzure> bash says that too
23:42 < fenn> ls /usr/bin/git
23:42 < kanzure> responds with /usr/bin/git
23:43 < fenn> uh.. ls -l  /usr/bin/git
23:43 < kanzure> /usr/bin/git -> /etc/alternatives/git/
23:43 < kanzure> erm
23:43 < kanzure> minus the lash /
23:43 < kanzure> *last /
23:43 < fenn> aroo
23:43 < fenn> ls -l /etc/alternatives/git
23:43 < kanzure> it's a link to /usr/bin/git.transition
23:43 < kanzure> which does not exist
23:43 < fenn> i see
23:44 < kanzure> so, remove /usr/bin/git ?
23:44 < fenn> first, uninstall git-core
23:44 < kanzure> yes, git.transition doesn't exist for a good reason
23:44 < kanzure> I did uninstall git-core earlier when there was that conflict
23:44 < fenn> ok
23:44 < kanzure> so it just left the link for some reason
23:44 < fenn> hack away
23:44 < kanzure> okay, let's see now
23:44 < fenn> or you could do update-alternatives git
23:47 < kanzure> http://heybryan.org/wiki/recentchanges/
23:47 < kanzure> wtf?
23:48 < fenn> yeah its pretty ugly
23:48 < kanzure> but why isn't the [[ wikicamel ]] interpreted?
23:48 < fenn> dont know
23:48 < kanzure> and now the edit page isn't working
23:58 < fenn> eyes burning..