←2007-10-25 2007-10-26 2007-10-27β†’ ↑2007 ↑all
00:08:29 -!- staplegun has quit ("ChatZilla 0.9.78.1 [Firefox 2.0.0.8/2007100816]").
00:34:23 -!- ehird` has quit (Read error: 104 (Connection reset by peer)).
01:26:03 -!- bsmntbombdood has quit (Remote closed the connection).
01:43:37 -!- bsmntbombdood has joined.
02:29:44 -!- Sgeo has quit (Read error: 104 (Connection reset by peer)).
02:32:56 -!- Sgeo has joined.
03:51:42 -!- bsmntbombdood has quit (Remote closed the connection).
03:52:25 -!- bsmntbombdood has joined.
03:52:35 -!- bsmntbombdood has quit (Remote closed the connection).
03:53:18 -!- bsmntbombdood has joined.
03:55:08 -!- bsmntbombdood has quit (Remote closed the connection).
03:55:41 -!- bsmntbombdood has joined.
03:56:37 -!- bsmntbombdood has quit (Remote closed the connection).
03:57:55 -!- bsmntbombdood has joined.
04:01:45 <RodgerTheGreat> I've had some really odd dreams
04:02:07 <RodgerTheGreat> Has anyone had one where you take yourself apart?
04:02:11 <pikhq> I've had a Volkswagen Bug try to eat my in one of my dreams.
04:02:12 <bsmntbombdood> O.o
04:02:38 <RodgerTheGreat> I had a really creepy one where I was basically pulling the muscles and tendons out of my hand, and another one involving teeth
04:03:37 <RodgerTheGreat> in retrospect, dreams are rarely if ever anatomically correct, but it doesn't make it any less creepy
04:04:24 <pikhq> Yeah. . .
04:04:33 <pikhq> Why the hell would a VW Bug have teeth?
04:05:51 <RodgerTheGreat> something about staring at your crumpled up hand and just knowing it's nothing but skin over bone, seeping blood out of the cuticles... and then you wake up.
04:06:14 <bsmntbombdood> hawt
04:11:06 <RodgerTheGreat> yup
04:15:13 <bsmntbombdood> i wish i remembered my dreams
04:31:40 <RodgerTheGreat> I'd say I recall dreams about 30% of the time
04:32:47 <pikhq> For me, it's more like 0.0001% of the time.
04:33:05 <pikhq> That dream was from when I was about 5. . . And it's the last dream I remember, I think.
04:34:16 <bsmntbombdood> i used to have recurring dreams when i was little
04:34:31 <bsmntbombdood> the other day i had a dream in one of the old recurring settigns!
04:34:52 <RodgerTheGreat> interesting
04:35:12 <bsmntbombdood> most of the recurers were nightmares
04:35:57 <RodgerTheGreat> I've thought about dream interpretation from time to time, but I've found I can generally explain my dreams when taking into account the events of the past few days and what was on my mind when I went to sleep
04:36:29 <RodgerTheGreat> it's like a jumbled-up version of your recent memories, stitched into something that appears coherent at the surface level
04:36:41 <bsmntbombdood> it's easy to find a meaning when there is none
04:37:14 <bsmntbombdood> oh damn this song is good
04:37:33 <RodgerTheGreat> Another thought has occurred to me- are dreams just an artifact of our brain's natural garbage-collection and memory storage processes, or do dreams themselves have an evolutionary benefit?
04:37:34 <bsmntbombdood> Airheadz - Stanley (Here I Am)
04:38:56 <RodgerTheGreat> Perhaps their ability to provide insight into new approaches to problems by separating ideas from context is a reason for their existence?
04:38:56 <bsmntbombdood> i don't think dreams would be an artifact of garbage collection
04:39:00 <pikhq> RodgerTheGreat: I'd say that the evolutionary benefit *is* the garbage-collection.
04:39:32 <bsmntbombdood> so many people don't remember their dreams i would say they have no purpose
04:39:38 <RodgerTheGreat> hm
04:39:56 <bsmntbombdood> and no evolutionary disadvantages, so no reason to not have them
04:42:34 <bsmntbombdood> but that is rather unsatisfying
04:42:58 <RodgerTheGreat> true
04:45:34 <RodgerTheGreat> Maybe it's more difficult to defrag recent memories *without* causing dreams as a side-effect, so the mechanisms that usually cause people to forget dreams act as some kind of patch to that behavior?
04:46:11 <bsmntbombdood> kind of an ugly hack
04:46:29 <bsmntbombdood> wouldn't it be better just to turn off the visual part of your brain?
04:46:44 <RodgerTheGreat> nature is best at making ugly hacks first, and then slowly smoothing out the rough edges
04:46:45 <bsmntbombdood> sensoral rather
04:48:04 <RodgerTheGreat> current knowledge of the brain suggests that there isn't a really convenient way to shut off all sensory input (which would really involve shutting down *consciousness*) without some tricky biochemical footwork
04:51:58 <lament> consciousness is a sensory input?
04:52:56 <pikhq> RodgerTheGreat: Technically, *sleep* is a loss of consciousness.
04:53:12 <RodgerTheGreat> pikhq: it might be
04:53:30 <RodgerTheGreat> memory and consciousness are intertwined in very interesting ways
04:54:12 <bsmntbombdood> meh
04:54:45 <bsmntbombdood> it's hard to argue about the physical aspects of the brain without large research
04:56:11 <pikhq> It's hard to argue about the physical aspects of the brain with large research.
04:56:36 <bsmntbombdood> it's hard to argue about the physical aspects of the brain
04:57:40 <RodgerTheGreat> it's hard to research the brain when we can only make coarse and minimally invasive observations. It'd be like trying to understand how a computer works by dissecting casio watches and looking over someone's shoulders as they typed letters in a word processor.
04:58:15 <bsmntbombdood> nice analogy
04:58:28 <RodgerTheGreat> I think it works well on several levels
05:35:56 <lament> actually i think it would be exactly like understanding how a modern CPU works, with any tools available.
05:36:08 <lament> (given that you don't have any knowledge of CPU design)
05:36:39 <lament> it's hard to reverse-engineer something so complex.
06:23:48 <oklopol> o
06:28:32 <oklopol> i've heard the human brain is more complex than a computer
06:29:20 <oklopol> to be honest, i don't really believe that
06:29:38 <oklopol> i gotta leave, just 1 hour late! ->
06:31:30 <oklopol> ...
06:31:34 <oklopol> i fail at this.
06:31:40 <oklopol> missed the bus.
06:37:41 <pikhq> Bravo.
06:38:36 <oklopol> omg
06:38:42 <oklopol> 1½ minutes till next one :O
06:38:45 <oklopol> fuck! ->
06:42:25 <oklopol> good and bad news: 1. i *would've* been on time for the bus 2. i realized i owe a teacher 25 euros and had to come back
06:44:26 <oklopol> if i miss the next one, this is code day.
06:44:34 <oklopol> getting a bit ridiculous
06:47:37 <oklopol> ->>>>>>>>>><
06:47:39 <oklopol> ->
06:52:34 * pikhq shall now sleep
06:52:36 -!- bartw has quit.
07:47:04 -!- Sgeo has quit (Read error: 110 (Connection timed out)).
07:48:30 -!- oklopol has quit (Read error: 104 (Connection reset by peer)).
07:48:38 -!- oklopol has joined.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
11:38:59 <oklopol> when drawing a wire that snaps into a grid, and only straight lines between adjacent points are possible (just directions NWSE), if the mouse moves say 5 points x-wise (say east), and 2 y-wise (say north), what should the resulting line be like? i first had EEEEENN, now i have EEENENE; or would it perhaps be better if it was as straight as possible?
11:39:13 <oklopol> this of course is a marginal case, since usually you wanna draw the wires sowlky.
11:39:15 <oklopol> *slowly
11:39:20 <oklopol> a bit of a typo there...
11:40:00 <oklopol> (EEENENE is the easiest to make ;))
11:42:47 <oklopol> hmm... most of you may be sleeping.
11:59:01 -!- sebbu has joined.
12:52:16 -!- ehird` has joined.
13:26:23 -!- Fa1r has quit (zelazny.freenode.net irc.freenode.net).
13:27:10 -!- Fa1r has joined.
13:29:19 -!- Fa1r_ has joined.
14:00:18 -!- RedDak has joined.
14:00:22 -!- Fa1r has quit (Read error: 110 (Connection timed out)).
14:33:57 -!- bsmntbom1dood has joined.
14:46:16 -!- bsmntbombdood has quit (Read error: 110 (Connection timed out)).
14:54:47 <bsmntbom1dood> 25 euros is a lot of money to owe a teacher
15:02:20 -!- RedDak has quit (Remote closed the connection).
16:18:40 -!- bsmntbombdood has joined.
16:30:00 -!- bsmntbom1dood has quit (Read error: 110 (Connection timed out)).
16:49:25 -!- sebbu2 has joined.
16:49:56 -!- tokigun_ has changed nick to lifthrasiir.
16:53:37 -!- Sgeo has joined.
16:54:11 <oklopol> i also owed a friend 30 euros, and had to pay 20 for an amplifier
16:54:24 <oklopol> this has been an expensive day.
16:56:40 <lifthrasiir> occasionally i have some friends says let us have some lunch or dinner. such a day is quite expensive...
16:58:24 <oklopol> that's one cool nick :O
16:59:48 <lifthrasiir> yup i have changed my nick months ago 8)
17:08:19 -!- sebbu has quit (Connection timed out).
17:31:55 -!- jix has joined.
18:37:06 -!- oerjan has joined.
18:37:18 <bsmntbombdood> wtf????????
18:37:25 <ehird`> ftw
18:37:27 <bsmntbombdood> lolcode just got onto boing boing
18:37:34 <ehird`> what
18:38:16 <ehird`> lolcode isn't functional...
18:38:21 <ehird`> oh, wait, it means 'working' in this context
18:38:24 <ehird`> i forgot boingboing was for retards
18:38:41 <ehird`> and it's obviously turing complete
18:51:31 <oklopol> lifthrasiir: what did you use to be?
18:54:29 <oerjan> bsmntbombdood: that norwegian article was about the Dutch/British closing of some OiNK network, and interviewed some norwegian lawyer for record and movie companies claiming there will soon be a similar crackdown in norway. He refused to say which network, although the article speculates that OiNK information will be provided by the british police to the norwegian one.
18:55:35 <oerjan> sounds me like the usual blather of journalists trying to bring a local perspective on an international case.
18:56:08 <oerjan> *to me
19:03:31 -!- Fa1r_ has changed nick to Fa1r.
19:35:41 <bsmntbombdood> oerjan: did they say anything about oink's database encryption or somesuch?
19:44:36 <oerjan> "according to a source tipping It-Avisen the OiNK member lists were encrypted to start with, and additionally equipped with a self-destruct mechanism triggering deletion unless they received a certain signal within a given time"
19:47:12 <oklopol> omg just like in the movies
19:53:13 <ehird`> haha
19:53:20 <ehird`> this member list will self distruct in 10 minutes
19:54:08 <oklopol> i'd love to have something like that, the problem is i'd lose my files quite quickly...
19:54:32 * oerjan wonders if the OiNK people were up-to-date with the Evil Overlord list
19:55:59 <bsmntbombdood> thanks oerjan
19:57:24 <oerjan> "I will not include a self-destruct mechanism unless absolutely necessary. If it is necessary, it will not be a large red button labelled "Danger: Do Not Push". The big red button marked "Do Not Push" will instead trigger a spray of bullets on anyone stupid enough to disregard it. Similarly, the ON/OFF switch will not clearly be labelled as such."
19:59:17 <bsmntbombdood> "When I've captured my adversary and he says, "Look, before you kill me, will you at least tell me what this is all about?" I'll say, "No." and shoot him. No, on second thought I'll shoot him then say "No.""
19:59:24 <bsmntbombdood> that pisses me off in movies and such
19:59:56 <GregorR> Needless dramatic pause leads to captured prisoner getting away? :)
20:00:16 <GregorR> Two people point a gun at each other, looking dr--BANG. Oh, well that was resolved easily.
20:00:21 <bsmntbombdood> yep, and it has the desirable side effect of explaining the plot
20:00:23 <oklopol> they should at least shoot the legs before explaining
20:03:21 <ehird`> GregorR: i agree!
20:03:57 <ehird`> "Now you shall be subjected to the worst death ever! It will involve: 1. a long explanation that I will tell you while you manage to escape 2. a long, drawn out, pointless death that would be trivial to escape from anyway"
20:05:12 <SimonRC> "Mr Bond. Now that the sedative is wearing off, the feeling should start coming back in the whole of your body except your left leg." // "Why not my leg leg?"
20:05:18 <SimonRC> "I removed it"
20:06:04 <bsmntbombdood> ?!?!
20:06:09 <ehird`> SimonRC: lmao
20:06:18 <bsmntbombdood> i don't remember that james bond movie...
20:06:22 <SimonRC> Just an idea that future villains will fail to follow
20:06:36 <SimonRC> not out of an actual movie, like duh
20:07:41 <bsmntbombdood> oh :P
20:07:49 <bsmntbombdood> that is perfect though
20:08:54 -!- jix has quit (Nick collision from services.).
20:09:04 -!- jix has joined.
20:12:57 <bsmntbombdood> "If I'm eating dinner with the hero, put poison in his goblet, then have to leave the table for any reason, I will order new drinks for both of us instead of trying to decide whether or not to switch with him."
20:13:01 <bsmntbombdood> that one is bad
20:13:11 <bsmntbombdood> why are you having dinner with the hero instead of killing him?
20:26:42 <oklopol> i still don't use whitespace, but i gotta admit i find my old codes even too obscure to understand myself
20:26:48 <oklopol> void line(V a,V b,long c){if(a.x>XSZ&&b.x>XSZ)return;if(a.y>YSZ&&b.y>YSZ)return;if(a.x<0&&b.x<0)return;if(a.y<0&&b.y<0)return;if(abs(b.x-a.x)>abs(b.y-a.y)){if(a.x>b.x){double tmp=a.x;a.x=b.x;b.x=tmp;tmp=a.y;a.y=b.y;b.y=tmp;}double rat=(b.y-a.y)/(b.x-a.x);while(a.x<=b.x){pset((int)a.x,(int)a.y,c);a.y+=rat;a.x+=1;}}else{if(a.y>b.y){double tmp=a.x;a.x=b.x;b.x=tmp;tmp=a.y;a.y=b.y;b.y=tmp;}double rat=(b.x-a.x)/(b.y-a.y);while(a.y<=b.y){pset((int)a.x,(int)a.y,c)
20:27:31 <oklopol> the algorithm is trivial, and not a good one; and there was no linefeed :D
20:27:37 <oklopol> i don't think i even had it when i debugged
20:27:57 <ehird`> what the heck does that do
20:28:02 <oklopol> draws a line
20:28:10 <ehird`> ............ on what
20:28:19 <oklopol> using the pset function
20:28:24 <ehird`> what is pset
20:28:26 <oklopol> whatever that draws onto
20:28:34 <oklopol> that code doesn't specify it.
20:28:36 <ehird`> what is pset
20:28:44 <oklopol> you wanna see that?
20:28:46 <oklopol> why?
20:28:50 <SimonRC> pset is the QBASIC name for the pixel-set function
20:28:57 <ehird`> but that's C
20:29:01 <SimonRC> and other BASICs, I presume
20:29:04 <oklopol> wait
20:29:10 <oklopol> my father came
20:29:13 <SimonRC> well one might ahve been named after the other
20:29:23 <ehird`> oklopol: that's... interesting
20:29:33 <SimonRC> oklopol: well, obviously, otherwise ou wouldn't exist
20:29:44 <oklopol> yeah yeah, anyway, he left now
20:30:09 <oklopol> so... why do you wanna see pset? that just calls pset for the dots that would exist on a line between a and b, where a and b are vectors
20:30:22 <oklopol> using the "color" c as the third param
20:30:32 <oklopol> pset can be anything.
20:30:47 <SimonRC> wait, why would your father being around change anything?
20:31:00 <ehird`> he doesn't want him to see his porn-irc client
20:31:04 <oklopol> i can't irc when my father starts asking me what i'm doing...
20:31:12 <SimonRC> mine does that too
20:31:16 <oklopol> i know, i'm pathetic...
20:31:25 <ehird`> SimonRC: i think every father does
20:31:25 <ehird`> :p
20:31:31 <oklopol> doing one thing at a time is for insects
20:31:44 <SimonRC> no, it is fore normal people
20:32:06 <SimonRC> real geeks can concentrate on a task so much they forget to breath
20:32:09 <SimonRC> e
20:32:14 <ehird`> "WHAT ARE YOU DOING?"
20:32:14 <ehird`> "Writing code to interface with the BIOS for my hobby OS and improving my irc client."
20:32:14 <ehird`> "..."
20:32:14 <ehird`> "WHAT ARE YOU DOING?"
20:32:32 <ehird`> (note: i have not actually tested the above)
20:32:46 <oklopol> i guess. i can actually irc and talk at the same time, in normal situations, but that was too complex a thought to express while talking irl at the same time
20:32:56 <oklopol> even though it was not that complex
20:33:09 <oklopol> i guess was for the normal people thing
20:33:14 <SimonRC> Did I tell you I was doing some Forth experimenting?
20:33:23 <oklopol> whoisn't?
20:33:26 <oklopol> *+" "
20:33:31 <oklopol> :)
20:33:33 <ehird`> SimonRC: ???
20:33:35 <ehird`> SimonRC: me too!!
20:33:41 <ehird`> did you write a forth in brainfuck? :)
20:33:46 <SimonRC> no
20:33:53 <oklopol> ehird`: my father knows more about bios than me
20:33:53 <SimonRC> I started before that
20:34:03 <ehird`> SimonRC: damnit
20:34:07 <ehird`> SimonRC: ok, what di dyou do then :P
20:34:20 <oklopol> when it comes to computers, i just own him at coding (which was his job for 20 years...)
20:35:17 <SimonRC> I just threw together a small VM
20:35:37 <SimonRC> it has a stack, a control stack, and main memory
20:35:37 <ehird`> ahh
20:35:44 <ehird`> hey, that's not forth-y :(
20:35:49 <SimonRC> huh?
20:35:51 <ehird`> real forths access the system directly :|
20:35:51 <SimonRC> yes it is
20:35:55 <SimonRC> ah
20:36:07 <ehird`> none of this vm crap! ;p
20:36:11 <SimonRC> well I didn't have a compiler that could do that
20:36:17 <SimonRC> it is a very minimalist VM
20:36:22 <ehird`> gnu as can do that ;)
20:36:47 <SimonRC> I am still assembling things by hand though
20:36:56 <ehird`> http://www.annexia.org/_file/jonesforth.s.txt very short gnu as forth system, comes with a tutorial which explains how it's done in great detail
20:36:58 <ehird`> it's very good
20:37:06 <ehird`> also, SimonRC, the stack is meant to go in main memory. :-)
20:37:41 <SimonRC> well I didn't have net access at the time
20:37:54 <ehird`> still, jonesforth is worth a read
20:37:55 <SimonRC> And I am still editing it in numbers, which is leet
20:37:57 <ehird`> it's really eye-opening
20:38:14 <SimonRC> "1, 48, 60, 102, 22" <-- that is printdigit
20:38:36 <ehird`> pff, read jonesforth
20:38:45 <ehird`> it uses handy gnu as tricks like, oh, being able to do:
20:38:51 <ehird`> name:
20:38:51 <ehird`> .int x
20:38:51 <ehird`> .int y
20:38:51 <ehird`> ...
20:38:55 <ehird`> and refer to it as name
20:39:09 <ehird`> still as low level, not as hyper-1337-oh-wait-what-does-that-number-mean-again ;)
20:40:14 <SimonRC> the only conditional I have is ?:
20:40:25 <ehird`> pff, jonesforth only has "branch"
20:40:33 <ehird`> read it! it doesn't take too long ;)
20:40:41 <ehird`> (it continues at http://www.annexia.org/_file/jonesforth.f.txt when it gets into forth)
20:40:43 <oerjan> shouldn't that be 1337?
20:41:21 <oerjan> (er, SimonRC not ehird`)
20:42:39 <ehird`> : FORTH COMPILER-SEMANTICS UNINTUITIVE GOOD ;
20:43:31 <oklopol> if you have less than a hundred commands, numbers are just as easy to use as words
20:43:47 <ehird`> oklopol: that is not the point
20:43:49 <bsmntbombdood> mnenomics are easier
20:44:17 <ehird`> bsmntbombdood: oklopol doesn't get "easy", he thinks that if /he/ knows how his code works (... right now... while he's writing it... for the first time...) then why should he do anything else
20:44:29 <ehird`> obviously incorrect, unless you want one session in your editor and then have to abandon it
20:45:30 <oklopol> i've never had any trouble reading my code after a long time, except for the sickest ones i've done; i'm just saying numbers are as eays to understand as words, if you just have a few of them to memorize.
20:45:54 <SimonRC> I comment religiously
20:46:13 <ehird`> i don't comment religiously because i make my code self-documenting
20:46:17 <ehird`> this means not using numbers for words ;)
20:46:23 <SimonRC> every time I want to add a word, I write it in BoredForth in a comment, then write the number underneath
20:46:34 <SimonRC> I haven't got it bootstrapping yet :-(
20:46:40 <ehird`> seriously, you should read jonesforth
20:46:43 <ehird`> getting out of bootstrapping is simple
20:46:56 <ehird`> go, read it now, then go back to boredforth with your new knowledge :-)
20:48:22 <SimonRC> I am reading
20:51:32 -!- jix has quit ("CommandQ").
20:54:15 <ehird`> i have a new life goal!
20:54:20 <ehird`> create a programming language where this is cat: http://rafb.net/p/GhR1Hn14.html
20:55:25 <oerjan> NNNGHHH! (that was a comment)
20:56:01 <ehird`> :D
20:56:04 <ehird`> it would be awesome
20:56:16 <ehird`> having / and slash both as commands is beautiful
20:57:48 -!- jix has joined.
20:57:54 <oklopol> i like the line noise ones that have a theme going on... it gets a bit boring when it's fully random
20:58:05 <oklopol> question marks remind me of that... whatsit...
20:58:16 <oklopol> the language with splot and mulbruf
20:58:25 <oklopol> but the names were something completely different
20:58:39 <ehird`> ok, how about the ? / language
20:58:46 <ehird`> i don't know what it is, but it's crazy
20:59:22 <oklopol> yeah, that one
20:59:29 <oklopol> ah the one in the paste?
20:59:42 <oklopol> i think the one i mean is cakeprophet's, but not sure
21:00:05 <oklopol> also, where is that guy... i hate it when regulars dissappear
21:00:20 <oklopol> it's like losing a friend :'(
21:00:31 <oerjan> FNRK BRTRTRTR SKRNK SVRPTK
21:00:43 <ehird`> oerjan: isisaoa9838383
21:01:34 <oklopol> ASDSFEFEBR ERBTIA
21:01:39 <oklopol> floodfest
21:01:45 <oklopol> *garblefest
21:03:29 * SimonRC goes
21:04:40 <ehird`> how about this:
21:04:57 <ehird`> / changes all /s into ?s
21:04:57 <ehird`> ? does something
21:04:57 <ehird`> :P
21:06:30 <oklopol> ? is call/cc!
21:06:44 <ehird`> i'm pretty sure those semantics aren't tc :p
21:07:00 <oklopol> well call/cc wouldn't make any sense, but anyway xD
21:07:18 <oklopol> since... wtf is calling in a substitution language :)
21:08:18 <ehird`> ooh, how about something that operates on the program code as a data structure
21:08:21 <ehird`> and the commands modify it
21:14:09 <ehird`> =D
21:14:21 <oklopol> LISP!
21:14:28 <ehird`> that is not what lisp does
21:18:20 -!- RedDak has joined.
21:19:41 <oklopol> true, but it should
21:19:51 <ehird`> that'd be odd
21:19:55 <ehird`> since lisp is lists not strings
21:19:56 <oklopol> everything should be self-modifying
21:21:36 <oklopol> "data structure" need not mean "string"...
21:23:45 <pikhq> Lists are a data structure.
21:23:55 <pikhq> And everything in Lisp is a list.
21:23:59 <pikhq> ;)
21:24:01 <ehird`> yes
21:24:03 <ehird`> well
21:24:05 <ehird`> apart from atoms
21:24:09 <ehird`> and a bunch of other stuff :-)
21:24:37 <oklopol> pikhq: but lisp cannot modify itself
21:24:38 <oklopol> directly
21:24:47 <ehird`> well, it kind of can
21:25:16 <pikhq> Isn't that what Lisp macros *are*?
21:25:18 <oklopol> yes, but you cannot make a loop that keeps itself going by adding nested lists to itself for more to evaluate
21:25:25 <oklopol> hmm, perhaps.
21:25:34 <ehird`> oklopol is right, without eval
21:26:25 <oerjan> you could do something with rplacd, surely?
21:26:31 <oklopol> i think macros are a bit limited, not being first-class thingies, but you might be able to do program flow with them... haven't really used them enough to know.
21:26:40 <oklopol> rplacd?
21:26:40 <oklopol> hmm
21:26:48 <oerjan> (but maybe not in the code)
21:26:49 <bsmntbombdood> hooray for archaic cl names
21:26:50 <ehird`> um macros are first class
21:27:00 <ehird`> lisp macros are first-class..
21:27:00 <bsmntbombdood> set-cdr!, not rplacd
21:27:10 <bsmntbombdood> ehird`: no they're not
21:27:28 <ehird`> yes they are
21:27:33 <oklopol> :|
21:27:39 <oklopol> ehird`: what lisp?
21:27:47 <ehird`> decent lisps
21:27:59 <bsmntbombdood> not in cl or scheme
21:28:38 <ehird`> hm, i thought scheme macros were first-class
21:28:52 <ehird`> ok, now someone has to implement first-class-macros using scheme macros :-)
21:29:01 <oklopol> ololobot lisp has first-class macros, but you can't define your own macros, so it's kinda retarded ;)
21:30:13 <ehird`> ololobot has a lisp?
21:30:16 <ehird`> get it in here!
21:30:18 <ehird`> i must test it
21:30:20 <ehird`> and hack on it
21:30:51 <oklopol> it's retarded, i tells ya!
21:30:52 <oklopol> but okay.
21:31:03 <oklopol> the whole thing is just a quick hack.
21:31:40 -!- ololobot has joined.
21:31:59 <oklopol> it just has a few basic things, and i'm not sure that's even a working version of it.
21:32:12 <oklopol> i'm too lazy to use the newest version, since it's on the other comp
21:32:19 <oklopol> >>> sch (+ 1 2)
21:32:21 <ololobot> 3
21:32:25 <oklopol> yay.
21:32:42 <oklopol> >>> sch (define a (lambda (b c) (+ b c)))
21:32:43 <ololobot> ()
21:32:43 <bsmntbombdood> >>> sch ((lambda (x y) x) 1 2)
21:32:44 <ololobot> 1
21:32:48 <oklopol> >>> (a 2 4)
21:33:03 <oklopol> lol.
21:33:06 <oklopol> >>> sch (a 2 4)
21:33:08 <ololobot> 6
21:33:09 <oklopol> i never learn
21:33:17 <ehird`> >>> sch (lambda (x) x)
21:33:18 <ololobot> <lambda>
21:33:32 <ehird`> >>> sch ((lambda (x) (x x)) (lambda (x) (x x)))
21:33:36 <ehird`> :-)
21:33:39 <ehird`> better kill that
21:33:45 <pikhq> ehird` beat me to it.
21:33:51 <oklopol> heh
21:34:03 <ehird`> >>> 2
21:34:07 <ehird`> >>> sch 2
21:34:08 <oklopol> i'm using python's __reload__ for "threading"
21:34:09 <ololobot> 2
21:34:14 <ehird`> oklopol: how?
21:34:18 <ehird`> >>> sch `2
21:34:24 <oklopol> so... it basically dies when you reuse the command, i think
21:34:32 <ehird`> I CAN HAS ERROR MESSAGES?
21:34:33 <oklopol> hmm... not sure i have quoting in that version
21:34:34 <ehird`> >>> sch '2
21:34:36 <ololobot> None
21:34:38 <oklopol> >>> sch 'oko
21:34:39 <ololobot> None
21:34:40 <ehird`> wait, no quoting?
21:34:41 <ehird`> ummm
21:34:44 <oklopol> >>> sch (quote oko)
21:34:44 <ehird`> it's useless, then?
21:34:45 <ololobot> oko
21:34:48 <ehird`> ah
21:34:52 <ehird`> do you have quasiquote
21:34:54 <ehird`> aka `
21:35:03 <oklopol> >>> sch `oko
21:35:06 <oklopol> >>> sch ΄oko
21:35:07 <ololobot> None
21:35:14 <ehird`> that is, `(a b ,c d) is (list 'a 'b c 'd)
21:35:19 <oklopol> no, haven't implemented it in that version
21:35:20 <ehird`> quasiquoting is useful you should support it
21:35:28 <oklopol> but i think i even have the comma thingie in the new one
21:35:39 <oklopol> >>> sch (list 1 2 3)
21:35:42 <ololobot> (1 2 3)
21:36:33 <ehird`> >>> sch (eval 2)
21:36:34 <ololobot> 2
21:36:49 <ehird`> >>> sch (define \ lambda)
21:36:50 <ololobot> ()
21:36:53 <ehird`> does it remember definitions?
21:36:56 <ehird`> >>> sch \
21:36:57 <ololobot> lambda
21:36:58 <oklopol> it should...
21:36:59 <ehird`> yay
21:37:00 <oklopol> yeah
21:37:03 <ehird`> >>> sch (\ (x) x)
21:37:04 <ololobot> <lambda>
21:37:42 <oklopol> primitives are always autoreloaded, so you can't kill them permanently
21:37:44 <ehird`> >>> sch (define \ (lambda (x y) (eval (list lambda (list x) y))))
21:37:46 <ololobot> ()
21:37:51 <ehird`> >>> sch (\ x x)
21:37:53 <ololobot> <lambda>
21:37:55 <ehird`> >>> sch ((\ x x) 2)
21:37:56 <oklopol> hmm
21:37:56 <ololobot> None
21:38:00 <ehird`> wait, what
21:38:26 <oklopol> umm umm
21:38:51 <oklopol> it seems it failed :<
21:39:01 <oklopol> but i don't know where
21:39:27 <oklopol> >>> sch (eval (list lambda (list x) 4))
21:39:28 <ololobot> <lambda>
21:39:28 <oklopol> oh
21:39:39 <oklopol> >>> sch ((eval (list lambda (list x) 4)) 5)
21:39:40 <ololobot> 4
21:39:52 <oklopol> x is evaluated.
21:40:03 <oklopol> -> it fales
21:43:44 <ehird`> back
21:43:48 <ehird`> ahh i see
21:43:57 <ehird`> well
21:44:00 <ehird`> it's hard, because
21:44:05 <ehird`> i WANT to evaluate x
21:44:10 <ehird`> (\ x y) should be (lambda (x) y)
21:44:14 <ehird`> my code SHOULD do that...
21:45:58 <oklopol> eh... no
21:46:06 <ehird`> yes
21:46:13 <ehird`> ahh, the problem is
21:46:17 <ehird`> is that (\ x y) fails right there
21:46:22 <ehird`> because x is evaluated right-there
21:46:23 <ehird`> bah
21:46:26 <oklopol> yeah, because \ isn't a macro anymore.
21:46:28 <ehird`> add a defmacro function
21:46:32 <ehird`> just a simple one
21:46:42 <ehird`> (defmacro name args code)
21:46:42 <bsmntbombdood> defmacro isn't a function
21:46:47 <ehird`> bsmntbombdood: yes, yes, i know
21:46:48 <ehird`> i typo'd
21:47:00 <ehird`> but yes, (DEFMACRO name args code) plz
21:48:18 <oklopol> :<
21:48:27 <ehird`> come on, it'll be trivial
21:48:30 <oklopol> make your own lisp and make it good ;)
21:48:36 <ehird`> no
21:48:37 <ehird`> :p
21:48:56 <oklopol> i'm too lazy to even run the new bot, you think i'll start adding stuff to it :D
21:49:04 <ehird`> nah, i won't
21:49:09 <ehird`> as long as your sch works, i'm happy :-)
21:49:41 <oklopol> i've been trying to make my wire drawing program all day, was doing graphics with windows' own drawing functions... i have no idea why, but that was my stupidest idea ever.
21:50:08 <oklopol> it seems to automatically redraw everytime i draw something, i have no idea how to make it wait until drawing is over...
21:51:04 <oklopol> so i tried to convert to sdl, but i can't find sdl_gfx for windows, and without it everything is too slow to use (if i just directly draw on the SDL_Surface, it's slow as hell...)
21:52:10 <oklopol> i know both those suck, and i should use opengl or something, but i'm so pissed off at having already spent hours trying to find the right functions, i don't really wanna start learning a new api...
21:52:52 <oklopol> I NEEW TO DRAW GRAY POINTS, DOTS, AND LINES, HOW THE FUCK CAN IT BE SO HARD
21:53:05 <ehird`> I'm writing a simple lisp in C now oklopol :-)
21:53:21 <oklopol> good for you
21:54:22 <oklopol> the problem with C is, i like having an interactive debugger, and they just don't seem to work...
21:54:28 <ehird`> gdb
21:54:34 <ehird`> gdb works
21:54:36 <ehird`> it works great
21:55:03 <oklopol> hmm... not sure i've tried that one
21:55:23 <ehird`> it's the gnu debugger
21:55:27 <ehird`> it is exceptionally good
21:56:09 <oklopol> can you get that for win?
21:56:14 <ehird`> sure
21:56:15 <ehird`> cygwin has it
21:56:17 <oklopol> i can't use my linux machine for graphics
21:56:23 <GregorR> MingW has it.
21:56:31 <ehird`> ok, but oklopol has cygwin
21:56:34 <ehird`> and i don't think he hsa mingw
21:56:47 <GregorR> To be honest, I doubt that the Cygwin one can debug non-Cygwin binaries.
21:56:51 <ehird`> it can
21:56:56 <GregorR> Well, there's that :)
21:57:13 <bsmntbombdood> rape us to death, eat our flesh, and sew our skins into their clothing, and if we're very very lucky, they'll do it in that order
21:57:16 <bsmntbombdood> wait what?
21:57:50 <oklopol> bsmntbombdood: where was that from?
21:57:57 <bsmntbombdood> firefly
21:58:06 <GregorR> That was bsmntbombdood's job description.
21:58:08 <oklopol> FEUER FREI
21:58:42 <ehird`> mini-lisp-implementation question
21:58:57 <ehird`> ints, longs, or bignums-as-list-of-digits-in-hexadecimal?
21:58:58 <ehird`> :-)
21:59:05 <oklopol> bugnums
21:59:13 <oklopol> but use 256-based
21:59:13 <ehird`> as a list of digits in hexadecimal?
21:59:14 <ehird`> hah
21:59:18 <ehird`> heh, naw
21:59:19 <ehird`> that's no fun
21:59:26 <ehird`> then you can't do things like
21:59:35 <ehird`> (parse-int (2 f 3 4 9 a 2 b))
21:59:40 <bsmntbombdood> yes you can
21:59:46 <ehird`> ok fine
21:59:47 <ehird`> but meh
21:59:47 <ehird`> :P
22:00:00 <oklopol> why would you wanna waste half your chars?
22:00:18 <oklopol> and just use 4 out of 8 bits
22:00:20 <ehird`> i think i will just do a normal int
22:00:23 <ehird`> ;)
22:00:55 <ehird`> also, "strings" (when i make them) will just be atoms
22:01:10 <ehird`> so "a b c" will just be the syntax to get an atom of the same name because you can't put just a b c in code
22:01:11 <ehird`> and you can do
22:01:18 <ehird`> ("func" '"arg")
22:01:19 <ehird`> mwahaha
22:01:30 <bsmntbombdood> ew
22:01:40 <ehird`> bsmntbombdood: yes, but funny to implement
22:01:46 <ehird`> also, it makes shit a hell of a lot simpler
22:01:50 <ehird`> as i only need to provide one set of functions
22:01:50 <ehird`> ;)
22:03:51 <ehird`> bsmntbombdood: shall i make you ew some more?
22:03:55 <ehird`> i think i'll use REFERENCE COUNTING!
22:04:02 <bsmntbombdood> meh
22:04:13 <ehird`> that was meant to make you explode
22:04:42 <bsmntbombdood> reference couning isn't bad
22:04:55 <ehird`> ok, you're right
22:04:55 <ehird`> :P
22:04:59 <ehird`> damn
22:05:00 <oklopol> reference counting is okay in most situations
22:05:08 <bsmntbombdood> it even works perfectly for lambda calculus
22:05:16 <oklopol> well, in all really, who cares about memory leaks, not me
22:05:45 <ehird`> #define NIL ((LIST *)0)
22:05:45 <ehird`> where LIST is a struct. am I evil yet?
22:05:47 <GregorR> Use reference counting, and also have a GC. The GC will be called so rarely it's not a big overhead, but it's there for circular refs.
22:06:01 <oklopol> yeah, that's prolly the best way
22:06:15 <ehird`> GregorR: but that's, you know. work.
22:06:23 <ehird`> refcounting = so damn trivial to implement
22:06:26 <ehird`> gc = not that much
22:06:48 <GregorR> GC = #include <gc/gc.h> -lgc
22:06:55 <oklopol> it's not that hard if you make a trivial one
22:06:57 <GregorR> (OK, so that's an ultralame solution :) )
22:06:57 <ehird`> yes, but that would be THIRD-PARTY
22:06:57 <ehird`> :O
22:07:05 <bsmntbombdood> i implemented a gc once
22:07:21 <ehird`> and the gc/refcounter is a pretty integral part of lisp
22:07:38 <ehird`> using a third-party solution seems kind of like deferring list handling to a library :-)(
22:07:38 <ehird`> *:-)
22:08:05 <ehird`> ok, one question
22:08:16 <ehird`> am i the only one obsessed with metacircular interpreters and bootstrapping?
22:08:30 <ehird`> whenever i implement a language, i force myself to do the minimum possible, then write the rest in itself
22:08:33 <ehird`> i can't help it
22:09:22 <GregorR> That's the best way to go.
22:09:32 <GregorR> Plof3 is just a parser.
22:09:37 <ehird`> GregorR: I mean even things like "if"
22:09:38 <oklopol> gdb is too hard for me to install
22:09:48 <GregorR> ehird`: Plof3's if is implemented in Plof3.
22:09:52 <ehird`> And - (it's obviously (+ x (neg y))!)
22:09:58 <oklopol> i really need the secretary...
22:09:59 <GregorR> ehird`: EHello, Plof2's if is implemented in Plof2.
22:10:06 <GregorR> EHello = Hell (wtf?)
22:10:12 <ehird`> sorry, i have no idea what plof is
22:10:17 <oklopol> :O
22:10:17 <GregorR> Heh
22:10:21 <oklopol> what...
22:10:23 <GregorR> http://www.codu.org/plof/
22:10:29 <oklopol> that's like not knowing what pebble is ^2
22:10:35 <ehird`> oh, it's a serious language?
22:10:43 <oklopol> or like not knowing what brainfuck is ^-7
22:10:48 <GregorR> ehird`: Yeah.
22:10:51 <ehird`> ok show me some examples
22:11:31 <GregorR> I have none, as my brain is entirely in Plof3 but my implementation is entirely in Plof2 :P
22:11:42 <ehird`> show me some plof3 examples
22:11:46 <ehird`> from your brain./
22:12:13 <GregorR> Well, Plof3 is a simple stack language with just some object manipulation operators, and a runtime parser.
22:12:29 <GregorR> The parser is bootstrapped with a grammar just simple enough to define a useful grammar within the language.
22:12:50 <ehird`> code examples.
22:12:51 <pikhq> I can give some simple Plof2 examples. . .
22:13:14 <oklopol> i thought i could, but i've forgotten some crucial things about it :<
22:13:35 <pikhq> (x):{x(x);}((x):{x(x);});
22:13:44 <ehird`> bah, i don't want to write a hash table in C for the variable table
22:13:45 <GregorR> No starting with horrifying examples :P
22:13:46 <pikhq> ==
22:13:59 <pikhq> ((lambda x (x x)) (lambda x (x x)))
22:14:00 <ehird`> pikhq: something that isn't (\x. x x) (\x. x x)
22:14:03 <ehird`> um i can tell
22:14:04 <ehird`> ;0
22:14:07 <pikhq> Ah.
22:14:26 <GregorR> Tell ya what - if you wait 4 hours until I'm not at work, I can make some good'ns :P
22:14:39 <bsmntbombdood> lol work
22:14:45 <ehird`> someone tell me a cheap way to get around writing a hash table
22:15:02 <GregorR> ehird`: Use D :)
22:15:53 <ehird`> noes
22:15:53 <ehird`> :P
22:16:03 <pikhq> Use Tcl.
22:16:04 <ehird`> i want to frolic in the fields of malloc
22:16:05 <pikhq> :p
22:16:10 <ehird`> and low-level ness
22:16:20 <oklopol> hmm... i have mingw...
22:16:20 <pikhq> Don't use a hash table.
22:16:41 <pikhq> ehird`: I recommend pulling the latest Plof, and playing.
22:16:43 <GregorR> Use a linear-linked list of variable->value associations :P
22:16:50 <ehird`> GregorR: i might just ;)
22:17:00 <ehird`> i'll have:
22:17:05 <ehird`> ((var . value) (var . value))
22:17:08 <ehird`> It's Lispy! ;)
22:17:12 <bsmntbombdood> alist
22:17:19 <ehird`> ok, what humorous name shall i give to my malloc-but-dies-on-error
22:17:25 <bsmntbombdood> also linear time lookup
22:17:28 <ehird`> i am thinking "moolloc"
22:17:42 <Fa1r> Spank that ass, put it in, let's go for a hell of a ride..
22:18:11 <GregorR> void *buf = spankThatAssPutItInLetsGoForAHellOfARide(bufferSize);
22:18:17 <ehird`> yes!
22:20:51 <GregorR> I wonder, if I really hunkered down, if I could get Plof3 written this weekend.
22:21:15 <ehird`> but seriously, what should i call the malloc
22:21:43 <GregorR> mallocAssert?
22:21:51 <GregorR> sfMalloc?
22:22:03 <ehird`> i know!
22:22:05 <ehird`> i'll call it:
22:22:06 <ehird`> AWESOME
22:22:15 <ehird`> AWESOME(buf_size)
22:22:15 <GregorR> lolloc?
22:22:38 <ehird`> iCanHasMemory
22:22:41 <oklopol> wonder what it'd cost if i paid someone to install me a C compiler + a graphics library + nice ide with debugging :)
22:23:18 <ehird`> smalloc i guess
22:23:21 <ehird`> i hate that name
22:25:22 <ehird`> hmm
22:25:28 <ehird`> i should probably have a heap with all objects on
22:25:31 <ehird`> shouldn't i?
22:25:44 <ehird`> ... hey, that'd make for an easy GC: if an object is on the heap but not on the stack, zap
22:25:49 <ehird`> ... wait, no, that wouldn't work, would it?
22:25:50 <pikhq> oklopol: On what?
22:26:36 <oklopol> on my computer
22:26:47 <Fa1r> on my watch, plz
22:26:49 <ehird`> he uses windows
22:26:53 <oklopol> yeah
22:26:55 <Fa1r> ;(
22:27:10 <ehird`> someone tell me i'm stupid -
22:27:11 <Fa1r> well.. i'd go for Dev-Cpp + SDL
22:27:16 <ehird`> a GC that just checks:
22:27:21 <Fa1r> but that's just me
22:27:23 <oklopol> i can't find SDL_gfx
22:27:28 <ehird`> if (on_heap && not_on_stack) free(obj)
22:27:33 <ehird`> where heap is, well, EVERY SINGLE OBJECT
22:27:38 <ehird`> ... that won't work as a gc will it?
22:27:46 <ehird`> i mean, global variables and the like surely?
22:27:52 <oklopol> if someone can link me an SDL_gfx for windows, i'd appreciate it
22:28:05 <ehird`> oklopol: sdl
22:28:07 <ehird`> google for it
22:28:12 <ehird`> or
22:28:14 <ehird`> libsdl.org
22:28:14 <oklopol> i have sdl
22:28:18 <ehird`> sdl has sdl_gfx
22:28:18 <oklopol> okay
22:28:21 <oklopol> no
22:28:27 <oklopol> not automatically
22:28:35 <ehird`> anyway
22:28:41 <ehird`> someone please tell me my gc idea
22:28:44 <ehird`> wouldn't work/would work
22:28:45 <ehird`> :P
22:28:50 <Fa1r> http://www.libsdl.org/release/SDL-devel-1.2.12-mingw32.tar.gz
22:28:52 <Fa1r> hm
22:28:59 <Fa1r> seems that one got it already
22:29:16 <Fa1r> that is, for dev-cpp/mingw compiling
22:29:20 <GregorR> ehird`: It seems to me like you're deleting every object from that.
22:29:27 <ehird`> GregorR: not objects that are on the stack
22:29:39 <oklopol> "error after processing 0 entries"
22:29:44 <oklopol> i love it how everything just works!
22:29:49 <ehird`> oklopol uses winzip, also.
22:29:55 <GregorR> ehird`: If it's on the stack, you don't need a GC, it'll get deleted when the stack unwinds.
22:29:59 <oklopol> yeah, it's the defautl
22:30:00 <oklopol> *default
22:30:07 <ehird`> GregorR: right but what about ... globals and stuff
22:30:37 <oklopol> i have about 5 zipping programs
22:30:41 <GregorR> Let me put it this way: I have no idea what that GC is doing, so I can't tell you if it's correct.
22:30:41 <Fa1r> where are we going tomorrow, as with windows today
22:33:01 <ehird`> GregorR: :-)
22:33:27 <oklopol> ehird`: doesn't look correct
22:33:45 <ehird`> well, what i'm doing with the heap is
22:33:48 <ehird`> the heap is a linked list
22:33:51 <bsmntbombdood> hmm
22:33:53 <bsmntbombdood> i'm hungry
22:33:56 <ehird`> latest element = most recently allocated object
22:34:02 <ehird`> etc, so on backwards
22:34:11 <ehird`> if something isn't on the stack, then it isn't being used any more
22:34:14 <ehird`> so i can search the heap
22:34:17 <ehird`> find stuff that isn't on the stack
22:34:18 <ehird`> and free it
22:34:19 <bsmntbombdood> wrong
22:34:20 <oklopol> err...
22:34:23 <ehird`> exactly
22:34:25 <ehird`> i thought it was wrong
22:34:31 <GregorR> Things on the heap can link to other things on the heap.
22:34:36 <GregorR> That's the entire challenge of GCs :P
22:34:37 <ehird`> ok
22:34:37 <oklopol> that will work as long as you can't make any compound objects
22:34:38 <ehird`> i'll just refcount
22:34:39 <ehird`> :P
22:34:46 <oklopol> what GregorR said.
22:34:48 <bsmntbombdood> (cons a b) is on the stack, a and b aren't
22:35:02 <bsmntbombdood> ehird`: you can read my gc, it's pretty simple
22:35:11 <ehird`> heh, i've just realised my refcount comments are like forth stack comments
22:35:14 <ehird`> i have things like:
22:35:23 <ehird`> /* REF +1 x, REF -1 y */
22:35:35 <bsmntbombdood> http://abacus.kwzs.be/~bsmntbombdood/gc.tar
22:36:05 <ehird`> everyone has weird domains in their urls
22:36:07 <ehird`> like kwzs.be
22:36:10 <ehird`> why do i have boring ones
22:36:11 <ehird`> :P
22:36:21 <GregorR> Mine is codu.org
22:36:25 <GregorR> That's not too weird.
22:38:46 <ehird`> mine is elliotthird.org
22:38:48 <ehird`> i am so imaginative
22:38:56 <oerjan> nvg has the nuts.edu domain
22:39:15 <oklopol> mingw... does that have an ide?
22:39:26 <oerjan> but it's not the default used
22:39:34 <oklopol> it seems everything without an ide is too hard for me.
22:39:51 <oklopol> i wanna press "run" or "debug", not switch between windows :|
22:47:51 <ehird`> phew, most of the object stuff is done
22:48:07 <ehird`> now i can write simple helper functions in C, the eval function, and the core stuff
22:48:08 <ehird`> :P
22:48:12 <ehird`> it's 150 lines right now
22:50:01 <ehird`> oklopol: how long has your lisp had macros?
22:50:04 <ehird`> since the start?
22:50:13 <ehird`> i want to feel not-too-bad about omitting macros right now
22:50:14 <ehird`> :P
22:50:37 <oklopol> lambda, define and if were almost the first thing i did... but that's all the macros it has, really
22:50:44 <oklopol> well, yeah, list and quote
22:50:48 <ehird`> they're not macros
22:50:50 <ehird`> they're special forms
22:50:53 <oklopol> and prolly a few more, but there's no real macro support
22:50:56 <oklopol> ah, sorry.
22:51:03 <ehird`> so it doesn't actually do any macro transformations?
22:51:17 <ehird`> just some special form things? i.e. functions that don't have their arguments evaluated?
22:51:22 <oklopol> then there are *no* macros, it has first-class macros, which cannot be created..
22:51:30 <oklopol> :)
22:51:34 <ehird`> does it substitute them for their code while "compiling"?
22:51:38 <ehird`> or does it "call" them when evaluating?
22:51:40 <oklopol> special forms are first-class
22:51:43 <oklopol> in mine
22:51:43 <ehird`> if its the latter, you have no macros
22:52:08 <oklopol> yeah, i thought special forms are a subclass of macors.
22:52:10 <oklopol> *maroccos
22:52:32 <bsmntbombdood> marco
22:52:34 <ehird`> how is your evaluator structured?
22:52:36 <bsmntbombdood> polo
22:52:37 <ehird`> recursive or using a stack?
22:52:41 <ehird`> since its python i guess recursive
22:52:41 <oklopol> recursive
22:52:44 <ehird`> but recursive kind of sucks in c :p
22:52:50 <bsmntbombdood> recursive is using a stack...
22:52:57 <ehird`> bsmntbombdood: yes, but it's an implicit stack
22:53:07 <ehird`> and as far as i know it's bad practice to recurse in a situation like this
22:53:13 <ehird`> :-) (i.e. having NO stack in the whole language)
22:53:27 <bsmntbombdood> umm
22:53:30 <bsmntbombdood> it's the same thing
22:53:32 <oklopol> for a while now i've been wanting to make my own assembly, and start making languages targeted for it
22:53:45 <ehird`> bsmntbombdood: i guess
22:53:50 <ehird`> oh well i might just recurse
22:53:52 <ehird`> and change it later
22:53:52 <ehird`> :-)
22:54:05 <oklopol> and yay, my installation was almost complete, then it popped up for some reason, and i pressed "C" while typing on the channel, and cancelled it :))
22:54:39 <GregorR> Rock ON
22:55:43 <oklopol> i should do all my coding on paper... using the computer seems to be too hard for me :P
22:56:03 <bsmntbombdood> good plan
22:56:07 <bsmntbombdood> hard to test though
22:56:39 <ehird`> shit, i just realised
22:56:43 <ehird`> variable scoping.
22:56:50 <ehird`> oklopol: what scoping do you do? lexical?
22:56:54 <oklopol> yeah
22:56:55 <ehird`> i've never been able to implement lexical scoping
22:56:56 <ehird`> :(
22:56:58 <bsmntbombdood> ummmmmm
22:57:00 <oklopol> it's trivial
22:57:10 <oklopol> although it took me a while to actually grasp how it's done
22:57:11 <bsmntbombdood> lexical scope is the only reasonable scope
22:57:12 <ehird`> maybe the descriptions i've read of its algorithm are just wrong i guess
22:57:17 <ehird`> bsmntbombdood: yeah i know =(
22:57:20 <ehird`> well hey
22:57:25 <ehird`> lisp 1 used dynamic scope
22:57:31 <bsmntbombdood> it's really easy to implememnt
22:57:39 <oklopol> bsmntbombdood: dynamic scoping is fun sometimes, when used correctly.
22:57:49 <bsmntbombdood> noooooo
22:58:00 <oklopol> yes.
22:58:06 <bsmntbombdood> how
22:58:17 <ehird`> i think what lisp needs is a new dialect (Not being sarcastic here :P)
22:58:20 * GregorR <3 dynamic scoping.
22:58:31 <ehird`> scheme started off OK, but then it kind of tripped up and it's kind of trawling along in limbo right now
22:58:34 <ehird`> common lisp is just /ugly/
22:58:43 <oklopol> bsmntbombdood: i don't really have a convincing argument about that.
22:58:46 <bsmntbombdood> cl is terrible
22:58:50 <GregorR> Uncommon LISP
22:58:53 <ehird`> bsmntbombdood: i agree
22:58:57 <oklopol> but it's nice sometimes
22:59:02 <ehird`> GregorR: haha
22:59:04 <bsmntbombdood> scheme is b e a utiful
22:59:18 <ehird`> bsmntbombdood: scheme is beautiful but it has been in limbo for a while now
22:59:24 <bsmntbombdood> so?
22:59:25 <oklopol> okay, i'll retry the install
22:59:33 <oklopol> let's hope i don't press C again
22:59:36 <bsmntbombdood> that just means it doesn't need any improvement
22:59:39 <oklopol> i'll just type without it.
22:59:47 <ehird`> so, a new dialect that combined scheme's beauty with unique practicality...
22:59:51 -!- RedDak has quit (Remote closed the connection).
22:59:59 <bsmntbombdood> i'm sure it would fail
23:00:08 <ehird`> perhaps, perhaps not
23:01:54 -!- oerjan has quit ("Good night").
23:02:02 <oklopol> ehird`: static scoping == when you create a function that encloses variables x, y etc., store the values of those variables (which you will find in the upper scope) in a closure or whaddyacallit and carry that around with the function
23:02:31 <ehird`> i know the theory
23:02:35 <ehird`> but every time i've tried to implement it
23:02:36 <ehird`> it's just failed
23:02:49 <oklopol> hmm, mine worked like that, but ...python <3
23:02:56 <oklopol> *just like
23:03:04 <ehird`> show me your code? :P
23:03:05 <bsmntbombdood> it's really easy
23:03:09 <oklopol> yeah
23:03:10 <ehird`> or rather, olololisp's code
23:03:23 <oklopol> nah
23:03:28 <ehird`> =(
23:03:38 <oklopol> you get so judgy.
23:03:50 <ehird`> i just wanted to see olololisp's code, haha
23:04:32 <oklopol> no matter how many times i tell people who wanna see my code that i already know everything that's wrong with it, and i just don't care, since i code for fun; still everyone needs to tell me the same things over and over again.
23:04:49 <ehird`> sheesh, i won't
23:04:55 <oklopol> aogji
23:04:56 <ehird`> don't be so pessimisticf
23:04:56 <ehird`> :P
23:04:59 <oklopol> okay, i'll paste...
23:05:37 <oklopol> i'm very pessimistic, i've been making a FUCKING PROGRAM FOR DRAWING LINES for like 6 hours
23:05:46 <oklopol> well, most of the time, like 5 hours, i've been idling
23:05:52 <ehird`> that's 1 byte in my language
23:05:55 <ehird`> DrawingLinesLanguage
23:05:57 <oklopol> and it's actually ready, i just don't have a graphics lib... but still
23:06:03 <ehird`> the program: ;
23:06:05 <oklopol> :)
23:06:15 <oklopol> darn, wish i'd used that one!
23:06:29 <GregorR> Is DrawingLinesLanguage TC?
23:06:33 <ehird`> GregorR: yes!
23:06:39 <GregorR> AWESOME
23:07:49 -!- Sgeo has quit (Success).
23:08:05 <oklopol> http://www.vjn.fi/pb/p255331634.txt try to keep in mind this was done in 2~3 hours, and was not meant for another human to see, ever.
23:08:21 <oklopol> well, the core was, i may have added stuff like quote later on.
23:09:54 <GregorR> Y'know, recently a concept for encoding descriptive metadata into programs was created.
23:09:57 <GregorR> It's called "comments"
23:10:01 <GregorR> You may want to try that out.
23:10:16 <oklopol> GregorR: thanks for doing exactly what i said you would ;)
23:10:23 <ehird`> i was about to say.
23:10:29 <ehird`> exactly what oklopol just said.
23:10:47 <GregorR> "Not meant for another human to see" != "free of comments"
23:10:59 <ehird`> "oklopol: no matter how many times i tell people who wanna see my code that i already know everything that's wrong with it, and i just don't care, since i code for fun; still everyone needs to tell me the same things over and over again."
23:11:19 <oklopol> hmm, why? english isn't any more descriptive than python to me :| well, prolly is, but i'll never admit that officially.
23:12:37 <oklopol> i'll start commenting once i learn lojban
23:12:38 <oklopol> !
23:13:14 <oklopol> the conlang i've been creating actually has an oklotalk module ;)
23:13:35 <oklopol> so... you could just write the code and the comments in the same language
23:13:36 <ehird`> what
23:13:39 <ehird`> haha
23:13:41 <ehird`> so, like
23:13:45 <ehird`> you can speak, in your languge
23:13:47 <ehird`> in oklotalk?
23:13:56 <ehird`> doesn't that make talking to people non-deterministic? lmao
23:14:06 <ehird`> "MENTAL STACK OVERFLOW, BRAINS NOW OUT OF HEAD"
23:14:16 <oklopol> err... sure
23:14:21 <ehird`> bah, i don't have a function type
23:14:27 <oklopol> you can read oklotalk code in english too...
23:14:46 <oklopol> it's just in english reading characters is quite verbose unless they form words.
23:15:21 <oklopol> # TODO:
23:15:21 <oklopol> # list stuph
23:15:25 <oklopol> commentz!
23:15:40 <oklopol> that's already been done though...
23:15:58 <oklopol> also some stuff is commented out!
23:16:02 <ehird`> woot, i have unified functions and special forms
23:16:03 <oklopol> and there are code examples!
23:16:05 <ehird`> i just have a special attribute
23:16:12 <ehird`> which specifies whether to map(eval, args)
23:16:13 <ehird`> :-)
23:16:21 <oklopol> yeah.
23:16:38 <ehird`> anyway
23:16:49 <ehird`> oklopol: so to implement lexical scoping
23:16:55 <ehird`> i have a "main mapping"
23:17:06 <ehird`> which is just your regular varname=>value mapping
23:17:14 <ehird`> then for a new scope (well, only scope is functions here, so:)
23:17:18 <ehird`> then for a new lambda
23:17:24 <ehird`> i have a seperate lookup table
23:17:26 <ehird`> at the start
23:17:33 <ehird`> i copy the current lookup table over to it
23:17:38 <ehird`> and then that's my scope
23:17:44 <ehird`> and i just bind vars, etc., whatever to that scope
23:17:46 <oklopol> yeah, lambdas carry a look-up table with them.
23:17:50 <ehird`> OK
23:17:52 <ehird`> so i have:
23:17:55 <ehird`> MAIN_TABLE
23:17:59 <ehird`> LAMBDA->LOOKUP_TABLE
23:18:02 <ehird`> TABLE_IM_USING_RIGHT_NOW
23:18:13 <ehird`> i need TABLE_IM_USING because i will copy LAMBDA->LOOKUP_TABLE to it
23:18:24 <ehird`> so, when i do (set var value) and the like
23:18:27 <ehird`> it isn't carried over calls
23:18:29 <ehird`> am I right here?
23:18:30 <oklopol> umm... when you use a lambda, it will not use any variables from the outer scope.
23:18:38 <oklopol> that only happens when you *create* it
23:18:47 <ehird`> yes
23:18:54 <oklopol> a lambda must always carry everything it uses, except for args
23:19:01 <oklopol> ihmm
23:19:02 <oklopol> *hmm
23:19:26 <ehird`> i need TABLE_IM_USING_RIGHT_NOW
23:19:29 <ehird`> to put arguments
23:19:35 <ehird`> and variables that i set
23:19:35 <ehird`> e.g.
23:19:41 <ehird`> (lambda (x) (set blah x))
23:19:45 <ehird`> blah shouldn't carry across calls
23:19:51 <oklopol> it's not carried over calls, if you do a set, true.
23:19:57 <ehird`> so new variables go to TABLE_IM_USING instead of LAMBDA->LOOKUP_TABLE
23:20:02 <oklopol> unless you pass by argument
23:20:13 <ehird`> basically, TABLE_IM_USING is "if i'm in a function, put new stuff and arguments in here"
23:20:34 <ehird`> sound reasonable?
23:20:55 <oklopol> hmm, i think so, although i am pretty tired
23:21:11 <ehird`> ok
23:21:18 <ehird`> hey, i thought of a good way to do variables without hash-tables
23:21:31 <ehird`> you have a backwards-linked list (i.e. you have a "TOP" and they have a "previous" property)
23:21:33 <oklopol> wuzzit?
23:21:39 <ehird`> with, a string as name
23:21:41 <ehird`> and object as value
23:21:42 <ehird`> obviously
23:21:49 <ehird`> so, to make a new variable, obviously you push it to the list
23:21:56 <ehird`> and you start from the top and go down to find a variable
23:21:57 <ehird`> BUT
23:22:00 <ehird`> when you want to change a variable
23:22:04 <ehird`> instead of finding it, then changing it
23:22:10 <ehird`> it finds it, deletes it, then pushes a new one
23:22:20 <ehird`> this takes advantage of the fact that recently-set variables are more likely to be used recently
23:22:20 <oklopol> what was the reason for not using a hash table for vars?
23:22:23 <ehird`> = less lookup time
23:22:27 <ehird`> and because i don't want to implement one in C :P
23:22:34 <oklopol> ah
23:23:02 <ehird`> so
23:23:04 <ehird`> sound reasonable?
23:23:26 <oklopol> well, first of all you should assing each atom... well, string that's used as an atom in your case i guess... an integer value, for O(1) equality
23:23:30 <oklopol> well, not should
23:23:31 <oklopol> could.
23:23:39 <ehird`> assing?
23:23:40 <ehird`> :P
23:23:46 <ehird`> and really, they do have one... the object id
23:23:56 <ehird`> although, my stuff is weird
23:23:57 <oklopol> and... hmm... that list thing might be good, but a hash table would pwn it
23:23:59 <ehird`> for example
23:23:59 <oklopol> ass-sing.
23:24:02 <ehird`> integers are allocated on-use
23:24:08 <ehird`> instead of saving them for later
23:24:10 <ehird`> like most languages
23:24:10 -!- sebbu2 has quit ("@+").
23:24:15 <ehird`> so, "3" is a different 3 each time
23:24:15 <ehird`> :-)
23:24:46 <oklopol> that doesn't really make much difference :)
23:25:26 <ehird`> but, what do you mean about an integer/string mapping
23:25:28 <ehird`> like a godel number?
23:25:52 <oklopol> mingw doesn't have an ide, or?
23:26:12 <oklopol> like a hashval
23:26:20 <oklopol> object id sounded right.
23:26:39 <ehird`> it isn't a hash
23:26:55 <ehird`> let's picture a repl session
23:27:12 <ehird`> > (id "hello")
23:27:12 <ehird`> 34
23:27:12 <ehird`> > (id "hello")
23:27:12 <ehird`> 37
23:27:14 <ehird`> see?
23:27:26 <ehird`> all objects - symbol, string (well, symbol :P), number, or list
23:27:33 <ehird`> are different each time you mention one as a literal
23:28:25 <oklopol> yeah, okay, well, the idea of using atoms is that you can just assign each atom a number, and forget the string the atom represents
23:28:43 <ehird`> yeah, well :P
23:28:48 <oklopol> except you need to store a num->string mapping separately, since you can access the atom string at runtime
23:31:20 <ehird`> my way follows the scheme-to-c compiler ichbins
23:31:24 <ehird`> which does the same as me
23:31:25 <ehird`> no hashing
23:31:29 <ehird`> and symbol == string
23:33:20 <oklopol> yeah
23:33:32 <oklopol> i guess that's not really necessary.
23:33:38 <oklopol> i mean, atoms in general.
23:33:59 <ehird`> my lisp will have a grand total of four types
23:34:04 <ehird`> cons, symbol, number, lambda
23:34:47 <ehird`> (cons is (a . b) or (cons a b)... lists are cons. (EL1 EL2 EL3) is (cons EL1 (cons EL2 (cons EL3 NIL))) where NIL is the empty list)
23:35:24 <oklopol> yeah, that's how lisp always workz
23:35:31 <ehird`> yeah
23:36:11 <oklopol> hey, i think i found an ide for mingw, dev-cpp!
23:36:12 <oklopol> ...
23:36:20 <ehird`> when i get this lisp (it's called Xlisp. officially "the X means it's awesome" but I just couldn't think of anything better) done, I'm going to bind a few C libs to it (like sockets) then write an irc bot in it :D
23:36:25 <ehird`> the irc bot, of course, will be scriptable in the language
23:36:30 <ehird`> oklopol: that was suggested to you... ages ago
23:36:34 <oklopol> i used to have dev-cpp... the debug didn't work
23:37:02 <oklopol> oh, indeed
23:37:21 <oklopol> i have read the line before and after that, but don't remember seeing that line :P
23:37:34 <oklopol> also, i've used dev-cpp, it just doesn't work
23:37:36 <oklopol> *didn't
23:37:44 <oklopol> perhaps it now does
23:38:55 <oklopol> if it doesn't work, i don't know what to do
23:39:21 <oklopol> all this installing isn't good for my health
23:44:32 <ehird`> heh
23:45:13 <ehird`> someone give me a three-letter abbreviation for 'lambda'
23:46:44 <oklopol> i'd prolly go with lbd
23:47:11 <ehird`> ok
23:47:52 <oklopol> o
23:47:53 <oklopol> m
23:47:53 <oklopol> g
23:47:58 <oklopol> debuggin actually works.
23:48:00 <ehird`> haha
23:48:02 <oklopol> *debugging
23:48:04 <ehird`> it uses gdb
23:48:05 <ehird`> :-)
23:48:20 <ehird`> now try a program in it, and realise the awesome of gdb
23:48:21 <oklopol> but... it works! it didn't work when i last installed that :)
23:48:25 * oklopol is so happy <3
23:48:25 <ehird`> main commands that you need:
23:48:31 <ehird`> set args ...
23:48:31 <ehird`> sets the command-line args
23:48:35 <ehird`> start/stop ... starts or stops
23:48:39 <ehird`> step step one instruction
23:48:52 <ehird`> next step one instruction but don't show e.g. what nested functions are doing
23:48:57 <ehird`> continue go until we die
23:49:02 <ehird`> tb get the traceback when we've died
23:49:12 <ehird`> print ANY_C_EXPRESSION_HERE wut is dis?
23:49:13 <oklopol> umm... how do i set args? :|
23:49:18 <ehird`> it's things you type
23:49:27 <ehird`> you type "set args a b c d" to set the args to "a b c d"
23:49:33 <ehird`> "start" to start the program, "stop" to stop it
23:49:41 <ehird`> "step" to go forwards one instruction
23:49:48 <oklopol> but... i assume you don't mean i should write them in the source code...
23:49:50 <ehird`> "next" to step forwards one instruction but skip inner function calls
23:49:54 <ehird`> "continue" until we die
23:50:01 <ehird`> "tb" get the traceback when we've died, "print BLAH" to show BLAH
23:50:01 <ehird`> and
23:50:04 <ehird`> you do it in the debugger
23:50:05 <ehird`> you type it in
23:50:09 <ehird`> to the debugger.
23:50:35 <ehird`> wait
23:50:35 <ehird`> bah
23:50:38 <ehird`> dev-c++ doesn't use gdb
23:50:40 <ehird`> useless
23:50:41 <ehird`> really useless
23:50:43 <oklopol> :|
23:50:47 <oklopol> i see..
23:50:50 <ehird`> well, it does internally i think
23:50:57 <ehird`> but it doesn't let you command it using the gdb interface
23:51:01 <oklopol> but it's better than VC6
23:51:04 <ehird`> just it's key-combinations which presumably are severely lacking
23:51:39 <oklopol> Debug -> Parameters
23:51:45 <oklopol> omg i found something myself.
23:51:48 <ehird`> AHA
23:51:50 <ehird`> i've got it
23:51:56 <oklopol> tell
23:51:57 <ehird`> in teh bottom bar
23:52:00 <ehird`> click the Debug tap
23:52:03 <ehird`> then click Output
23:52:08 <ehird`> you can see the output and send a command to gdb
23:52:15 <ehird`> now, use that, and accept no other interface for debugging. ;)
23:52:54 <ehird`> err
23:52:59 <ehird`> just make sure to put a breakpoint on your first line
23:53:01 <ehird`> so you can use the interface
23:53:21 <oklopol> ah
23:53:35 <oklopol> hey cool
23:53:46 <oklopol> now SDL...
23:53:58 <ehird`> so does the gdb commands work?
23:53:59 <oklopol> that shouldn't be hard to get working on that, right?
23:54:01 <ehird`> it should
23:54:03 <ehird`> and yeah, it's trivial
23:54:07 <oklopol> hmm, i can test
23:54:09 <ehird`> just try and compile an sdl program
23:54:11 <ehird`> it miiiight work
23:54:54 <oklopol> hmm... doesn't seem to work...
23:54:59 <oklopol> i mean
23:55:04 <oklopol> gdb
23:55:37 <oklopol> oh
23:55:38 <oklopol> it does.
23:55:40 <oklopol> now sdl
23:56:00 <oklopol> might work without installing SDL?
23:56:00 <oklopol> nice
23:56:27 <oklopol> can't find SDL.h :O
23:56:30 <oklopol> how can that be :)
23:56:37 <ehird`> you didn't put it in your include path
23:59:13 <oklopol> hmm
←2007-10-25 2007-10-26 2007-10-27β†’ ↑2007 ↑all