< 1184976008 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!persist regex load < 1184976008 0 :toBogE!unknown@unknown.invalid PRIVMSG #esoteric :Cannot register regex < 1184976011 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Huh? < 1184976017 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :oops wrong channel < 1184976017 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :sorry < 1184976026 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :meant to do it in #toboge < 1184976273 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :is toboge an egobot clone or something < 1184976355 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :He's trying to outcompete with EgoBot :( < 1184976358 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Damn evolution! < 1184976386 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :GregorR: you have gone too long without adding new languages :/ < 1184976426 0 :immibis_!n=IceChat7@125-238-33-245.broadband-telecom.global-gateway.net.nz JOIN :#esoteric < 1184976514 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: People haven't been very persistent in telling me to add them :P < 1184976544 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :add some non-esoteric languages < 1184976565 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :I won't add any languages with file I/O, and most non-esolangs have that. < 1184976590 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :do scheme without filezors < 1184976649 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :there are only a few file operators that you have to remove < 1184976711 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ACTION thinks blahbot is supreme! < 1184976716 0 :marvinbot`!unknown@unknown.invalid PRIVMSG #esoteric :yes i am! < 1184976721 0 :marvinbot`!unknown@unknown.invalid PRIVMSG #esoteric :i do all sorts of things! < 1184976728 0 :marvinbot`!unknown@unknown.invalid PRIVMSG #esoteric :but not everything quite yet. < 1184976731 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :just wrap the code in something like: (define (fuck-you . ignored) (write-to-channel "fuck you, hax0r")) (let ((with-output-file fuck-you) et cetra) ...) < 1184976746 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Interesting. < 1184976775 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :ACTION continues pondering stuff < 1184976810 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :\x is a function from a to a binder of x to a... < 1184976826 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :http://www.schemers.org/Documents/Standards/R5RS/HTML/r5rs-Z-H-9.html#%_sec_6.6.1 < 1184976832 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :those are the relevent functions < 1184976834 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :x is an a given a binding of x to a. < 1184976842 0 :immibis!unknown@unknown.invalid QUIT :Nick collision from services. < 1184976845 0 :immibis_!unknown@unknown.invalid QUIT :Nick collision from services. < 1184976849 0 :immibis!n=IceChat7@125-238-33-245.broadband-telecom.global-gateway.net.nz JOIN :#esoteric < 1184976879 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :\x :: all a. a -> Bind \x\ a < 1184976918 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :if anyone could tell me how to fix my connection, that would be useful. < 1184976924 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :x :: [x : a] => a < 1184976931 0 :toBogE!unknown@unknown.invalid QUIT :Nick collision from services. < 1184976935 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :immibis: duct tape. < 1184976988 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :call-with-input-file, call-with-output-file, with-input-from-file, with-output-to-file, open-input-file, open-output-file, load, transcript-on < 1184976993 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :that's all you need to overload < 1184977016 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Er, \x\ : a, not x : a. < 1184977075 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :\x :: all a. a -> Bind \x\ a; x :: [x : a] => a; (::) :: a -> * -> Dec; < 1184977077 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :bsmntbombdood: _provided_ he knows his scheme implementation has no i/o extensions. < 1184977080 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Er. < 1184977135 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: so he just needs to read his implementation's docs < 1184977183 0 :edwardk!unknown@unknown.invalid PRIVMSG #esoteric :ihope: seems kinda authmathy < 1184977185 0 :edwardk!unknown@unknown.invalid PRIVMSG #esoteric :er < 1184977187 0 :edwardk!unknown@unknown.invalid PRIVMSG #esoteric :automathy < 1184977195 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :edwardk: automathy? < 1184977195 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :or he could write his own scheme and be absolutely sure < 1184977209 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :bsmntbombdood: he could write himself a Scheme in 48 hours! < 1184977217 0 :edwardk!unknown@unknown.invalid PRIVMSG #esoteric :like automath, the grand-daddy of modern functional languages < 1184977232 0 :edwardk!unknown@unknown.invalid PRIVMSG #esoteric :on the non-lisp side of the family tree ;) < 1184977256 0 :edwardk!unknown@unknown.invalid PRIVMSG #esoteric :where we got this strange notion of type systems from, etc =) < 1184977259 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :and not miss anything that puts surprising I/O access into an "obviously" safe place. < 1184977324 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :\x :: all (\a. a -> Bind \x\ a); x :: all (\a. [\x\ : a] => a); (::) :: all (\a. a -> * -> Dec); all :: all (\a. (a -> *) -> *); * :: *; \x\ :: Id; Bind :: Id -> *-> *; Id :: *; (:) :: Id -> * -> Req; (=>) :: List Req -> * -> *; List :: * -> *; Req :: * < 1184977421 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Oh, and (.) :: all (\a. all (\i. (a -> Bind i a) -> [i : a] => b -> a -> b)) < 1184977432 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :And Dec :: * < 1184977488 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :And then there's let... < 1184977545 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :what are you doing? < 1184977566 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Trying to invent a language. < 1184977574 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Of the programming kind. < 1184977723 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :ihope: sorry for the late reply, but how can duct tape ensure a wireless connection stays connected? < 1184977736 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :immibis: duct tape'll connect anything! < 1184977750 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :even a wireless connection? < 1184977763 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :even a wireless, ducttapeless connection? < 1184977783 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Sure. < 1184977794 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :See if you can find wireless duct tape. < 1184977887 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :ihope: see if you can find wired duct tape < 1184978258 0 :toBogE!n=toBogE@125-238-33-245.broadband-telecom.global-gateway.net.nz JOIN :#esoteric < 1184978586 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :all the bizarre bits of Haskell suppoert one another < 1184978597 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :without type inference, monads are useless < 1184978609 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :hell, without types they are useless < 1184978635 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i am not quite sure of that. < 1184978684 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :GregorR: scheme scheme scheme scheme < 1184978686 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :you _could_ have objects with a bind method. < 1184978792 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :But it is a PITA to have to write type sigs all over the place < 1184978830 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :>> is ploymorphic remember < 1184978832 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i am talking about in a dynamically typed language < 1184978859 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :>> would call the bind method of its left argument. < 1184978871 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :but think of all those functions which work for any monad < 1184978881 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :how would you do those? < 1184978909 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :liftM :: a -> b -> m a -> m b < 1184978931 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :that's not right < 1184978941 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :yes it is < 1184978968 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :well... < 1184978970 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric : forall a1 r (m :: * -> *). (Monad m) => (a1 -> r) -> m a1 -> m r < 1184979014 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :or, in pseudo-Haskell: < 1184979020 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :clone :: a -> a < 1184979027 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :anyway, liftM f x = x.bind(\t -> return (f x)) < 1184979031 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :write the type signature for *that* < 1184979046 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: I know that, but that is verbose < 1184979072 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well, first you have x >>= f = x.bind(f), of course. < 1184979092 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :I see things like: < 1184979128 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :readThingy >>= liftM (+2) >>= writeThingy < 1184979169 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :in the IO monad that is: < 1184979192 0 :immibis!unknown@unknown.invalid QUIT :"Download IceChat at www.icechat.net" < 1184979202 0 :toBogE!unknown@unknown.invalid QUIT :Read error: 104 (Connection reset by peer) < 1184979206 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :SimonRC: i meant to make liftM f x a _function_ < 1184979213 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :defined by the right hand side < 1184979230 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :*liftM < 1184979231 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :ah, wait, i can see how that might work < 1184979247 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i actually thought about this before a bit < 1184979272 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :It is occasionally handy to be able to dispatch on return type < 1184979305 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :yes, that is hard to get. also, this method works only for monads strict in the left argument of >>= < 1184979318 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :but it does work for a number of monads. < 1184979321 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :How would one go about writing enumFromTo? < 1184979343 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric ::: forall a. (Enum a) => a -> a -> [a] < 1184979343 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :that would be a method too, of course. < 1184979357 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :ah, I can see how this works < 1184979368 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :Scala has operators as methods of their first argument. < 1184979400 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :it also has a bit of comprehension syntax, which is thinly disguised monads. < 1184979416 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :although the type system doesn't support the full concept. < 1184979435 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :ok, now a pathalogical example: "makeIntoZeros = map (\x -> 0)" < 1184979484 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric ::: forall a, n. (Num n) => [a] -> [n] < 1184979489 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :btw you can /msg lambdabot < 1184979491 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :does haskell allow variadic functions? < 1184979505 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :bsmntbombdood: kkinda < 1184979507 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :bsmntbombdood: in some cases you can do it with type classes < 1184979514 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :printf exists, for example < 1184979524 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :it conflicts interestingly with currying < 1184979552 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :basically, the final result of the function cannot be a function, i guess < 1184979561 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :ah, no... < 1184979586 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :the problem is if there is a type in the return value that cannot be deduced from the arguments < 1184979601 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :hm? < 1184979617 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :e.g. 0 :: (Num n) => n < 1184979617 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :printf is polymorphic on the return value :D < 1184979640 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :oh, i thought you were still talking about variadic functions < 1184979663 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :ad many of the types that are in one sense types of arguments end up as part of the type of the return value when you start currying. < 1184979671 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :e.g. readThingy >>= liftM (+2) >>= writeThingy < 1184979694 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :the monad type does not appear in the single argument to liftM < 1184979699 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :but it does in the return type < 1184979731 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :as i see it, the monad is found from the first object in the >>= chain which is not return _ < 1184979781 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :and obviously you lose majorly if you get rid of currying < 1184979815 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :another idea: < 1184979815 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well, getting rid of currying was not part of the original specification :) < 1184979851 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :if you allow currying the Java and C# programmers will kill you < 1184979916 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :suppose you have a function getStream :: m a -> m [a] < 1184979957 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :and because it is used deep inside an abstraction, for elegance you want to pass in "return 0", which eventually gets passed as the first argument of getStream... < 1184979990 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :you have a naked return, so you must specify the type somehow < 1184980011 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :any any hard-coded type will reduce generality < 1184980054 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well, there _would_ have to be default return(x) objects < 1184980068 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :"default"? < 1184980088 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :which would know how to insert themselves into a >>= chain < 1184980096 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :ouch, hack < 1184980116 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :getStream f = do { x <- f ; xs <- getStream f ; return x : xs } -- I think < 1184980117 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :no worse than having numerical conversions < 1184980193 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :basically, you are making the wrapped Identity monad a supertype of the others. < 1184980329 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :er, subtype < 1184980357 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :What's all this about? < 1184980381 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :how much of monads can be done in a dynamically typed language < 1184980416 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :with code polymorphic over the monad < 1184981469 0 :ehird`!unknown@unknown.invalid QUIT :Read error: 104 (Connection reset by peer) < 1184981478 0 :marvinbot`!unknown@unknown.invalid QUIT :Remote closed the connection < 1184982430 0 :immibis!n=IceChat7@125-238-33-245.broadband-telecom.global-gateway.net.nz JOIN :#esoteric < 1184982547 0 :toBogE!n=toBogE@125-238-33-245.broadband-telecom.global-gateway.net.nz JOIN :#esoteric < 1184982623 0 :toBogE!unknown@unknown.invalid QUIT :Read error: 104 (Connection reset by peer) < 1184987370 0 :ihope!unknown@unknown.invalid QUIT :Read error: 110 (Connection timed out) < 1184988990 0 :GreaseMonkey!n=saru@222-154-141-161.jetstream.xtra.co.nz JOIN :#esoteric < 1184991251 0 :andreou!unknown@unknown.invalid QUIT :Read error: 113 (No route to host) < 1184992454 0 :oerjan!unknown@unknown.invalid QUIT :"Good night" < 1184994870 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Hey, if you read() from a Reader, does it always pull in the next byte? < 1184994875 0 :Arrogant!i=Arrogatn@12.78.67.28 JOIN :#esoteric < 1184994881 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :um < 1184994886 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :yes, I do believe < 1184994927 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :actually, that reads a *character* < 1184994960 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :wait... wtf < 1184994966 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :this javadoc is confusing. < 1184994971 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :It reads an int, actually :P < 1184994978 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :"The character read, as an integer in the range 0 to 65535" < 1184994985 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :what the hell does that mean? < 1184994987 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Grr. < 1184994995 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :obviously, it IS an int, but... wait < 1184995007 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :It's the integer representation of the next unicode character. < 1184995009 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :this may be because Java has builtin Unicode support < 1184995010 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1184995087 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Now I have to like, completely redesign half my classes. < 1184995089 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Hooray. < 1184995100 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :why the refactor? < 1184995145 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Wait no, I don't. Only 1 class I need to redesign. < 1184995157 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :phew < 1184995199 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :I need to use an InputStream now, so I have to make sure the bytes are converted to their appropriate types before I have the classes perform the internal magic to represent the types I need. < 1184995225 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Can you test against bytes like (blah == -1) ? < 1184995231 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Or do you have to cast to int? < 1184995250 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :you should be able to make the comparison you have above < 1184995324 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :on an unrelated note, I've come up with a bunch of monsters and things for the player and fluffy, his faithful genetically engineered pencil-sharpener, to face in my RPG: http://rodger.nonlogic.org/images/CRPG%20combat.png < 1184995405 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :ideas not shown here include staple removers, peeps(TM) candy and the ghost of Edsgard Djikstra. < 1184995421 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :I want the Djikstra! < 1184995447 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :lol < 1184995531 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Also, if you cast byte to char, does it do the auto-conversion for you? < 1184995540 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :Djikstra's attacks will include "Shunting yard", "FOR loop", "A case against the GO TO statement" and "exhaustive proof" < 1184995560 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :This primitives business is what really confuses me. I'm so used to C primitives ;-; < 1184995574 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :char literals are dealt with internally as if they instantly become integers < 1184995582 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Aha. < 1184995603 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :that's how I always think about it- single-quotes are just an alias < 1184995638 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :so (57 == '9') is true < 1184995649 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :I haven't written ASM in a *looong* time. < 1184995657 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :I want to do a low level project. Methinks an emulator. < 1184995663 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :in Java? < 1184995667 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :In C :P < 1184995672 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :eeew < 1184995694 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :You can't write a substantial emulator in a high-level language and expect it to be fast, though. < 1184995729 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Plus you need cheap bit-flipping hacks that is total C-lurv :3 < 1184995742 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :you can't write anything in java and expect it to be fast, that includes emulators < 1184995797 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Funny how a byte-code compiled language can't be fast, no? < 1184995809 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :OSS anti-Java stigma, when unfounded, is funny. < 1184995822 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :at least, not on my computer < 1184995846 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :I'll bet my machine is worse than yours. < 1184995859 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I'm with Sukoshi on this one, immibis- Java has a tremendous amount of technology behind it to *make* it fast, even when it's innately at a disadvantage < 1184995868 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :JavaC is a fantastic piece of code. < 1184995942 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :really? i must have a slow computer then < 1184995951 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :ACTION checks in System Properties < 1184995970 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :2GHz, 248MB memory < 1184995999 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :there is no excuse to have that little RAM. It's a travesty. < 1184996006 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :immibis: 1.6 GHz, 256 MB. < 1184996024 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :;D < 1184996033 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :ram IS NOT EXPENSIVE. It's the most affordable upgrade you can make to your computer these days. < 1184996051 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :8MB is used by onboard graphics < 1184996067 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :i think there is actually 256MB in the box < 1184996084 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :I have a slower computer, and yet it runs fine. < 1184996095 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :You even run Windows, and the Linux JVM has historically been known for being crappy. < 1184996121 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :the sun jvm or gij? < 1184996170 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Sun. < 1184996200 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I can attest to this- applet compatibility on linux is absolute shit < 1184996224 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :unreliable keylisteners, improper graphics buffering, and a host of other intermittent problems < 1184996333 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I've had numerous programs run on OSX and windows flawlessly, and then utterly fail when I test them out on one of the fedora-based lab machines up here in the CS department < 1184996365 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :It's gonna improve now that Java is OSSing the thing. < 1184996373 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :...in theory. < 1184996397 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Never doubt the power of horrendous numbers of OSS coders. < 1184996399 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :OR, we'll wind up with a ton of slightly broken and weird forks of the language < 1184996414 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Read the GNU Classpath mailing list. It's *really* active. < 1184996423 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :"Woo I should add operator overloading to Java FOR NO REASON! Whoopeee!" < 1184996437 0 :GreaseMonkey!unknown@unknown.invalid PRIVMSG #esoteric :i reckon they'd have a fork of Java with built-in "Hello World!" support < 1184996446 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :Java 5 did enough bad things. :'( < 1184996458 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :But Java 1.6 really upped Linux VM awesomeness. < 1184996467 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Much faster/lighter on the memory. < 1184996481 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :the apple can only fall so far from the tree < 1184997704 0 :GreaseMonkey!unknown@unknown.invalid PRIVMSG #esoteric :getting off now, cya < 1184997733 0 :GreaseMonkey!unknown@unknown.invalid QUIT :"custom quit messages --> xchat.org <-- hydrairc sucks" < 1184997887 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Although I used to find it aggravating in the beginning, now I'm starting to like Java's restriction of one class per file and the class should have the same name as the filename. < 1184997904 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :I remember hunting typedefs in large globs of C codes and shuddering. < 1184998015 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric ::) < 1184998052 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :although in cases where it makes some sense (like non-public classes), it *is* sometimes possible to have more than one in a file < 1184998267 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :'later everyone- I require sleep < 1184998276 0 :RodgerTheGreat!unknown@unknown.invalid QUIT : < 1185001003 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :could someone please indicate what is wrong with the following bf program: +[,>[-]+.<[.,]+.[-]+++++++++++++.---.] < 1185001051 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :it is supposed to read from standard input until end-of-file and echo it putting the character with code 1 before and after it < 1185001070 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :in other words, it is meant to translate plain text into a CTCP request when run on EgoBot as a daemon < 1185001490 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :why so complicated? < 1185001514 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :+.>,[.,]<+ < 1185001523 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :left over from an earlier revision < 1185001530 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :s/<+/./ < 1185001532 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :wait a second... < 1185001537 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :what about the CRLF though? < 1185002118 0 :Arrogant!unknown@unknown.invalid QUIT :"Leaving" < 1185004799 0 :clog!unknown@unknown.invalid QUIT :ended < 1185004800 0 :clog!unknown@unknown.invalid JOIN :#esoteric < 1185004809 0 :sebbu!n=sebbu@ADijon-152-1-23-217.w83-194.abo.wanadoo.fr JOIN :#esoteric < 1185008328 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!daemon ctcp bf8 +[.[-],[.,]+.++++++++++++.---.] < 1185008332 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!ctcp ACTION blinks < 1185008334 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :ACTION blinks < 1185008335 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!ctcp ACTION blinks < 1185008338 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :ACTION blinks < 1185008343 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!undaemon ctcp < 1185008346 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Process 1 killed. < 1185008364 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!daemon ctcp bf8 +[.[-],[.,]+.+++++++++.] < 1185008368 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!ctcp ACTION blinks < 1185008370 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :ACTION blinks < 1185008377 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!ctcp ACTION blinks < 1185008380 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :ACTION blinks < 1185008388 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :anyone know what is happening? < 1185008391 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!undaemon ctcp < 1185008394 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Process 1 killed. < 1185008427 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!help usertrig < 1185008430 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Use: usertrig Function: manage user triggers. may be add, del, list or show. < 1185008454 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!usertrig add ctcp bf8 +.,[.,]+. < 1185008456 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Trigger added (ctcp)! < 1185008462 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!ctcp ACTION blinks < 1185008464 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :ACTION blinks < 1185008465 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!ctcp ACTION blinks < 1185008468 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :ACTION blinks < 1185008474 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :well, that works. < 1185008487 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!daemon cat bf8 +[,.[-]+] < 1185008494 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :meow < 1185008616 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :meow < 1185008765 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!cat < 1185008767 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!dog < 1185008770 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :woof < 1185008809 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :!goat < 1185008812 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :woof < 1185008817 0 :immibis!unknown@unknown.invalid PRIVMSG #esoteric :why does the goat go woof? < 1185009033 0 :immibis!unknown@unknown.invalid QUIT :"I cna ytpe 300 wrods pre mniuet!!!" < 1185013150 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :"If you are caught downloading copyrighted material, you will lose your ResNet privileges forever.", then, later on the page, "Copyright © 2005 by the University of Kansas". Ouch. < 1185013938 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :? < 1185014010 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :http://www.resnet.ku.edu/ < 1185014020 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric : Ach, du lieber! <<< OMG, rather you? < 1185014028 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :funny funny < 1185014164 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :hmph, why is everyone gone when i need them < 1185014183 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :okay, i admit i did't need oerjan that much < 1185014684 0 :ehird`!n=test@user-514f618c.l4.c3.dsl.pol.co.uk JOIN :#esoteric < 1185015634 0 :jix!n=jix@dyndsl-085-016-233-089.ewe-ip-backbone.de JOIN :#esoteric < 1185015830 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :where's that video about procedures in c2bf again? < 1185016858 0 :Cesque!n=Cesque@82-36-138-103.cable.ubr02.perr.blueyonder.co.uk JOIN :#esoteric < 1185016932 0 :Cesque!unknown@unknown.invalid QUIT :Client Quit < 1185018485 0 :andreou!n=andreou@84.38.8.31 JOIN :#esoteric < 1185018807 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :damn < 1185018817 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :made a language with static typing < 1185018844 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :(to be continued...) < 1185018864 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :eh < 1185018870 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :actually, i solved my problem < 1185019546 0 :jix!unknown@unknown.invalid QUIT :Nick collision from services. < 1185019560 0 :jix!n=jix@dyndsl-080-228-182-053.ewe-ip-backbone.de JOIN :#esoteric < 1185021415 0 :RedDak!n=dak@host115-89-dynamic.16-87-r.retail.telecomitalia.it JOIN :#esoteric < 1185021601 0 :andreou!unknown@unknown.invalid QUIT :"Leaving." < 1185022109 0 :oklofok!i=oko@194.251.101.183 JOIN :#esoteric < 1185022136 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :so okay, i make a language, then try creating i using s, k and i -combinators. < 1185022151 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :WHY CAN'T MY I COMBINATOR USE ITSELF RECURSIVELY??? < 1185022163 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :this kept me occupied for quite a while < 1185022168 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i'm no great <3 < 1185022212 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(don't use recursion if you don't know it or just happen to be a miserably failish person.) < 1185022223 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(is the lesson here) < 1185022385 0 :ololobot!n=ololobot@194.251.101.183 JOIN :#esoteric < 1185022411 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :>>> ul `ii < 1185022413 0 :ololobot!unknown@unknown.invalid PRIVMSG #esoteric : -> i < 1185022447 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :>>> numbda s={a->{b->{c->(a!c)!(b!c)}}};k={a->{b->a}};i={a->s!k!k!a};i!7 < 1185022448 0 :ololobot!unknown@unknown.invalid PRIVMSG #esoteric :num:7 < 1185022464 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :the i combinator via ``skk in numbda < 1185022509 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(the language i created to make possible to make lambdas using parenthesis while still having them for normal grouping) < 1185022526 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and no, this feature hasn't been done yet < 1185022536 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and yes, i know no one is interested in whether it is < 1185022548 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and now, gonna eat something funnish -> < 1185022587 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :>>> numbda 5+4-5*2 < 1185022588 0 :ololobot!unknown@unknown.invalid PRIVMSG #esoteric :num:-1 < 1185022606 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :crack it if you wish, tell me if you do < 1185022607 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :-> < 1185022856 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1185022910 0 :oklobot!n=oklobot@194.251.101.183 JOIN :#esoteric < 1185022912 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :hihi < 1185022921 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :!help < 1185022924 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon < 1185022925 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1185022927 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :1l 2l adjust axo bch bf{8,[16],32,64} funge93 fyb fybs glass glypho kipple lambda lazyk linguine malbolge pbrain qbf rail rhotor sadol sceql trigger udage01 unlambda whirl < 1185022928 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1185022945 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :!exec 5 5 3AddAddPrntnl < 1185022948 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Huh? < 1185022952 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1185022958 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :!exec 5 5 3AddAddPrntNl < 1185022959 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1185022959 0 :oklobot!unknown@unknown.invalid PRIVMSG #esoteric :13 < 1185022960 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Huh? < 1185023008 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oklobot sucks, i just wanted 4 nicks here for the hell of it < 1185023021 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :now, retry at the going away thing -> < 1185023027 0 :ihope__!n=ihope@c-71-205-100-59.hsd1.mi.comcast.net JOIN :#esoteric < 1185023052 0 :ihope__!unknown@unknown.invalid NICK :ihope < 1185024506 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :numbda looks like oklotalk < 1185024561 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :wait how does egobot do befunge < 1185024563 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :multiple lines < 1185024911 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :source file url < 1185024911 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :is there a precompiled binary of fukyorbrane for windows anywhere? < 1185024919 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :and i'm not gone < 1185024920 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :why... < 1185024922 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric ::< < 1185025052 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :=p < 1185025060 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1185025071 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :FukYorBrane combined with self-replicating brainfuck? < 1185025081 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :you could easily replace an opponents code with your own. < 1185025090 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :or similar weirdness < 1185025210 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ololobot has a new language now < 1185025213 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :just added < 1185025219 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :>>> bs 33<11<=!Hello> world>: < 1185025220 0 :ololobot!unknown@unknown.invalid PRIVMSG #esoteric :Hello, world! < 1185025225 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :yay :) < 1185025236 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :nice to extend, that one < 1185025249 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :now, perhaps, i'm going -> < 1185025934 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :one thing i don't understand about bf function calls like in c2bf < 1185025969 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :is that the only way to call a function is to put the function id in the current cell, and then >end the loop< (i.e. return from the current function.) so how do you handle my_function() { a_func(); more_code; }? you'd return right after a_func < 1185025985 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :and you can't use a call stack since you can't represent a certain part of a function < 1185027506 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :do many brainfuck compilers optimize x[x] to a do..while? < 1185028175 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Oh my. < 1185028194 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :what < 1185028203 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: what's that language? < 1185028212 0 :RedDak!unknown@unknown.invalid QUIT :Remote closed the connection < 1185028444 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :hmm, x[x] optimization could really speed up some code < 1185029364 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :ACTION ponders < 1185029399 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ponders what < 1185029416 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Ponders how to write that without x being present twice. < 1185029426 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :Oh < 1185029451 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :... i think it'd be hard < 1185029458 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :which is why lovely compilers should do it for us! < 1185029474 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :ACTION nods < 1185029504 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Perhaps AI means a good compiler. < 1185029530 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ACTION ponders writing a bf-to-c compiler in C, optimizing - yeah it's been done before, but they're short affairs, and you can optimize so much in BF < 1185029569 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :(wow -- i'm stupid, i just realised that cell-wrapping is just modulo 256) < 1185030185 0 :oerjan!n=oerjan@hagbart.nvg.ntnu.no JOIN :#esoteric < 1185032084 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i might write that bf compiler. < 1185035525 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ihope: numbda < 1185035615 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :what is numbda < 1185035623 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(ihope) oklofok: what's that language? < 1185035624 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1185035628 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oklobot's language? < 1185035633 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :that one i call oklobot :) < 1185035638 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :or The Oklobot Language < 1185035647 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :>>> bs. < 1185035652 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1185035653 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1185035658 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :that's a language of my friends < 1185035695 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :it's kinda like brainfuck, except you have bitwise logic and basic arithmetic for adjacent cells < 1185035704 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :is there a page on the wiki describing most of the good brainfuck-compilation optimization techniques known? < 1185035724 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :my friend's knowledge about esoteric languages is pretty much limited to brainfuck < 1185035733 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :>>> bs 33<11<=!Hello> world>: < 1185035734 0 :ololobot!unknown@unknown.invalid PRIVMSG #esoteric :Hello, world! < 1185035736 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :That's numbda? < 1185035741 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :no < 1185035742 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ehird`: that while -> do while thing isn't possible in general, methinks < 1185035748 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :oklofok, why not? < 1185035748 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ihope: that's b00tstrap_ < 1185035755 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :ACTION nods < 1185035773 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :just match on a parse tree x[x], where x is matched as what's in the [], then convert < 1185035776 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :because you can't keep a cell for the while in store if you don't know where in memory x will land < 1185035792 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1185035795 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you mean, optimizing that < 1185035796 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1185035799 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1185035802 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i was thinking about what ihope said < 1185035807 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and answered to him, actually < 1185035816 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :well you said "ehird: that while -> do..." < 1185035830 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i did, because i forgot who asked what. < 1185035832 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :anyway < 1185035840 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :what i mean is, instead of x[x] being e.g. x; while(*p){x} it's do{x}while(*p) < 1185035841 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :optimizing that is just a stirng match < 1185035844 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1185035847 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :*string < 1185035852 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :or a parse tree match for more advanced compilers :P < 1185035866 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :essentially the same in the case of brainfuck < 1185035880 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :maybe x[xy] could be optimized too < 1185035882 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :because in brainfuck you can't play with syntax < 1185035887 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :that is if x isn't just one character or something silly < 1185035912 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :um, wait, no. < 1185035942 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :>>> numbda "Hello, world!" < 1185035943 0 :ololobot!unknown@unknown.invalid PRIVMSG #esoteric :Hello, world! < 1185035956 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i realized my static scoping is broken when i was eating < 1185035971 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :recursion in general will not work < 1185035995 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but you can't notice it yet, really, since there aren't control flow operators to make recursion usable < 1185036008 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i also think that the algorithms to set the ptr to a certain value can be optimized < 1185036015 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :things like copying, too < 1185036031 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :you just need either some heuristics or some hard-coded snippits to optimize < 1185036039 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you mean [-]+++++ can be made into cell=5 < 1185036040 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :? < 1185036046 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :yes, and: < 1185036053 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i think my brianfuck compiler does that < 1185036056 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :*brainfuck < 1185036057 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :(wait) < 1185036065 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i will < 1185036083 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :yes, and: [>+<-] can be optimized too < 1185036096 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :it's *p = *(p - 1); *(p - 1) = 0; < 1185036101 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :my brainfuck compiler optimizes that methinks < 1185036107 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :to do it completely requires solving the halting problem of course < 1185036123 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :but you can try some heuristics, and use hardcoded optimizations for a few ways. < 1185036136 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :any [] that has right_moves-left_moves==0 can be completely optimized. < 1185036142 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and my compiler does that methinks < 1185036145 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :don't remember < 1185036150 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :also you can optimize every single one on http://esolangs.org/wiki/Brainfuck_constants :) < 1185036154 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :if i actually implemented the last optimization < 1185036159 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1185036166 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :oklofok, and that has no IO right, you mean :) < 1185036175 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :IO right? < 1185036182 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1185036184 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1185036185 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :"and that has no I/O, right" < 1185036191 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :and, how do you do it? < 1185036196 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :do you interpret it at compile-time? < 1185036200 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :err < 1185036204 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :otherwise nested loops suc hthat r-l==0 might be hard.. < 1185036218 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you just sum up the +'s and -'s for each level < 1185036224 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ah, right < 1185036229 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :but... < 1185036233 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1185036248 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and an optimized [] will just be a list like [ccell-4]+=4, [ccell]-=3 < 1185036261 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :so [+++[---]] would be compiled as while (*p) { *p += 3; while (*p) { *p -= 3; } } < 1185036271 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i was thinking you'd flatten the loop somehow and i was confused < 1185036283 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :err, [---] would be optimized as [-] = NULLIFY < 1185036287 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :well yes but < 1185036292 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i mean in the context of this optimizations < 1185036293 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :[+++NULLIFY]==[-]= nullify < 1185036296 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1185036334 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you can flatten a thing like [+-+-+-+->-+-+-++---->-+-++-<--+--<<-+++-<-+++++++>] < 1185036341 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :err < 1185036349 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :[+-+-+-+->-+-+-++---->-+-++-<--+--<>-+++-<-+++++++>] < 1185036376 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and nullifications can usually be there as well and can be optimized < 1185036394 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but that's it of course < 1185036398 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :so [>++<-[+>-<]] would be while (*p) { *(p + 1) += 2; *p--; while (*p) { *p++; *(p + 1)--; }} right < 1185036412 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1185036432 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but that's a pretty obvious optimization anyway < 1185036436 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :err < 1185036441 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :of course, i was wrong there < 1185036443 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i see these optimizations would be much easier with the code as a nested list (for loops) and a language with pattern matching ;) < 1185036450 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :this would be quite verbose in C < 1185036454 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Did somebody say Haskell? < 1185036464 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ihope, no SML love? < 1185036465 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :a non recursive one with num(>)-num(<)=0 can always be fully optimized < 1185036476 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i mean, with no nested []'s < 1185036480 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :I've hardly heard of SML. < 1185036485 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but obvious obvious, that doesn't really help < 1185036486 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ihope, i think it looks nice < 1185036489 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i haven't used it much < 1185036500 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Related to ML, probably. < 1185036505 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1185036507 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :SML = Standard ML < 1185036518 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ehird`: it isn't verbose < 1185036524 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :oklofok, :) < 1185036530 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and of course you have the code as a nested list < 1185036531 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :oklofok, what about initialization optimizations < 1185036533 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :*optimization < 1185036546 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1185036552 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you mean stuff like constants? < 1185036556 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :they can be precalculated < 1185036559 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :of course < 1185036560 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :>+++<- at the start of the program makes e.g. the char tape[3000] be char tape[3000] = { 255, 3 }; < 1185036571 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :instead of tape[3000]; < 1185036640 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :well yes, of course < 1185036657 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :the only thing that can't completely be optimized is stuff where a part of a code uses a cell whose value isn't surely known at that point < 1185036691 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :so everything done before an input can trivially be encoded in the starting patterns < 1185036694 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :*pattern < 1185036746 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :you mean, things like >+++<->[code] is optimized as code not being conditional at all? < 1185036759 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i mean < 1185036761 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :at root level that is < 1185036769 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :a program that doesn't take input is optimized into it's result. < 1185036774 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :if you do compiling/optimizing. < 1185036781 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :no matter what that program is? < 1185036787 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :no < 1185036789 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :a factorial program with a fixed input would be evaluated at compile time? < 1185036794 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :that doesn't take input. < 1185036795 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1185036800 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :but that, at compile time, is insane < 1185036803 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :you're not writing a compiler < 1185036804 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :errr < 1185036806 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :okay... < 1185036818 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i see it as the best optimization possible. < 1185036819 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :you're writing an interpreter which sometimes delegates input to the code outputted by it < 1185036833 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :seriously, no compiler would run a whole factorial program and then just compile the result < 1185036846 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :well, i'm not talking about a compiler < 1185036855 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i'm talking about what you *can* optimize away < 1185036864 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i don't care about what's actually feasible < 1185036874 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :the "optimization" you have described has a name it's called interpretation :) < 1185036910 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :a-ha < 1185036914 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :interpretation really just optimizes source code into a more optimal form - it does a pretty good job, too - it produces output requiring no computation. :-) < 1185036924 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you can't compile, run, recompile because... you'd get scared? < 1185036935 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1185036965 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :if a code always produces the same input, the best optimization is to have it just return that input < 1185036972 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :... < 1185036973 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :output < 1185036974 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :sorry < 1185036995 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :Yes, and that falls under the subclass of optimizations known as "interpretation" < 1185037003 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :if you don't want to optimize that because of your ideology, that's fine < 1185037010 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but do not start bugging me about it :) < 1185037020 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :However, interpretation is generally not a good optimization for a compiler to perform, as compilers are designed to generate code which goes through the optimization process of interpretation < 1185037026 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :Doing it before the output defeats what a compiler is meant to do. < 1185037042 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i'm not bugging you :) just saying < 1185037042 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :aha, so you can't optimize constants < 1185037055 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you said you would like it to do that earlier < 1185037057 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :you can, because that is not interpretation in its strictest sense < 1185037064 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i'm not sure where we went a different way. < 1185037067 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :(Really, everything is interpretation. But, let's think of it stricter) < 1185037083 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :we went a different way when you said that all programs without input should be optimized fully to their output < 1185037089 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :because that is interpretation in its strictest sense :) < 1185037101 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i said that's how far you get in optimization < 1185037105 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :doing less is fine < 1185037113 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :it's just you can choose any level between 0...that < 1185037117 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :for optimization < 1185037156 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :any loop that always just the same thing can be optimized, that's the most basic idea of optimization, you can choose to optimize it away fully, or just optimize some of it < 1185037185 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i'm just saying there's nothing superturing about optimizing code that produces the same output every time < 1185037189 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and it's trivial < 1185037217 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :sure. < 1185037251 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i know you mean you want +++++(<- input there) [code to calculate f(x) for any x indicated by the number of +'s in the beginning] to actually just have the loop optimized < 1185037258 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :so that the first +'s could be changed < 1185037259 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :my definition of a very-highly-optimizing compiler is that it optimizes up to everything but complete interpretation - the point of a compiler, IMO, is to produce code which you can then apply that final optimization on < 1185037274 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and it would have the same functionality, just change it's first few bytes < 1185037284 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :this is impossible. < 1185037288 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you can't know which + < 1185037289 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :---- < 1185037300 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you can't know which +'s in the code are input hardcoded by the programmer. < 1185037309 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :so you can't optimize anything. < 1185037321 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and i know i'm not being clear :) < 1185037328 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :kl < 1185037332 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :optimization, is all about heuristics < 1185037353 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :true optimization - to make code completely "optimal" - is impossible. < 1185037396 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :yes, you can't optimize fully a code that can take infinite input < 1185037406 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i mean, any lenght input that happens to be given < 1185037424 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but you can always trivially optimize anything that does not take input < 1185037432 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :unless you have ideological problems with that < 1185037436 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :as you seem to have < 1185037440 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :nah < 1185037450 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i think our definition of input is mixed up < 1185037453 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i don't care about that stuff, i just care about the fact you can optimize a constant. < 1185037466 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :by input you also mean hardcoded input, i know < 1185037470 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i said that earlier < 1185037473 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :or was i wrong?= < 1185037479 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :there is a subtlety if your non-input taking expression doesn't terminate. < 1185037486 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :oerjan, exactly < 1185037493 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1185037495 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :compilation in code without errors should ALWAYS succeed < 1185037497 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :even if it doesn't halt. < 1185037507 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :sorry about that < 1185037523 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :if it doesn't terminate quickly, of course you can't optimize it < 1185037525 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :fully < 1185037532 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :define quickly < 1185037538 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1185037542 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :err < 1185037545 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1185037550 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :in a feasible time < 1185037554 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ACTION does the halting problem dance < 1185037558 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you define it when you make your optimizer. < 1185037604 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :also, there is a subtlety if the result is actually much larger than the expression creating it, and isn't always used. < 1185037607 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :anyway, i just meant constants, and a program taking no input can always be optimized into it's result if you have it's result < 1185037625 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :so i could have some code that takes hours to compile but less than a second to run < 1185037641 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: stop making points :) < 1185037661 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :also i could have code that, just because it takes a long time to execute, is denied optimization -- Oh a-ha! This can result in /different output for the same input on different machine specs/ < 1185037665 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :Which is fundamentally wrong < 1185037669 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: i am saying, partial evaluation is a well-known optimization technique but it has limits. < 1185037669 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ehird`: if it takes an hour to compile, it takes an hour to run < 1185037673 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :that's obvious < 1185037683 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: yes, but i didn't think of that < 1185037695 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :stop being cleverer than me, is my point :D < 1185037701 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :sure but i might want to have some sort of automatic build process so people working on something can test the code < 1185037708 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :if its run at build time they can't < 1185037736 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :huh? < 1185037747 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :anyway < 1185037783 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :though i was wrong about the fact you can always optimize a non input taking program, which i now find very very dumb, i was right in saying if you can do it, you should < 1185037786 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :what's so huh < 1185037797 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :a team of people are working on software A < 1185037800 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :of then you are just making a bad optimization for fun < 1185037805 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :they agree to each test each new release < 1185037822 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :so, automated program B compiles the new version of A, so that the team can test it (hint: it has a bug - it loops forever!) < 1185037826 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and of course, true, you shouldn't optimize if the output is very complex compared to the code < 1185037838 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :however the compilation process runs on the automated program, so each coder only gets the output produced < 1185037840 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :in whic case you just optimize some parts < 1185037841 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :they cannot test the software. < 1185037851 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :define "very complex compared to" < 1185037852 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: never! especially when i am having trouble with #haskellers outclevering me :) < 1185037857 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :in algorithms. < 1185037868 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: i'll become better then, okay? < 1185037874 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ehird`: longer. < 1185037888 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :define longer < 1185037901 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :len(code)>len(memory state) < 1185037913 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :is that: < 1185037925 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :code being the unoptimized code, memory state being after the run < 1185037929 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :string:length(compile(code)) > string:length(compile(memory state))? < 1185037950 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :if so, you could have some really complex code that doesn't get optimized just because of its output size -- this seems like a bad heuristic < 1185037966 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ehird`: so you want an optimization that's still possible to turn into the original brianfuck code? < 1185037977 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :(AND, of course, you get a longer compile time) < 1185037987 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :(Since it has to compile BOTH (running one segment of code that may be complex), THEN compare the results) < 1185037988 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i get thta impression from teams-working-on-something example < 1185037991 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :*that < 1185037999 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :(If it decides against optimizatin, then it has to execute AGAIN at run-time - zzzz snore) < 1185038032 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ehird`: compiling oughtta be fast? < 1185038038 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :relatively. < 1185038053 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :relative to what? < 1185038081 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :errr < 1185038114 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you mean if the original program runs T seconds, and the compiler runs U seconds, the resulting code must run <= T-U seconds? < 1185038124 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i can't think of another criteria < 1185038147 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1185038171 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i'm not sure where i got that impression, you never said anything about a criteria < 1185038215 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :anyway, i don't see how a compiler shouldn't try to run the code fully < 1185038241 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :because of speed < 1185038244 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :that's just silly. < 1185038274 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :well, then why compile at all? :) < 1185038281 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :? < 1185038290 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :to make the program faster? < 1185038308 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :the compiler runs once. < 1185038317 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :for one piece of code < 1185038341 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :if you do precompilation, of course you don't optimize even +++>--<++ < 1185038347 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :in the beginning of the program < 1185038357 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :it's faster just to execute one instruction at a time. < 1185038364 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :err < 1185038370 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i mean, if you do interpretation < 1185038378 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :s/precompilation/interpretation < 1185038395 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :if you interpret the code, then my arguments about this have been wrong < 1185038401 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but you were talking about compilation. < 1185038412 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :unless you have mixed the to concepts < 1185038414 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :*two < 1185038424 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :*confused the two concepts < 1185038543 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :no < 1185038555 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :anyway a compiler is an interpreter and an interpreter is a compiler. < 1185038578 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :a-ha < 1185038587 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :Wow, a BF compiler that warns if < and > aren't balanced... < 1185038606 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :errr < 1185038613 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :sounds like a sucky compiler :P < 1185038616 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :exactly :) < 1185038617 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :very lame < 1185038623 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :does one exist? < 1185038625 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you mean? < 1185038626 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :yep < 1185038629 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :http://home.arcor.de/partusch/html_en/bfd.html < 1185038629 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric ::\ < 1185038648 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :okay... well guess you often have them balanced < 1185038668 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but i'd prefer syntax highlighting for those loops that have them balanced < 1185038690 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :a stack in brainfuck is 1 (item 1) ... 0 isn't it? < 1185038708 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :errr < 1185038716 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :[1][1][1]...[0]? < 1185038719 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :no < 1185038725 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :[1][my item][1][my item][0] < 1185038733 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1185038740 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :and you navigate it with [>process item>], and push with [>>]+>(CALCULATE VALUE HERE) < 1185038747 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :(assuming you're on the starting 1) < 1185038758 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :well, you can't really ask "what a stack is in brainfuck", but yes, i've done stacks that way, usually < 1185038761 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :and pop with [>>]<<->(USE VALUE) < 1185038770 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :well, i meant what's a common, kinda-efficient way :) < 1185038793 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :yeah, then i'd say that < 1185038828 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :if you use multiple stacks, you might wanna have them interleaved < 1185038829 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :the initial 1, of course, is to seperate stacks < 1185038829 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :of course < 1185038837 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :so two stacks, non-interleaved is: < 1185038855 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :[1][item][1][item][0][1][item][1][item][0] < 1185038871 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1185038878 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :whereas [item][1][item][0][item][1][item][0] is ambigious, depending on where you start etc < 1185038898 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and a cell for index carrying if you do random access memory < 1185038901 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i mean... a vector < 1185038914 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :you mean, a "where I am"? < 1185038916 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :like < 1185038917 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :[1][value][for calculation][1][value][for calculation][1][value][for calculation][0] < 1185038922 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :oh, right < 1185038930 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :those are always 0 but can be played with < 1185038931 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :also < 1185038934 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :so like, you do all your destructive operations involving value in [for calculation] < 1185038935 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you can use the 1-cell for that < 1185038938 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :so as not to disturb it < 1185038943 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and then make it one after your calculation < 1185038956 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :(What if you need more cells? Sounds a bit silly... maybe there's a better way) < 1185038960 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :Well, i guess one cell is goodo < 1185038962 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :yes, but i just realized you can use the 1-cell for that < 1185038972 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :for calculation < 1185038974 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1185038979 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :unless you do brainfork < 1185038982 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :you mean, use the interspersing [1]s? < 1185038990 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :and then do [-]+ once you move it out of the way? < 1185039016 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :so, you pop off the stack, compute a little bit, move that barrier cell to the top of the stack, go to that cell, repeat < 1185039020 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :until you're done? < 1185039042 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :when you move into index n, you carry n with you and each time you go one cell right in you vector, you decrease n until it's zero and you have your value < 1185039056 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :*your vector < 1185039067 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :also pushing should be [>>][-]+>[-](CALCULATE VALUE), you ned the [-]s since popped values stay on the tape, just after the end marker < 1185039089 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1185039102 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i'll write a short doc explaining it < 1185039104 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :what i mean < 1185039109 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :err okily < 1185039137 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i was talking about a random access vector, not a stack < 1185039145 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :unless i wasn't clear about that < 1185039155 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :which i most likely wasn't < 1185039472 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :this describes the stack representation i was talking about: http://pastie.caboo.se/80941 < 1185039475 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :is it common? < 1185039910 0 :i--!n=i@201.80.222.99 JOIN :#esoteric < 1185039950 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric ::/ < 1185040003 0 :trepliev!i=trepliev@static-ip-62-75-255-125.inaddr.intergenia.de JOIN :#esoteric < 1185040033 0 :i--!unknown@unknown.invalid PART #esoteric :? < 1185040702 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :wait < 1185040794 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ehird`: you want a way to get the value out of the stack as well, in some cases < 1185040806 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :you mean, navigate to a specific element? < 1185040809 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i mean, a way to move it to the beginning of the stack < 1185040810 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :nope < 1185040813 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1185040814 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i give that < 1185040815 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :see the end < 1185040816 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1185040825 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :it's <<[<<], while on a boundry < 1185040828 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :sorry, i didn't actually read it thorough yet xD < 1185040836 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :or, >[<<] on a value < 1185040843 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :(Well, <<<[<<] is better, but meh) < 1185040845 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :You get the idea < 1185040845 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :errr < 1185040852 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you don't move it out of the stack < 1185040860 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i dont understand < 1185040885 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you must be able to be able to get the value from the top of the stack to somewhere completely other < 1185040895 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :use copy functions? < 1185040903 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :that's not part of the stack itself. < 1185040917 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i mean, traverse the stack down carrying the value < 1185040930 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :so that you get it *out of the stack* < 1185040990 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :that's a bit harder to do < 1185040992 0 :oerjan!unknown@unknown.invalid QUIT :"Dinner, probably" < 1185041005 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(but easy still) < 1185041180 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1185041204 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i used it when making my brainfuck-brainfuck interpreter < 1185041215 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i should finish that some day < 1185041220 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i was so close :\ < 1185041232 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :the interpreter i was making it with was just goddamn crappy < 1185041246 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :infinite loop -> crash, negative value -> crash < 1185041461 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :it was about two years ago and i was a total noob, so i'm not actually sure it would even be that much of a challenge < 1185041471 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :anyway, i'll follow oerjan's footsteps -> < 1185041489 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(or in them, if that's the way to say it in english) < 1185041572 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :hey wow i managed to design a non-esoteric functional language < 1185041573 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :that's a first < 1185041578 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :and it doesn't even look much like haskell! < 1185041671 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1185041738 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :cool < 1185041750 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(me too, numbda ;)) < 1185041775 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :numbda is esoteric :P < 1185041782 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :mine doesn't look as esoteric: http://pastie.caboo.se/80953 < 1185041785 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :though numbda wasn't really designed, it's a result of me starting to code. < 1185041867 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :(Also, f(x, y) is not a shortcut for f(x)(y) right now, although it is always equivilent. Thinking about adding va-args later.) < 1185041893 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :(Currying va-arg functions once you have already supplied enough args will require explicit curry(f, list) guess) < 1185041893 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ehird`: i'd say that looks quite a lot like haskell < 1185041900 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :oklofok, SML is closer :) < 1185041905 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :SML and Haskell look eerily similar < 1185041911 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but then again, haskell doesn't have a "look", really < 1185041913 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :(Hint: because haskell is inspired by SML) < 1185041928 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :oklofok, one major difference is how i always use f(x, y) instead of (f x y) < 1185041932 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i like it more that way < 1185041950 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :in oklotalk, those two parse as the same thing, but for a different reason :) < 1185041957 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1185041962 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :is that reason: < 1185041965 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :x,y -> x y < 1185041967 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :and (x) -> x < 1185041969 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :yes! < 1185041984 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and f x = f.call(x) < 1185041988 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :so f(x, y) is f (x , y), which has x y, so it's f x y < 1185042027 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(if f isn't a funcoken, that parses differently) < 1185042031 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :one of the advantages of my syntax is that there's no pesky left-associative-messing-around < 1185042045 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(but since objoken and funcoken are my own terms, you don't know what they are) < 1185042056 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :also, you don't need to do e.g. (*) to get the * function (because f * x is f times x, not f (function *) x)) < 1185042063 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :you can just do f(*, x) < 1185042073 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i think x * y binary operators will be `*`(x, y) < 1185042074 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :not sure < 1185042142 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i love how everything like that just arises from the underlying structure of oklotalk < 1185042148 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but i hate how i can't stop talking about it < 1185042153 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :why didn't i go eat? < 1185042163 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :really, i'm an irc-a-holic < 1185042171 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :can't live without irc-a-hole < 1185042189 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(i prefer holes over hols.) < 1185042203 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :now, me goes -> < 1185042209 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :heh, i think my language has been heavily influenced by merd: http://merd.sourceforge.net/ < 1185042216 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :it's very similar! < 1185042227 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :except my language has no "if" < 1185042343 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i had this idea for a language when speccing numbda < 1185042358 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :a language called yawn, for it's excessive laziness < 1185042372 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but i just have ideas for it < 1185042418 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(so basically i was just telling the name which is trying to be clever, you have fun with that...) < 1185042433 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(i should filter what i say) < 1185042438 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :did i go? < 1185042442 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :--------> < 1185042696 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Excessive laziness? < 1185042729 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :http://pastie.caboo.se/80960 i should write a spec for this, shouldn't I? < 1185042729 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: do you have an oklotalk spec anywhere? < 1185042737 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ihope, he only has a parsing spec. < 1185042772 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :ehird`: how do you curry that there? < 1185043521 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ihope, you just apply to not enough arguments < 1185043525 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :note product -> fold(*, 0) ; < 1185043557 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :if you want to do va-args, when i implement va-args, then you'd have to do curry(vaFunc, [my, curried, args]) < 1185043570 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :(same with default arguments) < 1185043911 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ihope: i was thinking there'd be two separate threads evaluating, one so lazy it evaluates nothing, and the other dependant on that < 1185043926 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i have some ideas on how to make that work < 1185043932 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Hmm... < 1185043934 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but not enough to be interesting to tell < 1185044328 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ihope, the idea for implementing my language is for it to be interpreted ONLY < 1185044331 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :well, most of the time < 1185044349 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :and to have a small C base, and as much possible written in the language itself (no matter how strained the low-level code might look in it) < 1185044375 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :then, another version of the base, written in the language itself - so if a compiler is ever written, you can have a self-hosted interpreter < 1185044397 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Where's a C spec? < 1185044573 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :? < 1185044581 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :you mean a spec of the C language? < 1185044584 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :if so, you'll have to pay < 1185044704 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :You have to pay to look at specifications? < 1185044737 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Okay then, where's a GCC C spec? :-P < 1185045145 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Or maybe I should compile for GHC if there's no reason to go with C instead. < 1185045223 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :gcc c spec doesn't exist < 1185045227 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :you have to pay iso to get the spec < 1185045233 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :how do you think standards agencies make their money < 1185045239 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :it costs $80 for C89, iirc < 1185045249 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :you COULD pirate it.. < 1185045261 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Why not just get the C Programming Language? < 1185045267 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :cause that's not a spec < 1185045276 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Why do you need a spec? :P < 1185045282 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :because ihope is compiling to c < 1185045293 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Err... so? < 1185045303 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Does he not know C, or something? < 1185045319 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Couldn't you rewrite a spec to get an equivalent spec not protected by anything? < 1185045323 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :You need a spec to reliably compile < 1185045330 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ihope, Yes, but it's a pain in the butt so nobody will < 1185045342 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :You don't want your compiler to produce invalid code in obscure circumstances. < 1185045449 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :http://pastie.caboo.se/80978 more examples! < 1185045451 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i need to write a spec. < 1185045628 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :the comments on 99-bottles-of-beer are almost as stupid as on youtube. http://99-bottles-of-beer.net/language-java-1162.html "Alex Mirchev That language is definatly java.. btw, why is your code so weird... it doesnt look like a correct syntax..." < 1185045702 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :Also: http://web.mit.edu/kenta/www/two/beer_i_m.html "Java is a machine independent compiler based on C++ which targets to pseudo-code." "Java Script Interpretive Java." grrrrr < 1185045740 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :ROFL wut? < 1185045823 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :some people r dum lol < 1185045874 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i didn't know there was a language called Microsoft Word xD < 1185045889 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i know the language, however < 1185045891 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :that's weird. < 1185046637 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :What's the usual way of making a language "system-complete"? < 1185046691 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :...as in being able to make all the operating system calls and such? < 1185046723 0 :atrapado!i=openfil@187.Red-81-47-13.staticIP.rima-tde.net JOIN :#esoteric < 1185046783 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :I guess I could reserve some identifier space for... I/O extentions. < 1185046832 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :write a primitive like syscall() in your target language, < 1185046835 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :wrap around it. < 1185046846 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :or, wrap around cstdlib or equiv. functions manually < 1185046853 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Or do one of those. < 1185047053 0 :Sgeo!n=Sgeo@ool-18bf68ca.dyn.optonline.net JOIN :#esoteric < 1185047712 0 :RodgerTheGreat!n=Rodger@wads-5-232-125.resnet.mtu.edu JOIN :#esoteric < 1185047727 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :hi guys < 1185047843 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :great, i was just looking for ya < 1185047848 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :*waiting < 1185048165 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :hi < 1185048504 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Why am I getting a NoSuchMethodError? < 1185048520 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :When the thing is obviously compiling correctly, and the method exists. < 1185048801 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :*Chirp chirp* < 1185048824 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :omg chick in my soup < 1185048832 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: i don't believe you. < 1185048870 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :? < 1185048887 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i think the compiler is more reliable than you < 1185048890 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :they tend to be quite < 1185048898 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :(about the method) < 1185048905 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :(and a bit about the chirp) < 1185048946 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Well, my top Emacs buffer is viewing the method *right* now so :P < 1185048987 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1185048994 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :then i guess you are both a bit crooked < 1185049138 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :... Thanks for the help? :D < 1185049200 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :hey, no problem, that's what i'm for < 1185049338 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: i can't really believe that can happen if you aren't doing something very very weird < 1185049382 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Well, I've been purposefully avoiding generics because I'm not sure if GCJ supports them. < 1185049413 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i see < 1185049414 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :So I've been doing a whole bunch of casts. < 1185049433 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i like looking at code and i know some java, so if you isolate the problem, i'd love to look ;) < 1185049699 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: GCJ? eep. Good luck debugging that thing's output. :S < 1185049791 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat: I'm using Sun's JVM right now. < 1185049870 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :oh. hunh. < 1185049879 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :GregorR: How's D for writing an emulator? < 1185049882 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I've never seen NoSuchMethodError. < 1185049894 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :GregorR: I need to use heavy pointer-foo and ASM, so. < 1185049898 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat: ... :P < 1185049901 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Well, shower time for me < 1185049904 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :sorry < 1185049908 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :. < 1185050831 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: D certainly gives you heavy pointer-foo and ASM if you want it. < 1185050896 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :my brother got the harry potter book, he's gone all spastic < 1185050987 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :bsmntbombdood: I head that pretty much everyone dies < 1185051001 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :he just screamed < 1185051011 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :? < 1185051029 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :my brother, he just screamed < 1185051049 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :yeah, that was more of a "why the fuck did he scream" question mark < 1185051071 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :GregorR: How's native D speed compared to C and C++ ? < 1185051078 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Now I'm really going to shower, heh. < 1185051088 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :(Before this was shower preparation :P) < 1185051108 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :lol < 1185051134 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: That sort of depends on how heavily you use the GC. You can choose to stop the GC and do manual deletion, in which case it's as fast. If you use the GC, it'll stop the world on occasion. That being said, the GC-stopping functions are in there for purposes exactly like emulators, so :P < 1185051844 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :what's the most noobish form of GC currently known? < 1185051845 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i.e. simplest. < 1185051863 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1185051879 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :a C programmer? :) < 1185052011 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1185052178 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :reference counting < 1185052207 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :super fast and super easy, but misses cycles < 1185052208 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Calling reference counting GC is an insult to GC :) < 1185052234 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :why? < 1185052335 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :reference counting works perfectly in languages without mutators < 1185052336 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :sometimes you can build garbage collection into the compiler around some complicated scoping rules < 1185052353 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :set-car! etc < 1185052420 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :GregorR: Yeah, I want to stop the GC. < 1185052463 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :GregorR: Got any good tutorials on it? < 1185052468 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :For a C/Java/Lisp/ST er? < 1185053175 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i mean non-referencecounting < 1185053187 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ref counting is simple but ineffective for e.g. circular objects < 1185054016 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I found an IBM model M! < 1185054033 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :some heathen was going to throw it away < 1185054041 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :tut tut < 1185054047 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :now I must find a USB adapter to plug this beauty into my mac < 1185054051 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ow < 1185054053 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :model ms are nice < 1185054055 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :but not for macs! < 1185054066 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :that's like, harsh dissonance in hardware form, man! < 1185054069 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :USB adapters exist < 1185054070 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1185054099 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :Model M + OSX: beautiful interface for your eyes, and beautiful interface for your hands. :D < 1185054840 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Circular objects... < 1185054854 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :ACTION ponders < 1185054865 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Yes, there's sort of failure there. < 1185054923 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :how come? < 1185055021 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Well, if an object contains a pointer to itself, but nothing else contains a pointer to it, the reference counter is still 1. < 1185055043 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ihope, Well duh < 1185055051 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :that's why ref counting is not usable < 1185055060 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :Python only uses it with hacks (circular detection) < 1185055075 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ihope: then there is a pointer to it, let the poor object be, he obviously wants to live < 1185055079 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :It's sort of like determining whether an object is supported based on whether there's something directly under it. Put something under itself, and boom, support. < 1185055086 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: :-P < 1185055123 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :bbl- food < 1185055124 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ihope: are you implying i'm not strong enough to lift myself in the air? < 1185055156 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :oklofok: don't jump; you'll get garbage collected. < 1185055187 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :who wants to help design an analog computer rube goldberg machine < 1185055204 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ehird`: been my plan for years :) < 1185055213 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :oklofok, then help design its fruitition :) < 1185055223 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i just somehow feel that can't be made over irc :) < 1185055228 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :design, sure < 1185055231 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :it can be designed over the internet < 1185055239 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :boolfuck! < 1185055240 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :plus final plans can be made and a guide to make your own < 1185055346 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i'm kinda sleepy < 1185055353 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1185055353 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :wonder if i should sleep < 1185055360 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :noooo! sleep is useless! < 1185055361 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1185055368 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :true, it's the cousin of death < 1185055569 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i do know for sure i should either do something or sleep < 1185055571 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :not idle here. < 1185055581 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :staring at the screen... < 1185055588 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :hmm, gonna go buy something < 1185055590 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :-------> < 1185055800 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Model M == love. < 1185055817 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :hmm, how useful would a computer with a tape of 6 two-state cells be? < 1185055821 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i imagine not useful for actual computation < 1185055828 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat: You need an expensive one, by the way. < 1185055841 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :(assuming a programming language something like a highly simplified boolfuck) < 1185055850 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :GregorR: So? Tutorial? < 1185055880 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :ehird`: If you can prove that it's Turing Complete, then you can do anything in it ;) < 1185055957 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :well obviously 6 two-state cells isn't TC < 1185055966 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :but is it enough to perform some simple calculations? < 1185055968 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :well, i guess not < 1185055973 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :bitxtreme is tc < 1185055974 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :since, you can't store many numbers for one < 1185055978 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :no it isn't < 1185055980 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :why wouldn't that be < 1185055982 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :oh yeah it is < 1185055987 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :didn't ya read it's homepage!? < 1185055996 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :you're joking right < 1185056001 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :because that TC claim is a joke by the author < 1185056004 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :err, yes < 1185056010 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ok good :P < 1185056016 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i'm considering 6 0-9 cells < 1185056020 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :that'd be a bit more useful < 1185056026 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :errr..... don't think so :| < 1185056030 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :bit's are nicer < 1185056031 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :just a little bit :P < 1185056037 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :maybe i could squeeze up to MAX 20 0-9 cells < 1185056039 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :hihi bit < 1185056049 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :that should be useful for, i dunno, adding two small numbers together < 1185056059 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :well, you want the memory to be easily extendable < 1185056069 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :so you can make it tc when you get an infinite universe < 1185056085 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ehird`: still easier to do base-2. < 1185056091 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i mean, subtraction < 1185056096 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and addition < 1185056100 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(same thing) < 1185056126 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :yeah but 20 0-9s offer more computing potential than 20 0-1s < 1185056143 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but you can make 100 0 < 1185056144 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :... < 1185056155 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but you can make 100 0-1's easier than 20 0-9's < 1185056172 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and you can actually make them calculate stuff without doing something very incredibly hard < 1185056200 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :well, 100 0-1's will be hard this IS a rube goldberg machine < 1185056220 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1185056223 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i mean, i have to incorporate tennis balls as a main part - making 100 binary registers will not exactly be easy/fun < 1185056231 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1185056241 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :you think a 0-9 is even possible, then? < 1185056246 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i do not. < 1185056251 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :they made a difference engine in lego.. < 1185056274 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :does that use 10 base for other than output? < 1185056277 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i doubt it < 1185056284 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but i didn't understand the pic, so... < 1185056304 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :anyway, wtf am i still doing here? -----> < 1185056305 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :well my registers will be primarily output i guess < 1185056314 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :err < 1185056315 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1185056319 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :maybe, 10 output, 10 data < 1185056320 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but... 2-base < 1185056322 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :think about it < 1185056326 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :;) < 1185056327 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :----> < 1185056356 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :10 base-2 data cells give me only 1024 combinations of state... < 1185056374 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :10 base-10 data cells give me 10000000000. < 1185056407 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but a 10-base one cannot be used for computation, too complicated < 1185056414 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :now ----- < 1185056416 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :---> < 1185056420 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(for real this time) < 1185056429 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :it can be used for computation, albiet not too simply < 1185056455 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :though base-2 is easier, as i just need a switch < 1185056474 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :20 switches = 1048576 states, which is good < 1185056504 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :then 10 base-10 output displays. < 1185056624 0 :atrapado!unknown@unknown.invalid QUIT :"zadflksdg sh fhjd" < 1185056858 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :The structs in D are so ... easy. < 1185056861 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :It's like ... cheating. < 1185056980 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :how are they not easy in C? < 1185057028 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Well, there are stuff you get used to like wrapping stuff in structs for type checking, or doing union/struct combos and such. < 1185057042 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :And this new named-struct assignment thinger is waaay cheap. < 1185057053 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Whatever happened to programmer skill? :| < 1185057417 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: invent a worse language and use that one? < 1185057444 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :lol < 1185057578 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :D is fun, but sometimes lame < 1185057602 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :GregorR: I'm concerned about all the stuff D takes care of for you. < 1185057609 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :How's the performance hit from that? < 1185057620 0 :sebbu!unknown@unknown.invalid QUIT :"@+" < 1185057631 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Well, everything it "takes care of for you" you have to ask for except for GC> < 1185057631 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: i don't think anything else than gc really affects anything < 1185057648 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Wow. Really? < 1185057654 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :I... don't ... believe you. < 1185057658 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1185057658 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Thinks like dynamic array concatenation et cetera involve a malloc, but you pretty much have to ask for it. < 1185057663 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi, well, the runtime type system < 1185057665 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :but.. < 1185057668 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Yeah, there we are GregorR. < 1185057678 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Most of emulator stuff won't even deal with string concatenation and all. < 1185057688 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :It's just that, OOP is a godsend with that sorta stuff. < 1185057688 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Doing type-checking is a fairly quick lookup into the vptr, I've never seen /anyone/ complain about the speed there. < 1185057694 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Plus, you can just compile with -release to get rid of that. < 1185057717 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :[That is, once you're sure that you're not doing anything stupid in runtime type checking, just use -release and it all assumes it's OK] < 1185057725 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :it's constant time usually, that's like a negative number clock cycles < 1185057732 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :*of < 1185057738 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :What's this delegate stuff? < 1185057791 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :So will -release compile out the dynamic array stuff? < 1185057804 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Or is there a little marker you can give static arrays? < 1185057847 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :And lastly, how do you interface with ASM code? < 1185057898 0 :oerjan!n=oerjan@hagbart.nvg.ntnu.no JOIN :#esoteric < 1185057916 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :suifur: Uh, the dynamic array stuff can't be compiled out .. < 1185057917 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Erm < 1185057920 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: [above] < 1185057926 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: But it will compile out the bounds-checking of it. < 1185057947 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: As per interfacing with ASM, see http://www.digitalmars.com/d/1.0/iasm.html < 1185057961 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :When was the last time suifur even talked? :D < 1185057973 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Damn you tab-completion! :P < 1185058088 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :use a better client < 1185058107 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :one that uses last-talked order for tab completion < 1185058155 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Yeah. < 1185058193 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :a generic tab completion would be nice < 1185058205 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :last word used beginning with what you typed < 1185058218 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :l+tab=last < 1185058236 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :(not useful, nice) < 1185058313 0 :pikhq!n=pikhq@c-75-70-43-34.hsd1.co.comcast.net JOIN :#esoteric < 1185058377 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :how about just < 1185058379 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :=last < 1185058384 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :e.g. < 1185058387 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :hello, ! < 1185058390 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :or yes < 1185058395 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :two button irc client < 1185058401 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :great < 1185058410 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1185058416 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric : = last speaker < 1185058416 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :some text editors and word proccessors have tab completion of all words in their spellcheck database or previously typed < 1185058443 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :cool < 1185058450 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :good for them < 1185058457 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :wish i could do that < 1185058844 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Grrr. NoSuchMethodError!!! < 1185059307 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :this still java? < 1185059330 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :i thought java methods were looked up at compile time < 1185059455 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: sprinkle your code with assertions. < 1185059494 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :bsmntbombdood, the compiler uses exceptions as errors < 1185059536 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: i thought you were java-fu < 1185059560 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :java boy can't even code java! < 1185059653 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :well, java folks CAN'T code java < 1185059655 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :nobody can < 1185059658 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :really. :) < 1185059835 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :bsmntbombdood: Didn't I say that I'm a C coder? < 1185059839 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :ACTION CTCP TIMEs himself because he doesn't feel like double-clicking the clock < 1185059840 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Primarily. < 1185059851 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :(I mean, when it comes to static languages.) < 1185059864 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Well, I've found out the error ... and it's ... weird. < 1185059948 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :ihope, did it for you. < 1185059952 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :now you can be even more lazy :) < 1185059964 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric ::-) < 1185059993 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Though my client tosses CTCP requests. < 1185060005 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :data LCTerm = Var Label | Apply LCTerm LCTerm | Lambda Label LCTerm; data SKITerm = Apply SKITerm SKITerm | S | K | I < 1185060014 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :(Never mind the fact that I used "Apply" twice.) < 1185060040 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Now, continuations would probably help in compiling from LCTerm to SKITerm, though I'm not sure just how. < 1185060113 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :cannot imagine why. < 1185060119 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1185060126 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :there's a binary clock but no hexadecimal clock < 1185060128 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :somebody fix that < 1185060138 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Maybe delimited continuations. < 1185060140 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :compile (Apply t1 t2) = do t1' <- compile t1; t2' <- compile t2; return (Apply t1' t2 < 1185060154 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :...gah, left off the last two characters? < 1185060157 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :compile (Apply t1 t2) = do t1' <- compile t1; t2' <- compile t2; return (Apply t1' t2') < 1185060177 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :compile (Lambda l t1) = do t1' <- compile t1; return (Apply K t1') < 1185060178 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i think you are just reinventing hsakell < 1185060181 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :actually, you want an intermediate format that includes Vars. < 1185060193 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :+SKI < 1185060206 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :ehird`: writing something in Haskell is reinventing Haskell? < 1185060212 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :...oh < 1185060220 0 :ehird`!unknown@unknown.invalid PRIVMSG #esoteric :i thought you were still going on about your language :P < 1185060258 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :abstraction elimination is just simple recursion if you have vars on both sides. < 1185060282 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :I may be able to come up with a clever way of doing this. < 1185060358 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :compile (Var l) should somehow look for the corresponding compile (Lambda l t1) and... do something with it. < 1185060379 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i'd like to do D but i can't install the compiler < 1185060386 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :these computers are so hard to use :\ < 1185060392 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :you _don't_ want to consider more than one variable at one time. Trust me. < 1185060430 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Can you prove there's no really clever way of doing this? :-P < 1185060439 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :oklobot: Wanna help with an NES emulator? < 1185060451 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :of course not. But having a common data structure makes it so much simpler. < 1185060544 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: you mean oerjan or me? < 1185060553 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i wanna help, oerjan can help. < 1185060570 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i haven't done D but it looks awesome < 1185060574 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :among other things, you want to give the result of translating a sublambda _back_ into the simplification of the outer ones < 1185060584 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Hmm. Somehow, my mind read that as oerjan: you mean ihope or me? < 1185060585 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :someone install me the compiler and tell me how to use it :) < 1185060617 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :That makes sense as long as Sukoshi said "oerjan: Wanna help with an NES emulator?" < 1185060638 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Well, I don't have much to lose by trying to come up with a clever way of doing this. < 1185060641 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :err... you sure it would make sense then? < 1185060650 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1185060654 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :it would < 1185060657 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :ssh < 1185060660 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :which means that needs to be in the intersection of the before and after formats < 1185060723 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :now if you want to be _clever_, come up with an algorithm which doesn't grow exponentially as you nest lambdas. < 1185060907 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Hmm, I think cleverness is coming vaguely... < 1185060910 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :is that possible? < 1185060929 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :yes, although the initial overhead is greater. < 1185060969 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :you can pass a list of variables to look up in < 1185060998 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :it resembles deBruijn notation... < 1185061037 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Hmm, contexts... < 1185061086 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i am sure you could even do binary lookup somehow. < 1185061109 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :ACTION is home. . . :D < 1185061117 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :(logarithmic growth but horrible overhead, i guess) < 1185061128 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :you can always do the naive algorithm but then reduce afterwards < 1185061172 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :might be easier to choose while you still have lambdas to analyze < 1185061187 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Hmm, a monadic hole... < 1185061200 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Yes, you, oklofok. < 1185061221 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :I've found a Microsoft way to fix this error. < 1185061247 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :...a monadic version of LCTerm that can have holes in it? < 1185061267 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric : /* For some reason, the Hashtable contains an extra null element that is useless. When returning number of entries, decrease Hashtable entries by 1 */ < 1185061296 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :;P < 1185061311 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Hey, it works. < 1185061314 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ihope: zippers! < 1185061327 0 :bsmntbombdood!unknown@unknown.invalid PRIVMSG #esoteric :clothepins? < 1185061331 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Zippers are what I'm reminded of, yes... < 1185061357 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :although zippers with several holes are far more complicated < 1185061361 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: Call it a null-terminated Hashtable. :p < 1185061370 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :;D < 1185061376 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :But so far, I don't think this actually has anything to do with zippers. < 1185061392 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i think Oleg (TM) has done a tiny bit on it. < 1185061394 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :But because I want to deliver this code, I think I will do exactly that and do some more heuristics later. < 1185061423 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: i do want to help. < 1185061434 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :oklobot: Yay. < 1185061440 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :oklobot: How much ASM do you know? < 1185061440 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :NES emulator? that gamie thing < 1185061444 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :nintendo < 1185061451 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Cool, we're butchering trademarks... < 1185061452 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i know a lot of theory. < 1185061466 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i haven't written a line of assembly since i never got a compiler set up :) < 1185061471 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :and vincenz in #haskell was doing something the other day < 1185061478 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :If I wanted theory, I'd use Haskell, not ASM :D < 1185061488 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i know a lot of theory about asm < 1185061496 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Why are you doing stuff in ASM? < 1185061498 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Phaw. Be an engineer. Just Do It. < 1185061502 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :hehe < 1185061512 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: Because this is practice for a GBA emulator I plan to fork from VBA. < 1185061514 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: asm is love < 1185061517 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :err < 1185061519 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :and that. < 1185061519 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Because the Linux VBA is bleh. < 1185061531 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Ah. < 1185061537 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Good reason. < 1185061548 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :ACTION is an ASM amateur < 1185061563 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :If you have a brain, and can imagine stacks and registers... it shouldn't be too hard. < 1185061577 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i've read a few books about asm, and an inter processor manual or something half-way through < 1185061588 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Grr. Do more practice :P < 1185061594 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :hehe :) < 1185061607 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :really, i just didn't get tasm and masm to work < 1185061632 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :installing programs is reeeeal hard < 1185061636 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(i'll retry now) < 1185061659 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i have nasm and masm on my hd < 1185061661 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :it seems < 1185061676 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :Figs i think did some assembly... or who was it < 1185061684 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :perhaps him < 1185061695 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Uhh... < 1185061698 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :NASM we use. < 1185061752 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :hmm < 1185061753 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :actually < 1185061755 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :What makes me happy is that what I'm trying to do would probably be entirely non-obvious without monads :-) < 1185061765 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i recall making a program play random sounds with the pc beeper < 1185061769 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :but i didn't know asm then < 1185061771 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i was like 12 < 1185061779 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :(with asm that is) < 1185061802 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :that's all i ever made with it < 1185061813 0 :Sukoshi!unknown@unknown.invalid PRIVMSG #esoteric :Then grab a good tutorial around, and play with it. < 1185061833 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :good idea < 1185061835 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i'll do that now < 1185061929 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :uh you gotta love assembly < 1185061945 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :grab a tutorial, try the hello world program, get 7 errors <3 < 1185062046 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ihope: with monads, you can make it entirely incomprehensible! :D < 1185062052 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :Sukoshi: isn't making a NES emulator rather huge a challenge? < 1185062066 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: :-P < 1185062074 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :though i agree those are the best ones < 1185062107 0 :ihope!unknown@unknown.invalid PRIVMSG #esoteric :Indeed, Haskell is probably capable of writing extremely short stuff that doesn't make any sense at all until you've thought it over a few days. < 1185062170 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :i love it how i can just skip @ anywhere in a tutorial, see immediately what's happening and rememeber reading about how that's done (the basic bit and jmp fun i mean), but i have absolutely no idea how to make a "Hello world" program < 1185062186 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :*rememeber < 1185062188 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :*rememeber < 1185062190 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :... < 1185062197 0 :oklofok!unknown@unknown.invalid PRIVMSG #esoteric :rememeber, yes. < 1185062314 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :what you say three times is true