00:25:29 <ihope> Let's just pretend we can compute the uncomputable.
00:27:12 <pikhq> Let's just pretend that 1+1=3.
00:27:49 <pikhq> Or, in the factory language. . .
00:28:02 -!- ihope has changed nick to i.
00:28:07 <andreou> hm can 3 be overloaded in scheme to be 2?
00:28:08 -!- i has changed nick to ihope.
00:28:55 -!- ihope has changed nick to \050.
00:29:05 -!- \050 has changed nick to ihope.
00:29:16 <andreou> there's always (define three 3) (define two three)... but that doesn't really matter.
00:29:54 -!- andreou has quit ("kernel time").
00:33:07 -!- andreou has joined.
00:38:25 <ihope> Joy is not the same as luck, and there is no such thing as joy luck.
00:40:06 <andreou> consider yourself lucky if you have joy
00:40:15 <andreou> and be joyful if you have (good) luck
00:42:23 * pikhq joins bsmntbombdood in singing "Happy Happy Joy Joy".
00:46:15 <bsmntbombdood> That's what the MIT scheme interpreter says on exit
00:47:31 <pikhq> Ren & Stimpy fans, I see.
00:49:37 -!- ihope has quit (Read error: 104 (Connection reset by peer)).
01:16:05 -!- digital_me_ has joined.
01:27:12 -!- digital_me has quit (Read error: 110 (Connection timed out)).
01:41:37 -!- calamari has joined.
01:46:17 * andreou happily plays around with chicken scheme until he's fit for bathing
02:00:13 -!- ihope has joined.
02:11:21 -!- pikhq has quit ("leaving").
02:33:32 -!- ihope has quit (Read error: 110 (Connection timed out)).
02:49:53 -!- ShadowHntr has quit (Connection timed out).
03:40:06 -!- andreou has quit ("\").
04:03:40 -!- wooby has quit.
04:38:23 -!- wooby has joined.
05:20:49 <CakeProphet> but because I'm going to be using it soon... with little to no experience.
05:21:41 <CakeProphet> see... the people I'm "working", who have little knowledge about programming, seem utterly sure that C++ is the best language to use for their purposes.
05:22:04 <CakeProphet> I told them the best language for me to use would be the one I'm most familiar with... in this case Python, or Lisp (vaguely) as an alternative.
05:23:58 <CakeProphet> and static typing is a drag if you've always used duck typing.
05:24:19 <oklopol> with c++ i best have the feeling i can do anything, you have such direct access to the memoryt
05:24:36 <oklopol> i have a python question for you
05:24:40 <CakeProphet> meh... I've never actually -needed- direct access to the memory.
05:25:53 <CakeProphet> hmmm.. where can I get the full specification of the standard C++ implementation?
05:26:00 <CakeProphet> I can't seem to find anything but paper books.
05:31:23 <CakeProphet> and I'm not really sure how to access the compiler from windows.
05:43:51 -!- oerjan has joined.
05:46:01 <oerjan> I noticed that the Haskell tutorial you said you were reading was not the most recent version.
05:46:32 <CakeProphet> One thing that irks me about C++ is I haven't figured out how it's consistent.
05:47:11 <CakeProphet> In Python everything is universally consistent... but so far I haven't found this to be true in C++
05:47:16 <CakeProphet> it might jsut be my lack of understanding though.
05:47:40 <oerjan> Has anyone claimed C++ is consistent?
05:48:27 <bsmntbombdood> static typing is sooo annoying in high level languages
05:48:36 <oerjan> On the other hand (and I say this having never tried to program in it) people are complaining about how its features have lots of unexpected interactions.
05:49:23 <oerjan> Apparently you have to learn a lot of rules for what not to do in combination.
05:50:07 <CakeProphet> it's hard to keep all straight when you're learning.
05:50:16 <oerjan> Ah yes. I suppose that is a reason why Scheme invented the hygienic macro system.
05:53:39 <CakeProphet> could you define a C++ macro that substitutes all newline characters with ;\n?
05:54:11 <CakeProphet> if you're like me... and lazy and don't feel like getting into the habit of using semicolons and have no real use for writing multiple statements in one line?
05:54:21 <CakeProphet> eh... it has flimsy textual substititions with #define
05:54:36 -!- ShadowHntr has joined.
05:55:10 <CakeProphet> but any step of laziness I can take would be great.
05:55:24 <bsmntbombdood> no one will be able to understand your code, and it will break
05:56:03 <oerjan> I think you mean "no real use for writing a statement over multiple lines"
05:56:33 <oerjan> He didn't say to leave out brackets.
05:57:57 <oerjan> He could simply follow a Python-like rule: either use brackets or put the sub-statement on the same line.
05:59:27 <oerjan> On the other hand I am not sure whether { ; is permitted in all cases.
06:00:04 <bsmntbombdood> I think "{ ;" will work, it's just a line with no stuff on it
06:00:14 <CakeProphet> hmm... I do kind of wonder how C++ actually works though...
06:00:31 <CakeProphet> the more I read into it the more it starts to sound like how I thought a programming langauge would work back before I learned how to program.
06:00:35 <oerjan> Will it work for switch statements?
06:01:45 <CakeProphet> Does C++ use the same evaluation as Python does for crap?
06:02:20 <CakeProphet> I remember someone finding it odd that "\n".join(SomeList) was a valid python expression.
06:02:28 <CakeProphet> and they were primarily a C/C++ programmer.
06:03:10 <CakeProphet> some I'm wondering if C++ uses variables and statements as I knew them
06:03:52 <fizzie> On the other hand, some Python programmers might find it odd that 4["foob"] is a valid C expression. :p
06:04:22 <CakeProphet> That's not too odd... it wouldn't work in Python, and I have no clue what it means...
06:04:38 <fizzie> It means the same as "foob"[4]", ie. 'b'.
06:04:40 <oerjan> It means exactly the same as "foob"[4]
06:05:02 <CakeProphet> no the syntax... but what the syntax produces.
06:05:06 <fizzie> It's because a[b] is sort-of defined as *(a+b), and + is commutative.
06:05:06 <oerjan> because p[q] = *(p+q), so commutative.
06:05:21 <oerjan> Darn speaking in each other's mouths
06:06:23 <CakeProphet> how does it differenciate if it's communative?
06:06:36 <oerjan> It's + that is commutative.
06:06:40 <bsmntbombdood> CakeProphet: Have you programmed in a language with pointers before?
06:06:50 <CakeProphet> would it just as easily been the "foob" slice of 4? (which obviously doesn't make any sense... but it could have been read that way)
06:07:23 <oerjan> "foob" in a sense means the position of the 'f'
06:07:37 <CakeProphet> I basically conceptualize them to be like mutable data structures in Python... they point to the exact same chunk of memory rather than a new "copy" of it.
06:07:53 <oerjan> so "foob"+4 means the position of, well, I suppose not 'b', that was an error.
06:08:15 <CakeProphet> Alright... then I know how to use pointers.
06:08:35 <CakeProphet> I just need to remember that everything is implicitly a copy of the original value unless I use a pointer.
06:08:38 <oerjan> Not in C. "foob"[0] == 'f'
06:09:16 <CakeProphet> I could see the possible uses... I just question the way its implemented.
06:09:28 <CakeProphet> I would have made pointers implicit... and copies of the value explicit.
06:09:47 <oerjan> So "foob"[4]=='\000', the implicit NUL at end of string.
06:10:45 <oerjan> Pointers may be more efficient in some cases, I guess.
06:11:18 <CakeProphet> I think C just has a different idea of what a variable is than me.
06:11:27 <bsmntbombdood> Pointers are more than just mutability, because the pointers can be manipulated themselves
06:11:39 <oerjan> Yes, to C a variable is a region in memory, of arbitrary size.
06:12:11 <CakeProphet> since I get my ideas about variables form Python... which, in terms of C++, makes variables implicitly a pointer.
06:12:47 <oerjan> Not simply a reference to a region of memory, like presumably in Python (except for primitive immutable types, where the reference is optimized away)
06:13:54 <CakeProphet> I don't like C++ arrays either... if I must complain.
06:14:06 <CakeProphet> I can't think of too many uses for them...
06:14:26 <bsmntbombdood> Don't think of them as an array, just as a succint way to manipulate large areas of memory
06:14:47 <fizzie> It's probably the lowest-overhead way to have an array, since it's just a block of memory.
06:14:49 <CakeProphet> which... makes them kind of constained in what they can do.
06:15:25 <oerjan> Interestingly in Haskell and Ocaml, where things _are_ references by default, there are libraries for "unboxing", which means essentially doing it the C way for efficiency.
06:15:27 <fizzie> If you're using C++, you probably want to use STL's containers (like std::vector) anyway, if you want an array-like container, and arrays if you want to _implement_ a container.
06:16:07 <CakeProphet> ah... so arrays aren't intended to be the final structure?
06:16:38 <oerjan> Arrays were inherited from C.
06:16:59 <fizzie> I guess that depends on the user; but all C++ books probably tout the merits of the STL containers.
06:17:35 <oerjan> They essentially just show their age, as does pointers.
06:18:04 <oerjan> Except probably for really low-level programming.
06:20:38 <CakeProphet> I imagine when I first start with C++ I'll always forget to type "||" instead of "or"
06:20:56 <CakeProphet> I could use #define to substitute them... if I wanted.
06:21:16 <CakeProphet> simply to avoid it from screwing up my program.
06:23:35 <oerjan> I think what Oklopol's nop language needs is a type system so complicated that _it_ is Turing-complete.
06:24:07 <fizzie> C++ templates are, after all. :p
06:24:32 <CakeProphet> I'm not sure who the hell thought that C++'s comma operator was a good idea.
06:24:43 <fizzie> It's C's comma operator.
06:24:48 <bsmntbombdood> that's why high level languages should be dynamically typed
06:25:12 <fizzie> What's your problem with the comma?
06:25:24 <CakeProphet> I don't call Python's + operator C's + operator simply because C used it before Python.
06:25:31 <CakeProphet> nah... it's fine.. and I could actually see myself using it.
06:25:45 <CakeProphet> I 'm just curious who the hell thought it up... and why they chose a comma.
06:26:09 <oerjan> The comma operator is simply a result of C distinguishing too hard between expressions and statements, like a P-language I could mention.
06:26:18 <bsmntbombdood> give me an example, I have no idea what you're talking about
06:27:16 <fizzie> Incidentally, I haven't met anyone who wouldn't write that as "a = 5; b = 3; int x = 6;".
06:27:40 <CakeProphet> yeah I know... I probably wouldn't use it...
06:27:44 <fizzie> But the comma is used a lot in initializing several values in the init section of a for loop; for(a = 0, b = 0; ...) ...
06:28:07 <CakeProphet> so it's like a... creepy non-data-type version of a tuple?
06:28:34 <oerjan> Actually it's like a creepy expression version of a statement separator.
06:29:38 <CakeProphet> oh okay... I see WHY you would use it now...
06:29:41 <fizzie> The , and ?: operators are very useful if you have some sort of ; allergy and want to write your whole program as a single expression.
06:30:00 <CakeProphet> I like writing programs in single expressions. :D
06:30:17 <oerjan> Like Ocaml, a functional language uses ; for both, since it doesn't distinguish statements from expressions.
06:30:21 <CakeProphet> but for some reason I consider variable assignment in an expression "cheating".
06:30:37 <CakeProphet> but that's my inevitable Python bias... because python treats = as a statement.
06:31:41 <oerjan> However, Ocaml's syntax is generally not considered its best part.
06:32:54 <lament> of course it's cheating.
06:32:59 <CakeProphet> "for x in SomeList" in Python in "for(x = SomeList[y], y++, SomeList)" right?
06:33:04 <lament> any side effect in an expression is cheating.
06:33:23 <fizzie> Here's a well-structured brainf*ck interpreter in C I wrote once; it shows the amazing usefulness of the ?: operator:
06:33:26 <fizzie> main(j,a,n,t)int*a;{unsigned short p=-1;char*r=calloc(n=p+1,6),*i=r
06:33:29 <fizzie> +n,**k=i+n;for(read(open(*++a,t=0),i,p);n=*i-43,t<0?n-48?n-50||++t:
06:33:31 <fizzie> --t:n?n-2?n-19?n-17?n-3?n-48?n-50?n-1||read(0,r+p,1):p[r]?i=k[j]:j
06:33:34 <fizzie> --:p[r]?k[++j]=i:t--:putchar(p[r]):p--:p++:p[r]--:p[r]++,*i++;);}
06:33:41 <CakeProphet> oh I use conditional expressions all the time... and list comprehensions.
06:33:56 <lament> fizzie: i see a lot of ;
06:34:07 <fizzie> Yes, I don't really have a ; allergy.
06:34:31 <CakeProphet> hmmm... C makes it easier to avoid multiple statements...
06:34:41 <CakeProphet> in Python it's like a fun little challenge though... C makes it too easy. :P
06:34:59 <lament> CakeProphet: not really
06:35:23 <lament> it's probably easier in python since C doesn't have lambdas
06:35:42 <CakeProphet> you can do variable assignments, multiple-expressions-with-side-effects-but-only-use-the-last-one-to-evaluate,
06:36:21 <fizzie> And you have the ?: to do conditionals.
06:36:29 <CakeProphet> Python doesn't allow variable assignments in an expression... which makes it way more difficult (but more "pure") to write one-liners.
06:36:36 <CakeProphet> well.. Python added something for that in 2.5
06:37:53 -!- ShadowHntr has quit (Connection timed out).
06:38:15 <fizzie> That's a funny way to write it. Perl has the "... if cond;" statement modifier, but it doesn't add an else branch there.
06:38:52 <lament> true if cond else false doesn't read at all like english.
06:39:15 <oerjan> I suppose you cannot use ... if ... else ... inside an ... if ... else ... without parentheses.
06:39:22 <CakeProphet> how often do you put your ifs before your assertions?
06:39:43 <CakeProphet> but in conversation... I always say "I like pancakes, but only if it's noon"
06:40:08 <lament> i prefer the way forth does it.
06:40:09 <fizzie> "I like pancakes, but only if it's noon; else I like RAW MEAT ARRR."
06:40:39 <oerjan> What about pancakes with raw meat in them?
06:41:14 <lament> cond if true else false then
06:41:49 <oerjan> Yeah, Forth's then at the end is really weird.
06:41:50 <CakeProphet> hehehe... to someone unfamiliar with stack-based languages... that would look like someone scrambled the source code.
06:42:57 <CakeProphet> I'm still waiting for python to get a while-loop list comprehension/generator-expression.
06:43:57 <CakeProphet> usually just one for the main loop of the program.
06:44:54 <RodgerTheGreat> aw, I feel so robbed! SQL doesn't allow definition of recursive functions!
06:45:03 <RodgerTheGreat> CREATE FUNCTION adder(a INT(10), b INT(10)) RETURNS INT(10) RETURN IF(b<>0, adder(a + 1, b - 1), a);
06:45:13 <RodgerTheGreat> ERROR 1424 (HY000): Recursive stored functions and triggers are not allowed.
06:45:23 <CakeProphet> how will you go on without SQL functions being recursive?
06:45:41 <RodgerTheGreat> I was hoping I'd stumbled upon a brilliant esocoding opportunity.
06:46:17 * CakeProphet had a BF interpreter coded in Excel at one point.
06:47:03 <CakeProphet> it just gives you the entire array to work with.
06:47:27 <CakeProphet> but I guess you could use print to accumulate characters into a single "output cell"
06:48:46 <lament> oerjan: it just means, "... and then, do this"
06:50:34 <oerjan> if ... if ... else ... then else ... then
06:51:55 <CakeProphet> I would have implemented it true-stmt then false-stmt else if
06:52:26 <CakeProphet> reminds me of the backwardsiness of FORTH. :D
06:52:44 <oerjan> Doesn't work with the Forth compiler principle though.
06:53:05 <RodgerTheGreat> ooh. we have an idea- we can't make recursive calls in a general sense, but we *can* define functions with our functions. We might be able to "build the tracks as our train runs on them", so to speak
06:53:36 <oerjan> Because anything found before the first "keyword" must be directly executed.
06:54:01 <CakeProphet> make an imperitive esolang modelled after "it puts the lotion on the skin"
06:54:36 <RodgerTheGreat> "It puts the lotion on it's skin or else it gets the hose again"
06:55:11 * oerjan wonders what the heck you are referring to.
06:58:33 <oerjan> The obvious name for Ork's successor would be "ORK is to increment."
06:58:52 * oerjan is still reading the logs.
06:59:08 <CakeProphet> and because I intend to create a large number of things named "Sophia"
07:00:25 <CakeProphet> I wonder what C++ would have been like if it included the increment in its evaluation (++C)
07:01:23 <oerjan> Obviously one of them would have a syntax like: Sophia? Sophia. Sophia! Sophia?
07:01:56 <oerjan> What, you don't want to increment Ook? :)
07:02:25 <RodgerTheGreat> Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo.
07:02:44 <CakeProphet> It'll basically have ORKs syntax... with Metaclasses and coroutines...
07:02:57 <CakeProphet> and some new directive-type stuff via commands related to "Sophia"
07:03:21 <oerjan> I wasn't suggesting that you make Sophia have such a syntax, but that you make Sophia have it.
07:03:22 <CakeProphet> and some minor syntax tweaks... such as "When this program starts:" being changed to "When Sophia loves us:"
07:03:49 <CakeProphet> no no no... I would really only consider Sophia for that kind of silliness.
07:04:11 <CakeProphet> well... that's actually not a syntax tweak...
07:04:18 <CakeProphet> because Sophia will be an object with a method "loves us"
07:05:32 <CakeProphet> oh yeah... and special methods (yup... can't have OO without SPECIAL METHODS!!_
07:06:02 <CakeProphet> "be said" is the string representation method (and how the object is printed when outputted)
07:07:45 <CakeProphet> and I'll try to think of some ways to totally bastardize ORK.
07:09:45 <oerjan> You could add a functional layer.
07:19:22 -!- digital_me_ has quit (Read error: 110 (Connection timed out)).
07:19:45 -!- Sgeo has quit (Remote closed the connection).
07:28:06 -!- calamari has left (?).
07:58:42 <Sukoshi> Hey look. I've ignored all of you for the last 2000 lines.
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:00:07 <oerjan> That's OK, we were ignoring you too.
08:31:36 <Sukoshi> No, it's not OK. It's ORK.
10:20:54 -!- ihope has joined.
10:24:05 -!- oerjan has quit ("leaving").
12:54:55 <oklopol> [08:21:32] <oerjan> I think what Oklopol's nop language needs is a type system so complicated that _it_ is Turing-complete.
12:59:57 <oklopol> [08:44:14] * CakeProphet had a BF interpreter coded in Excel at one point.
13:00:09 <oklopol> if you're talking about vba, i made one during a class in school
13:02:23 <oklopol> [14:53:16] <oklopol> ny nop language
13:16:41 -!- andreou has joined.
13:21:04 <oklopol> it supports only datatypes list and nopad, nopad being the empty list
13:21:54 <ihope> I did Bitwise Cyclic Tag in Excel.
13:22:09 <ihope> And I don't mean a macro or anything.
13:22:35 <ihope> It's easier than BF, of course.
13:22:42 <oklopol> because making it in vba is as easy as in any language :)
13:22:56 <ihope> I think BCT earns the Simplest Turing-Complete Language award.
13:23:09 <oklopol> tho vb is the worst language i've run into
13:23:14 <oklopol> hmm i'll have to check it, don't remember
13:23:21 <ihope> Malbolge is the worse language I've run into.
13:23:33 <ihope> And by worse, I mean worst.
13:25:21 <oklopol> well, in vb it's nicer to do a program, but i like malbolge more :)
13:25:37 <ihope> Epigram has a ridiculously strong type system, doesn't it?
13:25:58 <oklopol> i'll have to see that one too........
13:31:30 <oklopol> BCT stops execution when datastring is empty?
13:32:46 * andreou would like to see the US gov't adopting mycelium as a stego device
13:37:58 <ihope> They probably have better ways of doing that, you know.
13:38:30 <andreou> probably; not as cool, though
13:43:38 <andreou> a combination of filigram.c and mycelium would also produce interesting results
13:45:11 <andreou> it's on ../filigram/ in the site of that putty guy
13:51:28 -!- ihope_ has joined.
14:07:29 -!- ihope has quit (Read error: 110 (Connection timed out)).
14:12:43 <oklopol> python: reduce ( (lambda a, b : a+b), [[[]], [[[], [], [[], []]], []], [[], [], []]] )
14:12:44 <oklopol> nopol: <<<>><<<><><<><>>><>><<><><>>>:<<..><:>:<::>>
14:13:13 <oklopol> it supports alphanumeric names tho, also comments and whitespace
14:13:44 <oklopol> the function is <<..><:>:<::>>, please crack it if you have time :)
14:15:59 <oklopol> the system is not only turing complete, it's actually pretty nice to write algorithms in
14:18:46 -!- jix__ has joined.
14:54:41 <oklopol> nopol is getting quite complicated for a language you cannot do anything with :\
14:59:38 <oklopol> i think the best feature is you can have lists of negative depth, if a([b]) == b, a(a(a([]))) for example is valid code :)
15:00:09 <oklopol> i gotta finish it so i can make a compiler!
15:00:35 <oklopol> the standard for compilers guarantees a -f final build mode that optimized the whole program to one nop
15:01:45 <oklopol> because, any number of nops is essentially one nop
15:01:48 <andreou> *every* program does absolutely nothing and does it in a quirky way?
15:02:10 <andreou> ah i didn't read the specs -- are there any or is it WIP"?
15:02:14 <oklopol> of course, you can have fun with it with a debugger
15:02:37 <oklopol> because you see what's happening in the memory
15:03:05 <andreou> i think this kind of fun is easier with hallucinogens
15:03:20 <oklopol> i'm not ready yet with the language
15:03:40 <oklopol> and it will be very hard to make an interpreter
15:04:34 <oklopol> i have to think over all the commands and such to make everything as logical as possible
15:20:13 -!- pikhq has joined.
15:29:09 -!- andreou has quit ("kernel test").
15:33:01 -!- andreou has joined.
16:24:51 -!- andreou has quit ("kernel test").
16:27:21 -!- tgwizard has joined.
16:31:16 -!- andreou has joined.
16:56:17 -!- wooby has quit.
17:05:01 -!- calamari has joined.
17:06:58 <calamari> apparently some spammers decided @kidsquid.com is a good return address :( getting lots of failure notices
17:07:13 -!- FabioNET has joined.
17:15:34 -!- ais523 has joined.
17:16:16 <ais523> So there are people on #esoteric at the moment after all, then? I was monitoring the logs to see if anyone was online, but somehow I never seem to be online at the same time as other people...
17:16:54 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
17:16:56 <EgoBot> 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
17:17:06 <EgoBot> To use an interpreter: <interpreter> <program> Note: <program> can be the actual program, an http:// URL, or a file:// URL which refers to my pseudofilesystem.
17:17:44 <EgoBot> cp: cannot create regular file `fyb/cache/egobot.AbWxMh': Permission denied
17:19:00 <ais523> After that publicly-visible error message, EgoBot started spamming me with error messages...
17:20:40 <ais523> Besides, how can it run a single fyb program anyway, considering that two of them, using each other as data space, are needed for the program to work?
17:22:06 <ais523> !fyb file://bomber.fyb
17:22:08 <EgoBot> cp: cannot stat `./files/bomber.fyb': No such file or directory
17:23:25 <ais523> I think it tries to run the program it's given against an internal list of programs to compete against, but it's getting 'permission denied' errors on the programs it has stored
17:24:15 * ais523 discovers that giving EgoBot another command stops the error-message spam
17:24:38 <EgoBot> Reporting score for :>+!;.
17:26:25 <ais523> It just sent me three hyphens and stopped...
17:29:00 <ais523> !unlambda ```s``s``sii`ki`k.*``s``s`ks``s`k`s`ks``s`k`s`k./``s`k`sikk`k``s`ksk
17:29:05 <ihope_> Maybe it lost three games in a row.
17:29:23 <ais523> I suppose so, it wasn't a very good program...
17:30:15 <EgoBot> Reporting score for +[>[-]!+].
17:30:46 <ais523> More hyphens. But that's a really vulnerable program, due to the tight loop near the start...
17:36:29 <ais523> !fyb {>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]++++++++++++++!}
17:36:31 <EgoBot> cp: cannot create regular file `fyb/cache/egobot.YnjVgJ': Permission denied
17:37:52 <ais523> Hey, I think I actually beat some of its library
17:38:11 <ais523> !fybs {>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]++++++++++++++!}
17:38:14 <EgoBot> Reporting score for {>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]++++++++++++++!}.
17:38:41 <ais523> More hyphens, but there was something encouraging in the error messages on the plain fyb
17:42:34 <ais523> !fyb %:[%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%[-]!]>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]++++++++++++++!;{{>>>>}{>>>>}[-]++++++++++++++!}
17:42:36 <EgoBot> cp: cannot create regular file `fyb/cache/egobot.Gl82IV': Permission denied
17:43:30 <pikhq> Enjoying Esolangs?
17:44:05 <pikhq> BTW, IIRC, fyb will compare the program given and some of the builtins.
17:44:18 <pikhq> And it seems that Gregor has fucked up Egobot a bit.
17:44:40 <pikhq> GregorR: Give egobot write access to itself.
17:45:05 <ais523> Yes, I'm enjoying esolangs. I enjoyed the logs, too, before I had access to an IRC client.
17:45:29 * pikhq continues hugging BFM
17:45:57 <ais523> The new program seems less good than the old one. Maybe it's better to be simple...
17:47:17 <ais523> !fyb :>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]+++++++++++++++!;:>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]+++++++++++++++!;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]+++++++++++++++!;
17:47:19 <EgoBot> cp: cannot create regular file `fyb/cache/egobot.2yppuf': Permission denied
17:49:02 -!- oerjan has joined.
17:49:19 * ais523 tries something really simple
17:49:22 <pikhq> string f! "Hello, oerjan."
17:49:43 <ais523> !fyb {>>>}{>>>}+++++++++++++++!
17:49:46 <EgoBot> cp: cannot create regular file `fyb/cache/egobot.CZrAiN': Permission denied
17:52:20 <ais523> The ps command does seems to stop the flow of error messages and useful answers... (it lost every single game, BTW)
17:53:24 <ais523> Hey, how does EgoBot manage the 2D languages?
17:54:08 <EgoBot> To use an interpreter: <interpreter> <program> Note: <program> can be the actual program, an http:// URL, or a file:// URL which refers to my pseudofilesystem.
17:54:27 <ais523> Oh, it seems that it reads it off the Web
17:56:22 <ais523> !1l http://esoteric.voxelperfect.net/files/1l/src/1l_a/a.1l
17:57:17 * pikhq is a bit sad that EgoBot doesn't seem to support Dimensifuck. . .
17:57:42 <pikhq> It's my n-dimensional Brainfuck variant. . .
17:57:46 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
17:57:48 <EgoBot> 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
17:58:02 * pikhq needs to write a BF->DF compiler
17:58:11 <ais523> It doesn't have any of my languages either.
17:59:07 <ais523> BackFlip, Underload, and MiniMAX are the main ones (there are also some BackFlip derivatives like ABCDXYZ and Unassignable)
18:00:05 <pikhq> My macro system for Brainfuck.
18:00:11 <pikhq> With much thanks to oerjan.
18:00:29 <ais523> How do you do a loop in Dimensifuck? The wiki isn't clear on how you affect the program flow
18:02:06 <ais523> So v and ^ affect the program counter?
18:02:19 <pikhq> v and ^ conditionally change the direction of program flow.
18:02:33 <pikhq> = and _ change the dimension v and ^ effect.
18:03:53 <ais523> So you could compile BF into 2D Dimensifuck just by drawing loops to represent literal loops, in much the same way as Sansism
18:04:46 -!- andreou has quit ("-").
18:05:14 <ais523> Maybe it would be possible to do it without wire-crossings
18:08:15 -!- sebbu has joined.
18:11:41 <ais523> !fybs {>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]++++++++++++++!}
18:11:45 <EgoBot> Reporting score for {>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>{>>>}{>>>}[-]++++++++++++++!}.
18:15:47 <pikhq> Well, I can *hand*compile BF to Dimensifuck. . .
18:19:13 <ais523> If you assign each loop its own y-coordinate (or better, its own dimension), you could use each of those as a bypass path for the loop if the value is zero
18:19:22 <ais523> and assign another one for the return path
18:19:27 <oerjan> I would expect every BF command to be compiled to a fixed 2D-block of DF commands, except for [], where you need to vary the height of the loop to avoid crossings.
18:20:12 <ais523> + - < > , . are all the same in DF, so it's only the flow control you have to deal with
18:21:15 <ihope_> And for a minute there I thought ! no longer did anything.
18:22:23 -!- ais523 has quit ("about to lose Internet access for a while").
18:28:30 * SimonRC fails to understand today's xkcd.
18:29:15 * oerjan hands pikhq the golden cup
18:43:13 <calamari> sorry, I'm a bit out of the loop.. is this some kind of game you are playing?
18:43:20 -!- bsmnt_bot has quit.
18:43:24 -!- bsmnt_bot has joined.
18:43:42 <EgoBot> cannot open checkpoint file /home/gregor/esoteric/egobot/egobot/daemons/: Is a directory
18:43:43 <EgoBot> cannot obtain a checkpoint stream
18:44:10 <pikhq> Gregor, do you not have write access to your home dir?
18:45:22 <EgoBot> realloc: Cannot allocate memory
18:45:44 -!- digital_me has joined.
18:46:38 <calamari> <ihope_> Maybe it lost three games in a row.
18:51:23 -!- digital_me has quit ("Lost terminal").
19:03:31 * pikhq continues prodding Gregor
19:33:17 -!- pikhq has quit (Read error: 104 (Connection reset by peer)).
19:35:06 -!- pikhq has joined.
19:42:05 -!- ShadowHntr has joined.
19:48:02 <pikhq> Kill egobot, Gregor.
19:48:59 <pikhq> I'm getting PMd error messages.
19:49:52 <CakeProphet> What data can do should be defined by its propertie, rather than some "type". :P
19:53:41 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
19:53:54 -!- EgoBot has joined.
19:54:35 <pikhq> Now, chmod some of its directories +w.
19:54:50 * pikhq waits for the error message
19:55:23 * pikhq waits for a newline, even
19:55:55 <oklopol> !bf +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
19:56:12 <oklopol> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
19:56:16 <oklopol> !bf +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
19:57:31 <GregorR> You realize that prodding is useless if you don't say "GregorR"
19:57:45 <GregorR> What with IRC clients highlighting tabs and such.
19:59:23 <pikhq> GregorR, you didn't respond when I said your full name.
19:59:56 <pikhq> Is your home dir rw now?
20:01:37 <GregorR> And it runs as user egobot in /home/gregor/esoteric/egobot/egobot :P
20:01:39 <EgoBot> 30 ++++++++[>++++++++>>><<<<-]>+. [53]
20:02:00 <oklopol> !bf >+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++.>-------------.>++.>++++++++.>+++.>--------------------------------.
20:02:50 <oklopol> !bf +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++.-------------.++.++++++++.+++.--------------------------------.
20:04:01 <EgoBot> 80 ++++++++++++++[>+++++>++++++>++++++++>+++++++<<<<-]>+.>>++.>+++.++.<---.+++.<--. [250]
20:05:22 <oklopol> actually, mine is not much slower
20:06:09 <oklopol> mine uses a generic algorithm and i wrote it just now in python in 2 minutes
20:06:33 <oklopol> so, yeah it sucks but i love all those chains of letters <3
20:06:57 <oklopol> what algorithm is GregorR's anyway?
20:07:13 <bsmntbombdood> GregorR: You should pipe the output of bf_txtgen through a bf optimizer
20:09:14 <GregorR> textgen.java . Look @ calamari :-P
20:09:51 <GregorR> ^[0-9]+ is the length, \[[0-9]+\]$ is the generations.
20:10:04 <GregorR> It's in the files archive.
20:10:35 -!- maverickbna has joined.
20:11:11 -!- ShadowHntr has quit (Nick collision from services.).
20:11:52 <oklopol> okay, what is the files archive :)
20:12:03 -!- ShadowHntr has joined.
20:12:10 -!- ShadowHntr has quit (Read error: 104 (Connection reset by peer)).
20:12:41 <GregorR> http://www.esolangs.org/wiki/LOOK_IT_UP_YOURSELF
20:12:56 <GregorR> Or just http://www.esolangs.org/ :-P
20:13:24 <oklopol> SUPRISINGLY IT WAS NOT IN THE WIKI
20:14:21 <oklopol> i can't find it there either :)
20:15:09 <EgoBot> cannot open checkpoint file /home/gregor/esoteric/egobot/egobot/daemons/: Is a directory
20:15:11 <oklopol> i thought it was like in a separate folder :)
20:15:11 <EgoBot> cannot obtain a checkpoint stream
20:15:47 <EgoBot> 1 EgoBot: daemon nop reload
20:17:05 <oerjan> now what i wanted to check.
20:17:37 <bsmntbombdood> Someone needs to do something clever with bsmnt_bot
20:17:48 <pikhq> GregorR: I can be cruel to bots at times.
20:18:14 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
20:18:24 -!- EgoBot has joined.
20:18:32 <pikhq> !daemon glass bf ,[.,]
20:18:33 <EgoBot> 1 EgoBot: daemon nop reload
20:19:05 <pikhq> !daemon glass glass ''
20:19:11 <pikhq> !glass There we go.
20:19:12 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
20:19:21 -!- EgoBot has joined.
20:19:40 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
20:19:42 <oerjan> Apparently daemons can be recursive?
20:19:50 -!- EgoBot has joined.
20:19:58 -!- maverickbna has quit (Read error: 145 (Connection timed out)).
20:20:37 <oklopol> bsmntbombdood, as wouter said, ppl who don't like c++ don't understand it
20:20:44 <GregorR> bsmntbombdood: People who don't like C++ --- thanks, oklopol 8-D
20:20:53 * pikhq needs to fiddle with egobot a bit
20:22:22 <pikhq> Why the hell are you writing IRC commands to stderr?
20:22:31 <pikhq> bsmntbombdood: It's the C++ stream interface to stderr.
20:22:45 <oerjan> !daemon undaemon bf ,[,]
20:22:51 <EgoBot> 1 oerjan: daemon undaemon bf
20:23:01 <GregorR> pikhq: netcat is a bit funky :(
20:23:05 <oerjan> That's better. Or worse.
20:23:45 <pikhq> bsmntbombdood: What's wrong with you.
20:23:46 <EgoBot> To use an interpreter: <interpreter> <program> Note: <program> can be the actual program, an http:// URL, or a file:// URL which refers to my pseudofilesystem.
20:23:57 <GregorR> pikhq: There's no help on !raw
20:24:19 <pikhq> !raw QUIT :I don't want to live!
20:24:45 <GregorR> !raw PRIVMSG #esoteric :Do you /really/ think I use security by obscurity, dorkus?
20:24:45 <EgoBot> Do you /really/ think I use security by obscurity, dorkus?
20:25:21 <pikhq> !raw PRIVMSG bsmntbombdood :Don't answer that.
20:25:53 * pikhq realised something stupid
20:26:02 <pikhq> if (sender != string(argv[2])) continue;
20:26:18 <pikhq> So Gregor alone can use raw.
20:27:56 <pikhq> ./egobot EgoBot GregorR esoteric 10485760 >> EGOOUT
20:28:11 <pikhq> I don't understand how the fuck that allows netcat to access IRC.
20:36:06 <pikhq> At least there aren't any buffer overflows to exploit. . .
20:36:41 <pikhq> . . . I think I stand corrected.
20:36:59 <oklopol> !bf_txtgen was this the command?
20:37:17 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
20:37:19 <EgoBot> 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
20:38:01 <EgoBot> 162 +++++++++++[>+++>+++++++++++>+++++++++>++++++<<<<-]>>--.>--.<----.<-.>+.>+++++++.+.<-.<.>+.------------.---.<.>--.++++++++++++.--..------------.>+++++.<+++.>>---. [930]
20:38:11 <pikhq> No, your use of C strings is safe. . .
20:38:18 <pikhq> Still. . . Bad Gregor!
20:38:51 <EgoBot> 54 +++++++++++++[>+++++++++>++++++++>><<<<-]>-.>---.<-.+. [32]
20:39:25 <EgoBot> 54 +++++++++++++[>+++++++++>++++++++>><<<<-]>-.>---.<-.+. [316]
20:39:41 <bsmntbombdood> Double quotes don't evaluate to a c string in c++?
20:39:52 <pikhq> Using char arrays in C++ isn't wise.
20:41:56 <bsmntbombdood> What's the point of forking and then waitpid()ing on it?
20:44:10 <pikhq> "foo" is a static C string in C++. . .
20:55:14 -!- cmeme has quit (Connection timed out).
20:56:45 <pikhq> string::substr is magic, indeed.
21:01:27 <oklopol> how does the txtgen randomize the same string every time :\
21:01:37 <oklopol> or, even two times in succession
21:02:54 <pikhq> It's a genetic algorithm. . . You're experiencing dumb luck.
21:05:59 -!- Sukoshi has quit ("ERC Version 5.1 (CVS) $Revision: 1.796 $ (IRC client for Emacs)").
21:08:07 <bsmntbombdood> !bf http://esoteric.sange.fi/brainfuck/bf-source/prog/99botles.bf
21:08:12 <EgoBot> 99 Bottles of beer on the wall
21:13:37 -!- oerjan has quit ("leaving").
21:39:11 -!- jix__ has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
21:45:21 <CakeProphet> In a static universe... it wouldn't be all that great.
21:45:21 <pikhq> I don't know what idea it is.
21:45:38 <CakeProphet> for a dynamic universe... it's pretty damn sweet.
21:45:54 <CakeProphet> It's a sequence of functions that can be called.
21:46:59 <CakeProphet> when you call a ring... it calls the first function with those arguments, and uses the return value as the arguments for the next function, etc
21:47:20 <CakeProphet> but there's a "ring return value" as well... which is what the ring returns as a whole.
21:48:51 <CakeProphet> it's not really meant to be a "pure" function (no side-effects)
21:48:59 <CakeProphet> it would work best where everything is a side-effect.
21:55:04 <ihope_> People who don't like C++ don't understand it? Lies!
21:55:33 <ihope_> I refuse to use any programming language that I cannot code first-order logic theories into!
21:57:03 <bsmntbombdood> "You don't like it, so you must not understand it"
21:59:22 -!- Sgeo has joined.
21:59:29 <CakeProphet> That would be assuming that anything understood is liked.
22:00:31 <ihope_> That's not the virtualization thing, is it?
22:00:49 -!- sebbu has quit (Connection timed out).
22:01:20 -!- pikhq has quit (Read error: 104 (Connection reset by peer)).
22:01:56 -!- pikhq has joined.
22:07:25 <oklopol> No, CakeProphet, just that C++ is nice when you get it.
22:11:07 -!- olli90 has joined.
22:12:47 <olli90> I have a question reguarding BrainF*ck ....
22:14:54 <ihope_> Depends on the question, of course...
22:15:50 <olli90> i have to make a brainfuck program that checks a string...
22:16:02 <olli90> like a serial key checker
22:16:45 <ihope_> Check one string against another, then?
22:17:46 <olli90> then if the first is = to the second the program prints "OK" and is not = the program prints "wrong"
22:19:26 <pikhq> I can think of the basic structure for such a program in BFM. . .
22:19:46 <pikhq> Would it be a specific, builtin string, or would it compare two strings from stdin?
22:20:07 <olli90> it haves to compare 2 strings...
22:20:10 <pikhq> ihope_: Sorry. . . It's easy to think about it at higher levels of abstraction.
22:20:28 <ihope_> Input a character, go right, increment, go right, input a character, go right, increment, go right...
22:20:45 <ihope_> Continue until you receive a newline.
22:21:26 <ihope_> After you receive it, go left to the cell you incremented last, then [<<], then go right.
22:22:11 <ihope_> From there, you're at the beginning of the string you want to check against, and there's one cell between each pair of characters, and the next thing that will be input is the other string.
22:23:25 <olli90> I think I have undertund :D
22:25:50 -!- olli90 has quit ("KVIrc 3.2.3 Anomalies http://www.kvirc.net/").
22:25:52 * pikhq realises one thing that could be much faster in BFM, when compiled into Tcl and interpreted. . .
22:25:56 <pikhq> itoa is slow as hell
22:28:16 <pikhq> Of course, I know an even easier way to make the BFM interpreter faster.
22:28:27 <pikhq> Make it just compile to BF and run through egobfi.
22:29:15 <pikhq> That's great and all, but BFM already targets C.
22:29:37 <pikhq> I just need to get c.tcl pulled over onto my laptop and package it up.
22:29:45 <pikhq> Besides, egobfi8 is very fast.
22:30:07 <pikhq> tclsh ./bfm.tcl -f ~/esoteric/bfm/bott.bfm 1.22s user 0.04s system 56% cpu 2.218 total
22:30:11 <pikhq> egobfi8 0.14s user 0.07s system 9% cpu 2.213 total
22:30:28 <pikhq> Comparing with the BFM interpreter. . .
22:30:34 <pikhq> Give it a few minutes.
22:31:07 <pikhq> (comparing with my in-BFM implementation of 99 bottles of beer)
22:32:46 <pikhq> Like I said: the in-BFM itoa implementation is slow as fuck.
22:33:10 <pikhq> (at least, it is in an environment where your interpretation of a while loop is very, very slow)
22:33:15 <ihope_> Just how slow is fuck?
22:33:48 <pikhq> I'm watching the thing spit out a string, wait a few seconds, spit out a number and a string, and so on and so forth.
22:34:34 <pikhq> Unbuffered output lets me see what the bottleneck is. . .
22:34:58 <pikhq> String output goes pretty quickly, even for a rather slow interpreter.
22:35:17 <pikhq> tclsh ./bfm.tcl -f ~/esoteric/bfm/bott.bfm -I 285.46s user 0.37s system 98% cpu 4:48.95 total
22:35:22 <pikhq> That's how slow fuck is.
22:36:57 -!- tgwizard has quit (Remote closed the connection).
22:39:15 * pikhq has made the thing a bit faster now. . .
22:39:29 <pikhq> I removed redundant calls to itoa in my bott.bfm program.
22:39:43 <pikhq> It should be 3 times as fast.
22:39:49 <pikhq> Which is still rather slow. . .
22:41:25 <pikhq> tclsh ./bfm.tcl -f ~/esoteric/bfm/bott.bfm -I 130.26s user 0.34s system 92% cpu 2:20.87 total
22:41:42 <pikhq> tclsh ./bfm.tcl -f ~/esoteric/bfm/bott.bfm 0.89s user 0.05s system 93% cpu 1.005 total
22:41:45 <pikhq> egobfi8 0.11s user 0.06s system 9% cpu 1.886 total
22:42:34 <pikhq> Now, we all know how slow fuck is.
22:43:47 <oklopol> i actually made an assignment! :)
22:45:55 <oklopol> i've done maybe 10 in high school if you don't count exams, so i'm very proud -_______-
23:13:01 <pikhq> I've got 939 lines of code in BFM. . .
23:13:16 <pikhq> Not counting my C backend, which I have yet to sync in with the rest of my tree.
23:13:59 <pikhq> My pre-rewrite build was 325 lines.
23:14:17 <pikhq> Kind of odd that I managed to have the thing grow in size as it increased in readability.
23:37:46 -!- FabioNET has quit ("notte notte").
23:38:37 <ihope_> oklopol: you made an assignment?
23:39:24 <ihope_> You assigned something, then?
23:42:15 <oklopol> ya i assigned my foot in yer ass :\
23:45:11 <oklopol> I had to carry out a derivation manually :OO
23:50:25 <oklopol> I have to do 150 to pass the course. I know the answer when I've read the question but it takes 20 minutes to do it.