< 1086854399 0 :clog!unknown@unknown.invalid QUIT :ended < 1086854400 0 :clog!unknown@unknown.invalid JOIN :#esoteric < 1086855598 0 :kosmikus|away!unknown@unknown.invalid NICK :kosmikus < 1086856683 0 :cmeme!unknown@unknown.invalid QUIT :calvino.freenode.net irc.freenode.net < 1086856683 0 :kosmikus!unknown@unknown.invalid QUIT :calvino.freenode.net irc.freenode.net < 1086856823 0 :kosmikus!~andres@kosmikus.developer.gentoo JOIN :#esoteric < 1086863939 0 :trman!~tony@199.224.33.65.cfl.rr.com JOIN :#esoteric < 1086864062 0 :trman!unknown@unknown.invalid QUIT :"Leaving" < 1086881337 0 :cmeme!~cmeme@216.184.11.30.unused.swcp.com JOIN :#esoteric < 1086889064 0 :calamari_!JeffryJohn@as02-pho-az-205-186-105-99.rasserver.net JOIN :#esoteric < 1086889067 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :hi < 1086889080 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :hi < 1086898519 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :know what's cool? < 1086898531 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :ice! < 1086898534 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :yes. < 1086898559 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :also, the non-turing-completeness of systems with finite memory makes it possible to prove whether a program halts in that system. < 1086898572 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :That's cool? < 1086898590 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :it's cool because at least Brainfuck does prescribe limited memory. < 1086898626 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :Taaus: I can play the C# minor fugue from WTC book I! < 1086898636 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Okay, so have you made a program that tests/proves halting/non-halting for an arbitrary BF program? < 1086898648 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :no < 1086898653 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :a naive one would be trivial to implement < 1086898668 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Ah, c# is a lot of fun. How many voices is it? < 1086898671 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :it would also require a fucking big computer < 1086898672 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :five < 1086898679 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Ah, that's what I thought. < 1086898682 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :five voices and three subjects < 1086898694 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :s/subjects/themes < 1086898706 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :It's pretty unique in that respect. Like the two-voice e-minor fugue. < 1086898709 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :is that really on-topic? I didn't think c# was an especially esoteric language. < 1086898710 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :i can't say i understand it, but at least i can play it. < 1086898724 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :Taaus: the Bb-minor one is also five-part < 1086898729 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :i can play it as well < 1086898735 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :it only has one subject though. < 1086898763 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :(and there's another triple fugue in book II) < 1086898783 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :I know c# isn't the only 5-part fugue, but the vast majority in WTC I+II are 3- and 4-parters :) < 1086898796 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :WTC II is boring. It only has 3 and 4. < 1086898819 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :C# minor is probably the most complex one in the entire WTC, structurally. < 1086898886 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :for brainfuck < 1086898901 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :you could just execute the program < 1086898911 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :keeping track of all memory states that occured. < 1086898924 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :if a memory states repeats, you're done - the program won't halt. < 1086898928 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :*state < 1086898944 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :since there's only a finite number of memory states, you'll be done eventually. < 1086898946 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Well... In theory, it's trivial... :P < 1086898962 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Just 64000^256. Lovely. < 1086898972 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :plus the pointer position. < 1086898972 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :64000? not really < 1086898982 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :didn't mueller specify 4000? < 1086898995 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :or something like that. < 1086898996 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :64k is pretty popular though. < 1086899002 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :He did? My bad. < 1086899003 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :but yeah, it's still a big number. < 1086899020 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :bfvga is a funny toy. too bad it's awfully hard to do anything pretty with it. < 1086899047 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :still it would be interesting to try to prove haltingness of at least some programs that halt. < 1086899057 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :then you can compile them into a singe statement. < 1086899119 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :(naturally this doesn't apply to programs which use ,) < 1086899166 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :it's a reasonable, if not always valid, assumption for a compiler to make, that a program containing a ',' will not halt. < 1086899195 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Alternatively, you could figure out how long (runtime-wise) the longest running halting program runs, then run all programs for that long. < 1086899212 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Ah, yes... "," is bothersome. < 1086899228 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :the longest running halting program... < 1086899232 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :it would have to visit all states < 1086899261 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :fizzie needs to depart for an evening walk out there. is away. < 1086899305 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Hehe, true... So actually, you can just run the program for memory * cell_size^memory, and see if it's halted. < 1086899313 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :yes. < 1086899335 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :how long would that take? :) < 1086899341 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :then you don't need a computer with heaps of memory, just lots of patienec. < 1086899350 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :yeah. It's a better approach. < 1086899354 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :lament: Constant time! :D < 1086899427 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :does this "halt"? +[++] < 1086899429 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :it's just 1e768 different states for 4000-byte memory < 1086899457 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :calamari_: depends on the semantics of our machine. Those would of course have to be agreed upon. < 1086899463 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :is brainf*ck's cell-size defined? < 1086899503 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :It's usually taken to be either 8 bit, or infinite. Of course, 'infinite' won't work here. < 1086899503 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :I could make a version that alternates between say, 1 and 2 that still wouldn't exit < 1086899524 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :calamari_: yes, but then it would be immediately seen that it repeats the memory state < 1086899532 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :oic < 1086899575 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :even the naive halting proofer will prove that in reasonable time < 1086899580 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :(i.e. almost instantly) < 1086899762 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :fizzie: where is the bfvga that you spoke of earlier? < 1086900000 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :i have once written a graphics extension for befunge. < 1086900008 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :but never wrote a single program for it :( < 1086900237 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :What techniques could be used to prove the haltingness of at least some programs that halt? < 1086900240 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :I was able to use ansi to extend bf a little, but that still managed to be standard bf < 1086900245 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :Clearly a program without loops will halt. < 1086900280 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :halt = exit? < 1086900284 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :Yes. < 1086900285 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Yes. < 1086900305 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :And a program that only has balanced loops will probably halt as well. < 1086900367 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :er. < 1086900374 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :balanced loops? < 1086900375 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :no. < 1086900379 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :not just balanced. < 1086900393 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :i'm talking about loops that move numbers from one cell to another. < 1086900426 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :the loop has to decrement the starting cell and always end on the same cell it started on. < 1086900432 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :e.g. [->+>+<<] < 1086900452 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :[->+<+] clearly won't terminate. < 1086900460 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :which sucks. < 1086900524 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :lament: *[ ... *-] or *[- ... *] < 1086900532 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :(* = same memory cell) < 1086900546 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :not counting nested loops at the ... of course < 1086900549 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :calamari_: [->+<+] is a [- ...] < 1086900566 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :so is [->+] < 1086900573 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :lament: yes, specific case of it < 1086900584 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :calamari_: those loops don't halt. < 1086900614 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :lament: wait a sec, I thought you repeated yourself < 1086900632 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :lament: those don't fit the description of * = same memory cell < 1086900646 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :calamari_: [->+<+] does. < 1086900678 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Uh, wrapping notwithstanding, can a [...+] loop terminate? Surely the cell is always non-zero due to the "+". < 1086900684 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :hmm.. good point.. however -+ really isn't - < 1086900700 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :Taaus: correct. < 1086900713 0 :deltab!unknown@unknown.invalid PRIVMSG #esoteric :are negative numbers allowed? < 1086900746 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Well... That depends on what semantics we choose :) < 1086900750 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :so [->+<+] is [>+<] and that doesn't fitthe pattern < 1086900751 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :deltab: not usually. < 1086900777 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :My favourite semantics is < 1086900785 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :8-bit unsigned cells < 1086900792 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :infinite memory space < 1086900800 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :going left of the origin crashes < 1086900812 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :overflow and underflow crashes < 1086900841 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :lament: if you have infinit memory space what do you do about something like +[>+] ? < 1086900880 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :calamari_: what do you mean "what do you do"? < 1086900891 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :calamari_: as taaus said, it's a loop that ends with a +. < 1086900902 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :it doesn't halt. < 1086900940 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :lament: what about [-]- < 1086900954 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :never mind < 1086900993 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :You don't have to subscribe to my favourite semantics, though. < 1086901003 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :Most people prefer to have wraparound instead of overflow/underflow < 1086901008 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :or so it seems. < 1086901009 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :actually, ending with a plus doesn't matter, it's the combined effect of the cell, right? .. for example +[>++-] < 1086901015 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Unfortunately, [->++-] matches [...-] < 1086901021 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Oh, heh. :) < 1086901023 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :GMTA. < 1086901039 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :that's because matching [...-] is silly. < 1086901055 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :lament: right, I just wanted to emphasize that :) < 1086901063 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :Any sequence of <>+- can be converted to a "normal form" < 1086901075 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :which is trivial to do and should be done prior to examining the program. < 1086901182 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :(existing optimizing compilers do it) < 1086901189 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :(hopefully) < 1086901195 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :
ACTION checks
< 1086901280 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :no, they don't :( < 1086901298 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :well, they do to an extent < 1086901303 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :+[[>]<] < 1086901321 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Ah, nested loops. We haven't even begun to worry about those yet! < 1086901330 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :nor about unbalanced loops < 1086901396 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :ok < 1086901414 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :the compiler bfc by Panu does it.- < 1086901420 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :sort of. < 1086901433 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :At which point do we realise the futility of this endeavour? < 1086901462 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :taaus: when we read that it's impossible to solve the halting problem? < 1086901488 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :bfc optimizes this [+>-<-] to this: < 1086901501 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :for(;a[p];p+=0){a[p+0]+=0;a[p+1]+=-1;} < 1086901510 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Well... It depends on the semantics... We proved earlier that Urban's original BF is halting-decidable. < 1086901531 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :taaus: that was with a finite memory space < 1086901537 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Yes. < 1086901546 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :calamari_: obviously you can't do it with infinite memory space. < 1086901549 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :Like I said, semantics :) < 1086901564 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :lament: " infinite memory space" < 1086901575 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :calamari_: that's just my favourite semantics. < 1086901593 0 :Taaus!unknown@unknown.invalid PRIVMSG #esoteric :What we're looking at now is better heuristics to check for halting-ness. Even though complete decidability is impossible :) < 1086901603 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :with finite space +[>+] this eventually exits < 1086901616 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :(assuming cell wraparound) < 1086901640 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :yes, and the halting prover would happily prove it. < 1086901652 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :how about better ways to optimize bf code -> bf code < 1086901674 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :that's a lot harder than optimizing compilation to c < 1086901728 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :but the aforementioned "converting -+<> sequences to their normal form" would be the first step. < 1086901739 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :right, but thats simple stuff < 1086901772 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :i've never heard of optimizing a language in that same language. < 1086901775 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :Has it ever been doen? < 1086901779 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :*done < 1086901793 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :automatic refactoring or something?.. < 1086902084 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :perhaps going to a higher level language and back again to bf? < 1086902106 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :Converting -+<> sequences to normal form (preferrably to shortest form) isn't trivial either < 1086902110 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :or so it seems < 1086902118 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :try doing it in BF: P < 1086902134 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :but, that doesn't seem very promising either, because higher level languages have other baggage problems < 1086902188 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :lament: aren't you talking about figuring out that +--++ is the same as + ? < 1086902208 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :that's part of it. < 1086902386 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :using the higher level form above, I get [+>-<-] => [>-<].. however if there were nested loops, that might not work right < 1086902448 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :nested loops clearly aren't parts of -+<> sequences. < 1086902452 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :Lunch. < 1086906059 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :hrm. < 1086906072 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :finding the 'normal form' isn't all that trivial. < 1086906081 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :it's annoyingly annoying < 1086906284 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :took me 53 lines of Python code! < 1086906290 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :>>> normal('+>+<-') < 1086906291 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :'>+<' < 1086906293 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :woohoo < 1086906373 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :what does it give for >>+>>++<-<-<-<- < 1086906402 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :'>>>>++<-<<-<-' < 1086906446 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :let's try >>+>>++<-<-<-<->>>> < 1086906456 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :'->->>->++' :) < 1086906490 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :it returns the provably shortest path, although i'm certainly not going to prove that. < 1086906491 0 :calamari_!unknown@unknown.invalid PRIVMSG #esoteric :cool < 1086906821 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :bfvga is a proggie which maps the vga 320x200x256 mode display memory as a 64k brainf*ck array. I think it was in scene.org somewhere. < 1086906887 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :http://www.pouet.net/prod.php?which=5060 I think. < 1086907711 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :i don't like the comments in that thread. < 1086907744 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :well, they are sceners. < 1086907749 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :not esoteric-language-people. < 1086907915 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :that makes them wrong! < 1086907919 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :my program doesn't quite work :( < 1086907961 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :but, i applied it to the BF mandelbrot generator and it didn't change anything at all. < 1086908494 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :re bfvga, I tried the analogous befvga, the befunge version of that, with a 320x200 playfield and the playfield positions mapped to the screen. < 1086908506 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :it wasn't any more fun than bfvga though. < 1086908760 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :oh actually < 1086908783 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :my program does make the mandelbrot generator 30 characters shorter :) < 1086908798 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :11421 vs. 11451 < 1086908888 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :it also does a lot of funky rearrangement of questionable quality < 1086908894 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :for example, it converts this: < 1086908900 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :[->++>>>+++++>++>+<<<<<<] < 1086908902 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :into this: < 1086908908 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :[>>>>>>+<++<+++++<<<++<-] < 1086908928 0 :fizzie!unknown@unknown.invalid PRIVMSG #esoteric :maybe you should make it not apply the modifications if they are not shorter. < 1086908982 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :also this: < 1086908989 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :[->+<] < 1086908990 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :into this: < 1086908993 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :[>+<-] < 1086909017 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :maybe. < 1086909058 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :but then the original idea was to convert everything to a "normal form" that would make it easier to process by other tools. < 1086909100 0 :lament!unknown@unknown.invalid PRIVMSG #esoteric :but that task is probably not compatible with that of always writing the _shortest_ version. < 1086909629 0 :calamari_!unknown@unknown.invalid QUIT :Read error: 104 (Connection reset by peer)