00:01:50 <pikhq> I think it does, but I'm not sure.
00:02:54 <ehird`> Hmmm, that means i'd have to gc in my outoput
00:05:20 * ehird` puts it on the TODO list
00:05:31 <ehird`> pikhq: How many lines is PEBBLE with the BF backend?
00:06:58 -!- pikhq has quit (Read error: 104 (Connection reset by peer)).
00:08:01 -!- pikhq has joined.
00:08:11 <ehird`> in case you didn't get thjat
00:08:12 <ehird`> pikhq: How many lines is PEBBLE with the BF backend?
00:08:43 <pikhq> No. I missed a file. 1246.
00:09:03 <pikhq> Ooops. Stuck in the interp backend.
00:09:09 <ehird`> Ignoring the stdlib right?
00:09:11 <pikhq> Quite a few lines.
00:09:26 <ehird`> I want the full compiler's source, without C-related bits, without the stdlib
00:12:36 <ehird`> pikhq: "CALCULUS - Common Administrator's Language Compilation Unit for Language Unity under Stalin"
00:13:51 <ehird`> pikhq: You have 785 lines without optimization files
00:14:13 <ehird`> pikhq: I think in PEBBLE I might be able to get 2500-3500 lines or so?
00:14:17 <ehird`> With no optimizations at all.
00:15:41 <ehird`> pikhq: Oh, plus the parser, which will be about another 500 lines I guess
00:15:50 <ehird`> pikhq: Am I crazy yet?
00:18:59 -!- sebbu has joined.
00:20:55 -!- pikhq_ has joined.
00:25:38 -!- pikhq has quit (Nick collision from services.).
00:25:39 -!- pikhq_ has changed nick to pikhq.
00:25:47 <ehird`> what is the last message you god
00:25:57 <pikhq> 17:09 < ehird`> I want the full compiler's source, without C-related bits, without the stdlib
00:26:05 <pikhq> 1075 lines of code.
00:26:38 <ehird`> I'll re-say what I said, at a slow pace so you can respond :P
00:26:42 <ehird`> pikhq: "CALCULUS - Common Administrator's Language Compilation Unit for Language Unity under Stalin"
00:27:46 <ehird`> pikhq: You have 785 lines without optimization filespikhq: You have 785 lines without optimization files
00:28:00 <ehird`> pikhq: I think in PEBBLE I might be able to get 2500-3500 lines or so? With no optimization at all.
00:28:04 <ehird`> pikhq: Oh, plus the parser, which will be about another 500 lines I guess
00:28:08 <ehird`> ^^^ end of repetitions ^^^^
00:28:50 <pikhq> I will confess: I've been meaning to do a rewrite of PEBBLE some time.
00:29:15 <pikhq> Although I might change the language radically, too. . .
00:29:28 <oklopol> ehird`: jix has made a math lib in glass
00:29:30 <ehird`> Yeah -- get rid of the temp vars! >:(
00:30:26 <ehird`> pikhq: Automatically allocate them.
00:30:36 <ehird`> pikhq: That is: make the compiler less of a dumb macro system. :-)
00:30:53 <pikhq> Maybe even change the syntax slightly to be more, well, formal.
00:31:03 <ehird`> pikhq: Yes, non-tcl would be nice :P
00:31:15 <ehird`> actually a C-like syntax fits in very well with brainfuck, as opposed to lispy/tcl-y
00:31:25 <ehird`> because you don't think of it as (set! a b)
00:31:31 <ehird`> it's not something you 'call out' to
00:32:28 <oklopol> i have no idea where jixmath is
00:33:12 <pikhq> A set of syscalls, which are like the basic PEBBLE macros. . .
00:33:16 <oklopol> gotta sleep, went to sleep an hour ago actually, but suddenly realized i have to finish a program :\
00:33:32 -!- sebbu2 has quit (Connection timed out).
00:33:37 <pikhq> And a compiler which runs sanely, parsing expressions and such into calls to those macros . .
00:33:58 <ehird`> pikhq: doesn't seem anything too interesting to me
00:34:16 <pikhq> So, one would have "func add(x, y){x+y}" which would compile into the addvar x
00:34:30 <ehird`> don't really like that
00:34:43 <ehird`> however, i do think one thing
00:34:47 <ehird`> C-like syntax /with macros/
00:34:55 <pikhq> Then we'd have bfc.
00:35:01 <ehird`> so, say there was no 'func' (probably true, since it's quite a big job to implement them)
00:35:07 <ehird`> (let's call it 'proc')
00:35:49 <pikhq> Actually, at this rate, I may want to call it a completely different language.
00:35:54 <ehird`> macro <proc $name($*args) { $*body }> { ... }
00:36:20 <ehird`> well, maybe more than that would be required
00:36:24 <pikhq> Something much more fully-featured, rather than bare-bones. . .
00:36:29 <ehird`> macro <proc $name($,args) { $*body }> { ... }
00:36:33 <pikhq> Perhaps supporting PSOX out of the box.
00:36:35 <ehird`> if , means 'comma-seperated names'
00:36:44 <ehird`> pikhq: PSOX is bloated vaporware :P
00:36:59 <ehird`> (apologies to Sgeo. :P)
00:37:09 <pikhq> ehird`: I'll grant you the vaporware bit.
00:37:26 <ehird`> also bloated in the over-engineered sense
00:37:51 <pikhq> Perhaps a very simple interaction layer could be used to make this insanely more full-featured.
00:37:51 <ehird`> If I were you I'd make the compiler backend agnostic
00:37:56 <ehird`> So you could compile to befunge too or whatever.
00:38:17 <ehird`> and the 'plain BF' backend would just crap out on compiling primitive IO operations other than read/write stdout
00:38:33 <ehird`> you could have a 'PSOX BF', 'PSOX Befunge', 'EsoAPI BF', ... too
00:38:52 <pikhq> What, then, shall be the syntax?
00:39:07 <pikhq> For this language.
00:39:31 <ehird`> I'll write what's in /my/ mind on a pastebin... an example of sorts
00:46:04 <ehird`> i just realised recursive macros will work badly, for e.g. factorial
00:46:08 <ehird`> you'd need to know the value at compile-time
00:46:13 <ehird`> so i'm rewriting it as non-recursive :)
00:47:38 -!- pikhq_ has joined.
00:48:55 <ehird`> pikhq: Give me something other than a factorial to use as an example :P
00:49:06 <ehird`> Preferably something that doesnt' require me to define new variables in the resulting code
00:49:12 <ehird`> (why will be apparent soon)
00:49:32 -!- GreaseMonkey has changed nick to N0body.
00:49:59 -!- N0body has changed nick to GreaseMonkey.
00:52:12 <ehird`> i'll define somethiing simple
00:53:35 <ehird`> http://rafb.net/p/OzgiHQ78.html
00:53:51 <ehird`> i'd expect hygenic macros to be there too, and maybe something that lets you define a pseudo-function without sigils etc :-)
00:54:17 <ehird`> `{...}, of course, is program quoting
00:54:41 <pikhq_> That is going to be a *painful* syntax to parse.
00:55:23 <ehird`> pikhq_: No more than C++. :)
00:55:30 <ehird`> Why is that painful, anyway?
00:56:09 <pikhq_> Namely, that it appears to entail runtime-modifiable syntax.
00:56:27 <ehird`> that's all compile time
00:56:32 <pikhq_> macro <$n+$z> { __builtin($n, $z) }
00:56:43 <pikhq_> Okay, fine. Compiletime-modifiable syntax. Sorry.
00:57:00 <ehird`> pikhq_: you'd need some kind of declarator there to specify it's a binary op
00:57:05 <ehird`> it's not >totally< free syntax
00:57:13 <pikhq_> It's still fairly painful.
00:57:23 <ehird`> plus it allows for implementing e.g. procedures in it even if you don't include them in the core
00:57:24 -!- pikhq has quit (Nick collision from services.).
00:57:25 -!- pikhq_ has changed nick to pikhq.
00:57:41 <pikhq> Painful as fuck, but useful.
00:57:59 <ehird`> painful as fuck for the time when you first write down it in the compiler
00:58:15 <ehird`> Of course, my stuff requires that the compiler has an interpreter.
00:58:28 <ehird`> Since macro definitions are evaluated, then the result as a quoted program is put into the program.
00:58:37 <ehird`> This is, of course, kick-ass.
01:01:47 <ehird`> pikhq: Confirm its kickassery!
01:08:28 -!- pikhq has quit (Read error: 104 (Connection reset by peer)).
01:09:24 -!- pikhq has joined.
01:10:42 -!- Sgeo has joined.
01:12:04 <ehird`> pikhq, what's the last thing you heard
01:12:10 <pikhq> "after that, wonderful".
01:12:27 <pikhq> Sgeo: I have been contemplating a new Brainfuck-targetting macro language.
01:12:29 <ehird`> Of course, my stuff requires that the compiler has an interpreter.
01:12:34 <ehird`> Since macro definitions are evaluated, then the result as a quoted program is put into the program.
01:12:37 <ehird`> This is, of course, kick-ass.
01:12:47 <ehird`> pikhq: I thought it was going to be agnostic?
01:12:54 <pikhq> One which *I* hope will use PSOX.
01:12:55 <ehird`> with esolang-PSOX as one backend
01:12:58 <pikhq> ehird`: That's you.
01:13:05 <pikhq> My language, my taste.
01:13:10 <Sgeo> G2G my dad's being a jackass
01:13:23 <ehird`> ok, guess i should fork
01:13:47 -!- calamari has joined.
01:13:56 <pikhq> Mine will probably be working within the next week.
01:14:07 <pikhq> (PEBBLE went from idea to working implementation in a day. :p)
01:14:27 <ehird`> are you going to steal my c-like syntax? :(
01:14:37 <pikhq> No. It's more C++-like.
01:14:46 <pikhq> With all the requisite problems in compiling.
01:15:09 <ehird`> BUT MY IDEA WOULD BE SO AWESOME
01:15:47 <pikhq> I won't bother reworking all the PEBBLE machinery.
01:15:58 <pikhq> My system shall use PEBBLE as an assembly language of sorts.
01:15:58 <ehird`> OK, i'm definately forking
01:16:52 * pikhq actually has no simple, quick idea, unlike PEBBLE had. :(
01:17:00 <pikhq> Frankly, I'm at the drawing board ATM.
01:17:27 <ehird`> i have a simple quick idea! :(
01:17:39 <pikhq> No, that's a travesty.
01:18:09 * pikhq has a purely stupid idea.
01:18:31 <pikhq> Implement a Brainfuck macro system as a C library. :p
01:18:50 <ehird`> And I could make my idea simple. :P
01:18:52 <pikhq> I said it was stupid.
01:19:59 <ehird`> ARgh you know what I'm sick of all this brainfuck concentration
01:20:05 <ehird`> Let's discuss some other interesting esolang.
01:20:54 * pikhq gets sick of all this PEBBLE replacement junk
01:21:34 * pikhq needs to finish some English homework
01:24:29 * pikhq needs an excuse not to do anything else today. :p
01:24:43 * oklopol made a small genetic algorithm testing language
01:24:44 <oklopol> pool AAAAAAAAA AAAAAAAAA AAAAAAAAA AAAAAAAAA AAAAAAAAA AAAAAAAAA AAAAAAAAA AAAAAAAAA AAAAAAAAA AAAAAAAAA AAAAAAAAA
01:24:44 <oklopol> pts sum \ [BBAAABBAA _] [a b] = a b
01:25:16 <oklopol> basically, you make a pool, and give it a function to use for assigning points to a certain string
01:26:01 <oklopol> after a few steps it finds the correct one, although i'm currently doing so much mutation it keeps giving random shit too :)
01:26:27 <oklopol> i guess i'll add stuff to specify how to reproduce and mutate
01:28:13 -!- cherez has quit ("Leaving.").
01:28:39 -!- ehird` has changed nick to ehirdsleep.
01:28:41 <oklopol> pts is the "points" function definition, sum is a sum of a list, \ [list list list...] [var var var...] expression is map, with variable names though, because lambdas would be stupid for this
01:28:51 <oklopol> although i guess that's obvious.
01:29:03 -!- cherez has joined.
01:29:15 <oklopol> well, it was actually there :)
01:29:20 <oklopol> i'll describe if i continue coding
01:30:25 -!- cherez has left (?).
01:37:30 -!- Sgeo has quit ("Ex-Chat").
01:49:17 <oklopol> now i have to name it that.
01:49:54 <oklopol> why did that pop into my head
01:57:40 <oklopol> wow, i never realized how much genetic algos kick ass :)
02:12:23 <oklopol> http://www.vjn.fi/pb/p234266216.txt
02:12:49 <oklopol> last line is the output, in the form (best_found, points_for_best, iterations_taken)
02:13:05 <oklopol> just been adding trivial stuff, but it's a fun toy anyway :P
02:13:53 <oklopol> the bad news is, 6 hours till i need to wake yp.
02:16:55 <Slereah> I wonder what a creationist algorithm looks like.
02:17:08 <Slereah> Maybe it's similar to Turing's Oracle Machine
02:20:01 <oklopol> i was thinking, i'll first extend that enough to be able to make bf text gen, then evolve a human out of a string of A's
02:20:55 <oklopol> it's kinda annoying, all day i feel like i really should code something, and then when i finally do, it's ready in an hour or two and i have nothing to code.
02:22:18 <oklopol> i can't code that anymore, since the part i wanted to work works, and i'd have to start thinking again
02:22:38 <oklopol> there's a mood for coding, and a mood for inventing something to code
02:23:18 <oklopol> unfortunately both do mix with the third mood, futurama mood, which kinda overrides both
02:23:29 <oklopol> btw. didn't name it genetal :)
02:24:21 <oklopol> my initial idea was to make a language for calculating fixed points :D
02:24:42 <oklopol> you'd run some time, then change something in the past, and recalculate if the change actually changed something
02:25:34 <oklopol> (you'd need to be able to set an epsilon of course)
02:26:35 <oklopol> tried to find a clear relation between this kind of mutation and plain old fixed point, but got bored of thinking and just coded something :-)
02:26:49 <oklopol> i'm fairly sure you could make something totally awesome with the fixed point idea
02:27:13 <oklopol> the only reason i'm talking really is to get your text to disappear from the screen
02:28:30 <oklopol> Slereah: so what's up with the machine of yours whose name i forgot :-)
02:29:20 <Slereah> Although I'm sure there's ways to make it faster.
02:29:23 <oklopol> have you been doing fun stuff with it
02:29:40 <oklopol> well, compiling to C seems to be pretty popular these days?
02:29:47 <Slereah> Well, right now I'm working on the lazy unlambda.
02:30:03 <oklopol> your the SKI evaluator : )
02:30:27 <Slereah> The lambda-SKI-other combinator-iota thingy.
02:31:04 <oklopol> hmm, wonder if i'd get sleep now if i tried... getting delusional
02:31:30 <oklopol> i think i'll watch a family guy or something
02:31:43 <oklopol> i guess i can skip one night of sleep
02:33:05 <Slereah> You can. Doesn't mean you should though!
02:34:16 <oklopol> well, there's the minor problem that if i go to sleep, i will definitely not wake yp
02:34:47 <oklopol> then again, i have 8 hours of school, plus some hobby-related stuff after taht
02:35:08 <oklopol> and i slept through the lectures today too
02:35:25 <oklopol> i doubt i'll die, i mean i won't wake up in times.
02:37:51 <Slereah> Heh. Reminds me. I should study
02:38:43 <Slereah> And I didn't study all that much.
02:39:11 <Slereah> Quantum physics, relativity, analytic mechanics, mathematics, that sort of things.
02:40:39 <oklopol> i'll try falling asleep here on teh armchair, lees comfortable than my bed, so i'll prolly wake up, no?
02:40:54 <Slereah> Boy are you in for a surprise!
03:18:19 <Slereah> ``^x^y````y.xri``xx```s``s`ks``s`k`s`ks``s``s`ks``s`k`s`ks``s``s`ks``s`k`s`ks``s`k`s`kkk`k``s`k`s`k`s`k`si``s`k`s`k`s``s`ksk``s`k`s`k`s`kk``s`k`s`kkk`k`kk`k`k`kiy^x^y````y.xri``xx```s``s`ks``s`k`s`ks``s``s`ks``s`k`s`ks``s``s`ks``s`k`s`ks``s`k`s`kkk`k``s`k`s`k`s`k`si``s`k`s`k`s``s`ksk``s`k`s`k`s`kk``s`k`s`kkk`k`kk`k`k`kiy^f^x`f`f`f`fx
03:18:30 <Slereah> Hurray, I made a count-down!
03:18:52 <Slereah> Although so far, it only did 4-3-2
03:19:53 <Slereah> The Turing fixpoint combinator is totally awesome.
03:21:30 <Slereah> It is intensely slow, though.
03:27:02 <Slereah> (It is pretty much ((^xy. (```y.xri) (xx pred (y))) ^xy. (```y.xri) (xx pred (y))) n) )
03:31:57 <Slereah> Here's a possibly faster version : ``m``s`k`s``s``s``si`k.x`kr0``s``s`ks``sbk`k``s``s`ks``s`k`s`ks``s``s`ks``s`k`s`ks``s``s`ks``s`k`s`ks``s`k`s`kkk`k``s`k`s`k`s`k`si``s`k`s`k`sb``s`k`s`k`s`kk``s`k`s`kkk`k`kk`k`k0``sb``sb``sb``sb``sb``sb``sb``sb``sb``sb0
03:35:53 <Slereah> Hell, is SB actually equivalent to the successor function?
03:46:38 <Slereah> That will trim down my input system a whole lot!
04:15:25 -!- calamari has quit (Connection timed out).
04:34:25 -!- oerjan has joined.
04:43:30 <oerjan> <oklopol> or then oerjan just checks for highlights.
04:43:51 <oerjan> not always, but today i don't think i'll read it all
05:07:33 <Slereah> Hm. If I replace ```y.xri by (iszero y) (v) (```y.xri), maybe the program will halt!
05:35:42 -!- cherez has joined.
05:38:37 <Slereah> Hell. It gets complicated!
05:46:31 <pikhq> http://en.wikibooks.org/wiki/Programming:ColdFusion/control_structures
05:46:40 <pikhq> Is it an esolang if it's meant to be used seriously?
05:47:54 <pikhq> Recommended for usage in website design.
05:48:31 <Slereah> Well, if it's even recommended, maybe not!
05:50:26 * pikhq hurls at the idea of XML programming.
05:50:32 <pikhq> And not even well-formed XML at that.
05:56:59 -!- oerjan has quit ("Caffeine").
07:33:55 -!- lament has quit ("Ducks!").
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:03:25 -!- Slereah- has joined.
08:22:17 -!- Slereah has quit (Read error: 110 (Connection timed out)).
08:35:26 -!- cherez has quit (Read error: 110 (Connection timed out)).
08:41:56 -!- GreaseMonkey has quit ("Welcome to 2008. I will be your tour guide.").
08:44:19 -!- sebbu2 has joined.
08:52:01 -!- cherez has joined.
09:00:17 -!- sebbu has quit (Connection timed out).
10:10:48 <oklopol> Slereah-: woke up 4 hours late, good idea to go to sleep :P
10:13:03 <Slereah-> I personnaly use a program to launch some Mp3 when I'm not sure I'll wake up.
10:13:13 <Slereah-> "Chocolate rain" at generous volume works okay.
10:14:54 <oklopol> why the fuck did i wake up in my bed
10:15:04 <oklopol> i went to sleep right here.
10:15:46 <Slereah-> Well, if you woke up in China, that would raise the question.
13:12:05 -!- oerjan has joined.
13:31:02 -!- sebbu has joined.
13:37:12 <SimonRC> oklopol: what is up with your sleep
13:37:27 <SimonRC> I couldn't figure out quite what was going on before
13:39:15 <Slereah-> From what I can make out, "It is late and if I sleep, I won't wake up on time!"
13:40:44 <SimonRC> well duh, use an alarm clock
13:41:07 <SimonRC> unless I am missing something here
13:41:12 <Slereah-> Won't work with any pussy alarm clock.
13:41:29 <Slereah-> When I was a kid, I had some real serious business alarm clock.
13:41:43 <Slereah-> It was shaped like a racing car, and made the same noise.
13:41:54 <Slereah-> It woke up everyone in the house.
13:44:08 -!- sebbu2 has quit (Connection timed out).
14:08:34 <Slereah-> Is there any simple combination of combinators for the pred. function?
14:09:29 <Slereah-> I've got 16 so far, I might as well continue!
14:10:31 <oerjan> hm... let me lookup my Deadfish implementation
14:11:14 <Slereah-> The shortest version I got is ``s``s`ks``s`k`s`ks``s``s`ks``s`k`s`ks``s``s`ks``s`k`s`ks``s`k`s`kkk`k``s`k`s`k`s`ko``s`k`s`k`sb``s`k`s`k`s`kk``s`k`s`kkk`k`kk`k`k0
14:11:44 <Slereah-> I can't check slightly more complex formulas for accuracy.
14:12:48 <oerjan> ``s``s``s``s`k?d`kii`k
14:12:48 <oerjan> ``s`kk ``s``s`ks ``s`k`s`ks ``s`k`s`kk ``si`kk `ki
14:14:23 <Slereah-> Do the space inditaces different formulas?
14:14:47 <oerjan> possibly the part starting on the third line after `k
14:15:00 <oerjan> i just tried to use a sensible indentation style
14:16:11 <oerjan> this is the part of the program specific to the d operator, which decrements
14:18:34 <oerjan> or it could be all of it except the first line
14:20:27 <oerjan> ah, found my scratch file, which explains some of what's going on
14:21:48 <oerjan> ah yes, it should be what i pasted except the first line
14:24:27 <Slereah-> In a different way than ``s``s`ks``s`k`s`ks``s``s`ks``s`k`s`ks``s``s`ks``s`k`s`ks``s`k`s`kkk`k``s`k`s`k`s`ko``s`k`s`k`sb``s`k`s`k`s`kk``s`k`s`kkk`k`kk`k`k0 somehow.
14:24:46 <Slereah-> (```pred n .x i prints everything after a while instead of continuously)
14:25:34 <oerjan> it is essentially based on iterating ^p (`$p k + 1, `$p k)
14:27:04 <Slereah-> Well, the slightly trimmed version is ``s``s`o`k``s``s`ks``s`ko``s`kk``s``s`ks``s`k`s`ks``s`k`s`kk`o`kk0``s`kk`o`kk`k`k0`k0
14:28:37 <Slereah-> I'd make a special combinator just for it, but since it also contains lambda, I'm not sure it will gain that much time.
14:37:48 <Slereah-> There's apparently some rules for abstraction elimination in the SKIBC system
14:51:44 <Slereah-> ``c``bc``b`bc``c``bc``b`bb``c``bbi``b`b`ci``b`cii``bkii
14:53:27 <oerjan> well in a.e. for ^x.E(x)F(x), the rules for K, B and C are just special cases of the rule for S, when at least one of the parts don't mention x
14:54:36 <Slereah-> And it gives more compact expression, for this poor slow interpreter.
14:56:57 <Slereah-> I even already have the combinator for CI!
14:59:55 <Slereah-> ``c``bc``b`bc``c``bc``b`bb``c``bbi``b`bt``bti``bkii
15:00:01 <Slereah-> It is more fashionable that way.
15:01:25 <Slereah-> And ``bki seems to be no one else but our old friend k!
15:03:09 <Slereah-> Is ``b[stuff]i equivalent to [stuff]?
15:08:17 <oerjan> ``bXi = ``s`kXi which is X by the eta-rule?
15:09:26 <Slereah-> I don't think enough of the eta rule.
15:18:23 <Slereah-> ``c``bc``b`bc``c``bc``b`bb``c`b``b`bttki
15:18:41 <Slereah-> Can't think of anything further, but it's more reasonable alread.
15:20:34 -!- timotiis has joined.
15:21:42 <Slereah-> ``c``bc``b`bc``c``bc``b`bb``cb``b`bttki, more accurately
15:25:09 <SimonRC> if c is call/cc, then you are a sick bastard
15:27:04 <Slereah-> Hell, I can even define substraction in less than a line! ``b`c`t``c``bc``b`bc``c``bc``b`bb``cb``b`bttkii
15:28:40 <Slereah-> And iszero seems to be `t`k0 !
15:28:52 <Slereah-> It's quite a nice way to eliminate abstractions.
15:45:26 -!- calamari has joined.
15:58:12 -!- Slereah has joined.
16:00:53 -!- jix has joined.
16:08:20 -!- Tritonio_ has joined.
16:12:34 -!- calamari has quit ("Leaving").
16:22:12 -!- Slereah- has quit (Read error: 110 (Connection timed out)).
16:27:15 -!- lulz has joined.
16:27:21 -!- lulz has changed nick to christ.
16:28:50 <christ> what's up slereah ? how're u doing ?
16:29:34 -!- christ has quit (Client Quit).
16:29:51 -!- ehirdsleep has changed nick to ehird.
16:29:56 -!- ehird has changed nick to ehird`.
16:30:34 -!- Slereah- has joined.
16:38:31 -!- puzzlet_ has quit (Read error: 104 (Connection reset by peer)).
16:38:48 -!- puzzlet has joined.
16:44:40 <ehird`> does anybody know when i first came in here?
16:48:50 -!- Slereah has quit (Read error: 110 (Connection timed out)).
16:56:08 -!- oerjan has quit ("leaving").
17:15:39 <ehird`> i'm looking through ircbrowse to find
17:15:54 <ehird`> earliest i've found so far is 20070806
17:16:00 <ehird`> but i'm pretty sure it was earlier than that
17:16:24 <sekhmet> ehird`: You joined once on Dec 29 2006 but didn't say anything
17:16:40 <sekhmet> ehird`: Then the next time I've got in my logs was May 14 2007
17:16:53 <sekhmet> 10:48 < ehird`> i honestly think my language may be worse than malbolge
17:17:02 <ehird`> sekhmet: well, that was fast.
17:17:19 <ehird`> i wonder why i didn't say anything
17:19:25 <ehird`> side note: that language was worse than malbolge, but the decoding mechanism unfortunately meant that most programs couldn't be encoded
17:55:32 * ehird` realises this is the first itme sekhmet has actually spoken
18:00:49 <sekhmet> Nah, I spoke for a bit when I first joined here
18:01:09 <sekhmet> Not much though, I mostly lurk and go check out new esolangs when I notice 'em being discussed. :)
18:06:58 <ehird`> anyone here malbolge-knowledgable?
18:31:25 <ehird`> http://esoteric.voxelperfect.net/wiki/Deadfish%7E this seems turing complete to me
18:37:42 -!- RedDak has joined.
19:24:44 <cherez> It might be Turing complete, but I don't see how it would be Turing equivalent.
19:41:34 <ehird`> cherez: what sense does that make.
19:43:14 <ehird`> GregorR: I can has egobot?
20:07:36 -!- EgoBot has joined.
20:08:40 <bsmntbombdood> http://www.mitadmissions.org/topics/learning/coursework/the_end_of_an_era_1.shtml
20:11:03 -!- faxlore has joined.
20:15:40 <ehird`> god damn you gregorr, i just compiled netcat to get GlassBot in here
20:15:40 -!- GlassBot has joined.
20:16:45 <ehird`> GregorR! Your parser is broken.
20:17:55 <ehird`> i'm trying to figure out t he exact allowed characters in e.g. ()s
20:17:59 <ehird`> for my haskell implementation
20:19:30 <faxlore> you writing a bunch of interpreters in haskell for esolangs?
20:22:17 <johnl> i'm supposed to be writing a compiler for kipple...
20:22:35 <ehird`> kipple, i've heard of that before
20:22:42 <ehird`> link me to the esolangs pge and i might implement it :P
20:22:57 -!- Jontte has joined.
20:25:41 <johnl> but don't you implement it :P
20:25:54 <johnl> i'll get round to it before the end of the week...
20:26:05 <ehird`> looks like there's already lots of implementations
20:26:07 <johnl> it's just coursework i've procrastinated for weeks
20:26:17 <johnl> i just wanted an easy task for my compiler design course
20:26:27 <ehird`> you won't learn much compiler design from that
20:26:51 <johnl> but i have other tasks to learn that from
20:27:05 <johnl> this was just a trivial exercise to implement in CoCo/R
20:28:31 <ehird`> hah, since glass Strings name-clash with haskell strings, I followed by muscle memory and added a prefix - since it's a glass compiler, G.
20:39:10 <ehird`> > Push left operand onto right stack
20:39:10 <ehird`> < Push right operand onto left stack
20:39:13 <ehird`> these are redundant, right?
20:39:33 <johnl> in simple expressions, i think
20:39:47 <ehird`> what i mean is that i can parse them to be the same
20:40:27 <ehird`> hm, i need to allow arbitary code for the operands too
20:41:23 <ehird`> the *parsing* of kipple is non-trivial
21:26:26 -!- puzzlet_ has joined.
21:27:15 -!- puzzlet has quit (Remote closed the connection).
21:30:38 -!- Tritonio_ has quit (Read error: 113 (No route to host)).
21:31:25 -!- Tritonio_ has joined.
21:41:37 <ehird`> anyone have a language they want implemented? :P
21:43:12 <faxlore> well I don't really want a particular language implemented
21:43:19 <faxlore> just a certain kind of parser
21:43:30 <faxlore> (I was going to hook pu a few different lambca caluclus to it)
21:44:05 <ehird`> i'd do all parsing using parsec, so implementing a certain kind of parser would be a bit...heh
21:44:30 * faxlore would use parsec to write this too probably
21:47:35 <ehird`> OH WELL. anything other than a parser? :P
21:51:42 <faxlore> http://www.esolangs.org/wiki/Thue
21:52:10 <ehird`> thue, the one language you can't parse because you'd lose the information it needs to evaluate!
21:52:25 -!- Jontte has quit ("Konversation terminated!").
21:53:10 <faxlore> you could finish this line "sortPlaces = " :p
21:53:13 -!- johnl has quit (Read error: 104 (Connection reset by peer)).
21:55:00 <ehird`> sortPlaces = deliciously frozen food!
21:56:15 -!- jix has quit ("CommandQ").
21:57:13 -!- johnl has joined.
21:57:57 <faxlore> oh you know what's a fun problem
21:58:07 <faxlore> I tried this the other day but didn't do well ...
21:58:37 <faxlore> write a program that composes combinators (like solving the puzzles in To Mock A Mockingbird) to match some lambda abstraction
21:58:50 <faxlore> It's not really a language though
21:59:12 -!- GreaseMonkey has joined.
21:59:44 -!- tesseracter has joined.
22:06:03 -!- RedDak has quit ("I'm quitting... Bye all").
22:06:06 <ehird`> an optimizing SKI->lambda calculus
22:06:13 <ehird`> that is, doesn't just do 'dumb' replacement
22:08:18 <faxlore> given the type of some function, you can infer the minimal size term with that type?
22:08:31 <faxlore> is that first or second order unification or something else?
22:09:55 <faxlore> in any case if you do write a SKI-> lambda caluclus thing I wanna see it :D
23:13:41 -!- timotiis has quit ("leaving").
23:24:33 -!- Tritonio__ has joined.
23:24:58 -!- Tritonio_ has quit (Read error: 110 (Connection timed out)).
23:27:18 -!- faxlore has quit ("Leaving").
23:46:08 -!- GregorR has quit (Remote closed the connection).
23:47:37 -!- GregorR has joined.
23:48:38 <GregorR> And will be inactive momentarily.