< 1167439896 0 :ivan`_!n=ivan`@wikipedia/ivan JOIN :#esoteric < 1167440589 0 :bsmntbombdood!n=gavin@abacus.kwzs.be JOIN :#esoteric < 1167440963 0 :ivan`!unknown@unknown.invalid QUIT :Connection timed out < 1167440964 0 :ivan`_!unknown@unknown.invalid NICK :ivan` < 1167442268 0 :tgwizard!unknown@unknown.invalid QUIT :Remote closed the connection < 1167445577 0 :jix_!unknown@unknown.invalid QUIT :"Bitte waehlen Sie eine Beerdigungnachricht" < 1167448041 0 :RodgerTheGreat!n=Rodger@c-68-42-107-2.hsd1.mi.comcast.net JOIN :#esoteric < 1167448057 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :howdy, everyone < 1167448066 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :vcnbv < 1167448067 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :;'kl;k' < 1167448069 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :l' < 1167448070 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :k < 1167448086 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :nice to see you too, CakeProphet < 1167448088 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION made a semi-broken Lisp-like list constructor in Glass. < 1167448103 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :howdy. < 1167448106 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and an incomplete BF interpreter. < 1167448106 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :interesting < 1167448147 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :http://esolangs.org/wiki/User:CakeProphet#Glass_stuff < 1167448179 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :The con glass works fine (although I haven't tested the iter method yet) < 1167448187 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but List doesn't work right yet. < 1167448196 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :++++++++++>,<[>.,<-] | World's stupidest Brainfuck program. < 1167448197 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Wheee. < 1167448300 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :a 10-character cat command? < 1167448311 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Yup. < 1167448323 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Actually < 1167448324 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Stupid, no? < 1167448337 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!bf +. < 1167448340 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric : < 1167448343 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Is probably worse. < 1167448354 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :or even just... < 1167448357 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!bf . < 1167448363 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :My program at least indicates some knowledge of Brainfuck. < 1167448371 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :-.- < 1167448374 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Thus... less stupid. < 1167448377 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!bf -.- < 1167448380 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :ÿ < 1167448381 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :haha < 1167448387 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I always thought the most stupid BF program was "[]", because it's what n00bs assume will i-loop an interpreter < 1167448398 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :they always forget the + < 1167448399 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :It's not even a quine. < 1167448403 0 :cmeme!unknown@unknown.invalid QUIT :"Client terminated by server" < 1167448404 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!bf < 1167448407 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :I WIN! < 1167448414 0 :cmeme!n=cmeme@boa.b9.com JOIN :#esoteric < 1167448417 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... has anyone done a quine in BF? < 1167448423 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Several. < 1167448424 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :the null program isn't all that special in BF < 1167448424 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :that's not huge... and is something I would understand? < 1167448449 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :most quines end up being rather brute-force, but the basic design is simple < 1167448474 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :you need the source of your program stored in an encoded form and a decoder stub < 1167448494 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :the stub will print out the encoded form and then the unencoded form (itself) < 1167448500 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :bingo- quine < 1167448502 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :http://esoteric.sange.fi/brainfuck/bf-source/quine/quine410_with_comments.b < 1167448503 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric ::D < 1167448521 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :print (lambda x:x%x)("print (lambda x:x%%x)(%r)") is one of the coolest quines ever. < 1167448544 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :wow- that's pretty readable < 1167448551 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :That's the commented version. < 1167448556 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :kudos to the guy who wrote that one < 1167448566 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :clarity in BF takes some skill < 1167448680 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!bf ;+++++++++++++. < 1167448682 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric : < 1167448686 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!ps < 1167448688 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :2 CakeProphet: ps < 1167448696 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!bf ,+++++++++++++. < 1167448699 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!ps < 1167448703 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :2 CakeProphet: bf < 1167448703 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!bf ] < 1167448704 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :3 CakeProphet: ps < 1167448718 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 A < 1167448722 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :N < 1167448728 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hehehe... ROT13 < 1167448798 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!bf +[,+++++++++++++.[-]+] < 1167448804 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 Hello < 1167448812 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!ps < 1167448816 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :2 CakeProphet: bf < 1167448818 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :3 CakeProphet: ps < 1167448824 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 B < 1167448847 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :>.< < 1167448851 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!kill 2 < 1167448854 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Uryy|O < 1167448857 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Process 2 killed. < 1167448859 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ooooh < 1167448864 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Didn't give a newline. ;) < 1167448879 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Thought it just spouted output on the spot. < 1167448882 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but it buffers it. < 1167448904 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!bf +[,+++++++++++++.[-]+] < 1167448912 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 a < 1167448913 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 b < 1167448915 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 b < 1167448916 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 a < 1167448918 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 \n < 1167448918 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!kill 2 < 1167448920 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :noon < 1167448923 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Process 2 killed. < 1167448923 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :.... < 1167448945 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!bf +[,+++++++++++++.[-]+] < 1167448948 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 a < 1167448950 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 b < 1167448952 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!i noon < 1167448952 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 b < 1167448958 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :...oh < 1167448963 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 noon < 1167448972 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 \n < 1167448973 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :I don't think it works fully. < 1167448977 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!kill 2 < 1167448980 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :noo{||{- < 1167448982 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Process 2 killed. < 1167448984 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :haha < 1167448984 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :wait, when did gregor decide to bring back EgoBot? < 1167448994 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!bf +[,+++++++++++++.[-]+] < 1167448998 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 a < 1167449000 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 b < 1167449003 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 b < 1167449007 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 o < 1167449011 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 \n < 1167449018 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :>.> < 1167449031 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!kill 2 < 1167449032 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :noo| < 1167449034 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Process 2 killed. < 1167449037 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric ::( < 1167449051 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :But yeah... it's a crude ROT13 < 1167449055 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :otherwise that would have said "noob" < 1167449063 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :it doesn't wrap at the end. < 1167449289 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... < 1167449296 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :so... I've been working on my IRP iterating quine. < 1167449303 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :so here's a test run: < 1167449308 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Could someone please ask someone to repeat this request? < 1167449329 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Could someone please repeat the previous request? < 1167449342 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :"Could someone please ask someone to repeat this request?" < 1167449346 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :NOOB < 1167449348 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :NO QUOTES < 1167449362 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION adds to the wiki < 1167449383 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :ERROR 8: DON'T_BE_A_DOUCHE_TO_YOUR_INTERPRETER ERROR < 1167449385 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :with someone like "as you can see, the results are not always accurate" or something. < 1167449418 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :or I can just... strip the quotes and pretend the run went successfully. < 1167449473 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1167449480 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :ERROR 9: THE INTERPRETER DOESN'T EXECUTE THE LANGUAGE < 1167449535 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :the only real problem with a quine in this format is that it could easily lead to infinite recursion, until the interpreters get bored. You might want to add a clause for that < 1167449543 0 :digital_me!n=william@209-234-165-2.static.twtelecom.net JOIN :#esoteric < 1167449551 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :hi < 1167449551 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :That'd be SIGKILL. < 1167449771 0 :ihope_!unknown@unknown.invalid QUIT :Connection timed out < 1167449841 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :IRP isn't Turing complete because it consists entirely of undefined behavior. < 1167449855 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Nothing in the specification guarantees the a defined result. < 1167449945 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :It's occasionally Turing complete, but that's just out of sheer luck. < 1167450014 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!help < 1167450017 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon < 1167450018 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 < 1167450027 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I'm going to assume that Turing-completeness requires a certain degree of reliability, because it deals with solving computable problems in a finite amount of time < 1167450057 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!daemon bf irp ,[.,] < 1167450060 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Huh? < 1167450065 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Grr. < 1167450066 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :One of the requirements for Turing completeness is well-defined behavior. < 1167450068 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!help daemon < 1167450070 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Use: daemon Function: start a daemon process. < 1167450075 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :there you go < 1167450083 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!daemon irp bf ,[.,] < 1167450090 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :EgoBot now does IRP. < 1167450106 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!irp Please say "Hello, world!" < 1167450120 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!irp \n < 1167450121 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION has some weird Python classes that implement various forms of the computational classes. < 1167450121 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :XD < 1167450126 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :as they're formally defined. < 1167450131 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :perhaps IRP would benefit from the use of legalese, it being a more precisely defined form of English < 1167450155 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :The problem isn't undefined input. < 1167450159 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :it's undefined output. < 1167450168 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :The interpreter can choose to output what it wishes. < 1167450188 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :which makes IRP intelligent... but not very Turing machiney. < 1167450194 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :my point was that a more precisely defined program would at least make some progress toward predictable output < 1167450203 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :true < 1167450205 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :IRP would benefit from gnomes that smack bad interpreters. < 1167450213 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Yes. < 1167450244 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :or like... ops that kickban interpreters for "not adhering to the specification". < 1167450254 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1167450287 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :Ah yes, the Merriam-Webster IRP spec. < 1167450290 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Maybe... such interpreters just simply aren't adhering to the specification of the language.... which (should) state that output MUST be performed exactly as requested. < 1167450290 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :I've got a good idea. < 1167450293 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :#irp. < 1167450305 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :discussion about the irp language? < 1167450347 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :But is IRP truly esoteric? < 1167450356 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :No, for a controlled region where IRP may be interpreted. < 1167450386 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Hmmm... I want to build a genetic programming language. < 1167450405 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Are there any that I could take as an example? < 1167450488 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Ideas for #irp policies? < 1167450560 0 :tokigun!unknown@unknown.invalid PRIVMSG #esoteric :how about limiting maximum depth of execution stack? < 1167450583 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :that's stupid. < 1167450590 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :our stack should be HUGE-ABLE < 1167450609 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Send me suggestions; I'll write up an IRP#irp spec and set of policies. < 1167450636 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :perhaps some sort of certification system to confirm the reliability of interpreter nodes < 1167450668 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :I prefer a kicking system to remove unreliable nodes. < 1167450714 0 :ihope_!n=foo@cpe-071-075-186-016.carolina.res.rr.com JOIN :#esoteric < 1167450728 0 :ihope_!unknown@unknown.invalid NICK :ihope < 1167450853 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION demands an example of a genetic/natural-selection-ish programming language. < 1167450914 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :well, I've been working on one primarily based around self-modifying code- it's kinda the same base idea < 1167451022 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm.... maybe object-oriented? < 1167451036 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :a "species"... which is basically a class. < 1167451050 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :with some other base data structures. < 1167451058 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... self-modifying seems interesting. < 1167451133 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :inheritane would be like creating a genus, phylum, etc. < 1167451174 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmm... I don't like the sound of that. < 1167451176 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but.. eh. < 1167451210 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :the approach I took was to make a command that can execute a string as a subroutine. Thus, you can treat strings as functions. Since the functions can be changed by other functions (or themselves), you have a powerful recursive programming language on your hands < 1167451220 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Sounds like Redcode. < 1167451267 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :redcode is essentially assembly with entirely relative addressing. And yes, it's a good language for genetic programming < 1167451286 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :And it's self-modifying. < 1167451326 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1167451350 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :redcode has a way of creating wonderfully elegant code. < 1167451355 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :MOV 0,1 < 1167451368 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I wonder if the imp can be considered a quine? < 1167451376 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Not really. < 1167451395 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :The binary version could be, though. < 1167451599 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oooh... < 1167451604 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :string functions... that's cool. < 1167451642 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :so like... each character reacts differently to other characters in other functions or something? < 1167451719 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :kinda < 1167451881 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :the basic idea is that everything is built around a stack- you push some parameters, then a reference to a function, and then do an "execute string" call. The function runs, with it's parameters sitting on the stack. If the contents of the string being used as a function is changed before it's "called" again, it may do something completely (or subtly) different < 1167451883 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION will expand on his object-oriented idea. < 1167451903 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :stack-based? < 1167451910 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1167451916 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Like how Glass does functions -nod- < 1167451934 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :it seemed like the simplest way to make function calls. < 1167451939 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oooh. < 1167451950 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :The function call can be altered mid-execution? < 1167451953 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I didn't realize that was how glass worked... heh < 1167451966 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Well.. the parameters are sitting on the stack. < 1167451980 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :well, I hadn't planned on that initially, but it's an interesting idea < 1167451985 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION nods. < 1167452002 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :it might make it needlessly tricky to do self-modyfying recursion, though < 1167452118 0 :ihope!unknown@unknown.invalid QUIT :Connection timed out < 1167452203 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_e)I! (_o)O! (_e)i.(_o)o.?]} < 1167452217 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 Lol cat < 1167452226 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :... >.< < 1167452231 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oooh < 1167452241 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_e)I! (_o)O! (_e)i.?(_o)o.?]} < 1167452246 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 Lol cat < 1167452249 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :? < 1167452266 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :should be a cat program. -.- < 1167452270 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!ps < 1167452282 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :or... EgoBot isn't here? < 1167452298 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :perhaps it broke again < 1167452306 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :How to fix?? < 1167452320 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I could summon my bot, but it only speaks brainfuck and doublefuck. < 1167452349 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Well... everything in Glass runs on a global stack... so function calls are basically the same as copying and pasting the functions code where the wall is... < 1167452374 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1167452379 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and since the language allows you to access data based on its location on the stack... functions can access the last bits of data on the stack and manipulate them like parameters < 1167452427 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :It fits with the rest of the languages syntax... being postfix and all. < 1167452543 0 :ihope_!n=foo@cpe-071-075-186-016.carolina.res.rr.com JOIN :#esoteric < 1167452557 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION hits EgoBot with a hammer. < 1167452564 0 :ihope_!unknown@unknown.invalid NICK :ihope < 1167452565 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric ::( < 1167452572 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I thought my best idea for my language was the datatype- everything is a string, and operators you'd expect to work with numbers deal with the first char in the top string. That way, everything on the stack can have the same type and you can use it for both math and function calls easily < 1167452587 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :is egobot broken, gregor? < 1167452592 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Yeah... I would have never thought of it. < 1167452596 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Idonno, maybe? :P < 1167452607 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :string == function WTFerror < 1167452612 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1167452620 0 :EgoBot!unknown@unknown.invalid QUIT :Read error: 54 (Connection reset by peer) < 1167452621 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... < 1167452624 0 :EgoBot!n=EgoBot@c-24-22-56-63.hsd1.or.comcast.net JOIN :#esoteric < 1167452626 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :maybe linked lists as functions? < 1167452646 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :it would be like strings... except higher-up... < 1167452656 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :!undaemon cat < 1167452666 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :well, my earlier idea was to represent functions as stacks of characters, but it's not functionally all that different from a string depending on how your operators work < 1167452667 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :instead of characters you have elements. < 1167452694 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :yeah... it wouldn't be that different. < 1167452727 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Glass is kinda like that... since each character means something different. < 1167452733 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but not -everything- is an item on a stack. < 1167452733 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :I ask you, television commercial, how do you dent your car when crashing into a tent? < 1167452761 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :the concept is different. < 1167452844 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... I've considered doing a queue-based language... or a deque-based lanauge (which is basically a cross between a stack-based language and a queue-based language) < 1167452861 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :double-ended queues are essentially stack-ques. < 1167452863 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :queues < 1167452868 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :...meh < 1167452926 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :set-based language as well. :D < 1167452937 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :lol- I remember hearing stories about a CS professor that insisted "deque" was pronounced "deck" < 1167452960 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I prenounce it "deek" < 1167452971 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :or just... don't pronounce it at all. < 1167452978 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :it's "Dee-kyoo" < 1167452988 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :that's how I originally pronounced it. < 1167452993 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but that's like dequeue < 1167453000 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :exactly < 1167453044 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... wonder if you could combined a set with a queue. < 1167453061 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :even though... the definition of a set specifically states "a collection of unordered elemenets" < 1167453084 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :which makes storing code a bit problematic < 1167453094 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hehe < 1167453109 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :associative-array-based language? < 1167453115 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :ooo... how about a language based around my favorite data structure? Hashes. < 1167453123 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Most popular languages can be described as a stack and a hash table of some sort. < 1167453126 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :... < 1167453127 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Suicide-note based language. < 1167453128 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :man, we're on the same wavelength < 1167453141 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hashes are pretty awesome. < 1167453152 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :GregorR: Destructive-Execute programming? :) < 1167453155 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Lua's base data-type is a hash (called a "table") < 1167453169 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :like cons in Lisp. < 1167453196 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... it would be interesting to remove the stack from the picture... and just use -only- hash. < 1167453218 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but if you did it wrong... it would just be a series of variable assignments. < 1167453321 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Plof's only stack is a stack of hashes (the scope) < 1167453350 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :object oriented is something like a hash-based system. < 1167453365 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I was thinking about it a while back, and I think you could build a UTM out of nothing but LET statements and computed GOTOs in BASIC < 1167453380 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :since objects are typically just a hash with some rules for accessing a different hash when nessicary. < 1167453412 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :of course, that idea is really a natural consequence of the Z3 turing-completeness proof < 1167453445 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :(while-loop, variables, and the four arithmetic operators = UTM) < 1167453514 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :pfft... < 1167453518 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :while loops are so overrated. < 1167453526 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and overused. >.< < 1167453583 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :A while loop is two ifs and a goto. < 1167453589 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I'm personally a fan of FOR...NEXT loops. < 1167453606 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :wassat? < 1167453617 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :... < 1167453623 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Like a for loop in Python? < 1167453633 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :(iterators) < 1167453648 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :for(int x=0;x<5;x++) {System.out.println(x);} < 1167453654 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :^ For...Next loop. < 1167453661 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Ah... yeah that's a for loop in Python. < 1167453671 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :you're speaking to someone who's never bothered to touch C. < 1167453694 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :10 FOR X = 0 TO 4 STEP 1: PRINT X: NEXT X < 1167453700 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :screw C < 1167453701 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :O.o < 1167453711 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Indeed. < 1167453713 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I use BASIC, PHP and Java to do my dirty work < 1167453714 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION doesn't like C. < 1167453730 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :and I'm starting to warm up to Perl < 1167453732 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Python... and... well just Python. But I also do a litle Scheme. < 1167453737 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Perl is kinda cool. < 1167453756 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I only really dislike 3 languages: C, C++, and Ruby. < 1167453760 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I haven't used it much... but I like the design concept... if a little unpredictable. < 1167453774 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :C and C++ are inelegant, and Ruby is just a monstrosity < 1167453781 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :C, C++ here < 1167453791 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Ruby looks kinda cool... but I've never used it or looked into it much. < 1167453828 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :C is one of those languages that sacrifices for the machine. < 1167453838 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :it's painful... Imagine an unholy mix of Javascript, Perl, and a little bit of BF. < 1167453840 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :which is partly why it's so common... because it's at the base of every OS. < 1167453864 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... Ruby does look a little like a weird syntaxed version of Python and Perl. < 1167453876 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION is, naturally, a fan of Python. < 1167453906 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :it's reasonably powerful, but it's syntax is all over the place. It's like it was designed by three people independently and then superglued together < 1167453921 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Not because of any grand design concept... or because it does a paticular thing well... it's just -really- easy to work with and generally does what you think it would do. < 1167453944 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I haven't used python much, but it's syntax for working with strings is fucking brilliant < 1167453956 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Which part? < 1167453966 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :interpolation? < 1167453975 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :the way you access substrings or specific characters < 1167453981 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :slicing? < 1167453991 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :"Hello World!"[0] ? < 1167453993 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :is that what it's called? < 1167454008 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :That would be "H" < 1167454011 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1167454030 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Yeah... that's called slicing or indexing... it's basically like arrays. < 1167454040 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Same exact thing... actually. < 1167454094 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I'd say my favorite language will probably always be BASIC, because of how it combines extremely friendly syntax and ease of use with ridiculous levels of power via PEEK(), POKE and CALL < 1167454118 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I've never used basic... but it doesn't seem popular. < 1167454134 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I remember it doing some weird context-based stuff with = < 1167454147 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :plus, if you're fluent in BASIC you can instantly do cool things with any old machine from the 80's < 1167454160 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :which is a good idea for beginners.. but not too well for my tastes. < 1167454172 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Python kinda reminds me of Lisp... in some ways. < 1167454194 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric := is used for both assignment and comparison in BASIC, but the way it's used almost never leads to problems < 1167454229 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Yeah... but then you can't do things like x = y == 2 (which, honestly... isn't very useful... but it's still nice to have the freedom) < 1167454245 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :essentially, it solves the problem by making assignment done not by the = operator itself, but the LET statement < 1167454276 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :LET x = 2? < 1167454288 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :aaah. < 1167454294 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :x=y=2 in BASIC generally does the same as x=y==2 in other languages < 1167454312 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :thought more ambiguous when you read it. < 1167454328 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :LET is an interesting command, because it's usually implied. If a line doesn't contain a command, it's assumed to be prefixed with LET. < 1167454339 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :O.o < 1167454345 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Weird. < 1167454358 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :so, "10 LET x=y=2" is the same as "10 x=y=2" < 1167454391 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Python's main design goal seems to be readability and ease of use. < 1167454399 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :and both will store a boolean value (1 or 0, in BASIC's representation) representing wether y is equal to 2 or not to the variable x < 1167454443 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :BASIC's main design goal is minimal memory use and the ability to function as both an interpreter and a rudimentary OS, much like FORTH < 1167454476 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :there are a number of BASIC implementations that fit in less than 4k of ROM. < 1167454476 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Python is OO at heart... but it has this weird conflicting idea of multi-paradigmism. < 1167454504 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I've seen both "Python is an object-oriented language" and "Python supports multiple paradigms" as arguments for why something should be implemented into it. < 1167454540 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1167454550 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :It basically works with multiple paradigms... while being object-oriented at the core. < 1167454582 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :...which... isn't really what I would call being multi-paradigmed. < 1167454635 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :BASIC sounds interesting... not sure if I'd like using it though. Might be cool. < 1167454644 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Doesn't it use sigils like Perl? < 1167454666 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :do you have a device that runs PalmOS? < 1167454674 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Nope. < 1167454681 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :damn. < 1167454687 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Python seems tons more consistent than what I've seen of C. < 1167454691 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :C makes absolutely no sense to me at all. < 1167454696 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :Cbaspad, one of my favorite BASIC implementations runs on PalmOS. < 1167454724 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :My other favorite, DarkBASIC, I can't really play with anymore because it's windows-based. < 1167454737 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :C's semantics seems to change upon context... < 1167454749 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :in a really weird way. < 1167454751 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :SmallBASIC is pretty nice- it runs on PalmOS, windows, and Linux. < 1167454801 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :C just bugs me because it's obvious it was written by and for compiler writers, rather than as a clear or interesting way of expressing algorithms. < 1167454803 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Like... function definitions are just... floating out in space with nothing defining them as such... and type declarations are kind of screwy and have different functions based on what other types are beig used. < 1167454836 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :yeah... its design goal is totally different than what it's being applied to. < 1167454889 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :which really frustrates me when I've been exposed to so many languages that are better designed. < 1167454898 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :C's static typing also bugs me... but then again my first dive into programming was from within the comfort of a dynamically typed language. < 1167454946 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :C maintains dominance in a circular fashion- applications are written in C because C is used to code other applications. Plus, it doesn't have a huge number of direct competitors. < 1167454972 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION nods. < 1167454995 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Makes me wish there was some other language that was really good at being a "base language" that didn't suck quite so much. < 1167455020 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :BASIC is weak-typed, but Java has taught me the structural value of strong-typing. I still really enjoy weak-typing when I'm doing simpler tasks in a language like PHP < 1167455027 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :There's some OS project being worked on with most of the source being in a Python implementation. < 1167455059 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :it's a pretty interesting concept... orthagonal persistency and a weird memory layout. < 1167455078 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :http://en.wikipedia.org/wiki/Unununium_%28operating_system%29 < 1167455113 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet: well, I've been slowly working on a project to try to build an operating system, and that's pretty much what I thought, so I'm researching modern compiler design. Hopefully, I can come up with something that combines the positive aspects of C with the design of better structured languages. < 1167455166 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hehe... an esoteric operating system? < 1167455182 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :possibly. < 1167455191 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION will be your Python codemonkey. < 1167455218 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :although, I hope that it will one day become something on par with commercial OSes and the offerings of the open-source community. < 1167455335 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm.. orthogonal persistence is a neat idea. < 1167455361 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :uuu initializes the entire hard disk into the virtual memory... and manages it so that any changes to the virtual memory as saved to the hard disk. < 1167455368 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I agree- Uuu has some fascinating ideas behind it. < 1167455418 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :it makes sense... why the hell are we required to use databases and persistence libraries to do something that could be handled by the OS? < 1167455653 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :you're talking to the person that thinks a kernel should consist primarily of a memory manager and an interpreter for a language that can serve in an interactive mode as a shell. :) < 1167455670 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric ::D < 1167455686 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I like the way uu did time. < 1167455694 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :solves the whole time problem. < 1167455771 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :heh- yeah, it works pretty well < 1167455876 0 :digital_me!unknown@unknown.invalid QUIT :"night" < 1167456045 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION considers helping out uuu. < 1167456108 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat, I'd love to do some crazy OS stuff... besides my totally lack of knowledge on how OSes are developed. < 1167456129 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :But... I'm sure there's new ways it could be done... so eh. < 1167456293 0 :wooby!n=alan@ny-lancastercadent4g1-3a-236.buf.adelphia.net JOIN :#esoteric < 1167456315 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :operating system development is the grandest challenge out there in the world of commercial software development- if I'm going to do anything in the industry, that's what I want to build. < 1167456329 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :...except a lot of the developers seem like total assholes. < 1167456336 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :well, yes. < 1167456341 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Nothing annoys me more than grumpy coders. < 1167456349 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :which are strangely common. < 1167456357 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :lol yes < 1167456364 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :oh man OS dev is such a boondoggle < 1167456382 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :yeah, it generally happens when coders find themselves having to do administrative things. < 1167456387 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Well... I'm a reckless and overconfident n00b... so I'm up for it. < 1167456395 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :boondoggle is an excellent word. < 1167456405 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :indeed < 1167456427 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :well, I think I need to get some sleep. G'night, guys. < 1167456444 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :goodnight < 1167456464 0 :RodgerTheGreat!unknown@unknown.invalid QUIT : < 1167456558 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :what is new and good in the world of esoteric programming technology < 1167456570 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :>.> < 1167456593 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I've got some ideas for a genetic-ish object-oriented programming language? < 1167456601 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :sounds awesome < 1167456603 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :what are your thoughts? < 1167456605 0 :ihope_!n=foo@cpe-071-075-186-016.carolina.res.rr.com JOIN :#esoteric < 1167456610 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :possibly queue-based... or maybe double-ended-queue-based. < 1167456619 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :or some other crazy-data-structure-based < 1167456625 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :i don't know much about genetic algorithms outside the few dewdney examples from however long ago < 1167456633 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :me neither :P < 1167456639 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :lol < 1167456655 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :But I know the basic concept of natural selection... which is basically all you need. < 1167456663 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :well yes < 1167456668 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :my hunch is that it's like neural networks < 1167456686 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :perhaps not < 1167456697 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :there was an idea tossed around briefly yesterday about a "spiderweb language" that worked kinda like a network of inter-related parts. < 1167456699 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :well i'd imagine you'd need an algorithm that changed some property of whatever data structure you came up with < 1167456746 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1167456750 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :well.. < 1167456765 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :have you ever thought of the idea of like < 1167456769 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :a massive human powered computer? < 1167456780 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :like individuals doing operations and timing is done with music or something < 1167456785 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :A computer that eats humans? < 1167456792 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :lol no < 1167456809 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :anyways just a brainfart of mine < 1167456813 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Sounds slow, cumbersome, inhumane, and inefficient. < 1167456815 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :a programming language that simulated the design of such a thing < 1167456818 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :indeed it would be < 1167456830 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ooogh < 1167456890 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :but yes < 1167456893 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :on genetic algorithms < 1167456895 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :i know nussing < 1167456915 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :(This is Bob) picks up (this is block-Sue)/(This is Steve) gets Sue from Bob with (this is a hammer-Kim) < 1167456952 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :a huge people metaphor. < 1167457086 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :We should band the entire esolang crowd together to make an esoteric operating system. < 1167457112 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oh my... but what would the base language be? < 1167457120 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :BF isn't powerful enough... < 1167457141 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :it could be < 1167457146 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :what about a fullblown BF machine < 1167457158 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :then an OS written in basic :) < 1167457456 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :.... < 1167457466 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :writing a whole OS in BF would be mind-boggling. < 1167457476 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Maybe a combination of a bunch of languages... < 1167457493 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :esoteric languages are all fairly small. < 1167457609 0 :ihope!unknown@unknown.invalid QUIT :Connection timed out < 1167457715 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Sure... we could put the whole lot of them into the OS... and somehow make the whole thing cohesive. < 1167457837 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :it has potential < 1167457862 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Yes yes, everybody's discussed this possibility. < 1167457931 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :So let's do it. ^.^ < 1167457953 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Fine fine, carry on. < 1167458436 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :.. < 1167458453 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Where should we start? < 1167458458 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Perhaps informing everyone? < 1167458505 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I think the base languages should be BF, Befunge, Glass, and a bunch of otherones I can't think of right now. < 1167458591 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :I think you should start with a good idea, like EsoOS or, oh, EsoOS, or that other EsoOS, or EsoAPI or PEsoIX, or ... < 1167458605 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :esOS? < 1167458802 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :esoos :D < 1167458828 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :We could bring it up on the Wiki... and decide a name there? < 1167458851 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :that could be a good start < 1167458857 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... < 1167458869 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :We could use a more modular version of BF. < 1167458873 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I considered the idea myself. < 1167458879 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Like a functional BF... < 1167458926 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hehe... and we can ditch a filesystem... and the whole desktop metaphor. < 1167459202 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hahaha... the entire OS could be a stack. < 1167459206 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :a stack-based OS. < 1167459326 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :OH < 1167459370 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :it could be represented as a infinite 2d grid... like befunge. < 1167459800 0 :cmeme!unknown@unknown.invalid QUIT :Remote closed the connection < 1167459816 0 :cmeme!n=cmeme@boa.b9.com JOIN :#esoteric < 1167459843 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hola < 1167460138 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :ACTION hits his head against a wall. < 1167460223 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm? < 1167460715 0 :ihope_!unknown@unknown.invalid QUIT :Connection timed out < 1167461145 0 :oerjan!n=oerjan@hagbart.nvg.ntnu.no JOIN :#esoteric < 1167461289 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :http://esolangs.org/wiki/Esoteric_Operating_System < 1167461464 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :cakeprophet: did you notice my comment that the A class in Glass seems to be broken? < 1167461526 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... < 1167461531 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Nope. < 1167461568 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :the programs hang on the . lookup command. < 1167461588 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :at least they did yesterday. < 1167461597 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_a)A!(_o)O! <2><2>(_a)a.?(_o)o.?]} < 1167461605 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oh wait... I think EgoBot is ded. < 1167461608 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :!ps < 1167461612 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :1 oerjan: ps < 1167461615 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :nope < 1167461615 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :.... < 1167461659 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Someone should fix it before we implement Glass into our operating system. ;) < 1167461661 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_a)A!(_o)O! <2><2>(_a)a.?(_o)(on).?]} < 1167461679 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oh... yeah < 1167461689 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_a)A!(_o)O! <2>(_o)(on).?]} < 1167461691 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Why must the output be split by type? >.< < 1167461692 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :2 < 1167461734 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :The OS will need a universal system for retrieving data from various programs. < 1167461739 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :because Glass is not supposed to be easy :) < 1167461766 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and I think we should ditch the desktop metaphor... and the filesystem. < 1167461819 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Glass isn't all that hard once you get used to it. < 1167461823 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :which takes about a day. < 1167464447 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Weird... < 1167464458 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :My very first BF interpreter.... < 1167464469 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and the Hello World program from the esolang wiki only prints out "Hello" < 1167464538 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :!bf >+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-] < 1167464539 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Hello < 1167464561 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :!bf >+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+. < 1167464565 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Hello World! < 1167464585 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :whoops. you didn't happen to copy only the first line, too? :) < 1167464616 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... possibly. < 1167464626 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :or perhaps your interpreter breaks when encountering the newline < 1167464666 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Don't see why it would. < 1167464687 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :if you don't ignore non-command characters properly, say < 1167464692 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!bf >+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-] < 1167464694 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+. < 1167464695 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Hello < 1167464721 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :That's exactly what I put into my interpreter. < 1167464748 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :so it seems likely that it breaks at the newline in the program, then. < 1167464784 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :either because you don't ignore non-command characters, or because the interpreter only reads one line of input. < 1167464787 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :EgoBot did the same thing... < 1167464812 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION points above. < 1167464835 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :that's because EgoBot parses only one single line, which it pretty much has to do on IRC. < 1167464855 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oh... yeah I forgot to get rid of the newline. < 1167464910 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :!bf ++++++++[>+++++++++<-]>.<++++[>+++++++<-]>+.<++[>+++<-]>+..+++.++++[>++++++++<-]>.<+++++[>++++++++++<-]>+++++.<<.+++.------.<+++[>---<-]>+. < 1167464912 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Hello˜Ï < 1167464914 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :As far as I can tell... it ignores them completely. < 1167464914 0 :wooby!unknown@unknown.invalid PRIVMSG #esoteric :woops < 1167464963 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :what happens in your interpreter if you replace the newline with a space? < 1167464963 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :http://deadbeefbabe.org/paste/3085 < 1167464978 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :...nothing? < 1167464989 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oh... what happens? < 1167464995 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :heh, lemme check. < 1167465101 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :now it just hangs and does nothing... < 1167465154 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION figures out the problem with some breadcrumbing. < 1167465239 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :you mean you solved it? < 1167465266 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :no. < 1167465274 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... < 1167465282 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :it seems to have faulty while loop parsing. < 1167465323 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :but then why would it get Hello right? < 1167465377 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :dunno.. < 1167465390 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I made some changes to the source inbetween runs when I noticed a bug. < 1167465394 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :could have messed something up. < 1167465401 0 :ivan`_!n=ivan`@wikipedia/ivan JOIN :#esoteric < 1167465416 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Here;s the soure again... with a test run at the bottom < 1167465417 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :http://deadbeefbabe.org/paste/3085 < 1167465429 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :The long line of commands is the symbol the interpreter was interpreting. < 1167465449 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :It seems to go on forever on the while loop. < 1167465474 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :there is something wrong with [, anyhow - it never skips the first iteration < 1167465489 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Right. < 1167465554 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :which it cannot because of the way parse is called - you cannot escape from the "for char in toparse:" in parsecode. that must be changed. < 1167465596 0 :wooby!unknown@unknown.invalid QUIT : < 1167465599 0 :clog!unknown@unknown.invalid QUIT :ended < 1167465600 0 :clog!unknown@unknown.invalid JOIN :#esoteric < 1167465736 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :anyhow this problem cannot be why the Hello World doesn't work. < 1167465848 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :it doesn't need to escape. < 1167465879 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :parsecode() calls parse() on each character in toparse < 1167465898 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :yes it does, because a loop shall not be executed at all if the cell is 0 on the first try. < 1167465940 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oooh. < 1167465987 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :may i suggest something like "while self.pos < length(self.code):" < 1167466000 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :and then you make [ and ] adjust self.pos. < 1167466085 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I've got a spiffier and more elavorate solution. < 1167466098 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :good :) < 1167466128 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Using a coroutine. :D < 1167466136 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Which is something I've yet to have a chance to use. < 1167466455 0 :ivan`!unknown@unknown.invalid QUIT :Connection timed out < 1167466456 0 :ivan`_!unknown@unknown.invalid NICK :ivan` < 1167466901 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm < 1167466913 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oerjan, Not sure how to reliable tell where a ['s corresponding ] is. < 1167466928 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... oh wait. < 1167466931 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION facepalms. < 1167467046 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :got problems? < 1167467096 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... just parsing problems. < 1167467132 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Given the sequential order of parsing... I'm not sure how to reliably find the right ] to jump to. < 1167467334 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :the elegant solution is to have a separate parsing and execution stage < 1167467362 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :wait - another method. < 1167467397 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :have a flag that tells whether you are skipping or executing. < 1167467410 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I considered that. < 1167467424 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I don't really like it... but.. eh < 1167467480 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :you basically have to do _some_ non-executing parse at some step. < 1167467523 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :But then... < 1167467532 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :The problem with that is nested []'s < 1167467564 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :If I tell it to... upon always finding "]"... change the "amparsing" flag to True. < 1167467591 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :no, you should use recursion for [] like with ordinary execution. < 1167467638 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :the flag should be a method parameter, not an object property. < 1167467711 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :it needs to be combined with the self.pos adjusting approach. < 1167468244 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :heh... I did some funky stuff to get it to work right. < 1167468264 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :...provided it works right. < 1167468273 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :btw the same advice i just posted to Sphen lee on the wiki applies to you too: < 1167468297 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :"It requires infinite lookahead/backtracking if you compile in the same step as parsing, but that works only for the simplest languages anyhow. Instead parse into an AST, then compile that. Much more flexible." < 1167468346 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :.....you want me to compile the AST of BRAINFUCK? < 1167468369 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :it is much simpler to handle loops if you reify them first... < 1167468402 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well, compilation or interpretation, i was just quoting myself. :) < 1167468427 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I really haven't figured out the difference. < 1167468446 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :They both involving parsing to a more machine-readable set of opcodes. < 1167468536 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :but getting the AST (before either compiling or interpreting it) is about getting the essential structure of your program, so you don't have to go do complicated text searches. < 1167468918 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Either way... you're going to need to do some text searching to get the AST < 1167468921 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :brainfuck has very little structure (only loops), but it is still that structure that is giving you problems. < 1167468943 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well, i meant back-and-forth searching. < 1167468959 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :How would I represent -single character commands- any more clearly with an AST? < 1167469001 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :yeah, needing more than just strings for those _is_ a bit annoying. < 1167469057 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :No I mean. < 1167469066 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :AST wouldn't help parse the syntax... because it's so simple to parse. < 1167469069 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :it's little just opcodes. < 1167469073 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :literally. < 1167469131 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ok, i got another idea. < 1167469180 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :instead of a whole AST, use an initial parse to build a lookup table between matching []'s. < 1167469226 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Well... I'm sort of just using attributes to keep track of how the execution is going. < 1167469237 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :it's not quite as fancy... but it gets the job done. < 1167469265 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Plus I'm not sure how to... do that. < 1167469309 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i may be spoiled by Haskell, which makes ASTs so easy... < 1167469352 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Just use exclusively EgoBF and you'll be fine. < 1167469373 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :gregorR: seen my comment on the Glass A class bug? < 1167469480 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Well... I was going to build a BF interpreter so I could subclass it and work on a functional BF I've been thinking of. < 1167469525 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :cakeprophet: do you have a paste of your updated interpreter? (and BTW does Hello World work now?) < 1167469549 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Eh I'm still working on it. < 1167469556 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ok < 1167469564 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :!glass < 1167469567 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :OK < 1167469735 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmm.. < 1167469775 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :My functional BF was going to have two pointers... and have a way to split BF programs into subroutines. < 1167469789 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :. would become a return statement of sorts. < 1167469812 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and , would be function input. < 1167469854 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :do you mean function call? < 1167469857 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but.... I'm not sure how useful a one-character return value would be. :/ < 1167469868 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :no.. I mean , would represent whatever the functions input was. < 1167469880 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :parameters. < 1167469915 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :eh.. I'm still working it out. < 1167469950 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :A BF program would be a "pile" of subroutines. < 1167469955 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :perhaps you could put parameters on the tape instead. < 1167469957 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :like a two-dimensional array. < 1167470000 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Well... I thought , would give the function more control over where the parameters ended up. < 1167470010 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :plus it fits nicely with the current syntax. < 1167470039 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :A @ command would switch your "current" pointer to the other one. < 1167470112 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and & would call the subroutine that the "other" pointer is pointing to... using the "current" pointers cell as input. < 1167470158 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :so the tape would contain subroutines? < 1167470170 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :eh... it would be like a tape of tapes. < 1167470200 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :with a subroutine pointer and a multiple array pointers. < 1167470205 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :but a subroutine is code, so you would need to put code on the tapes, or at least code pointers. < 1167470216 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :right. < 1167470225 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :a tape of tapes... a tape of subroutines... which are all tapes. < 1167470253 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :reflective then, if you could access the source code directly? < 1167470304 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :The subroutine pointer just points to the subroutine that will be called when you do a &... not sure if that makes it reflective or not. < 1167470326 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I guess it would be interesting to make it reflective like you said... sounds kinda neat. < 1167470340 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but I'll have to change how it references other subroutines to do calls. < 1167470359 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_o)O!(_a)A!<2><2>(_a)a.?(_o)(on).?]} < 1167470380 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_o)O!(_a)A!<60><5>(_a)a.?(_o)(on).?]} < 1167470389 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :EgoBot, you are _so_ borken :) < 1167470395 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :!ps < 1167470398 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :1 GregorR: ps < 1167470405 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_o)O!(_a)A!<60><5>(_a)a.?(_o)(on).?"foo"(_o)o.?]} < 1167470406 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... < 1167470412 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :aah... I see what you mean. < 1167470426 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :I'll look at it tomorrow, I have to sleep. < 1167470444 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well good night to you. < 1167470445 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I was sorta just thinking the code would just be normal brainfuck programs with some delimiter between them... but having it like a tape of tapes is cool. < 1167470496 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :There could be two pointers on the big pointer... a subroutine pointer and a call pointer. < 1167470532 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :the subroutine pointer points to whatever subroutine you're "editing"... and the call pointer points to the subroutine you'll call via the & command. < 1167470597 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :so then... & by definition would temporarily move the subroutine pointer to the call pointer. < 1167470608 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :or something... < 1167470612 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :damn that's confusing. < 1167470718 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :OH < 1167470737 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :@ would swap the rolls of the "big" pointers. < 1167470765 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :current-tape pointer would swap places with function-to-call pointer. < 1167470804 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :er... wait. < 1167470861 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :damnit I'm confused. < 1167471025 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I think it would make more sense to just simply do &(subroutiine reference name) < 1167471034 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and be done with it :P < 1167471149 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well, otherwise you need at least one tape whose contents represent points in the code < 1167471162 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :although that could be done in many ways. < 1167471192 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :*contents or positions < 1167471249 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Having the subroutines on a tape would be the more BF-ish of the two. < 1167471270 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but... it makes BF infinitely more useful if it had subroutine reference names. < 1167471334 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :heh... it would be kind of postfix notation. < 1167471368 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :generally subroutines would manipulate the contents of the array behind them... if there are more than one manipulated cells. < 1167471375 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Like an add function. < 1167471426 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :just behind them? < 1167471431 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :+>+++>&(add) < 1167471441 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :would dump 4 into the third cell. < 1167471460 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :there would need to be some sort of "protocol" for subroutines to follow if they intended to be re-used. < 1167471479 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :it would be awkward in typical BF code for calls to occur before their data. < 1167471511 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :by "before" I mean spatially before. < 1167471524 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :>>+>+++<<&(add) < 1167471526 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :just doesn't seem right. < 1167471558 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but then again... I've been doing a lot of Glass lately. < 1167471573 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :so maybe all that reversed subroutine calling has been fucking up my conceptualization :P < 1167471639 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :(in truth... Glasses subroutine calls are more accurately displated than in standard languages) < 1167471685 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :arguments are always evaluated and pushed to the stack before their subroutine calls are. < 1167472379 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :well, not always in Haskell :) < 1167472430 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :....how? < 1167472531 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :Haskell is a lazy language, so arguments may not be evaluated until they are actually used by the subroutine. < 1167472567 0 :ivan`_!n=ivan`@wikipedia/ivan JOIN :#esoteric < 1167473624 0 :ivan`!unknown@unknown.invalid QUIT :Read error: 110 (Connection timed out) < 1167473624 0 :ivan`_!unknown@unknown.invalid NICK :ivan` < 1167474176 0 :okokoko!unknown@unknown.invalid NICK :oklopol < 1167477139 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :good use for the start of the day < 1167477156 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :read everything talked in the 11 hours i slep < 1167477157 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :*t < 1167479453 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ACTION is in nearly complete agreement. < 1167479761 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :not just here, i'm on over 50 channels :) < 1167479780 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :(k i didn't read EVERY channel, but many) < 1167479788 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :ACTION is no longer in nearly complete agreement :) < 1167479823 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i couldn't even read that fast. < 1167479869 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i thought i might learn writing binary fast in ascii today so i'm making a stepmania with ones and zeroes < 1167479908 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i didn't read every !glass (stuph...) DARNFUCK! < 1167480053 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i do _not_ believe i used the f word. < 1167480160 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :you might not have, i don't think darnfuck is a word < 1167480185 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i mean, i didn't read code that is indicated incorrect on the next line < 1167480229 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :actually some of that wasn't the _code_ being incorrect, but rather a bug in the interpreter. < 1167480251 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i know, A < 1167480299 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but anyways, i meant no use reading code when it's being further developed < 1167480309 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :(not generally, but in oneliners) < 1167482290 0 :jix_!n=jix@L61aa.l.strato-dslnet.de JOIN :#esoteric < 1167483183 0 :oerjan!unknown@unknown.invalid QUIT :"Up, up, and away" < 1167484172 0 :ihope_!n=foo@cpe-071-075-186-016.carolina.res.rr.com JOIN :#esoteric < 1167484187 0 :ihope_!unknown@unknown.invalid NICK :ihope < 1167488420 0 :anonfunc!unknown@unknown.invalid QUIT : < 1167489842 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :how does the thing work in freenode, if i should flood 500 lines of ososososososososososo here, would one of you get ops out of no where and kickban me? < 1167489849 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :and no, i'm not gonna try < 1167490141 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :then another mindboggler, can i make a regexp that... solved it but gonna say this anyway, it seems < 1167492759 0 :tgwizard!n=tgwizard@c-9b3ee155.178-1-64736c10.cust.bredbandsbolaget.se JOIN :#esoteric < 1167494084 0 :pgimeno!unknown@unknown.invalid QUIT :"reboot" < 1167494374 0 :pgimeno!n=pgimeno@124.Red-80-59-211.staticIP.rima-tde.net JOIN :#esoteric < 1167495097 0 :RodgerTheGreat!n=Rodger@c-68-42-107-2.hsd1.mi.comcast.net JOIN :#esoteric < 1167495106 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :ACTION waves < 1167495367 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I was looking at yesterday's logs- an OS written in BASIC would be fascinating < 1167496235 0 :Sph1nx!n=sphinx@89-178-13-182.broadband.corbina.ru JOIN :#esoteric < 1167496401 0 :Asztal!n=asztal@host81-158-88-90.range81-158.btcentralplus.com JOIN :#esoteric < 1167497682 0 :Sph1nx!unknown@unknown.invalid QUIT :"äÏ Ó×ÉÄÁÎÉÑ ×ÓÅÍ!" < 1167497763 0 :Aardwolf!n=lode@dD5765115.access.telenet.be JOIN :#esoteric < 1167498558 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat, but but < 1167498617 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :http://esolangs.org/wiki/Esoteric_Operating_System < 1167498834 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :I would love to code shell scripts in befunge... well, I guess I already can < 1167498882 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :sigh < 1167498893 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :darn weather < 1167498933 0 :oerjan!n=oerjan@hagbart.nvg.ntnu.no JOIN :#esoteric < 1167498972 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :If we had some hardware nerds we could even design our own assembly language. :D < 1167498997 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :ACTION indicates the INTERCAL microprocessor. < 1167499011 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hahaha < 1167499488 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :ACTION considers the similarities between unununium and Smalltalk. < 1167499545 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :The main one, AFAICT, is that Unununium's meta-object protocol is crapper. < 1167499559 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :OISC? < 1167499866 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :I am suprised that one hasn't been implemented. < 1167499895 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :You could get 3Ginstr/sec per core if it was < 1167499931 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :what hasn't been implemented? < 1167499946 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :OISC < 1167500210 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :ACTION wonders, on average, the ratio of OISC instructions per x86 instruction in a typical program ;) < 1167500235 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :you mean there is no physical implementation of an oisc? < 1167500278 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :I think so < 1167500302 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :c'mon, people don't do that much multiplication. < 1167500306 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :because for example the computer made in wireworld is an oisc < 1167500343 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :http://en.wikipedia.org/wiki/Oisc < 1167500345 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oh yeah! < 1167500350 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :wireworld... that was crazy. < 1167500354 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oisc is a KING OF KENT < 1167500360 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :ACTION reads the story of virtudyne on the front page of The Daily WTF. Absolutely amazing story. < 1167500365 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet: heh < 1167500466 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :If you had a wireworld simulator... you could build a virtual computer. < 1167500502 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but I guess it's not too surprirsing... the similarities between wireworld and actual electrical witing are very close. < 1167500520 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :did you see my paste? < 1167500529 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i pasted one here < 1167500542 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i mean, a link to it, not the code < 1167500568 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :Can floating point arithmetic actually be done in OISC? < 1167500601 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oklopol, no < 1167500608 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :ACTION can't see a way that wouldn't be horribly long-winded < 1167500612 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Asztal, I'm sure it's possible... just don't know how easy it would be. < 1167500627 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :I'm sure bitwise operations are terribly useful there < 1167500633 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :You could represent it with two integers possibly... < 1167500664 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :true, that would be a lot easier < 1167500664 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i lost all my logs, been running two mircs, they overwrite each others logs < 1167500679 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :so i can't find it anymoew < 1167500680 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :*re < 1167500682 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :in Python a floating point is implemented by a double in C. :D < 1167500745 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :still, I wouldn't want to be the person who has to write the logarithm function :) < 1167500789 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :...yeah < 1167500804 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Asztal: It's assuredly possible. < 1167500808 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Just a bitch. < 1167500993 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :oklopol: It's a MOV machine. :) < 1167501016 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :not an oisc? < 1167501028 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :It's an OISC. . . < 1167501037 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Just describing the specific type of OISC. < 1167501043 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :It's one instruction is MOV. < 1167501058 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Special registers allow for one to get use out of that. < 1167501124 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :pikhq, i know how it works, so i didn't know why you told me that < 1167501170 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :I don't know, either. < 1167501179 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Coffee hasn't hit the bloodstream yet. < 1167501209 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :poor you :( < 1167501280 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :http://www.quinapalus.com/wi-index.html < 1167501314 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :That one uses only one instruction set... but all the different registers react differently to it. < 1167501481 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :actually, there is a wireworld computer around somewhere. < 1167501488 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :It has 64 6-bit registers < 1167501500 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :OST, 12-bit < 1167501546 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :It can be found containing a program to calculate prime numbers. < 1167501571 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :^ < 1167501582 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Pretty sure that was it. < 1167501597 0 :ihope!unknown@unknown.invalid QUIT :Connection timed out < 1167501647 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :SimonRC: We were *talking* about that computer. -_-' < 1167501740 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :ah, I thought you were talking about one of the OISC machines. < 1167501770 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :Though he ww computer is an OISC machine too, but not the traditional SJM type. < 1167502155 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :1. that was the wireworld program i was talking about 2. that was the program simonrc was talking about < 1167502173 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :the link < 1167502625 0 :Asztal!unknown@unknown.invalid PRIVMSG #esoteric :#define IMAGE_FILE_MACHINE_OISC 0x301 ;) < 1167502670 0 :Asztal!unknown@unknown.invalid QUIT :"p0w p0w!" < 1167503196 0 :Aardwolf!unknown@unknown.invalid QUIT :"Leaving" < 1167503543 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :ACTION defines behavior for IRP#irp < 1167503668 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :the irp-quine i saw here the other day, it's a bit cheatish, a quine should not read it's own source! < 1167503692 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :It's not reading it's own source. . . < 1167503700 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :It's just executing the source as defined. < 1167503886 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :hmm, well, that's philosophy, very hard to tell in this case :D < 1167503903 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Heheh. < 1167504113 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :OK then... < 1167504267 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :Please say the following, first without quotes, then within quotes: "Please say the following, first without quotes, then within quotes:" < 1167504415 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :hm, IRP seems to be down. < 1167504490 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :Please say the following, first without quotes, then within quotes: "Please say the following, first without quotes, then within quotes:" < 1167504500 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :oerjan, have i told you you are a genius? :D < 1167504536 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Go to IRP#irp < 1167504538 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i tell that easily tho < 1167504539 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :i don't know, but someone around here promised to deify me for my shortened Glass quine. < 1167504554 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric ::DD < 1167504559 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :ye it was me! < 1167504579 0 :oerjan!unknown@unknown.invalid PRIVMSG #esoteric :and Malcolm Ryan declared me insane for my Unlambda interpreter in Intercal, which I took as a great compliment. < 1167504637 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :if i hear of intercal one more time, i'm gonna learn it < 1167504639 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :oerjan: In #irp, we are working on giving IRP defined behavior. < 1167504764 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :And I'm wondering why the hell I can't get SSHFS to work. < 1167504871 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Ahah. < 1167504889 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :fusermount, on Ubuntoids, is mode 700. < 1167505369 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :ACTION ponders some way of representing hex as surreal haiku, to make it easier to recognise. < 1167505372 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :or even remember (!) < 1167505479 0 :calamari!n=calamari@ip72-200-73-175.tc.ph.cox.net JOIN :#esoteric < 1167505614 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... reminded me of "Yields falsehood when preceeded by its quotation" yields falsehood when proceeded by its quotation. < 1167505653 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :SimonRC, oh... yeah that would be cool. Haikus always have a fixed number of syllables. :D < 1167505761 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :obvious;ly multiple haiku would be needed < 1167505853 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :You could use the kigo to represent some sort of encoding? < 1167505858 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :(the "season" word) < 1167506141 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :or... you could use all the craziness of http://en.wikipedia.org/wiki/Renga to construct various representations of numbers. < 1167506146 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :There's a crapload of terminology :P < 1167506203 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :nah, i was thinking of some silly way of doing it in English < 1167506204 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :The haiku was based off of the opening stanza of a renga < 1167506244 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :*was* < 1167506260 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :in modern net culture, that is largely forgotten < 1167506280 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Yah. < 1167506285 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Each haiku could be a digit. < 1167506298 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :which would work nicely... as three haiku stanzas would form a hex triplet :P < 1167506322 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :-how- you calculate what the value is... will take some consideration. < 1167506388 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Well... a haiku has 17 syllables... and a hex number has 16 possible values. < 1167506418 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :maybe certain properties of a haiku stanza make it either True or False. < 1167506426 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and the hex value is the total of all the Trues < 1167506443 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :with the last syllable being some sort of metadata or something. :D < 1167506608 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :That would be awesome... as a full three-stanza haiku would be a hex triplet... which would be a color. < 1167506617 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :HOW POETIC < 1167506639 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :I was thinking of something that would be suitable for recognising hashes, fingerprints, etc, actually < 1167506666 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :How do you do that? < 1167506677 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION isn't familiar with using hex to... recognize hashes and fingerprints. < 1167506707 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :I was thinking of using a load of lookup tables to encode 4 hexits per stanza, maybe 8, in rather surreal text. < 1167506774 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... < 1167506820 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :So.. < 1167506830 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :2 or 4 hex values per stanza? < 1167506919 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :You could go with the length of each line. < 1167506932 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :that tends to give you a lot of freedom in what you can write.. but isn't as cool. < 1167506950 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :As its not the haiku itself that gives it a hex value... but the length of the haiku. < 1167506956 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :...so it's not as nifty. < 1167507085 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :I am ont really concentrating on the decoding, mor the encoding < 1167507954 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... < 1167507961 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :septidecimal numbers? < 1167508112 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I've been doing some thinking about a proper name for EsoOS, and the idea that popped into my mind was "Framework" < 1167508151 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :ACTION recommends that you make it an OS. :P < 1167508800 0 :SimonRC!unknown@unknown.invalid PRIVMSG #esoteric :ACTION goes to dinner < 1167508876 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :I still recommend having a random factor.. so that each user has a unique os.. nobody can provide support < 1167508988 0 :calamari!unknown@unknown.invalid QUIT :"Leaving" < 1167509019 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :perhaps make the OS a basic system that provides core services, and then has esolang "modules" loaded to provide functionality < 1167509060 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I could configure my system to run BF, DBF, SYNTHESYS, and perhaps Glass, while someone else could run BASIC and Befunge. < 1167509116 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :the kernel would provide memory management, threading, a simple network stack, and a simple shell that can access modules as backends < 1167509168 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :turn on the computer, and it can run a series of startup scripts using hosted languages, before providing the user with an interactive interpreter of their choice. < 1167509169 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... < 1167509183 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Sounds good... no need for files either. < 1167509186 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Just "modules" < 1167509189 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1167509210 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :That would of course require some sort of OS-level importing mechanism that would work in all interpreters. < 1167509218 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Although files would be needed if you wanted to make it support PESOIX. < 1167509256 0 :RodgerTheGreat_!n=Rodger@c-68-42-107-2.hsd1.mi.comcast.net JOIN :#esoteric < 1167509257 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION is working on a functional BF that's a bit more modular. < 1167509273 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :you could use a PalmOS-style "database" system for storing user data and code on media < 1167509277 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :ACTION mumbles some disparaging remarks about wifi < 1167509334 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat Let's do orthogonal persistency... and make it totally weird! < 1167509334 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :weirdness + esotericism == good < 1167509334 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :The kernel could represent memory as BF arrays. < 1167509357 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and access to it could use BF commands? < 1167509368 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :we'd probably have to be resigned to the idea of recoding all the interpreters we wanted from scratch, so we can make our own executable format for modules. < 1167509385 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION nods. < 1167509392 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :What would be the base language? < 1167509397 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :to code all the interpreters. < 1167509418 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I was thinking more in terms of creating a useful OS, but we could try to build some kind of capability for filesystem abstraction, etc. < 1167509420 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1167509423 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :a good question < 1167509444 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :our first step could be designing such a language and it's associated development kit. < 1167509457 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Or just use C and a special library. < 1167509461 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION gags. < 1167509463 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :blech < 1167509463 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :NO C < 1167509475 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :The core OS, at least, would need to be in C. . . < 1167509491 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :nothing *needs* to be coded in C. < 1167509503 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat_: You want it in D or ASM? < 1167509507 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :it just needs to be coded in something that ends up being machinecode. < 1167509524 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :no, I want to build a new language for the express purpose of avoiding C. < 1167509538 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :esooslang :D < 1167509610 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Define some stuff. . . < 1167509628 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :ACTION will be back < 1167509638 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I think implementing the processor register as a BF array would be the esoteric way to do it... plus it's not terrible unuseful. < 1167509650 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1167509664 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :brainfucks concept of memory storage maps fairly easily to a computer's main memory. < 1167509734 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :well, let's see... what does a low-level language need? < 1167509755 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :input, output, and something to move around. < 1167509779 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :memory allocation and deallocation, function definition < 1167509805 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :a functional BF? :D < 1167509808 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I think that allowing inline ASM is an extremely bad idea, if we ever want to be able to cross-compile < 1167509828 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I'm not familiar with what ASM is anyways < 1167509829 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :memory allocation in brainfuck: [>] < 1167509839 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I suppose you could make it similar to BF, but we need a way to make the source a little more readable in general. < 1167509876 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Using DefBF (functional brainfuck) would work nicely... it allows you to abstract BF to make it somewhat useful. < 1167509889 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :an extension to BF. < 1167509894 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :to make it more useful. < 1167509939 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :perhaps set it up to use a reasonably conventional function syntax, so you could make calls like substring[x, a] or something < 1167509994 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :advanced looping constructs aren't that vital if we allow normal- and tail-recursion < 1167510039 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :My first idea for my a functional BF just used named references to do function calls. < 1167510051 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and the function would just start working with the current array. < 1167510061 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1167510065 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :kinda like in Glass... except with an array instead of a stack. < 1167510091 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :well, if you use an array properly, it can do the same things as a stack < 1167510097 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :*nod* < 1167510115 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :so there isn't anything inherently wrong with doing it that way < 1167510127 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :my second idea, to make it more esoteric, involved a array of data and an array of subroutines... both having a pointer. < 1167510147 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1167510153 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but that makes it harder to get the function you want... as the functions are referenced by a name and you have to move around a subroutine pointer. < 1167510171 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :might not be suitable for an environment where it needs to be good at something. < 1167510180 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :aren't < 1167510186 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :referenced by a name ;) < 1167510188 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :typoz < 1167510195 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I think the most important thing to add to BF if it's going to be used for a large project is some syntax for loading other source files as libraries and comment syntax. < 1167510222 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :they don't add anything to the actual language, but they add tremendous benefits in terms of organization < 1167510228 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :eh... the "ignore all non-commands" comment syntax works fine. < 1167510244 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :an "import" syntax as well as functions could be done. < 1167510250 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :essentially you'd be giving it namespaces. :D < 1167510279 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :sorta... the manipulated data remains universal nomatter what. < 1167510305 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :arguments to the functions would simply just be sitting on the array. < 1167510338 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :++>++>&(add) creates [2,2,4,0,0,0,0,0,0, ...] < 1167510373 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :the exact mechanism for each function would differ.. but they would all follow some basic format. < 1167510443 0 :RodgerTheGreat!unknown@unknown.invalid QUIT :Connection timed out < 1167510456 0 :RodgerTheGreat_!unknown@unknown.invalid NICK :RodgerTheGreat < 1167510525 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :0,0,4, maybe? < 1167510545 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :eh... depends on if you plan on reusing those values. < 1167510564 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :yeah, there is the issue that BF tends to operate on values in a destructive manner < 1167510571 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :do you want it in-place... or do you want to create a new memory space? < 1167510581 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :you should have different versions of everything to be able to imply copying like in your example < 1167510587 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :since it's slower in bf < 1167510598 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :*nods* < 1167510610 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :you might want some way in the function definitions to specify wether your code will preserve the original operands. < 1167510650 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :well... if the functions are literally just executed like normal code... there's no way to disginuish operands from other memory. < 1167510658 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :you have to think of this on both sides- how will the coder work with it, and how will the compiler work with it? < 1167510678 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :One method is to have a (move) function for copying values into new cells.... which would be used extensively by functions so they don't have to destroy old values to get new results. < 1167510708 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :that could be difficult to post-optimize < 1167510745 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1167510760 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :how about giving BF pointers> < 1167510761 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :#rotates current value in the cell 13 places#%(rot13)+++++++++++++% #Main program ---># +++++++++++++++&(rot13) < 1167510791 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :using some implied psuedo-syntax for now. < 1167510797 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :we can work out syntatical details later. < 1167510802 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :rtg that sounded like a good idea < 1167510810 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :make GOSUB and RETURN equivalents that take an argument from the current cell? < 1167510812 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :giving BF pointers? < 1167510819 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :so you could just have a call and a return < 1167510844 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :v=call, ^=return < 1167510849 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :How would you do binary operations? < 1167510851 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :those being just jumps < 1167510858 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat: For libraries, try BFM. . . < 1167510861 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :possibly also have such a system for the BF array pointer, so that you could pop it from place to place and back quickly and easily < 1167510862 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :and of course, you would need 64-bit < 1167510865 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :(shameless plug) < 1167510905 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... maybe a mix of glass and BF? < 1167510909 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :some of the BFM codebase would likely prove useful, although we'd have to modify it a bit to work efficiently in the new language < 1167510912 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hehe < 1167510927 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :at the very least, it'd be a good way to quickly have a standard library < 1167510931 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Well, I'd of course want to rewrite the standard libraries. < 1167510957 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :But the core language would, in fact, make for a powerful way of operating in Brainfuck on this OS. < 1167510958 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Use glass functions and stack pushes... but with BF syntax? :D < 1167510963 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :we could take the BFM libraries to begin with, and then over time rebuild them to suit the new langage < 1167511010 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I just like the idea of augmenting BF with execution and memory pointers. It seems like an elegant way to build structured code with BF < 1167511012 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Fortunately, BFM at the moment has been designed to be language-independent. < 1167511025 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat: I really like that idea. < 1167511061 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :BFM would also allow for some pure-Brainfuck utilities in our language. < 1167511069 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :s/language/OS/ < 1167511070 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :take that basic idea, wrap it in a little syntactic sugar to make it programmer-friendly, and it sounds like we have ourselves a solid plan for a language < 1167511078 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :good idea < 1167511110 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :And I've got to admit I like the idea of the whole OS being written in esolangs. < 1167511116 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... not sure how it would work exactly though. < 1167511153 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Like... how would you expand the syntax to make function calls take multiple arguments from multiple cells? < 1167511154 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :by maintaining complete backwards compatibility and making it easy to simulate giving subprograms their own pristine memory space, the new language wouldn't have to abandon any existing BF code < 1167511170 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet: I'm thinking... < 1167511182 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :give me an hour or two, and I'll see if I can whip up a rough spec. < 1167511197 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Currently the closest one to be conceptually realized is to simply make the array universal for all subroutines... and have some sort of built-in command for copying values. < 1167511201 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :does anyone here have any experience in compiler design? < 1167511210 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Nope. < 1167511227 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Tiny amount. < 1167511258 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :I think calamari has a decent amount of experience. < 1167511279 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :alright, I appoint myself and CakeProphet as language architects, and pikhq and calamari to the compiler implementation team < 1167511315 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :I'd recommend asking him, though. ;) < 1167511323 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :In glass having a universal stack works fine and doesn't make it hard to build working subroutines.... and by augmenting BF to have a quick way to copy values you can prevent the destructive nature of BF from destroying the coder's existing data. < 1167511390 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I think that a single tape will be fine, as long as we can call and return memory locations for the tape pointer < 1167511397 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but then again... each-function-with-its-own-array works even cleaner... you just have to figure out how to make the syntax work easily. < 1167511426 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :whatcha mean? < 1167511431 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :the big question is wether pointers should use direct or relative addressing. < 1167511446 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :ACTION prefers some idea of a two-dimensional array. . . < 1167511448 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :*shrugs* I'm a high-level junkie... I don't anything about that. :P < 1167511457 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :More like, say, a stack of arrays. < 1167511467 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :that was my original idea. < 1167511474 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :sorta kinda. < 1167511477 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Yeah. < 1167511493 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :I'm thinking of the memory layout as a single array for BF memory, and then a pair of stacks for function execution and the memory pointer < 1167511530 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Calls will be named right? < 1167511540 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :you can simulate giving functions their own tape pretty easily, and the whole idea maps to assembly pretty neatly < 1167511542 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1167511570 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Push a clear one on for a function, with the function's arguments copied onto the first cells. < 1167511581 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and then alter add some form of import syntax... depending on how our memory is segmented (i.e. how we do file-like entities) < 1167511598 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1167511633 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :what did we decided we want to name this language? < 1167511637 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :*decide < 1167511644 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_o)O! "lol"(_o)o.?]} < 1167511647 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :lol < 1167511660 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I've just been colling it "functional brainfuck" and "DefBF" < 1167511673 0 :RodgerTheGreat!unknown@unknown.invalid PRIVMSG #esoteric :DefBF it is < 1167511675 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :bf>++[-<+>] < 1167511675 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :? < 1167511678 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Ah. < 1167511685 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :It rhymes at least :D < 1167511704 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Def-BF to make it look less crowded. < 1167511724 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :or Define Brainfuck if you're feeling verbose. < 1167511748 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Out of curiosity, what sort of OS architecture are we talking about on top of this? < 1167511763 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Most likely something unique. :D < 1167511791 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I'd like to do the whole thing as a huge thought experiment. < 1167511796 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :no Unix-like crap. < 1167511819 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :How's about getting PESOIX as at least a basic sort of API? < 1167511842 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I think a lot of the inter-communication will be tuned directly into the architecture. < 1167511848 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :At least an inspiration of how to do some additional API functions, like, say, hard drive access. . . < 1167511861 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I like the "component" model of uuu... where there's no files and everything is on the same memory space. < 1167511878 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :yeah... we'll need to tweak all the languages a bit for more access. < 1167511908 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :if we do orthogonal persistency... we might not even need hard drive access. < 1167511929 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_o)O! (_x)I! (_x)i.?(_o)o.?]} < 1167511938 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 Hello World! < 1167511943 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 \n < 1167511952 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!ps < 1167511955 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :1 CakeProphet: ps < 1167511969 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :I think one should have additional functionality to the various languages via input and output. . . < 1167512003 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :We could universalize the data... so languages can share data. < 1167512015 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Everything breaks down to numbers in the end... < 1167512090 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :A BF program could theoretically make a Glass program run, print an output, and use that for input. < 1167512093 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :using some sort of API. < 1167512120 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :The "filesystem" could be totally functional... < 1167512186 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Allow me to at least write a cat program for this OS. < 1167512193 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :each program is a "function" that's called with an input and returns an output. The output would be universal to all languages. < 1167512195 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :@ char < 1167512196 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :in char < 1167512198 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :while char { < 1167512201 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :out char < 1167512202 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :in char < 1167512204 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :} < 1167512232 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Presumably the shell will just call functions. < 1167512243 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Basically. < 1167512260 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :If organizing names becomes a problem... we could do some sort of namespacing. < 1167512281 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but not too complex... massive directory names have always annoyed me. < 1167512302 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_o)O! (_x)I! (_x)i.(_o)o.?]} < 1167512310 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 Lol < 1167512317 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!eof 2 < 1167512328 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Hmm. < 1167512336 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :ACTION sees one issue with that glass program. . . < 1167512342 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :No looping involved. < 1167512344 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ah. < 1167512348 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_o)O! (_x)I! (_x)i.?(_o)o.?]} < 1167512351 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!i 2 lol < 1167512357 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Actually... I just forgot to call the input method. < 1167512370 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!ps < 1167512373 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :1 CakeProphet: ps < 1167512399 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_o)O! (_x)I! (_x)i.?(_o)o.?]} < 1167512401 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ack.. < 1167512476 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_o)O! (_x)I! (_s)S! /<1> (_x)i.? "\n" (_s)a.?(_o)o.?\]} < 1167512482 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!ps < 1167512485 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :1 CakeProphet: ps < 1167512490 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :gmmm... < 1167512592 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I think the neat thing about the OS would be the universiality... it could basically tie all the esoteric languages together and make them work as a collective whole to do something useful. < 1167512646 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Heheh. < 1167512693 0 :calamari!n=calamari@ip72-200-73-175.tc.ph.cox.net JOIN :#esoteric < 1167512761 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION pokes RodgerTheGreat < 1167512795 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_o)O! "RodgerTheGreat, calamari's here."(_o)o.?]} < 1167512799 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat, calamari's here. < 1167512810 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!cat Whee. < 1167512813 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Huh? < 1167512818 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Grr. < 1167512827 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!daemon cat bf ,[.,] < 1167512831 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!cat Wheee. < 1167512833 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :Wheee. < 1167512856 0 :RodgerTheGreat!unknown@unknown.invalid QUIT :Read error: 104 (Connection reset by peer) < 1167512859 0 :RodgerTheGreat_!n=Rodger@c-68-42-107-2.hsd1.mi.comcast.net JOIN :#esoteric < 1167512860 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :... < 1167512865 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :WELCOME BACK < 1167512873 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :woo < 1167512879 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :!glass {M[m(_o)O! "RodgerTheGreat, calamari's here."(_o)o.?]} < 1167512881 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat, calamari's here. < 1167512894 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :!cat !cat works better. < 1167512897 0 :EgoBot!unknown@unknown.invalid PRIVMSG #esoteric :!cat works better. < 1167512902 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I have a nearly done spec for Def-BF < 1167512906 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric ::) < 1167512924 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat: were you looking for me? :) < 1167512979 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yeah- interested in joining an exciting and challenging project? < 1167513001 0 :oerjan!unknown@unknown.invalid NICK :oerjan_ < 1167513012 0 :oerjan_!unknown@unknown.invalid NICK :oerjan < 1167513018 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :dunno.. I'm already working on such a project :) < 1167513061 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Well... this one is better... < 1167513065 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and more profitable. < 1167513106 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1167513146 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :FOR GREAT PROFIT! < 1167513184 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :CODE OFF EVERY ZIG! < 1167513184 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :I'm currently working on putting wikipedia and the scriptures on my ipod < 1167513193 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :writing the renderer now < 1167513203 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :We're discussing an OS written in Esolangs. < 1167513218 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :doesn't sound profitable to me hehe < 1167513356 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :alright, here's the first revision of my spec. < 1167513357 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :http://nonlogic.org/dump/text/1167512946.html < 1167513358 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat_, If the data of programs is universally accessible... an import syntax may not even be nessicary... a function call could just reach out to all Def-BF files. < 1167513379 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :take some time to read it over, and then we can discuss clarifications, changes, and additions. < 1167513390 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1167513396 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :a good idea. < 1167513412 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :ick.. need to clean my scanner.. that image looks horrible < 1167513429 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :however, some Def-BF compilers will exist for other operating systems, so it's probably a good idea to have an import statement in the spec. < 1167513505 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat_, Should we set imported functions in a namespace? < 1167513518 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I'm still thinking about that < 1167513521 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :not sure yet < 1167513532 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Well... other than recommending some syntax changes... I still need to figure out all this addressing stuff. I'm a noob at low-level memory stuff. < 1167513572 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :we might do it like ReX, by calling all functions as Library.FunctionName[], with local functions called as just FunctionName[] < 1167513599 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :What's all this absolute address stuff? < 1167513609 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :at least, that's how I remember ReX working... < 1167513628 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :pointers have to be absolute addresses to be useful. < 1167513640 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :absolute is the opposite of relative < 1167513647 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :>.> < 1167513667 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I've never delt with memory allocation... < 1167513677 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :garbage collection for the win. < 1167513677 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :like, with absolute addressing, 0x00000000 would be the VERY first memory address on your machine < 1167513682 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1167513690 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ah. < 1167513696 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :memory address... gatcha < 1167513699 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric : 0x00000001 is the second, and so on < 1167513701 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :you have to specify that? < 1167513726 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :relative addressing is like in redcode, where 0 would refer to the current address, and 1 would refer to the next < 1167513732 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :With relative, 0x00 would be the current address. 0x01 would be the next, -0x01 would be the previous. . . < 1167513737 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1167513744 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :exactly < 1167513748 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Like in Brainfuck. < 1167513775 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :why a separate stack for the calls? < 1167513776 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :But why do you need to specify absolute address? < 1167513784 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and how would you know it? < 1167513796 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :just the one array < 1167513804 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :and relative addressing the primary reason that functional pure brainfuck would be really hard to code with, so we add pointer functionality < 1167513834 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :except... I have no clue how it works now. >.< < 1167513838 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :call = jump to whatever is in the current cell, store the previous place < 1167513838 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet: for the most part, the compiler will deal with and assign the absolute addresses < 1167513871 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :oklopol: it's the difference between making a jump in code, and a jump in memory location < 1167513884 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :yes, no jump in memory location is needed < 1167513908 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :you don't need anymore the pointer to where you came from < 1167513910 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :...I don't really like the spec all that much... it doesn't really resemble BF anymore. < 1167513927 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :it's bf with a jump < 1167513932 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :the stack one has... stacks < 1167513948 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :the advantage of memory location jumps is that we can make functions that can pretend that they have their own independent memory spaces < 1167513970 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :well, true < 1167513978 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I think of it as "BF with pointers" < 1167514002 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but... by using variables and all really takes it a long ways from feeling BFish. < 1167514019 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i just dislike the multiple stacks thing, but concurrency seems to need it < 1167514021 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :it doesn't do a whole lot that's impossible with normal BF, but it makes it more possible to code in a structured manner < 1167514024 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :now that i think of it < 1167514050 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :constants could just be functions... < 1167514051 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :ACTION would rather see just BFM compiling to the low-level version. XD < 1167514072 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: well, yeah- that's why both exist < 1167514073 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION doesn't like it at all... :/ < 1167514099 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet, what does "constants could just be functions" mean? < 1167514123 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :pure access to the nuts and bolts of the language, plus some nice features for less esoterically inclined coders < 1167514127 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat_: are you using @ notation? < 1167514146 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :erm... well, I use the @ character for something... < 1167514180 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :: resume execution from previous address < 1167514189 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :oh < 1167514190 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :for example x=x+y, @y[@x+@y-@t+]@t[@y+@t-] < 1167514191 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :you said stacks < 1167514220 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :calamari: ah, I see what you mean- no, not currently < 1167514221 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :assuming % means "start definition" and "end definition"... %(lol)[-]+++++++++++% would be the same as a constant. < 1167514251 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat_: it does a lot to make it easier to code in BF, but can be easily converted to pure BF < 1167514261 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :source ^stdcons.bfm < 1167514265 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :giving functions scopes, returns, and arguments makes it look more and more like C-based languages. < 1167514267 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :consfoo bar : baz < 1167514268 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yeah, I agree... < 1167514270 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :err that program is flawed < 1167514270 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :;) < 1167514281 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :@y[@x+@t+@y-]@t[@y+@t-] < 1167514283 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :there we go < 1167514325 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I may revise the syntax to use that notation, if it's a common way of expressing BF algorithms already < 1167514328 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :For calamari's suggestion, I could just rewrite the "goto" proc in BFM, and automagically port every BFM program. < 1167514339 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :nice < 1167514344 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :I thought that Easel, ESOapi or the like would be used for the os < 1167514360 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :I was thinking PESOIX. < 1167514361 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat_, Wouldn't a global scope, and literally just substituting functions into the source be just as effective? < 1167514370 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :then you wouldn't have to change bf at all < 1167514372 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet: That'd be a macro system. < 1167514396 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :It achieves much of the same effect. < 1167514426 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :runtime macros like that are much less bf < 1167514427 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :ish < 1167514430 0 :calamari!unknown@unknown.invalid PRIVMSG #esoteric :afk.. continuing my project < 1167514431 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet: yes- I would like to use global scoping, but I think a basic returning system would be a good idea < 1167514453 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat_, What is there to return if it's global scope? < 1167514475 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :to continue the code < 1167514480 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :not return a value < 1167514506 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :like a "break"? < 1167514512 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :hm < 1167514513 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :like a return < 1167514516 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :to break out of the function? < 1167514520 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1167514556 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Not sure you'd need that if you do functions right. < 1167514557 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :is there a nice intercal reference? < 1167514574 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :that's effectively what the current "return" statement does- you can optionally use it to pass a specific pointer back to where the function was called from < 1167514602 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :if you already know where the function is operating in memory, you don't need it to pass back a pointer < 1167514646 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :the value of pointers is that they allow the compiler to arrange memory and code however it determines is the most efficient, without having to modify hardcoded values < 1167514649 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Why pointers? Global scoping does the same thing as pointers. < 1167514688 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :in an interpreted language, they aren't very important. In a compiled language, they're extremely powerful. < 1167514708 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Maybe the word "pointer" is just invoking images of C. < 1167514713 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1167514725 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yeah, I imagine it does. < 1167514735 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :we could go the Java route and call them "references" < 1167514749 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :We could just call them.... cells? < 1167514761 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :cell references. < 1167514764 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :It's the same thing. < 1167514793 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :call them cell indexes < 1167514805 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :... < 1167514810 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :reference has an abstactionish feel to it < 1167514820 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :*abstractionish < 1167514843 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :alright, in the interest of avoiding any painful allusions to C, we will call what were previously referred to as "pointers" as "cell indices" < 1167514856 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but I mean... how does using pointers and scopes make the language more efficient than a global array that simply takes the nearby cells as parameters? < 1167514870 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :meh... cell indices doesn't sound nice either. < 1167514884 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :what then? < 1167514885 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric ::P < 1167514890 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION grumbles. < 1167514907 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Call them fish bowls. < 1167514915 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :a global array with no scoping OR pointers means that code can't be arbitrarily re-arranged without breaking it. < 1167514924 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :nor can memory. < 1167514932 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Whatcha mean? < 1167514948 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :actually, they CAN, it's just nontrivial, and adds needless complexity to the compiler < 1167514966 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :....but it seems simpler. < 1167514984 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :let's say your program assumes a memory model like [A][B][blank][blank[C] < 1167514994 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :a universal strip of memory... no referencing... and calls just substitute the functions definition into the code. < 1167515001 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :and then you add a function to make use of the blanks... < 1167515016 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :[A][B][D][E][C] < 1167515049 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :now, if a new function requires memory, it has to know these chunks are all full, and know how to get from it's own areas of memory to existing ones. < 1167515052 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet, are you talking about a runtime substitution? < 1167515061 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :the alternative with pointers... < 1167515072 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :*shrugs* nothing detailed... just "sbustition". < 1167515087 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I'm talking in vague terms... it would have the -effect- of being substited. < 1167515094 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :{area1}[A][B]....{area2}[C]....{area3}[D][E] < 1167515098 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :runtime substitution wouldn't be very brainfuck imo < 1167515105 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I don't know the specifics of how compilers do things < 1167515124 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :now, it doesn't matter where these areas are in actual memory, just that they have references to one another's locations < 1167515141 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Glass would be a good example of this kind of universal stack... with functions that are still just as useful. < 1167515163 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat_, Maybe I'm just not used to working at a low level. < 1167515171 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet, runtime would be very non-brainfuck and compile-time would be idiotic < 1167515172 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I think of the memory of a BF array being literally.. side by side. < 1167515180 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :that could be it < 1167515258 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I guess what I'm trying to get across is just that having something like a pointer makes it a great deal easier for the compiler to do it's jobs without the programmer having to know the precise memory layout of the entire machine < 1167515306 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :yes, changing the need for memory in one place would affect every single function in the whole computer < 1167515308 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat_, hmmm... oh... this is for the machine's memory array? < 1167515309 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :it's a complication that you run into in the process of creating very large or memory intensive programs in BF < 1167515314 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1167515355 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ah... yeah, this is definetely going to need to be geared to a more lower-level application. < 1167515368 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I do wish it were less memory-related. :/ < 1167515372 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :with pointers you could have virtual memory and stuff much easier etc. < 1167515390 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i mean, the compiler could allocate small things in virtual etc < 1167515422 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :pikhq: making a two-stage compile system might be a good way to do this- you can compile high-level code (or any alternate version thereof) into the basic Def-BF language, which can then be compiled into machinecode < 1167515423 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I really have -no- esperience with memory allocation. < 1167515450 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :hey, I'm a Java coder myself. < 1167515467 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :can we at least make the statements one-character? :D < 1167515475 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :BF just doesn't look right with whole words in it. < 1167515496 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :well.. obviously we need function names in the code. < 1167515507 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but the operations should all stick to the one-character commands. < 1167515518 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :the statements in the low-level version *are* one character. If you don't want words, you could easily create your own abstraction of the basic language < 1167515544 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :the whole point is just to standardize the basic version, and then allow abstractions to grow as needed < 1167515608 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :the only non single-character command is ?, which is entirely unnecessary aside from aiding in compiling to machinecode- don't use it if you don't want to < 1167515625 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :what about "define" and "return"? < 1167515632 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and function calls taking variable arguments. < 1167515642 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :that's a huge step away from BF-style programming. < 1167515647 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :no < 1167515649 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :Those are high-level abstractions layered on Def-BF. < 1167515650 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :those are just abstractions of @/: and #/; < 1167515651 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :you allocate manually < 1167515659 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :or? < 1167515688 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :you aren't gonna put in functions(with,arguments) or smth like that are you? < 1167515691 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :pure Def-BF itself is just +-<>,.[];:#@ < 1167515709 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION feels much better now. < 1167515719 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I thought return and define were -statements- < 1167515730 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :everything in the spec under "High-level programming" is just a convenience to programmers < 1167515757 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :all of those statements translate directly into a series of +-<>,.[];:#@ < 1167515760 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :You should show examples of what it would look like in the actual code. < 1167515778 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I guess code examples are the next step. < 1167515786 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I'll do some work in that vein < 1167515791 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and... do we need comment syntax? < 1167515805 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :the programs are in the same memory as memory, right? < 1167515809 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I think it's worth having, but once again that's just part of the abstraction < 1167515827 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :so that you can dl programs etc :) < 1167515840 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :oklopol: not sure we can assume that, but that's most likely how it'll be on a real machine < 1167515849 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :fuck Von Neumann. >:D < 1167515851 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Given the small nature of the command set... it seems the ignore-all-non-applicable-commands would work fine and be just as readable. < 1167515877 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :Like I said, comments are just part of the abstraction- not the core language < 1167515880 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :how could programs be added without programs being in the same memory? < 1167515891 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :bah... all this abstraction syntax is confusing me. :P < 1167515917 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet: then just ignore everything under this line: "High-level programming:" < 1167515932 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Will do. ;) < 1167515938 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric ::) < 1167515939 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION found that part the most sickening. < 1167515966 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION is happy now. < 1167515997 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :essentially, just think of @ controlling the program counter and # controlling the BF memory pointer < 1167516013 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ah. < 1167516021 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and what's the /? < 1167516028 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :nothing. < 1167516036 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :in english, it means And OR < 1167516044 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :which is how I was using it < 1167516053 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oooh. < 1167516055 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :looked confusing. < 1167516084 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :@ works in tandem with : and # works in tandem with ; < 1167516090 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION nods. < 1167516095 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :That makes a lot more sense now. < 1167516101 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :excellent < 1167516116 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION thought all the pointer stuff was going to muck-up the brainfuckiness. < 1167516123 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but it doesn't really. < 1167516124 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :so, are we all happy with at least the spec for the low-level version? < 1167516157 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... yeah the spec works. ^ seems like a more descriptive command for : thought. :D < 1167516165 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :I'm not going to touch the high-level version, so, yeah. < 1167516165 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :: is kinda like a "return" right? < 1167516171 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1167516179 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :thought so. < 1167516186 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :didn't really expect you to, pikhq. ;) < 1167516213 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I'll need to figure out how # and ; work specifically... but I get their function now. < 1167516226 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but, how do you do argument copying with the high-level version? < 1167516232 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :*low-level version < 1167516238 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :the high-level spec is just how I'd like to build a metalanguage out of Def-BF. < 1167516273 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :oklopol: assuming I understand what you're asking, you can still do it how you'd normally do it in BF. < 1167516304 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but, "if a function call includes parameters, these pointers < 1167516305 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :are copied to the first x cells of the memory location specified < 1167516305 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :by the compiler." < 1167516312 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1167516315 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :how does the low-level do that < 1167516318 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :# would be argument getters. < 1167516322 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :methinks. < 1167516323 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :it doesn't know about argument < 1167516328 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :ah < 1167516331 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :of course < 1167516337 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :it'd be a normal BF cell-to-cell copy < 1167516347 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but with absolute addresses? < 1167516359 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :it just uses pointers to locate the source and destination < 1167516371 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I'm guessing ; simply copies the altered value back to where it was taken from. < 1167516399 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :@[-;+@]; << like that? (i forgot the symbols :)) < 1167516422 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :only one @ < 1167516439 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :go back - [do things] - com back < 1167516443 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yeah, something like that, except @ should be # < 1167516451 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :k < 1167516485 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... < 1167516491 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Doesn't it need a name though? < 1167516508 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :How do @ and # know where to go? < 1167516512 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :no, just a value representing a location- the absolute address < 1167516513 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :that was argument copying from the main program memory to function memory < 1167516522 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet: that's what the stack is for < 1167516535 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ah.... the value in the current cell represents the address? < 1167516549 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :when you do a @, it pushes the old location onto a stack. When you : back, it pops off the old value < 1167516556 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :like a GOSUB... RETURN < 1167516576 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :with absolute addresses, it's possible to allocate and "infinite" bit of the tape for every function right? < 1167516593 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :where is the "old location" specified? < 1167516599 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :as far as the functions need to know. :) < 1167516601 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :because they can be moved around as needed etc if the address is absolute < 1167516611 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1167516613 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oh.... wait I think I get it. < 1167516631 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :the cell value represents the address of the function to call? < 1167516642 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :the high-level version ought to have some way of specifying how much memory a function uses, so that the compiler can allocate memory sensibly < 1167516651 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet: yes < 1167516668 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and that address value will be replaced by whatever the function returns? < 1167516679 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet: OR, the address of the memory location to go to, depending on wether you're using @ or # < 1167516695 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet: you're confusing yourself with the high-level version again < 1167516696 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION isn't familiar with the low-level aspects of a function call. < 1167516724 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :the low-level version of the language doesn't explicitly *have* functions, it just has mechanisms for implementing them < 1167516732 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :++>++>@ ---- (here the retriving of the arguments... how?) < 1167516747 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :in low-level < 1167516753 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :RodgerTheGreat_, Which is why I'm confused... I don't know the low-level mechanisms. < 1167516756 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :how do you call a function? < 1167516770 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet, it's the stack-way < 1167516772 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :as in glass < 1167516791 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :except... getting arguments is different. < 1167516800 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :is it? < 1167516802 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :oklopol: I guess it'd require knowing an absolute memory address to call in the first place < 1167516806 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I get how to call them now... < 1167516814 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :well... the functions all have different scopes... < 1167516814 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :which is what could make coding in pure low-level problematic < 1167516821 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric : meant the absolute address < 1167516823 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :in Glass the functions just pick up values from the stack. < 1167516843 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :oklopol: oh, I see < 1167516866 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :CakePropher, the scope is the fact that you can push() in the stack even in the sub without altering main program data < 1167516887 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :oklopol: you'd want to either make the function call copy the arguments to the function's memory, or pass it (copy it) a reference to the location of those arguments < 1167516888 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :see an assembler-book :) < 1167516905 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :ah, of course, do the argument sending in the main prog < 1167516911 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1167516911 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :...as in assembler actually < 1167516914 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :precisely < 1167516920 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :absolute addressing seems like it would be difficult to work with once you start using Def-BF away from memory allocation. < 1167516921 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :that's the whole idea. :) < 1167516944 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :perhaps there should be two different languages? One for the memory manamgement and another more usable, low-level form for more application-level stuff? < 1167516969 0 :pikhq!unknown@unknown.invalid PRIVMSG #esoteric :That would be the. . . high-level language. < 1167516978 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :absolute addressing would get confusing when you get out of the context of memory management. < 1167516981 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet: well, yes. That's what the abstractions are for. You can also make the executable format make all the absolute addresses relative, and convert them when the app is loaded into memory- that's how normal OSes work < 1167516992 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but the high-level language looks more like C than Brainfuck. :o < 1167517022 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :it doesn't necessarily have to- as long as the base language is the same, you can abstract it however you want < 1167517050 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :you could make your own abstraction that looked like glass or Python < 1167517068 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Huh? < 1167517077 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :That's syntatic differences... < 1167517094 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I meant... the high-level version syntatically reminds me of pretty much all c-based languages. < 1167517115 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :(memory allocation function provided by the os here)@<<++[->>@+;<<]>++[->@>+<;<]>(find the add-function's address somehow)# < 1167517118 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :like that? < 1167517122 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :2+2 < 1167517125 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :=4 < 1167517132 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :that's because I want *my* abstraction to look like Java to some extent, and it's a curly-bracket language < 1167517153 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :@ i meant as the memory jump < 1167517158 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I think that would work, oklopol < 1167517160 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :# as the program execution jump < 1167517162 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :okay... so is the high-level version going to use the same syntax? < 1167517164 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :good < 1167517180 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet, you can make your own high-level < 1167517190 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :...how? < 1167517199 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :since it's converted to bf anyway... or? < 1167517220 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :we all just agree on the low-level language, and then we make our own "compilers" to turn our abstractions into the low-level code < 1167517223 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i mean, isn't the high-level just a way to write it nice, but insert as brainfuck? < 1167517228 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :ye < 1167517238 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I'm talking about syntax differences... where in the specification does it let you alter the syntax? < 1167517257 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :the OS can of course have a function that does high-level -> low-level < 1167517282 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet, basically the high-level is just a standard way to make programs in a nice manner for the OS < 1167517291 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i think < 1167517294 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :am i right? < 1167517306 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :>.> I thought we were just going to use esoteric languages to make the OS? < 1167517309 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i mean, nice for the programmer < 1167517317 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :yes, the OS runs ONLY bf < 1167517318 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :C-look-alikes that convert to brainfuck isn't what I had in mine. < 1167517323 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :DEF-BF < 1167517368 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :it is only an abstraction, anyone can make one for themselves, but it's te core brainfuck of Def-BF that is used by the OS < 1167517384 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1167517390 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :intel uses binary, but you write in python, CakeProphet < 1167517414 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :the same not anyone might wanna write everything in bf < 1167517438 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... < 1167517461 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :alright... I understand. < 1167517467 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :what i like about this, the increment-system makes it O(n) to even do addition (unless done bitwise reducing to O(logn)) < 1167517490 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :heh < 1167517493 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :so an irc client might have a hard time ponging the ping in the right amount of time in a concurrent system :) < 1167517511 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :exaggerating tho < 1167517514 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :well, in theory the Def-BF->Machinecode can improve that a bit < 1167517529 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :*compiler < 1167517549 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :yeah... no need to do one-by-one transitions. < 1167517559 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :the compiler can just convert it to specific instructions. < 1167517580 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but on the programmers end it's good ol' BF. < 1167517586 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :with... some funky changes. < 1167517588 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yup < 1167517599 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but, i hope the bf is only converted to machine code when running? < 1167517620 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :no executable files etc (unless needed for the OS of course) < 1167517643 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :depends- we might use Def-BF to write the kernel and bootloader, in which case it'll need to become Machinecode eventually < 1167517654 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I'd like a more friendly abstraction of def-bf that still looks like def-bf for making new stuff... < 1167517655 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :but it can be used both ways < 1167517671 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Like with names instead of memory addresses. < 1167517679 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :more like the first idea I had for def-BF. < 1167517710 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :it'd be pretty simple to make the @-notation system calamari suggested as an alternate abstraction < 1167517721 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :no names in the def-bf code, not good, but you can have OS functions that switch string->address < 1167517729 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION nods. < 1167517735 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I meant... as an alternate language of sorts. < 1167517757 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :so I don't have to fool with memmory addresses with higher-level stuff I might want to play around with. < 1167517772 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION will do that himself though. < 1167517795 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :btw is someone able to actually make a computer boot into their own os? < 1167517823 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :dunoo... I'm just having fun writing it out on paper. < 1167517859 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :the high-level is merely a tool, it's not important to have it until something big is done imo < 1167517875 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :Use OSKit or that other one that's like OSKit but more up to date. < 1167517880 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Well... even for small things it's nice to... not-have-to-fool-with-memory-addresses. < 1167517917 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :GregorR can you link? < 1167517919 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I was figuring we could use Def-BF to write the OS itself, with a bit of pure ASM to build the bootloader and such < 1167517924 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i can google of course < 1167517930 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :the point of an OS is to manage memory addresses for us... so naturally an abstraction of the core language is needed to continue to make things easier. < 1167517935 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :oklopol: There's a good one on SF, the name of which eludes me X_X < 1167517968 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :k, i saw one once but it went offline before i managed to dl it < 1167517969 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Unless it's easier than having to remember numbers.... < 1167517977 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :you don't have to < 1167517990 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :If I understand correctly... def-BF doesn't have a concept of assignable names. < 1167518005 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :which is mainly what I would add to it. < 1167518015 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :outside of memory management < 1167518016 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :the core language doesn't, but the abstraction does. < 1167518023 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION nods. < 1167518035 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :that's what I meant... should I decide to abstract it... that's what I abstract it with. < 1167518053 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :function names.... pretty much. < 1167518071 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :+>++>[-]<<<(address of an OS funtion that swaps string->address)# <<< and you have called the function with the name \0x1\0x2 < 1167518086 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :you see what i mean? < 1167518106 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :the code must not depend on neither addresses of functions nor their names < 1167518119 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :(well, can be names if done like that in low-level) < 1167518140 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :you haven't called, sorry < 1167518154 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :you have "gotten" the function in that memory space < 1167518159 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :then do another # to call it < 1167518172 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :+>++>[-]<<<(addr)## < 1167518189 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :the address there can be a constant since it's an OS function < 1167518196 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :kinda like an interruption < 1167518198 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :in asm < 1167518220 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :heh.... unfortunately I didn't understand any of that. < 1167518236 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :damn low-level.... < 1167518274 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :so, before call, memory is like [(address of the OS func),1,2], after the call to the os func [(address of the \0x1\0x2 func),1,2], in the end [whatever the func returned,1,2] < 1167518303 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :tho one might want to change 1 and 2 to something sent to the function, and actually send them < 1167518309 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i hope someone understands me? < 1167518324 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I got it... just not sure how that lets me do string names. :P < 1167518326 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I believe I'm following you so far < 1167518343 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I'd need an entire BF array to do a string name. < 1167518344 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet, this is very basic, for an OS it's the compulsory depth of lowishness imo < 1167518353 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :no < 1167518356 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :it's done by the os < 1167518376 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :the os function expects a null-determined string after the point at which it is called < 1167518380 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :...and how does the program send the string name to the OS function? < 1167518388 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :and there you have \0x1\0x2 < 1167518431 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :so you can have nice names in the high-level -functions and you can access them in other programs too because you store and retrieve the name with os functions < 1167518449 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :eh, store the name, retrive the address < 1167518452 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :more like < 1167518498 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :++>++>%(add) ...how would my language interpreter... written in def-BF... transfer "add" to this OS function without doing something like (OSFunc, "a","d","d") < 1167518502 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :and the absolute need not be converted to relative because i believe this isn't brainfuck but Def-BF, which supports absolute? < 1167518504 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :right? < 1167518562 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet, your high-level would've changed the "add" into a code that assigns ["a","d","d"] into the memory and calls the necessary OS function for name->address < 1167518579 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :then taking the returned address of the program executed < 1167518602 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Right... but it would need to use up a whole array, right? To ensure that it can take a string of variable length and store it. < 1167518604 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :Def-BF, am i right in saying this is a new language that extends BF a little for us? < 1167518622 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet, no arrays in BF < 1167518628 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :>.> < 1167518630 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :what? < 1167518634 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :just a few preceding cells < 1167518637 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION 's head implodes. < 1167518640 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :that are needed < 1167518652 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :how can you not have an array in BF? < 1167518689 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :How can you represent a string in BF by any other means than multiple cells of characters? < 1167518694 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :you can, but it will just be the knowledge the next n cells are used for one var < 1167518705 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :null-determination prolly < 1167518707 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :easiest < 1167518742 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :or [length,char1,char2,etc] < 1167518744 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... alright. < 1167518751 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :null determination would be better. < 1167518758 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :it makes string mutable-er. < 1167518759 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i assume you understand i'm just representing a part of the main array python-tsyle? < 1167518761 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :*st < 1167518771 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :right. < 1167518778 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :good. < 1167518808 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I'm just going over in my head how I would use Def-BF to write a new interpreter for an abstracted version of it. < 1167518824 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :oh yeah, been wanting to ask that < 1167518845 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :does the OS need to be writed in Def-BF too? i was thinkin it just ran it :\ < 1167518894 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :We're going to implement a bunch of esolangs as core languages. < 1167518895 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :it doesn't *need* to be written in Def-BF, but it'd be nice if we could do that. < 1167518897 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :to write all the OS stuff. < 1167518930 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i mean a normal c++ (or python or whatever) program that is the "OS", having an array of programs running and their memory pointers, running them one by one < 1167518940 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :If the kernel is designed for universiality in mind... allowing the core languages to interchange data should be a breeze. < 1167518972 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :Def-BF is an example of taking a canonical Esolang (BF) and extending it to be powerful enough to do the jobs of an OS. We could similarly extend other existing Esolangs to have these capabilities if we felt it necessary < 1167519001 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I'd like esoos to be a big mass of esolangs working together. :D < 1167519028 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :well, we know for a fact that everything higher than kernel-level will be coded in an esolang. < 1167519034 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :with Def-BF being the base for memory management and constructing some simple interpreters. < 1167519039 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i'd say we make the memory allocation etc in a "normal" language and then start making OS modules in Def-BF < 1167519044 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :oh :D < 1167519047 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :well then :D < 1167519052 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :how the kernel will break down remains to be seen < 1167519061 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Def-BF was designed to be for memory management. < 1167519065 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I think. < 1167519065 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :the kernel need not that many operations < 1167519072 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1167519147 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but i'm thinking now of an only-Def-BF computer, that has been coded in two layers, c++/such, then esolangs for modules like virtual memory management, Def-BF being what actual programs are written in, am i right in this? < 1167519187 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :We were mainly using Def-BF so that we didn't have to use C or its variants. < 1167519194 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :C is yucky. < 1167519201 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :because you wanna use both hard-disk and ram without breaking off the "one tape for everything" principle < 1167519206 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :oh? < 1167519213 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :and shouldn't even be a major part of an esoteric operating system. < 1167519260 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :oklopol: universally contiguous memory is a major design goal < 1167519262 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i'm a little confused still, k, can i use in this OS a program i use on my computer now? < 1167519290 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Hmmm... dunno. < 1167519296 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :yes, but can be cut anyway we want in reality because Def-BF doesn't do everything relatively? < 1167519298 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :We haven't discussed portability yet. < 1167519324 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :okay, because i'm thinking the computer only runs brainfuck < 1167519331 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :oklopol: it depends on how we decide to build the kernel. < 1167519352 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :nah... it can run more than BF. < 1167519363 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :if the kernel itself is written in Def-BF, there will be a single tape and Def-BF will be used to host all the other language interpreters, in a sense < 1167519380 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :as i described before, array of "processes" where a process is two arrays (@; & #:), program pointer and a memory pointer < 1167519389 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I don't know what the base-base language is... but Def-BF will be for the kernel and consttructing interpreters and some other super-low-level stuff. < 1167519391 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :but one way or another the OS will support a number of esoteric languages < 1167519397 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :and each is run one step sequentially < 1167519439 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :it will, because the first thing to do is to write interpreters in Def-BF < 1167519453 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Yeah. < 1167519471 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :as well as a standard library of some sort. < 1167519472 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but, i'd say Def-BF is kinda like asm of normal computers < 1167519508 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i can't see why it should be the core language for PROGRAMMING the OS... even if that was it's original purpose :D < 1167519525 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I'd agree with that idea < 1167519530 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ACTION wishes there was a named variant of def-bf that could be used for easier construction of a standard library. < 1167519550 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :it shouldn't... the OS should be programmed by esoteric languages in general. < 1167519570 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :it'd be trivial to compile such a language into Def-BF proper, which is probably how it'll be done < 1167519578 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :We just needed an extension to BF to make it a bit more useful. < 1167519613 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :true, things like brainfuck -> faster code are done on the fly i thing, they are coded in esoteric languages < 1167519619 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I see Def-BF as being used to write the bulk of the OS, and other languages being used to write all the utilities and applications necessary to make it a complete system < 1167519642 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :bulk of the OS? < 1167519651 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :by OS, I mean the kernel < 1167519652 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :can you specify? < 1167519655 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :k < 1167519717 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :kernel does what exactly? (i'm really that stupid, yes :)) < 1167519740 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :managemes memory, performs software-to-hardware transactions and disk writing. < 1167519764 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :among other things. < 1167519773 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :and coordinates the inter-operations between other software < 1167519798 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :oh... and it handles processes. < 1167519809 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :YEAH. < 1167519814 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :(caps lock) < 1167519821 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :heheh < 1167519834 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :was my idea of the processes a little correct? the array thing < 1167519847 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :because imo that's all you need for bf < 1167519848 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :not sure. < 1167519881 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :It would need to be more powerful than that. < 1167519881 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :I think it could work < 1167519903 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :even if you do things like +++++ -> 5, if we use bignums for the tape (we could :D) there just would be one operation instead of five < 1167519925 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :because a bignum can be used an array like [inc-oper,5] < 1167519927 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... and we won't be doing a traditional filesystem will we? < 1167519930 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :directories are teh suck. < 1167519934 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :we can < 1167519938 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :Def-BF provides us with facilities for creating virtual tapes from our primary tape, so it wouldn't be ridiculously hard to implement < 1167519946 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :yep < 1167519984 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :of course with non-optimized brainfuck you always know when a program will end < 1167519999 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :because the ticks of the OS are at steady intervals < 1167520002 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :This is partially a thought experiment as well... to explore some new OS design ideas. < 1167520028 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but in case of a change to the optimization algorithms, it's execution time can vary < 1167520043 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :of course, different options can be set for the optimization < 1167520058 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :^^^^^^ these are the jobs done in esolangs < 1167520063 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :the optimizers etc < 1167520080 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Everything is done in an esolang. :D < 1167520090 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet, i'd say it's pretty fucking experimental to do a BF-OS, but whatever < 1167520145 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :it's just, i can't figure out how to do the core without a lang that understands what is inside a computer < 1167520159 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :and esolangs are usually very abstract < 1167520164 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :am i making sence? < 1167520185 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1167520202 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :good then < 1167520219 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :my solution to that problem relies on the idea that Def-BF isn't overly complex to translate into machinecode < 1167520228 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :true < 1167520238 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :We have the Def-BF-to-machinecode compiler... the kernel... interpreters for a crapload of esolangs... some sort of modular structure for organizing programs, almost like individual functions to the OS. < 1167520245 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :hey! me got idea! :D < 1167520264 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :no i didn't < 1167520269 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :lol < 1167520269 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :it was stupid :( < 1167520325 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but i mean, kernel needs to do the memory allocations etc, so it doesn't help if Def-BF to is easy, we need it the other way around < 1167520334 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :yeah < 1167520345 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :so, how? < 1167520359 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :ultimately, we may be forced to use another language to build some very core parts of the OS < 1167520364 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Well... our esolang interpreters probably won't fit the specification exactly... and they'll definetely communicate with the kernel quite heavily to allocate inter-connection between differing programs. < 1167520385 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :in general, I think we should just try to place as little reliance on these other languages as possible < 1167520407 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :you mean to non-esolangs? < 1167520420 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :if so, you're right < 1167520440 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I think esolangs would work fine. < 1167520444 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :If you organize it right. < 1167520445 0 :RodgerTheGreat_!unknown@unknown.invalid PRIVMSG #esoteric :bbl- dinner < 1167520452 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but, Def-BF is slow, so i'd recommend we don't use it for the core, but rather as the primary lang to use for programs etc < 1167520467 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :It's only slow if you make it slow. ;) < 1167520475 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :most other esolangs on the other hand do not slow things don't at all < 1167520489 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet, do you understand the concept of ordo? < 1167520497 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ordo? < 1167520500 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :big O? < 1167520504 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :yes < 1167520508 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Yeah. < 1167520516 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :good < 1167520522 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :BF has only + and - < 1167520525 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but it'll only be O(n) if you make it work like that. < 1167520532 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :addition is O(logn) max < 1167520551 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :and it becomes extremely verbose done like that < 1167520570 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :yeah... they're just syntax instructions... with the proper optimizations you can shorten computation times greatly. < 1167520603 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :The commands and what they do are just visualizations... you can compress it into smaller operations. < 1167520639 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :in most cases, yes, but in that case i'd say Def-BF is already used as the main language for the actual programs, so why not use something else for internal functionality of the OS < 1167520689 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hehe... we could ues a modified form of Glass. :D < 1167520722 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :in brainfuck you think something, convert it to brainfuck by doing everything the hard way, when the computer tried to get "what you meant" from the bf-code which doesn't really show the "consept" at all, it might fail < 1167520746 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :leaving you with less optimizations than you would've had doing it with another lang < 1167520780 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hey... if uuu is using --Python--, which is a super-high-level language, to construct an entire OS... it can't be that slow. < 1167520782 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i doubt there is an interpretor that can convert a division from brainfuck [a thousand chars] to c++ [a/b] < 1167520808 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :characters do not translate to speed. < 1167520812 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :huh? the only thing slow is BF < 1167520852 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :what i mean is, the computer doesn't understand how easy it is for it to do the division < 1167520857 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :it has it built-in < 1167520884 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :a/b is an abstraction for some underlying low-level bit-by-bit operation... < 1167520896 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but instead it tries to do it the brainfuck-way, no way it can figure out what it's really doing and substitute a DIV-asm-command < 1167520922 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but what does DIV do at heart? < 1167520945 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :what i mean is, bf -> machine code is of course worse code than python -> machine code < 1167520951 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :what does that matteR? < 1167520952 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :*r < 1167520961 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :it's faster than doing a division manually < 1167520980 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Programmers are terrible at conceptualizing how their programs work... because they're so damn abstract. < 1167520996 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :it's probably not even worth the trouble of considering it. < 1167521004 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :actually might not be, but are you really saying an interpretor can make brainfuck as fast machine code that it can make python? < 1167521020 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :might not be DIV faster that doing manually i mean < 1167521030 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :But what's "manually"./ < 1167521043 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :that's not the point < 1167521060 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :in BF... the operations are just very specific... it doesn't nessicarily translate to any more work for the computer. < 1167521067 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :manually = with bit shifts and bitwise logical operations < 1167521088 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :omg i want RodgerTheGreat_ here... hopefully agrees with me :\ < 1167521101 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :if he says what you say, i admit defeat < 1167521119 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :(i'm not really sure what you mean, actually) < 1167521197 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :yeah I'm probably wrong. < 1167521231 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :probably more wrong than you... but being right when it comes to optimization is nigh impossible. < 1167521292 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :huh? < 1167521305 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :what do you mean by that? < 1167521330 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :it's almost impossible to optimize? < 1167521371 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :almost, but not exactly! i can show you: ++--- -> - <<< i optimized here < 1167521434 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :meh... alright. < 1167521511 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :it's possible... but if you didn't -set the situation up yourself-, and the optimization wasn't so painfully obvious... I'm saying conceptualizing optimization to a certain extent, in less specific languages than brainfuck, can be difficult. < 1167521583 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :well then, how do you tell a brainfuck program to divide two numbers by each other using a fast way? < 1167521604 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :all you can do is do it the brainfuck way, which, believe me, is very verbose < 1167521634 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :that will prolly be translated to what it was in brainfuck, only with incs instead of +'s < 1167521655 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :so instead of a fast DIV a,b, tons of incs and decs and loops < 1167521661 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :alright... but if your BF implementation maps directly to machine code... it will be much faster than a BF implemented in C. < 1167521688 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :O() is relative to the environment < 1167521704 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :but yeah, you're right about BF being slower. < 1167521704 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :you talking about compilation of interpretinf? < 1167521706 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :*g < 1167521728 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :no.. I'm just talking about language. < 1167521731 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i'm talking about the core, so compilation < 1167521735 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :just language? < 1167521740 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :k < 1167521741 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i'm not < 1167521747 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Python is implemented in CPython, which is implemented in C... O(n) in Python will be slower than O(n) in C. < 1167521750 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i'm talking about the programming of the core < 1167521773 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :CakeProphet, no no no no no, O(n) in python is O(n) in C < 1167521788 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but it's ALWAYS O(nlogn) in BF < 1167521811 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :actually, no ucase on the always < 1167521819 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :+ is O(1) everywhere < 1167521823 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :for example < 1167521836 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but python is conseptually the same as C < 1167521845 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :in speed < 1167521852 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :BF on the other hand is not < 1167521858 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :O(n) means n * times one comptation. one computation takes longer amounts of times in different languages. < 1167521898 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :O() is used to describe -relative- speed. < 1167521898 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :yes, what is your point? < 1167521907 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :orly? < 1167521908 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric ::D < 1167521928 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :my point is that O(n) in C is faster than O(n) in Python. < 1167521943 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :because it's relative to the speed of "one computation". < 1167521944 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :then you don't know what you're talking about < 1167521951 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :well, technically < 1167521959 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but it's not the point with O() < 1167521983 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :Any benchmark between C and Python involving something with the same O time will show that C is usually the faster of the two. < 1167522006 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :of course... the point of O isn't to comparse like that, you're right. < 1167522012 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :good < 1167522044 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but, in python everything is guaranteed to be the same ordo as in c < 1167522048 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :everything normal < 1167522056 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :in brainfuck it isn't < 1167522058 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :How? < 1167522063 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :how what? < 1167522091 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I mean... how can a language implemented in some other language have operations that are the same speed in the other language? < 1167522098 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :-__________- < 1167522114 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :let's say everything is compiled, for one < 1167522135 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :eventually, yes. < 1167522137 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :no c running when you run your python, no python running when you run your pythong code < 1167522139 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :*python < 1167522143 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :www.pythong.org < 1167522174 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :... < 1167522187 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :written that wrong 3 times now, two times trying for www.python.org < 1167522205 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :maybe i'm subconsciously gay or something < 1167522232 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :but that's a teensy bit off-topic maybe < 1167522253 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :For your enjoyment, part of why it's interesting to be me: < 1167522262 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :I was trying to decide where to go for New Years ... < 1167522268 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :So I called some friends to see where they were going ... < 1167522277 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :At least four of them were already planning to come to my abode. < 1167522281 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :And have a NY party there. < 1167522285 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric ::D < 1167522316 0 :GregorR!unknown@unknown.invalid PRIVMSG #esoteric :I don't have to plan a New Years party, it plans itself. < 1167522322 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :quine < 1167522330 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :not really < 1167522699 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :i wanted to code the NY but i gotta go party with my friends :( < 1167523038 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :hmmm... what's ASM? < 1167523079 0 :oklopol!unknown@unknown.invalid PRIVMSG #esoteric :assembly < 1167523086 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :ah. < 1167523154 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :I think glass would be a good candidate to use. :D < 1167523160 0 :CakeProphet!unknown@unknown.invalid PRIVMSG #esoteric :for some stuff.