←2008-01-04 2008-01-05 2008-01-06→ ↑2008 ↑all
00:02:43 <Slereah> http://membres.lycos.fr/bewulf/Russell/AE6.py
00:05:04 <Slereah> There's nothing to distinguish variables from combinators, so I would avoid s-k-i.
00:05:22 <Slereah> Although I'm not even sure what it might do.
00:07:15 <Slereah> Well, it screw it up apparently.
00:50:50 -!- faxathisia has quit ("Leaving").
01:15:31 -!- Sgeo has quit ("Ex-Chat").
01:55:43 -!- SimonRC has quit (Read error: 110 (Connection timed out)).
02:05:34 -!- tesseracter has changed nick to weilawei.
02:08:32 -!- weilawei has changed nick to tesseracter.
02:21:05 <Slereah> Damn. The predecessor function won't pass through the ABSTRACTOR
02:48:46 -!- Jontte has quit (Remote closed the connection).
04:00:03 -!- calamari has quit ("Leaving").
04:49:33 -!- slereah_ has joined.
05:08:48 -!- Slereah has quit (Read error: 110 (Connection timed out)).
05:09:05 -!- oerjan has quit ("Good night").
05:48:25 -!- slereah_ has changed nick to Slereah.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
10:52:53 -!- SimonRC has joined.
10:59:00 -!- Jontte has joined.
11:48:39 -!- sebbu has joined.
11:50:47 -!- AnMaster_ has joined.
12:01:50 -!- AnMaster has quit (Connection timed out).
12:19:22 <sebbu> [amsg] carte mère, cpu, ram, carte graphique, alim changés, windows marche encore
12:25:20 -!- faxathisia has joined.
12:25:24 -!- Hiato has joined.
12:25:34 <Hiato> Wassabi all :)
12:26:16 -!- AnMaster_ has changed nick to AnMaster.
12:34:52 <Hiato> alright fine, Hi all
12:35:19 <faxathisia> Hello
12:36:11 <Hiato> Anything new happening in the eso community? (Wasn't here since Wednesday...)
12:37:26 <faxathisia> hmm I'm not sure
12:37:39 <Hiato> ok cool
12:37:44 <faxathisia> I'm trying to decide if this language is esoteric or not
12:37:56 <Hiato> which?
12:38:06 <faxathisia> It's called Janus
12:38:15 <faxathisia> Here is bubblesort http://rafb.net/p/woIN0k75.txt
12:38:31 <Hiato> hrmm
12:38:39 <Hiato> looks Lua-esque to me
12:38:43 <faxathisia> it does look so odd (it's almost exactly like the While language), but you can any valid program in it forwards and backwards
12:38:51 <faxathisia> which is certainly not usual :)
12:38:59 <Hiato> woow
12:39:03 <Hiato> that's cool
12:39:04 <faxathisia> so I'm not sure how to classif y it
12:39:13 <Hiato> did you make it?
12:39:27 <faxathisia> well I read a paper on it, then I emailed the authors asking for their interpreter..
12:39:35 <Hiato> I see
12:39:36 <faxathisia> they didn't reply though.. so I have written one
12:39:42 <Hiato> lol, awesome
12:40:06 <Hiato> hrmm
12:40:07 <Hiato> well
12:40:08 * faxathisia (is doing a compiler now so I can hopefully run the self interpreter)
12:40:18 <Hiato> that would be wicked
12:40:30 <Hiato> I must say, that it is not what I would expect from an eso lang
12:40:44 <faxathisia> yeah, it might not count
12:40:49 * faxathisia isn't sure
12:40:52 <Hiato> I generally expcet either obfuscation or minimisation
12:41:07 <Hiato> seems to be a very structured language to
12:41:11 <Hiato> very keywordy
12:41:13 <Hiato> ;)
12:42:18 <faxathisia> the only things are += -= ^=, if_then_else_fi_, from_do_loop_until, call_, uncall_ and skip, and the only data is numbers
12:42:34 <Hiato> oh... hrmm...
12:42:41 <faxathisia> (32 bit integers)
12:42:44 <Hiato> I see
12:42:47 <Hiato> ^=?
12:42:50 <faxathisia> XOR
12:42:54 <Hiato> cool
12:43:05 <faxathisia> += -= are inverse, ^= is it's own inverse
12:43:13 <Hiato> yeah
12:43:16 <Hiato> and procedure
12:43:20 <Hiato> is that also a keyword?
12:43:23 <faxathisia> Yes
12:43:33 <Hiato> hrmm
12:43:36 <Hiato> maybe it's eso
12:43:40 <Hiato> so hard to tell
12:43:42 <Hiato> ;)
12:43:45 <faxathisia> It's kind of on-the-edge :D
12:43:49 <Hiato> yip
12:43:57 * faxathisia should try to come up with an esolang...
12:44:07 <Hiato> Yeah, that's a nice idea
12:44:16 <Hiato> I'd like to see what your mind can create :P
12:44:50 -!- timotiis has joined.
12:45:24 * faxathisia would really like to see more interesting sub-turing languages though
12:45:41 <Hiato> well, Im working on one as we speak
12:45:51 <faxathisia> oo
12:45:57 <Hiato> actually though
12:46:03 <Hiato> it might be Turing complte
12:46:07 <Hiato> but who knows :)
12:46:23 <faxathisia> someone will soon have proof by implementing brainfuck in it
12:46:24 <faxathisia> :D
12:46:31 <Hiato> lol, yip
12:46:36 <faxathisia> What is it?
12:46:43 <Hiato> I'll link now
12:46:46 <Hiato> one sec
12:48:53 <Hiato> http://rafb.net/p/TFMAVK60.txt
12:49:08 <Hiato> if stuff is mis-aligned, it's cause it cam out of word
12:49:11 <Hiato> ;)
12:49:22 <Hiato> sorry about the quantity
12:53:15 <faxathisia> It's got loops and conditional branching.. probably universal
12:53:24 <Hiato> true
12:53:25 <faxathisia> mad though :p
12:53:29 <Hiato> thanks :)
12:55:52 <faxathisia> hmm
12:55:58 <Hiato> ?
13:01:38 <Hiato> be back soon(ish)
13:10:38 <faxathisia> esolang propsal 1: Nothing -- Only valid program is the empty program, this language can compute everything in the NONE complexity class
13:14:20 <Hiato> back
13:14:22 <Hiato> hrmm
13:14:26 <Hiato> faxasthisia
13:14:34 <Hiato> I'm not so keen on that one
13:14:42 <Hiato> for some odd reason ;)
13:14:54 <Hiato> that would be leaning towards joke language
13:15:35 <Hiato> even though scientifically accurate, it can compute anything of zero complexity
13:15:48 <faxathisia> http://qwiki.stanford.edu/wiki/Complexity_Zoo#none
13:16:29 <Hiato> lol
13:16:31 <Hiato> well
13:16:36 <Hiato> yes, you have a point
13:16:53 <Hiato> but then the interpreter would be int main() {return0};
13:16:55 * faxathisia provides an implementation, in Nothing:
13:16:56 <Hiato> fascinating
13:16:59 <Hiato> :P
13:17:01 <Hiato> lol
13:17:26 <Hiato> ok, I wrote up the hello world prog : ""
13:17:31 <Hiato> and fib
13:17:33 <faxathisia> That's impossible
13:17:35 <Hiato> ;)
13:17:37 <Hiato> true
13:17:44 <Hiato> what about a self interpreter
13:17:47 <Hiato> """"
13:18:05 <faxathisia> I already pasted a self interpreter :P
13:18:14 <Hiato> :)
13:18:23 <faxathisia> ok ok *tries harder*
13:18:29 <Hiato> lol
13:18:36 * faxathisia is reading the complexity zoo for inspiration
13:18:54 <Hiato> preferably come up with something with >=1 dimension of complexity
13:18:56 <Hiato> :)
13:18:59 <Hiato> enjoy ;)
13:19:01 <faxathisia> hehe
13:32:04 <Hiato> ok, going somewhere, be back later
13:32:08 -!- Hiato has left (?).
15:28:51 -!- jix has quit (Read error: 60 (Operation timed out)).
15:29:18 -!- jix has joined.
15:57:05 -!- sebbu2 has joined.
16:01:10 -!- iEhird has joined.
16:01:26 <iEhird> esilang idea.
16:01:54 <iEhird> haskellesque type definitions only
16:02:08 <iEhird> they are much more powerful though
16:02:40 <iEhird> function bodies ate inaccessivle and determined by something like lambdabots djinn
16:03:24 <iEhird> Turing complete. hopefully.
16:03:56 <iEhird> thr ultimate dwcparative Lang
16:05:39 <faxathisia> iEhird I love it!!
16:06:07 <faxathisia> this is what I want to code in
16:06:14 <faxathisia> though it is not very eso..
16:06:39 <faxathisia> Do you know this sort of exists already?
16:07:01 <faxathisia> (just that the djinn bit is mostly done by the programmer)
16:08:18 -!- iEhird has quit (Remote closed the connection).
16:08:21 -!- oerjan has joined.
16:14:39 -!- sebbu has quit (Read error: 110 (Connection timed out)).
16:14:59 -!- iEhird has joined.
16:18:51 <oerjan> faxathisia: i say there are at least two kinds of esolangs, those that are syntactically esoteric and those that are semantically esoteric. Janus should not be disqualified just for not being in the first group.
16:19:48 <oerjan> especially since a bit of the second makes a language much more interesting...
16:20:37 <oerjan> it's just that making a weird syntax is so much easier that those tend to be a huge majority
16:22:09 <faxathisia> in that case, Do you think it is one or not?
16:23:13 <faxathisia> I mean I know of only.. 5 I think reversible languages
16:23:20 <oerjan> i think reversible languages are pretty esoteric :)
16:23:30 <faxathisia> cool :D
16:23:48 <oerjan> there's a category on the wiki for them
16:24:20 <oerjan> however, we have a tradition that the intention of the language author counts too
16:24:37 <faxathisia> oh right..
16:24:56 <faxathisia> I really have no idea what the authors intended
16:25:06 <faxathisia> might be research
16:26:19 <oerjan> indeed
16:26:26 -!- faxathisia has left (?).
16:26:29 -!- faxathisia has joined.
16:27:38 <iEhird> type Integer = a -> Integer -> Integer
16:27:42 <iEhird> I think
16:27:59 <faxathisia> huh ?
16:28:25 <iEhird> zero :: a -> b -> b
16:28:26 <oerjan> Error: Recursive type
16:28:41 <iEhird> oerjsn this ain't Gaskell
16:29:03 <faxathisia> It's twelf!
16:29:03 <oerjan> Error: Lousy typing
16:29:04 <iEhird> thisbis Tc type system and nothing elsev-skell
16:29:18 <faxathisia> Nat : Type, Z : Nat, S : Nat -> Nat
16:29:19 <iEhird> error iPhone youvhedreej tuppbg
16:29:25 <iEhird> touchscree
16:29:44 <iEhird> fax not enough without bodies
16:29:46 <faxathisia> I don't think turing complete type system is good idea
16:29:48 <iEhird> anyway
16:29:49 <faxathisia> but almost turing
16:30:05 <faxathisia> if everything terminates you can encode proofs
16:30:27 <faxathisia> otherwise you can prove false and proofs don't mean anything anoymore
16:30:46 <faxathisia> Qi has TC type system apparently though
16:31:24 <iEhird> hmm anyone know a func rep of into that isn't church numerals
16:31:32 <oerjan> afair the point is if your type system is not terminating then you have to actually _run_ the types in your program
16:31:50 <oerjan> to check that they do terminate
16:32:03 <oerjan> you cannot just do them statically
16:32:04 <iEhird> oerjsn the types terminate the functions autogrnned by them may not
16:32:24 <faxathisia> if you can encode a fixpoint in the type system then you basically got X : (a -> a) -> a, which lets you prove any 'a'?
16:32:40 <faxathisia> e.g. everything is provable
16:32:57 <oerjan> yep - except the proof will not terminate
16:33:19 <oerjan> so if you actually run the proof you are still safe from reaching an erroneous conclusion, i think
16:33:26 <faxathisia> hmmmmm
16:33:35 <iEhird> type Recur = Recur -> a
16:33:52 <oerjan> now this as usual my vague understanding from reading discussions...
16:33:57 <oerjan> *is as
16:34:22 <iEhird> Y :: Recur a -> ...
16:34:33 <iEhird> CBS to type the rest Oman iPhone
16:34:44 <iEhird> someone else fi I'd :P
16:34:49 <faxathisia> lol
16:35:29 * oerjan half thinks iEhird must be wearing boxing gloves as well :D
16:35:50 <iEhird> no just typing really fast and ompeefixely
16:35:54 <iEhird> imprecicelt
16:36:22 <oerjan> doesn't it have spelling correction or something?
16:36:28 <iEhird> yes
16:36:39 <iEhird> that's the main problem
16:37:17 * faxathisia agrees about it being the ultimate declarative language
16:37:45 <faxathisia> The kind of theorm proving required would be ... a lot of work to code in the first place though
16:38:39 <iEhird> I guess
16:38:46 <iEhird> I would just do
16:39:22 <iEhird> djinn(defs)
16:39:37 <iEhird> and die if we run into problems
16:39:49 <faxathisia> actually they should add #djinn to haskell
16:40:00 <faxathisia> #djinn curry :: ((a, b) -> c) -> a -> b -> c
16:40:20 <iEhird> IMO the best strategy would be compiling to c using some vm like stuff for dtnamicism
16:40:36 <iEhird> compiler written I'm hadell for pat matching
16:41:22 <iEhird> I think I lost xobbecton???
16:41:30 <oerjan> hm a language based on spelling errors...
16:41:39 <oerjan> iEhird: still hearing you
16:42:09 <faxathisia> lol xobbecton
16:42:30 <iEhird> oerjsn Yes
16:42:34 <iEhird> :D
16:43:34 <iEhird> I want iEmacs for iphone
16:43:51 <iEhird> write my compiler right here
16:43:53 <iEhird> :P
16:47:09 -!- iEhird has quit (Remote closed the connection).
16:53:08 -!- iEhird has joined.
16:56:44 -!- iEhird has quit (Remote closed the connection).
17:58:30 <Slereah> *yawn* Hello people.
18:02:18 * pikhq is of the opinion that an iPhone has a horrible keyboard, as do most portable devices.
18:04:24 <timotiis> hm, I wasn't a great fan of it when I played with one
18:05:50 <Slereah> Here, have some propaganda : http://www.thebestpageintheuniverse.net/c.cgi?u=iphone
18:06:22 <timotiis> no thanks, I don't feel like having propaganda
18:06:40 <faxathisia> I do, but not right now
18:07:17 <pikhq> The iPhone actually has a decent interface, aside from that damnable keyboard.
18:07:28 <pikhq> The big thing that I hate is that it's all locked up.
18:07:37 <pikhq> I enjoy things like Rockbox and OpenMoko.
18:07:52 <pikhq> There's just something wonderful about sticking Doom on your MP3 player.
18:08:51 <Slereah> I have a mp3 of some vaguely Doom inspired song on mine.
18:08:55 <Slereah> "Blood on the wall"
18:09:06 <pikhq> Mine also runs the Game of Life.
18:10:02 <timotiis> my phone runs the game of life. useful when bored
18:10:57 <pikhq> Mine would if a) I had money b) the damned Neo 1973 would ship already.
18:11:26 <Slereah> http://rome.ro/sounds/Blood_On_The_Walls.mp3
18:11:35 <Slereah> Heh, still online.
18:19:42 <timotiis> hehe
18:19:53 <timotiis> there's a pretty nifty little java implementation out there
18:21:14 -!- iEhird has joined.
18:21:24 -!- iEhird has quit (Client Quit).
18:21:35 -!- iEhird has joined.
18:21:54 <iEhird> now THAT'S clever
18:22:36 <iEhird> a scheme interp that has really efficient continuations: it actually portable c
18:22:45 <iEhird> plies the c stack
18:23:51 <iEhird> now if you did that in a compiler scheme-c interaction would be trivial
18:24:17 <iEhird> scm proc = c proc
18:25:19 <iEhird> tail calls could be done using setjmp
18:25:34 <pikhq> Gah! Long jumps!
18:25:34 <pikhq> :p
18:25:43 <iEhird> like a macro TAIL(func,arg...)
18:26:19 <iEhird> setjmp(buf); func(buf,arg...);
18:26:37 <iEhird> dunno
18:27:22 <iEhird> basically: every function that tailcalls has a trampoline embedded
18:28:36 <pikhq> You want fun? int foo __attribute__((cleanup (foo_deconstructor))) = 0;.
18:28:44 <pikhq> Mmm. Attributes. :p
18:29:39 <iEhird> :)
18:29:57 <iEhird> no gcc specifics!
18:31:06 <pikhq> But GCC runs everywhere!...
18:32:20 <iEhird> SCMVAL scm_fact(SCMENV env, struct jmp_buf tail, SCMVAL n) {
18:32:43 <iEhird> hmm make that jmo buf *
18:33:14 <iEhird> hm
18:33:20 <iEhird> not sure...
18:35:22 <iEhird> pikhq
18:35:36 <iEhird> I guess if you are stack smashing already
18:36:19 <iEhird> then you could mangle sp-1 then jump
18:51:33 * pikhq observes that stack smashing might *not* work on this system. . .
18:52:05 <pikhq> My system, being AMD64, enforces the NX bit.
18:52:14 * Slereah imagines the incredible Hulk, smashing stacks
18:53:04 <iEhird> there's probably a way pikhq
18:53:21 <iEhird> stack smashing is quite a common trick
18:54:39 -!- iEhird_ has joined.
18:55:00 <pikhq> Um. . . Surely stack smashing is something that shouldn't be used?
18:55:19 <pikhq> (no more than actually *using* a buffer overflow?)
18:56:40 <iEhird_> controlled stack smashing is useful in cases like this :-)
18:57:19 <iEhird_> most/all common arch/os's support it somehow
18:57:33 <pikhq> It's also non-portable as fuck, *and* liable to break on systems like OpenBSD, NX-bit supporting systems, etc.
18:57:51 <iEhird_> you can do it on openbsd
18:57:59 <pikhq> (granted, you can disable the stack-smashing protection on those systems. . . Doesn't make that a good idea.)
18:58:13 <iEhird_> writing a libcstack would be good
18:58:16 <pikhq> Yeah; you have to compile with -fno-stack-protector
18:58:47 <iEhird_> pikhq several common prigs do it
18:58:49 <iEhird_> progs
18:58:51 -!- Sgeo has joined.
18:59:10 <pikhq> Doesn't make it a good idea.
18:59:50 <pikhq> It's almost *exactly* like relying on buffer overflows in your code.
18:59:57 <iEhird_> void *dest; cstack_copy(dest);
19:00:25 <iEhird_> cstack_unwind(); cstack_pushall(dest);
19:00:58 <iEhird_> or something
19:04:52 -!- iEhird_ has quit.
19:05:14 -!- iEhird_ has joined.
19:05:54 -!- iEhird has quit (Read error: 113 (No route to host)).
19:13:59 <iEhird_> pikhq ping
19:14:42 <pikhq> Pnog.
19:15:57 <Slereah> Gnap
19:18:20 <iEhird_> I wonder how this will interact with gnu c
19:19:06 <pikhq> That depends.
19:19:28 <pikhq> If it depends upon undefined behavior, GCC will shoot you, then hand you a few errors and warnings.
19:19:30 -!- iEhird has joined.
19:19:45 <iEhird> actually I wonder the most portable way to find the srams
19:19:47 <iEhird> stack
19:21:06 -!- Hiato has joined.
19:21:29 <Hiato> Alright, back :)
19:21:32 <Hiato> Wassup all
19:22:03 <Hiato> Faxasthisia, how's the inspiration going?
19:22:08 <iEhird> another fun trick: call out native compiler then cast object code to func
19:22:25 <iEhird> = traditional interactive scheme system
19:22:52 -!- _KS has joined.
19:31:47 -!- oerjan has quit ("Sup").
19:35:37 <iEhird> ping
19:36:06 -!- calamari has joined.
19:42:59 -!- Hiato has left (?).
19:45:52 -!- iEhird_ has quit (Read error: 113 (No route to host)).
19:57:20 -!- iEhird has quit.
19:58:01 -!- iEhird has joined.
20:06:08 <SimonRC> There is one way to make tail recursion really easy to do:
20:06:16 <SimonRC> seperate the data and return stacks
20:06:27 <SimonRC> It is trivial for forth-like languages
20:07:10 <bsmntbombdood> how does that make it easy?
20:08:54 <SimonRC> all calls have either a look-ahead or the compiler modifies the call into a jump
20:10:09 <SimonRC> and every defined word ends in a call to another word, so there are lots of oportunities for tail-recusion
20:10:13 <SimonRC> optimisation
20:10:15 <iEhird> ("hello".^#)^#
20:10:18 <SimonRC> iEhird: ?
20:10:43 <iEhird> stack based esolang requiring quoting and unwrapping to loop!
20:11:05 <iEhird> (...) is a list
20:11:21 <iEhird> with elements "hello", ., etc
20:11:29 <iEhird> ^ is dup
20:11:39 <iEhird> . is output and pop
20:12:14 <iEhird> # is append the list on the top of the stack to the program and pop
20:12:25 <iEhird> so (x)# == x
20:13:15 -!- Hiato has joined.
20:15:44 <SimonRC> iEhird: cool
20:15:52 <SimonRC> seems familiar though
20:16:21 <iEhird> oh damn underload foes it
20:16:38 <iEhird> ok how about this
20:16:58 <iEhird> # wraps the rest I'd the prog
20:17:13 <iEhird> #abc -> (abc)
20:17:26 <iEhird> wait, no
20:17:44 <iEhird> hm
20:18:27 <iEhird> what about a Lang involving rewriting its own code by virtue of it being concatenrive and lists cab store code
20:20:04 <iEhird> ("hello".$0@$+$0!)$0@$+
20:20:11 <iEhird> I think that's right
20:20:27 <Hiato> woow
20:20:45 <iEhird> where $ the program as a list
20:20:54 <iEhird> @ nth element
20:21:00 <iEhird> + append
20:21:05 <iEhird> ! delete
20:22:09 <SimonRC> nasty
20:22:19 <timotiis> just put the whole program down, and have the output be the code after an illegal operation is executed. The only things you can modify are progra msource
20:22:25 <iEhird> simonrc but fun
20:23:51 <iEhird> ("hello"0\$@)0\$@
20:24:15 <iEhird> @ get element call func with it
20:24:31 <iEhird> \ quote func
20:24:33 <iEhird> hmmm
20:24:37 * SimonRC goes.
20:25:31 <iEhird> ("hello"!+@0)+@0
20:26:03 <timotiis> hm
20:26:22 <iEhird> hm
20:26:58 <timotiis> I think that a language where the only thing you can do is modify the program itself would be interesting. Then the prog itself is simply read left to right, and each symbol has it's effect
20:27:00 <iEhird> +(!"hello"+@0)
20:27:11 <iEhird> no more stack
20:27:14 <timotiis> as soon as something illegal happens, the whole program exits, printing the current source
20:27:25 <iEhird> next remove @
20:30:34 <iEhird> if you have a :xyz
20:30:41 <iEhird> x index
20:30:43 <iEhird> y list
20:30:49 <iEhird> z thing
20:31:01 <iEhird> append to y at x z
20:31:10 <iEhird> then that's possible
20:31:10 -!- calamari has quit ("Leaving").
20:36:40 -!- calamari has joined.
20:37:40 <Hiato> Is daar iemand hier wat verstaan my as ek Afrikaans praat?
20:38:49 <timotiis> ??
20:39:00 <Hiato> Ek het so gedink.
20:39:14 <timotiis> Come again, preferably in English
20:39:23 <Hiato> I said, "Is there anyone who will understand me if I speak Afrikaans?"
20:39:31 <Hiato> then I said "I though so" :P
20:40:05 <timotiis> I see
20:40:19 <timotiis> I got Afrikaans, but that was about it
20:40:24 <Hiato> lol
20:40:27 <Hiato> I suspected as much
20:40:30 <Hiato> what about
20:40:47 <Hiato> Mih mevin oti ca-usher uni ma-duber Ivrit?
20:40:49 <Slereah> Well, the verstaan is close enough to other germanic languages to understand too
20:40:55 <Hiato> yip
20:41:03 <Hiato> well, Afrikaans is nearly Dutch
20:41:05 <Slereah> For the rest, it will be hard!
20:41:09 <Hiato> :)
20:41:15 <Hiato> and the Hebrew?
20:41:19 <Hiato> no-one? ;)
20:41:27 <Slereah> I once spoke hebrew.
20:41:32 <Hiato> :D
20:41:34 <Slereah> When I was six years old.
20:41:40 <Slereah> Now, I've forgotten most of it.
20:41:45 <Hiato> Aha, well, I see
20:41:53 <Hiato> where are you from, Slereah?
20:41:56 <Slereah> France.
20:41:59 <Hiato> Cool
20:42:04 <Slereah> But my dad taught me.
20:42:04 <Hiato> so let me try:
20:42:15 <Hiato> Ja na par pa Franscois...
20:42:18 <Hiato> or something
20:42:20 <Hiato> cool
20:42:21 <tejeez> puhutteko suomea
20:42:21 <Slereah> Lulz
20:42:29 <tejeez> (= do you speak finnish)
20:42:36 <Slereah> Perkele!
20:42:36 <Hiato> nien
20:42:53 <Hiato> Ngia Kwazi Ogokoolooma Isizulu?
20:43:00 <Hiato> (I can't spell)
20:43:11 <Hiato> (=do you speak zulu?)
20:43:33 <Slereah> I got the zulu part!
20:43:36 <Slereah> Heh.
20:43:39 <Hiato> Hooray :)
20:43:56 <Hiato> there should be lots of "h" s though
20:44:30 <Hiato> Slereah, if you don't mind my asking, where was your dad from?
20:44:41 <Slereah> France as well!
20:44:46 <Hiato> :)
20:44:59 <Hiato> So where did the Hebrew pop out from ;) ?
20:44:59 <Slereah> But my great-grand-father was from Turkey.
20:45:04 <Hiato> Aahh
20:45:05 <Hiato> ok
20:45:09 <Hiato> mystery solved
20:45:10 <Slereah> And his ancestors from Spain.
20:45:15 <Hiato> hrmm
20:45:18 <Slereah> And their ancestors from Judea.
20:45:22 <Hiato> Woow
20:45:23 <Slereah> So that's that.
20:45:28 <Hiato> Ok, I see
20:45:37 <Hiato> nice to know your family history :)
20:45:48 <Hiato> I don't really know mine...
20:45:56 <Slereah> I have three relatives interested in genealogy, so it's not hard
20:46:05 <Hiato> lol, classic :D
20:46:36 <Hiato> Hrmm.. what is Haskel for?
20:46:43 <Slereah> Programming?
20:46:43 <Hiato> can it actually be used as a language?
20:46:47 <Hiato> yeah, yeah
20:46:50 <Hiato> but I mean
20:46:53 <timotiis> being laughed at because you don't use scheme, of course
20:46:53 <iEhird> ofc
20:47:05 <Hiato> should I bother writing anything in it
20:47:09 <Hiato> oh, I see
20:47:09 <Slereah> Oh timotiis, you minx.
20:47:11 <Hiato> right
20:47:11 <iEhird> its one of the best production lands
20:47:21 <iEhird> along with scheme
20:47:23 <Slereah> Hiato : Well, if you bother writing in Brainfuck, does it matter at all?
20:47:32 <timotiis> Slereah: I've been called a lot of things, but I think minx is a first
20:47:34 <Hiato> lol, so very true Slereah
20:48:05 <Hiato> but say, I distribute a prog (script?) in Haskell, is everyone gonna laugh and say :"Go learn a real language"?
20:48:29 <Hiato> compaered to FPC, Ruby etc
20:48:34 <timotiis> nah, it's a good language
20:48:37 <Slereah> I won't, but that's because I'm not in the programming communauty.
20:48:57 <Slereah> I also have a Haskell interpreter, to run the classic Unlambda.
20:49:15 <timotiis> I need to grab the scheme unlambda interpreter one of these days
20:49:20 <Hiato> Roger that timotiis, thanks. Slereah, that's a shame :(
20:49:27 <iEhird> no hiato
20:49:37 -!- iEhird has quit.
20:49:39 <Hiato> lol, wow, plenty of confidence there
20:49:42 <Hiato> ha
20:49:57 -!- iEhird has joined.
20:49:59 <Hiato> guess you can't give him a comeback, because he's not here
20:50:01 <Hiato> lol
20:50:09 <iEhird> yes I am
20:50:09 <Hiato> nevermind
20:50:15 <Slereah> Me, when I program, it has to be really easy or really hard.
20:50:21 <Slereah> Either Python or esolands.
20:50:25 <Slereah> g*
20:50:32 <Hiato> hrmm
20:51:04 <Hiato> Python + me = :(
20:51:04 <Hiato> Ruby + me = :\
20:51:04 <Hiato> Delphi + me = :)
20:51:04 <Hiato> Eso + me = :D
20:51:16 <Slereah> But, python is awesome! :o
20:51:24 <Hiato> I can't use it though
20:51:31 <Hiato> I keep getting indentation blah blah
20:51:46 <timotiis> I like scheme, never really got into anything with too much syntax to learn
20:51:46 <Slereah> Heh.
20:52:15 <iEhird> scheme+haskell+c for objcode
20:52:18 <iEhird> yum
20:52:27 <Hiato> :)
20:52:31 <timotiis> hm
20:52:44 <timotiis> I should go back to haskell someday
20:53:12 <Slereah> Is that the Mecca of programmers?
20:53:13 <timotiis> incidentally, does anyone know if TeX is turing complete?
20:53:16 <timotiis> maybe
20:53:23 <iEhird> yes it is
20:53:26 <timotiis> I liked the XKCD on lisp, as far as they go
20:53:29 <Hiato> Well, other than Haskell, is there any *interesting* _easy_ (ish) and pleasant language that yanyone can recommend
20:53:36 <Hiato> *anyone
20:53:39 <timotiis> Scheme!
20:53:39 <iEhird> scheme.
20:53:45 <Hiato> cool
20:53:48 <Hiato> will check it out
20:53:52 <Slereah> I don't use many languages.
20:54:00 <timotiis> it's a dialect of lisp, so you'll have to get the hang of the parens
20:54:08 <timotiis> but it's really quite fun to use
20:54:14 <Hiato> O, I'll dig arounf
20:54:15 <Hiato> cool
20:54:17 <Hiato> *around
20:54:27 <Hiato> I've been wanting to move from delphi for a long time..
20:54:34 <Hiato> but the C group brings me to tears
20:54:35 <iEhird> use my risk scheme compiler! oh wait its not written yet :P
20:54:41 <Hiato> and ruby has no real purpose
20:54:44 <Hiato> ;)
20:54:48 <Hiato> lol
20:54:54 <iEhird> use chicken. for now.
20:54:59 <Hiato> well, I'd like to iEhird
20:55:03 <timotiis> ruby could be worse. I've just never liked anything with more than two types of brackets
20:55:07 <Hiato> but PETA has something to say
20:55:20 <Hiato> Timotiis
20:55:22 <Hiato> I think
20:55:25 * Slereah is eating chicken right now.
20:55:29 <iEhird> heh.
20:55:31 <Slereah> Come and get me, PETA!
20:55:32 <timotiis> Therefore you are?
20:55:40 <Hiato> that how much you like a language, is directly related to the tutiorials you use
20:55:44 <Slereah> Yes. I are eating chicken.
20:55:46 <Hiato> :)
20:55:46 <iEhird> chicken = scheme compiler
20:55:47 <Hiato> lol
20:55:52 <timotiis> Maybe. I got into scheme with SICP
20:55:52 <Hiato> :D
20:56:11 <Hiato> Well, Ruby for me was hilarious because of Why's poignant guide
20:56:49 <timotiis> dangit, keep forgetting I have screen running. It's C-a a C-k to kill the line
20:57:38 <Hiato> :)
20:59:33 <Hiato> woow
20:59:39 <Hiato> Scheme looks daunting
21:00:00 <timotiis> why?
21:00:11 <timotiis> I could give you a basic primer in about 10 mins
21:00:19 <Hiato> yes please
21:00:21 <Hiato> :)
21:00:26 <Hiato> I get the reverse polish notation
21:00:28 <Hiato> but the rest....
21:00:32 <timotiis> no, that's just polish notation
21:00:41 <Hiato> lol, shows how much I know
21:00:54 <timotiis> rpn is 3 2 +, pn is + 2 3
21:01:01 <Hiato> oh, I see
21:01:04 <Hiato> right o
21:01:09 <Slereah> rpn?
21:01:14 <Hiato> about that primer...
21:01:17 <timotiis> reverse polish notation
21:01:23 <Slereah> Oh.
21:02:00 <iEhird> hiato
21:02:02 <timotiis> okay...
21:02:05 <timotiis> let me see
21:02:14 <iEhird> what part is hard
21:02:18 <Hiato> yes iEhird
21:02:31 <Hiato> well, the whole thing in the wikipedia entry
21:02:38 <timotiis> syntax of define: (define (name arg1 arg2 ... argn) <body of function>)
21:02:38 <Hiato> (define a 10) (define eval-aplus2 (delay (+ a 2))) (define a 20) (force eval-aplus2) => 22
21:02:49 <Hiato> ok
21:02:51 <Hiato> roger
21:03:19 <iEhird> hiato
21:03:26 <Hiato> yes iEhird
21:03:28 <timotiis> (define (square x) (* x x))
21:03:32 <timotiis> that should make sense, yes?
21:03:34 <iEhird> (lambda (args) code )
21:03:34 <Hiato> yes
21:03:38 <Hiato> crystal clear
21:03:50 <iEhird> that square syntax
21:03:51 <Hiato> ooh, ok
21:03:54 <Hiato> yes
21:03:55 <iEhird> us short for
21:04:12 <iEhird> (define square (lambda (x) ...
21:04:20 <Hiato> aha
21:04:21 <Hiato> well
21:04:23 <timotiis> what's wrong with this one?, (define (fib n) (+ (fib (- n 1) (- n 2))))
21:04:36 <Hiato> as in synatx
21:04:38 <Hiato> or logic?
21:04:40 <timotiis> logic
21:04:45 <iEhird> timoriis
21:04:46 <Hiato> well thta's obious
21:04:51 <iEhird> silly
21:04:54 <iEhird> :P
21:05:00 <timotiis> intentional, I promise
21:05:15 <Hiato> 1 argument is taken for fib for starters, yet 2 are provided
21:05:16 <Hiato> then
21:05:21 <Hiato> its gonna go negative
21:05:26 <Hiato> very quickly
21:05:28 <Hiato> needs to be
21:05:35 <timotiis> no, the arguments aren't a problem. the lack of a test is a problem
21:05:48 <iEhird> timoriis wrong
21:05:53 <iEhird> (fib a b)
21:06:12 <iEhird> lawl yuu dum
21:06:13 <timotiis> generates the nth fib. what's wrong with that, apart from the fact it never stops computing?
21:06:32 <Hiato> hrmm
21:06:35 <timotiis> well, and it's tree recursive, so it's hopelessly ineffiecient
21:06:38 <Hiato> well
21:06:44 <iEhird> dude
21:06:50 <iEhird> read your code
21:06:52 <Hiato> I don't see it
21:06:55 <timotiis> I have, I wrote it
21:07:05 <timotiis> Hiato: doesn't test for 0 or the like
21:07:09 <iEhird> you give fib two args
21:07:19 <Hiato> Oh, ok I see
21:07:21 <timotiis> ah, shoot. typo
21:07:24 <Hiato> well I said it would go negative
21:07:27 <iEhird> lawl
21:07:34 <timotiis> (define (fib n) (+ (fib (- n 1)) (fib (- n 2))))
21:07:35 <Hiato> (11:05:36 PM) Hiato: 1 argument is taken for fib for starters, yet 2 are provided
21:07:43 <timotiis> that's now correctly wrong
21:07:43 <Hiato> ;)
21:07:59 -!- iEhird has quit.
21:08:12 <Hiato> so if you feed in 0
21:08:18 -!- iEhird has joined.
21:08:20 <Hiato> its gonna give the fib's in negative
21:08:26 <Hiato> ?
21:09:00 <timotiis> yeah
21:09:05 <Hiato> cool
21:09:12 <timotiis> it never tests for reaching the bottom of the recursion
21:09:13 <Hiato> I grasp it :)
21:09:20 <Hiato> yeah
21:09:27 <Hiato> (11:05:42 PM) Hiato: its gonna go negative
21:09:33 <iEhird> hiato
21:09:33 <Hiato> Hooray ;)
21:09:36 <iEhird> suggestion
21:09:38 <Hiato> yes iEhird
21:09:51 <iEhird> read the little sxhener
21:09:55 <iEhird> sxhener
21:09:59 <timotiis> yes, read that
21:10:04 <iEhird> schemer
21:10:05 <timotiis> (define (fib n)
21:10:05 <timotiis> (if (zero? n) 0
21:10:05 <timotiis> (if (= n 1) 1
21:10:06 <timotiis> (+ (fib (- n 1)) (fib (- n 2))))))
21:10:09 <timotiis> that's better
21:10:32 <iEhird> timoriis! remember tls? use cond
21:10:33 <timotiis> although it would break on a negative input
21:10:46 <timotiis> I much prefer if when it's a small statement like that
21:10:54 <Hiato> ok, I see now the structure of scheme
21:11:02 <iEhird> nested ifs are bad
21:11:03 <Hiato> but, where does a prgramme enter etc
21:11:13 <iEhird> hiato anywhere
21:11:15 <timotiis> (define (fib n)
21:11:16 <timotiis> (cond
21:11:16 <timotiis> ((zero? n) 0)
21:11:16 <timotiis> ((= n 1) 1)
21:11:16 <timotiis> (else (+ (fib (- n 1)) (fib (- n 2))))))
21:11:22 <Hiato> and does (if (zero? n) 0 return zero?
21:11:30 <iEhird> you just put your code there
21:11:32 <timotiis> if n was 0, it does
21:11:39 <Hiato> cool
21:11:43 <iEhird> mostly
21:11:54 <iEhird> you interact with scheme via a
21:11:55 <Hiato> mostly?
21:11:58 <iEhird> repl.
21:12:02 <timotiis> zero? n returns #t if n was 0, so the if takes the first option, which was 0
21:12:14 <iEhird> you enter an expression it shows the results
21:12:26 <Hiato> oh, I see
21:12:34 <Hiato> iEhird, so like a shell
21:12:38 <iEhird> you do (load "file") to load some code you wrote
21:12:48 <timotiis> or just paste it in
21:12:48 <Hiato> cool, I get it
21:12:51 <Hiato> ok
21:12:54 <iEhird> when you're done developing that iteration
21:13:03 <Hiato> well, now I see the light ;]
21:13:03 <iEhird> then you use a batch compiler
21:13:12 <iEhird> and produce an executable
21:13:17 <Hiato> w00t
21:13:20 <Hiato> ;)
21:13:26 <Hiato> I like Scheme already
21:13:28 <timotiis> iEhird: happier with this then?
21:13:29 <timotiis> (define (fib n)
21:13:29 <timotiis> (if (or (zero? n) (= n 1))
21:13:29 <timotiis> n
21:13:30 <timotiis> (+ (fib (- n 1)) (fib (- n 2)))))
21:13:39 <timotiis> there you go, properly written with a single if
21:13:42 <Hiato> and is functional stuff actually built with it?
21:13:47 <timotiis> it is functional
21:13:53 <Hiato> meh
21:13:55 <Hiato> I meant
21:13:55 <timotiis> although taht wasn't quite your question
21:14:04 <iEhird> it is imperative with a functional core
21:14:05 <Hiato> fully functional programmes
21:14:06 * Slereah is writing the help file for his pseudo-unlambda.
21:14:11 <Slereah> It's full of bird names.
21:14:14 <Hiato> (cool)
21:14:18 <iEhird> there is a set! func
21:14:23 <Hiato> ( :) )
21:14:25 <timotiis> da, so it's not quite pure
21:14:25 <Hiato> meh
21:14:30 <Hiato> no no
21:14:33 <Hiato> I mean
21:14:34 <timotiis> but it's pretty good, and still generally usable for things
21:14:43 <timotiis> oh, what is it used for?
21:14:48 <Hiato> has Bob written stuff in Scheme
21:14:54 <Hiato> that you and I use
21:14:55 <Hiato> etc etc
21:15:03 <Hiato> yes, essentially timotiis
21:15:41 <timotiis> it's occasionally an extension language. I think the gimp is scripted in scheme. guile is a scheme dialect. you can do some pretty neat web stuff with it as well iirc, and there's an implementation for shell scripting
21:15:42 <iEhird> brb
21:15:47 <Hiato> k
21:16:00 <Hiato> awesome
21:16:00 <timotiis> but you probably don't use something written in it daily
21:16:06 <Hiato> understood
21:17:07 <Hiato> shceme vs haskell (because I like languages that can do [99,98..0] )
21:17:10 <Hiato> which one?
21:17:46 <Hiato> http://99-bottles-of-beer.net/language-scheme-582.html
21:17:50 <Hiato> http://99-bottles-of-beer.net/language-haskell-1070.html
21:20:09 <timotiis> your call, really. I'd tend to rate scheme as easier to learn, but that's my opinion
21:20:31 <Hiato> ok, thanks
21:20:39 <Hiato> I'm just interested
21:20:44 <Hiato> because they both look the part
21:20:49 <Hiato> and both are unique
21:21:01 <Slereah> Does this work as an SKI-unlambda translator? http://membres.lycos.fr/bewulf/Russell/ski-unlambda.py
21:22:31 -!- Jontte has quit (Remote closed the connection).
21:22:35 <timotiis> I'm actually half-working on writing an infix notation system for scheme, including operator precedence :)
21:23:09 -!- Jontte has joined.
21:23:15 <bsmntbombdood> why?
21:23:20 <timotiis> for the hell of it
21:25:09 <timotiis> it's an interesting project to work on, really
21:25:22 <timotiis> and some of the functions I'm building as a part of it are quite useful
21:34:17 -!- RedDak has joined.
21:41:11 <Slereah> The iszero function seems to go okay through the Abstractor.
21:42:13 <Slereah> Why won't pred or succ go through!
21:44:18 <oklopol> Hiato: i got that.
21:44:18 <oklopol> that afrikaans
21:44:29 <Hiato> really
21:44:31 <Hiato> awesome
21:44:55 <Hiato> As ek nou Afrikaans pratt, sal net ons dit verstaan!
21:45:13 <Hiato> Praat jy Hollandse of Deutsch?
21:45:19 <faxathisia> Hiato: "because they both look the part" -- What part?
21:45:55 <Hiato> by "the part" I mean "interesting, new to my eyes and different from everything I have seen thus far"
21:45:58 <oklopol> "Mih mevin oti ca-usher uni ma-duber Ivrit?" <<< this one i have no idea about, though, perhaps "i opine"?
21:45:58 <oklopol> :P
21:46:22 <Hiato> lol, well oklopol
21:46:26 <faxathisia> ah right, I agree.. they are very unique
21:46:34 <Hiato> hebrew is next to impossible to write out in enlgihs letters
21:46:36 <Hiato> *English
21:46:54 <Hiato> yes faxathisia, even though I finally went with Haskell
21:47:04 <Hiato> because of lazy evalutaion and less brackets
21:47:23 <faxathisia> should learn both though
21:47:51 <Hiato> yeah, I will eventually, but first I want to understand functional programming, and what better way to do it then Haskell
21:47:58 <timotiis> scheme, of course
21:47:59 <Hiato> then I can move onto scheme
21:48:06 <faxathisia> I don't think there is a better place to find out what the hell call-with-current-continuation does than scheme
21:48:09 <Hiato> well, I see Haskell as being easier
21:48:18 <Hiato> true
21:48:26 <Hiato> though haskell is just, well I don't know really
21:48:35 <Hiato> I just think it looks easier to learn
21:49:30 <timotiis> faxathisia: I use scheme, and I still haven't figured out what it does
21:49:54 <timotiis> not properly, anyway
21:49:56 <timotiis> I have a few ideas
21:50:31 -!- ehird` has joined.
21:50:54 <faxathisia> haha
21:51:09 <ehird`> anyhow.
21:51:21 <timotiis> ah, on a better machine at last?
21:51:57 <Hiato> Faxathisia: Did you ever come up with an Esolang in the end, or did the zoo prove useless?
21:52:17 <faxathisia> well I kind of just watched Dune
21:52:20 <faxathisia> :(
21:52:28 * faxathisia is going to try agian
21:52:30 <Hiato> oh
21:52:35 <Hiato> yes, I like that idea
21:52:47 <Hiato> Dune<Esolang<Mad Max :P
21:52:56 <Slereah> Made a Dune esolang?
21:53:05 <Hiato> lol, nope
21:53:08 <Slereah> "More spice required"
21:53:14 <Hiato> :)
21:53:45 <Slereah> Hm.
21:53:50 <Slereah> A D&D esolang.
21:54:03 <Hiato> that would be cool
21:54:08 <oklopol> Hiato: did it have something to do with "i opine"? :P
21:54:15 <Slereah> Variables would be in your backpack
21:54:19 <Hiato> though I think it is in the work in progress thing
21:54:21 <oklopol> fucking 40 minutes of logs
21:54:27 <Hiato> what is I opine
21:54:28 <Hiato> lol
21:54:43 <Slereah> Let's see if it is!
21:54:45 <oklopol> that thingie i tried to translate earlier
21:55:20 <Hiato> the hebrew, I understand that part, but what is "i opine" ?
21:55:22 <Slereah> There's one based on "a roguelike game"
21:55:30 <Hiato> there we go Slereah
21:55:52 <Slereah> I liek the idea.
21:56:02 <Hiato> Knock yourself ou
21:56:07 <Hiato> *out
21:56:07 <Hiato> :P
21:56:20 <Hiato> anyone: what is "i opine" ?
21:56:22 <Slereah> I already have trouble parsing minimalist languages.
21:56:33 <Hiato> lol, swithc to Ruby of FPC
21:56:41 <Hiato> then you just do case when/if
21:56:44 <Hiato> very easy
21:56:46 <Slereah> I'm not sure I could parse something with actual text.
21:56:50 <Hiato> lol
21:57:10 <Hiato> check out the Full 0 source, and you'll see it's just one big case statement
21:57:21 <Hiato> I will gladly write the interpreter though
21:57:25 <Hiato> if you want
21:57:35 <Hiato> oklopol
21:57:38 <Slereah> Well, I still need to finish my unlambda thingy.
21:57:41 <Hiato> don't leave me hanging
21:57:44 <Slereah> Maybe later.
21:57:46 <Hiato> sure Slereah
21:57:47 <Hiato> cool
21:58:32 <Hiato> oklopol, the Hebrew meant "Who will understand me when I speak Hebrew"
21:58:44 <oklopol> that was what you said first
21:58:54 <Hiato> yes
21:59:03 <oklopol> oh, afrikaans, then same in hebrew?
21:59:04 <Slereah> Maybe numbers could be, liek, a LEVEL N SWORD
21:59:21 <Hiato> yes, I did say the same thing in as many languages as I couldoklopol :P
21:59:25 <Slereah> "I hit input with my LEVEL N SWORD"
21:59:31 <Hiato> slereah, I like :)
21:59:42 <Hiato> perhaps, casting spell x calls the function
21:59:48 <Slereah> Yes!
21:59:48 <Hiato> and the mana is the argument
21:59:50 <Hiato> :P
22:00:02 <ehird`> timotiis: ?
22:00:08 <Hiato> and you need to move to an in to declare vars
22:00:10 <Hiato> or something
22:00:11 <Hiato> :P
22:00:20 <Hiato> *inn
22:00:22 <Slereah> Well, I think the argument would be more of a "cast spell on arg"
22:00:27 <Hiato> true
22:00:30 <Hiato> fair enough
22:00:37 <Hiato> and talking to an NPC would be output
22:00:42 <Hiato> or input
22:00:44 <Hiato> depending
22:00:46 <oklopol> puhutteko suomea? pratar ni svenska? sprechen sie deutsch? do you speak english? xu do tavla la lojban, plus a syntax error in the lojban one prolly.
22:01:00 <Hiato> wooow
22:01:06 <Hiato> Swedish!! :)
22:01:10 <Slereah> Input number : "YOU RECEIVE A LEVEL N SWORD!"
22:01:12 <Slereah> Yay!
22:01:12 <oklopol> heh
22:01:14 <Hiato> spechten?
22:01:15 <Hiato> surely
22:01:23 <Slereah> Although it would suck if your old word was better!
22:01:32 <Hiato> lol, yip
22:01:33 <Slereah> but you don't refuse a gift from the MJ!
22:01:40 <Hiato> oh yeah
22:01:41 <Slereah> err, GM.
22:01:47 <oklopol> sorry, i make no errors.
22:01:53 <Hiato> :)
22:01:53 -!- calamari has quit (Read error: 104 (Connection reset by peer)).
22:01:55 <Hiato> no worries
22:02:07 <Hiato> I don't even speak German, but I knew that much ;)
22:02:11 <oklopol> ...
22:02:22 <oklopol> i don't think you understood me :)
22:02:24 <Hiato> that it was german
22:02:29 <Hiato> I understood you
22:02:32 <Hiato> you were right
22:02:35 <Hiato> and I was wrong
22:02:36 <Slereah> A loop could be casting a spell on a monster with n health point, until he's dead! :o
22:02:42 <Hiato> but I recognised it was german
22:02:53 <oklopol> oh, i guess i misunderstood you too, a bit :)
22:02:55 <Hiato> that's what I was saying
22:02:59 <Slereah> Although you'd have to specify the damage of the spell in the function.
22:03:05 <oklopol> or then just i misunderstood anything.
22:03:06 <Hiato> a mutual misunderstanding :)
22:03:08 <oklopol> heh
22:03:24 <oklopol> i'll be fullscreen now, or i'll never get anything eaten...
22:03:24 <oklopol> ->
22:03:30 <ehird`> int Check_Stack_Grows_Down () {
22:03:30 <ehird`> char foo;
22:03:30 <ehird`> return &foo < stkbase;
22:03:30 <ehird`> }
22:03:30 <Hiato> Yes, though what would that mean Slereag
22:03:32 <ehird`> clever, clever
22:03:35 <Hiato> *h
22:03:40 <Hiato> :)
22:03:49 <Hiato> oklopol ^
22:03:50 <Slereah> What would what mean?
22:03:58 <Hiato> damage of the spell in the function.
22:04:06 <Slereah> Well, for instance.
22:04:11 <Slereah> You have this monster.
22:04:15 <Slereah> He has 99 HP!
22:04:20 <Hiato> gasp
22:04:22 <Slereah> Then, you hit it with magic missile
22:04:30 <Slereah> With 1 damage point.
22:04:35 <Slereah> Until he's dead.
22:04:37 <Hiato> (cough someones been playing NWN ;) )
22:04:44 <Hiato> I see, but why
22:04:45 <Slereah> Actually, no.
22:04:51 <Hiato> there needs to be incentive
22:04:55 <Hiato> we need to say that
22:04:56 <Hiato> XP
22:04:57 <Slereah> That way, the function is used 99 times!
22:05:03 <Hiato> ahahaha
22:05:08 <Hiato> that's brilliant
22:05:10 <Hiato> :D
22:05:14 <Hiato> recursion
22:05:19 <Hiato> so you can play as the DM
22:05:22 <Hiato> and summon a monster
22:05:22 <Slereah> Well, maybe the conclusion of the program would be "YOU WIN A MILLION XP"
22:05:26 <Hiato> then switch to hero
22:05:31 <Hiato> lol
22:05:31 <Slereah> Yes, the user is the DM.
22:05:34 <Hiato> then when hero
22:05:41 <Hiato> you cast spell x for n times
22:05:43 <Hiato> wicked
22:05:55 <Hiato> hrmm
22:05:56 <Slereah> He summons input monsters, and random number monster encounter!
22:06:03 <Hiato> Oh yeah!
22:06:09 <Slereah> And output would be talk to DM
22:06:12 <Hiato> xp = buy new functions premade
22:06:16 <Hiato> yeah
22:06:24 <Hiato> so 10 xp = fibonacci etc
22:06:35 <Hiato> or not actually....
22:06:40 <Slereah> Heh. Maybe not.
22:06:49 <Slereah> The idea would be to have it usable.
22:06:56 <Hiato> true
22:06:59 <ehird`> Risk will be suuch a fast compiler :P
22:07:07 <Hiato> so where do NPC's fit in
22:07:10 <Hiato> :)
22:07:20 <Hiato> why bother talking
22:07:22 <Hiato> to them
22:07:25 <Slereah> I'm not sure so far.
22:07:28 <Hiato> aha
22:07:31 <Hiato> conditional
22:07:35 <Hiato> ooh
22:07:38 <Hiato> say you have stas
22:07:53 <Hiato> and you can only talk to an NPC if impress>10 and muscle>15 etc
22:08:00 <Hiato> so you can do if's like that :D
22:08:03 <Hiato> *stats
22:08:18 <Slereah> Well, if variables are objects, I guess conditional would be if you possess the object.
22:08:23 <Hiato> meh
22:08:27 <Hiato> I like the stats idea
22:08:28 <Slereah> For instance, a boolean could be a key to some dungeon door.
22:08:45 <Hiato> but okay
22:08:47 <Hiato> sure
22:08:51 <Hiato> it's you lang ;)
22:08:59 <Slereah> It's just an idea thrown around.
22:09:07 <Slereah> Not sure I will actually do something with it.
22:09:27 <faxathisia> wait so programming is like you use a level editor
22:09:29 <Slereah> But it's true that it would be better to include NPC's, instead of just monster grinding.
22:09:31 <faxathisia> then some AI plays your game?
22:09:43 <Hiato> well, kinda
22:09:51 <Hiato> I was thinking that you can be both DM
22:09:53 <Hiato> and Hero
22:09:57 <Hiato> to make it easier
22:10:01 <Hiato> but I suppose
22:10:08 <Hiato> that if we make it imperitive
22:10:12 <Hiato> then the hero
22:10:18 <Hiato> would just follow instructions
22:10:22 <Slereah> Maybe the input could be of two kinds.
22:10:24 <Hiato> and react acrdingly
22:10:33 <Hiato> *accordingly
22:10:44 <Slereah> Monster and object variables from the DM, and actions from the hero
22:10:50 <Hiato> yeah
22:10:52 <Hiato> there we go
22:10:53 <Hiato> :)
22:11:14 <Hiato> and it needs flashy 2D ascii graphics :P
22:11:17 <Hiato> like @ and #
22:11:19 <Hiato> ;)
22:11:29 <Slereah> The general words "monster" and "object" would be a cue for input
22:11:38 <Slereah> "A monster appear!"
22:11:53 <Hiato> hrmm
22:11:59 <Hiato> sounds like a script to me
22:12:02 <Slereah> While specific monsters would be values without requiring input
22:12:05 <Hiato> I imagined it differently
22:12:18 <Hiato> yes, that would be cool
22:12:26 <Hiato> each monster is the value of it's XP
22:12:30 <Hiato> and thus
22:12:34 <Hiato> killing it
22:12:48 <Hiato> adds it to the currently equipped item/variable
22:12:59 <Hiato> and casting on it casuses a loop
22:13:05 <Hiato> for it's Hp number of times
22:13:14 <Hiato> I like where this is going :)
22:13:14 <Slereah> Something like that.
22:13:33 <Slereah> But what would be strings?
22:13:45 <Slereah> Magic books or something?
22:13:56 <Slereah> I always carry a bunch of these in Oblivion.
22:13:57 <Hiato> yeah tomes of knowledge
22:14:00 <faxathisia> Could you actually cannibalize an existing rouge-like? and use that for computing
22:14:01 <Hiato> :)
22:14:13 <Hiato> lol, I like
22:14:30 <Hiato> Perhaps, lists would be quests
22:14:35 <faxathisia> :D
22:14:36 <Hiato> and Strings would be boks/tomes
22:14:48 <Hiato> and spell books would list the functions avaliable
22:14:49 <Hiato> :)
22:14:58 <Hiato> *books
22:15:05 <Slereah> "You find item n on your quest list"
22:15:09 <Slereah> And bam, you can use it
22:15:17 <Hiato> I like
22:15:33 <Hiato> or perhaps, quest lists could also be arrays
22:15:38 <Hiato> but yeah, it works anywho
22:15:42 <Slereah> a premature exit function would be when you die! :O
22:15:48 <Slereah> "You are eaten by a grue"
22:15:53 <Hiato> Ooh, sucks
22:15:55 <Hiato> :)
22:15:59 <Hiato> yes, though
22:16:02 <Hiato> that would be nice
22:16:11 <Hiato> and portals would return from a function
22:16:17 <Hiato> or quest
22:16:33 <Hiato> ?
22:16:36 <faxathisia> call-with-current-continuation is when you go to a save point?
22:16:49 <Slereah> I don't know what that is, but sure, why not.
22:16:50 <Hiato> :D, but I like
22:17:13 * faxathisia is not sure if hat is close enough semantically
22:17:18 <Hiato> static main void would be the world (naah, just kidding)
22:18:00 <Slereah> Maybe you can include sentences without any program-specific meaning, to avoid doing a linear adventure.
22:18:11 <Hiato> Bandits would be the "garbage collectors" or variable destroyers as they raid unused variables
22:18:17 <ehird`> faxathisia: i'll explain call with current continuation
22:18:21 <Slereah> Heh.
22:18:21 <Hiato> yes, that would be nice
22:18:42 <Hiato> Say, you can only have x variables on you
22:18:48 <Hiato> so you go back through a portal
22:18:53 <Hiato> to you private stash
22:18:58 <Hiato> and exchange variables
22:19:06 -!- calamari has joined.
22:19:13 <ehird`> (call/cc f) copies the call stack, and constructs a function k. It then does (f k). When k is called with the argument x, the saved call stack is reinstated and the top call - that is, call/cc - returns x
22:19:17 <Slereah> Well, maybe your stash could be the other players.
22:19:33 <Hiato> and we could have the "Gardens of Negativity" from within which, if you drink the water, it applies NOT to all you equipped variables
22:19:33 <Slereah> "Take this, my back is killing me!"
22:19:41 <ehird`> alternatively: in (+ 2 (* 3 4) 5), when you get to (* 3 4), your continuation is (+ 2 [_] 5)
22:19:46 <ehird`> and the hole gets fileld in by the result
22:19:47 <Hiato> "I am encumbered, and cannot move!"
22:19:58 <ehird`> (call/cc f) calls f with a function that takes an argument to fill the hole
22:20:01 <Slereah> "Backpack overflow!"
22:20:15 <Hiato> lol :)
22:20:17 <Hiato> awesome
22:20:25 <Hiato> I Like ver much
22:20:27 <Hiato> :D
22:20:33 <Hiato> *y
22:20:50 <Hiato> Anyway, sorry to cut the "brainstorm" short
22:20:55 <Hiato> it's been fun
22:21:03 <Hiato> but its late here in GMT+2 land
22:21:09 <Slereah> Okay, bye.
22:21:14 <Hiato> so, I'll see you guys some other time
22:21:16 <Hiato> cheers
22:21:25 -!- Hiato has quit ("Leaving.").
22:26:54 <Slereah> I should really try to solve my lazy unlambda's problem, but now, there's no way I can think about it until I have some ideas written down.
22:27:26 <Slereah> "Dungeons and Data"
22:27:42 * ehird` is reinventing Foobrain with multiple files because it was getting bloated
22:27:45 <ehird`> and using Parsec
22:27:57 <ehird`> who wants to help make a brainfuck compiler that in the end will probably do the most optimizations evarr? :P
22:27:59 <Slereah> Parsecs? That's going to be a large program!
22:28:08 -!- elsa22 has joined.
22:28:13 <Slereah> I can't write machine code.
22:28:19 <Slereah> I got a note from my doctor!
22:29:21 <oklopol> faxathisia: getting to a save point would be calling a continuation, call/cc would be saving
22:30:22 -!- elsa22 has quit (Client Quit).
22:32:02 -!- Arrogant has joined.
22:35:53 <ehird`> no-one? :-)
22:36:10 <Arrogant> Nope
22:36:50 -!- oerjan has joined.
22:37:04 <Slereah> It is far more exciting to be involved in a glorious medieval fantastic adventure, I guess!
22:37:13 * faxathisia doesn't know what optimizations you can do
22:37:16 <faxathisia> (other than trivial stuff)
22:37:29 <faxathisia> seems a very hard language to do optimizations with
22:37:54 <ehird`> nahh
22:38:03 <ehird`> there's even a compiler that optimizes 'if' algorithms
22:38:08 <ehird`> with haskells pattern matching!
22:38:12 <ehird`> it'll be easy!
22:41:30 <faxathisia> wait
22:41:40 <faxathisia> I was assuming Brainfuck -> Brainfuck
22:41:51 <faxathisia> but you actually meant something else didn' tyou?
22:42:05 <ehird`> yes
22:42:05 <ehird`> Brainfuck -> C
22:45:06 <oklopol> ehird` and his crazy best-ever brainfuck compilers :-)
22:45:18 <ehird`> same one all the time
22:45:20 <ehird`> :P
22:45:22 <oklopol> heh
22:45:41 <oklopol> have you read egobf?
22:45:42 <Slereah> The important thing is that no one notice!
22:50:01 <ehird`> egobf is fun :P
22:50:43 <Slereah> Hm. What would be a good way to define a real variable in Dungeons and Datas?
22:51:00 <faxathisia> drop some item in a specific place?
22:51:16 <Slereah> Yes, but what kind of item!
22:51:45 <Slereah> Integers are either n xp with some weapon including the name of the variable, or just some level n weapon.
22:52:33 <Slereah> Booleans are keys.
22:52:45 <Slereah> Strings are books.
23:14:30 <Slereah> I think I will have to make more than one process for loops.
23:20:22 -!- timotiis has quit ("leaving").
23:27:46 <ehird`> oerjan: you there?
23:28:18 <oerjan> yep, just posting an interpretation of the obfuscated Perl code on the wiki
23:28:35 <oerjan> *ahem*
23:29:00 <ehird`> X_X
23:29:02 <ehird`> ANYWAY.
23:29:13 <ehird`> Doest though know the `Parsec'?
23:29:23 <oerjan> Indeed I do.
23:30:13 <ehird`> how doth my parser `infini-loop'?!
23:30:24 <ehird`> exampl~e:
23:31:14 <ehird`> http://hpaste.org/4818
23:32:30 <ehird`> :S
23:32:42 <ehird`> maybe i need a terminating case but i think it's more than that
23:32:51 <oerjan> no that's it
23:33:03 <ehird`> ok
23:33:07 <ehird`> so what would that be? :)
23:33:09 <oerjan> brainfuck = many oneIns <?> "program"
23:33:58 <oerjan> you should browse the combinators in the parsec manual
23:34:13 <ehird`> possibly! :-)
23:34:27 <ehird`> my brain was thinking many (oneOf "abc")
23:34:30 <ehird`> instead of many PARSER
23:34:31 -!- RedDak has quit (Remote closed the connection).
23:34:42 <ehird`> aha, oerjan
23:34:44 <ehird`> you are wrong
23:34:48 <ehird`> oneIns returns [BF]
23:34:51 <ehird`> wait
23:34:53 <ehird`> that's unneeded
23:34:56 -!- Arrogant has quit ("Leaving").
23:35:21 <oerjan> indeed
23:36:27 <oerjan> the <|> oneIns is wrong
23:36:48 <ehird`> kay
23:36:48 <ehird`> what should it be
23:37:03 <oerjan> or wait
23:37:30 <oerjan> the thing is, in Parsec you nearly always want to skip whiteSpace and comments before starting a real parser
23:37:45 <ehird`> OK
23:37:49 <ehird`> elaborate
23:37:50 <ehird`> :P
23:38:23 <oerjan> because of the way Parsec works, you don't want to have to back up more than necessary
23:39:26 <oerjan> put another way, your parser as written has the same problem of ] or eof following comments as your hand-written one had at one point
23:39:55 <ehird`> okay.
23:40:05 <ehird`> so how do i do skipping?
23:40:09 <oerjan> because you are entering oneIns before you know that there _is_ a non-comment operation available
23:40:11 <ehird`> i assume there's a combinator for it
23:40:22 -!- sebbu has joined.
23:40:29 <oerjan> skipMany (noneOf "[]<>+-.,")
23:41:09 <ehird`> in oneIns?
23:41:32 <faxathisia> why not do like: map (fromJust . lookup [('+',Add 1),...] $ filter (any "[]<>+-,.") $ text
23:41:41 <faxathisia> or whatever the syntax is
23:41:48 <ehird`> faxathisia: plz give me the [ and ] entries.
23:41:50 <oerjan> at the beginning, and after every operator
23:41:53 <ehird`> kthx
23:41:56 -!- iEhird_ has joined.
23:42:03 <faxathisia> oh right I get you
23:42:05 <ehird`> oerjan: hm, example?
23:42:14 <oerjan> faxathisia: that will lose position information
23:42:49 <oerjan> like the lexeme parsers in Parsec
23:42:54 <oklopol> oerjan: perl interpretation obfuscated posting?
23:43:07 <oerjan> oklopol: my last wiki post
23:43:29 <oerjan> someone added Perl to the wiki
23:43:35 <oklopol> :D
23:43:47 <ehird`> arguably justified
23:43:49 <oerjan> and i was inspired
23:44:59 <oklopol> that your interpretation?
23:45:14 <oklopol> sorry, i'm bad at using the fancy wiki features...
23:45:32 <oerjan> ehird`: i use to define a function op c = char c >> skipSpace >> return c or equivalent
23:45:46 <ehird`> hm
23:45:48 <oklopol> probably, you did say something about interpretation...
23:45:55 <ehird`> oerjan: where would that be used, though?
23:45:57 <ehird`> oneIns?
23:45:58 <oerjan> yes i added that section
23:46:11 <oerjan> ehird`: also loop
23:46:30 <oerjan> everywhere you use char, since in brainfuck every character can be followed by comments
23:46:36 <oklopol> i think that's a pretty perfect description of what the code does
23:47:02 <oklopol> anyone happen to know what "continuation" is in finnish :-)
23:47:16 <oerjan> i'm not even sure of norwegian...
23:47:17 <ehird`> i use char in loop
23:47:19 -!- iEhird_ has quit (Remote closed the connection).
23:47:21 <ehird`> but oneOf in bfIns
23:47:23 <ehird`> :-)
23:47:40 <oerjan> oh right oneOf
23:47:51 <oerjan> then you want the skip function right after oneOf
23:47:57 <oklopol> i've tried searching in a few dictionaries... unfortunately it seems these web dictionaries are made by java queers who don't know what a continuation is :)
23:48:22 <oerjan> also, skip at the beginning of program
23:48:22 * oklopol apologises to any java queer residing here
23:48:44 <ehird`> oerjan: so what would the oneOf become?
23:49:00 <oerjan> the oneOf is as before
23:49:17 <oerjan> but on the next line, add your skip operation
23:49:48 -!- iEhird has quit (Remote closed the connection).
23:49:55 <oerjan> hm it may not actually be worth having an op that takes an argument
23:50:55 <oerjan> just make a skipComment function
23:51:31 <oerjan> add it (1) after char ']' (2) after oneOf (3) at the beginning of brainFuck
23:51:57 <ehird`> skipComment :: ?
23:52:06 <oerjan> skipComment :: Parser ()
23:52:49 <ehird`> oneIns surely has to change?
23:52:49 <oerjan> after char '[' is not necessarily because it passes straight to brainfuck which already starts with one
23:53:07 <oerjan> yes, add one as a second line
23:53:26 <ehird`> ?
23:53:45 <oerjan> you want to do skipComment right after you do oneOf
23:54:32 <oerjan> oh btw the return's can be moved outside the case
23:54:37 <ehird`> it doesn't handle unmatched ]s now :(
23:54:39 <oerjan> just put $ between
23:55:51 <oerjan> hm? surely the parser would stop with an error if oneIns hits ] without being in ... oh right
23:56:13 <oerjan> you want your main parser to do an eof after calling brainfuck
23:56:40 <ehird`> i..see
23:56:44 <ehird`> explainerate :P
23:57:14 <oerjan> brainfuck just reads up until eof or ], it doesn't raise any error itself
23:57:26 <oerjan> so its caller must take care of the check
23:57:37 <ehird`> ok
23:57:38 <ehird`> esplain
23:57:40 <ehird`> :P
23:57:42 <ehird`> :P
23:58:28 <oerjan> mainParser = do prog <- brainfuck; eof; return prog
23:58:29 -!- sebbu2 has quit (Connection timed out).
←2008-01-04 2008-01-05 2008-01-06→ ↑2008 ↑all