00:20:21 <Figs> http://www.space-invaders.com/rubikdown.html
00:23:43 <oklopol> that's pretty easy once you know how to solve a rubik's cube
00:34:57 <jix> except not all color combinations are legal
00:38:38 <oklopol> once you know how to solve it, you pretty much know what's legal
00:39:36 <Figs> so what usually goes on here?
00:40:36 <oklopol> discussion about languages, usually
00:40:58 <Figs> Speaking of languages...
00:41:10 <Figs> continuations:
00:41:20 <Figs> Good, bad, or what?
00:41:33 <Figs> (and continuated exception handling... whatever that's called)
00:42:56 <oklopol> but i find it a useful concept
00:43:03 <oklopol> and a great toy used excessively
00:43:47 <Figs> I've never really gotten into most functional languages, so I never use them, and in fact, never even heard of them `till I started doing language design research
00:45:05 <oklopol> i learned about functional programming here, pretty much :P
00:47:32 <SevenInchBread> well, coroutines are simply awesome... and they use a form of continuation.
00:47:55 <oklopol> continuations are pretty obligatory in order to actually implement threading
00:48:01 <SevenInchBread> here's what I've got on Sophia so far, for those interested : http://deadbeefbabe.org/paste/4111
00:48:31 <SevenInchBread> coroutines are procedures that can return multiple outputs and receive multiple inputs.
00:48:37 -!- sebbu has quit ("@+").
00:49:02 <SevenInchBread> a basic example would be processes running in an OS...
00:50:42 <Figs> well, I've had a few language ideas about returning multiple values, but I think you're talking about something a little bit different :P
00:51:10 <oklopol> Figs you mean returning multiple values simultaneously?
00:51:16 <SevenInchBread> ...let me write up an example in Python. Familiar with it?
00:51:35 <Figs> (yeah@oklopol, no@SIB)
00:51:45 <oklopol> with coroutines you return something and leave the function in a state where it expects more arguments
00:51:56 <SevenInchBread> heh... if you've ever dealt with any kind of programming language... basic Python won't take but a few seconds to figure out.
00:52:11 <Figs> I do most of my programming in C++
00:52:19 <Figs> I can probably take a guess at it :P
00:52:40 <oklopol> so... you have a statement in a funtion that is kinda like next_arg=return_and_wait(5);
00:53:06 <oklopol> so, it returns from the function normally, but the next given argument is given to next arg
00:53:26 <oklopol> so, it returns the continuation implicitly
00:53:43 <Figs> I'd think of that as returning a function
00:54:06 <Figs> (which I've done things similar to, but not exactly that)
00:54:18 <Figs> I can see how that'd be useful
00:54:24 <oklopol> kinda like that, though it's usually not returned, but the function itself changes into the new function, that now is the continuation waiting for more parameters
00:55:00 <oklopol> (correct me if i'm wrong, i've never used yield, which i believe is return_and_wait)
00:55:07 <Figs> If I was picking a syntax for it based on the way you guys've just described it, I'd do something like
00:56:29 <Figs> where f is a function returning a function type :P
00:57:28 <oklopol> Figs the problem with that is f(x) will actually return a value, not just the continuation
00:57:59 <Figs> I come from C++ remember? :P
00:58:13 <Figs> reference arguments as return path :P
00:58:52 <Figs> void triple(int& x) {x=3*x;}
00:59:05 <Figs> well, for lack of a better term
00:59:28 <Figs> if you have ever done C/C++ programming
00:59:39 <oklopol> i've done mostly c/c++ programming
01:00:01 <oklopol> but, returning is a better way, usually
01:00:13 <Figs> in a fair number of cases, yeah.
01:00:28 <Figs> but you can do it that way, if you have to
01:00:41 <Figs> one of the things I thought about for Creole (my language) was to do this:
01:00:49 <Figs> struct Z = f(x);
01:01:18 <Figs> if(Z.foo) {bar();}
01:01:44 <Figs> with f returning multiple values
01:02:09 <Figs> I haven't tried to impliment that yet
01:02:15 <Figs> so I don't know if it is a good idea or not :P
01:02:42 <SevenInchBread> ...I like it... and I've actually found practical uses for it.
01:02:42 <oklopol> though i'd not do it exactly like that
01:03:16 <oklopol> well, using names for returning makes sense in that you usually have names for the args
01:03:18 <Figs> how could you do it, oklopol?
01:03:54 <SevenInchBread> Here's a coroutine in Python : http://deadbeefbabe.org/paste/4112
01:04:22 <RodgerTheGreat> "bullet" supports multiple named return values from a function: http://www.nonlogic.org/dump/text/1174856252.html
01:04:25 <oklopol> i would do it exactly like that.
01:05:16 <oklopol> do subdiv[val1:a val2:b] to [subresult:sub divresult:div]
01:05:47 * SevenInchBread tries his best to stomach the type declarations to figure out what we're talking about.
01:06:18 <Figs> heh, you'd hate the stuff I'm working on then, 7"
01:07:19 <Figs> personally, I find [ ] for blocking to be hard to read, but that's just because I've grown up on {}'s and ()
01:07:49 <oklopol> RodgerTheGreat i assume you'll do 'struct lambdas' as i call them like Figs just showed... i mean that struct is just a hash table
01:08:03 <RodgerTheGreat> in bullet, parameters are given in the form type:name and returned values are extracted in the form storeValueName:ReturnedValueName
01:08:03 <SevenInchBread> I think []'s are easier to follow without "losing them"... it is a little weird though.
01:08:24 <SevenInchBread> with Sophia, I just made everything lazy... so all ()'s are essentially blocks.
01:08:53 <oklopol> i don't know why i assume that.
01:09:22 <Figs> heh, my whole language is blocks @_@
01:09:32 <Figs> and interfaces
01:09:52 <Figs> I still have to figure out a lot of the syntax though
01:10:06 <RodgerTheGreat> bullet doesn't really need interfaces, because it's non-OO
01:10:18 <SevenInchBread> Figs, if everything is blocks... you could probably afford to get rid of a block syntax.
01:10:21 <Figs> no, it has interfaces :P
01:10:40 <Figs> def subdiv[double:a double:b] returns [double:sub double:div]
01:10:43 <Figs> that is an interface
01:10:54 <Figs> two inputs (a,b)
01:11:04 <Figs> and two outputs
01:11:12 <Figs> unless I am misreading?
01:11:18 <SevenInchBread> io is a good example of a language that doesn't eagerly evaluate function arguments - http://iota.flowsnake.org/
01:11:18 <Figs> yes. Functions have interfaces :P
01:11:20 <RodgerTheGreat> ok, If that's how you define interfaces. I think of them how Java uses interfaces
01:11:40 <Figs> abstract base classes (ABCs) in C++ then
01:12:21 <Figs> the thing I've found while I've been working on Creole is that at some point, everything breaks down to actions.
01:12:29 <Figs> it doesn't matter what language you're in.
01:12:36 <Figs> be it Lisp or Fortran
01:12:45 <Figs> or something in-between
01:12:56 <Figs> statement; statement; statement;
01:13:20 <SevenInchBread> -nod- in all my experience with language designing... everything breaks down to the primitives.
01:13:31 <oklopol> well, that is one way to abstract any language
01:13:41 <oklopol> but many languages do not have statements
01:14:00 <Figs> Lisp has statements :P
01:14:09 <Figs> though not the "blah;"
01:14:15 <SevenInchBread> well... it has macros... which can sometimes look an awful lot like statements.
01:14:16 <RodgerTheGreat> the main reason I designed functions in a name [params][unloads] style rather than unloads=name[params] style is that rather than getting really long lines of nested functions for some operations, you just get a series of code blocks one after another
01:14:51 <Figs> not sure I follow that
01:14:54 <oklopol> Figs it's all about abstraction, you can think of everything as functional as well, it's just not every language is inherently the "action" kind
01:15:03 <SevenInchBread> Smalltalk, from what I can tell... has no statements. and currently Sophia executes as one huge expression.
01:15:44 <Figs> unless you're doing something like prolog
01:15:51 <Figs> then you're doing statements... essentially.
01:15:57 <Figs> prolog is more like declarations
01:16:01 <oklopol> RodgerTheGreat: i thought that might have something to do with it
01:16:05 <RodgerTheGreat> bullet will never have something like Length[Mid[Input[0],5,8]]
01:16:23 <Figs> there's probably a better way of explaining
01:16:28 <RodgerTheGreat> because that looks nasty and matching brackets is hard to read
01:16:50 <oklopol> actually that's one thing i thought you might've not thought through :P because... well i like the nested chaos
01:16:57 <Figs> so, how do you do Length(mid(input(0),5,8)?
01:18:20 <Figs> now, maybe my problem is I really don't see that big a difference between functional programming and proceedural programming...
01:19:01 <RodgerTheGreat> I'm ignoring var types and proper return names because I just made those functions up and this is an example
01:19:07 <oklopol> do mid[rtn,5,8] to [rtn] -> do mid[input,5,8] to [rtn] i suppose
01:19:46 <Figs> how are you combining input[0] with 5 and 8 for mid?
01:20:05 <oklopol> is oklotalk 'Length(mid(input(0),5,8)' is written '3' PLUS it never fails!
01:20:36 <RodgerTheGreat> well, remember, in bullet "do foo[arg:x] to [y:val]" is equivalent to the C-style "y=foo[arg];"
01:21:13 <Figs> does it matter?
01:21:16 <oklopol> input[0] is input's length
01:21:28 <oklopol> since arrays and strings are 1-indexed
01:22:18 <Figs> so... how exactly are you combining input[0], 5, and 8?
01:22:31 <Figs> or can you not do that as a single statement?
01:22:53 <Figs> I don't care what it does
01:22:59 <Figs> just how your interfaces connect
01:23:15 <RodgerTheGreat> in bullet "do foo[arg:x] to [y:val]" is equivalent to the C-style "y=foo[arg];
01:23:33 <oklopol> first_input=input[1]; do mid[first_input,5,8] to [sub:ret]; Length(sub); i guess
01:23:47 <Figs> wouldn't it be
01:24:02 <Figs> input[1] to [first_input:notsureonthis];
01:24:26 <oklopol> do <function call> to <set returned vals to vars>
01:24:29 <RodgerTheGreat> assuming foo is "def foo[int:x] returns [int:val][val = x+x]
01:24:29 <Figs> do input[1] to [first_input]
01:24:46 <oklopol> BUT var = value, if value needs no function call
01:24:56 <Figs> I thought input[1] was a function O.o
01:25:14 <oklopol> then it'd been how you said
01:25:34 <Figs> something I read a while ago about making languages easy to teach
01:25:45 <Figs> is to make visually distinct syntax for each concept
01:25:53 <Figs> what was input[1] supposed to be then?
01:26:09 <RodgerTheGreat> this was the problem with the example: I wasn't specifying return types and input types, so it's impossible to tell if foo[x] is supposed to be an array index or a function
01:26:11 <SevenInchBread> ...hmmm, if that were true... Perl would make a great educational language.
01:26:16 <oklopol> input(0) in the first example
01:26:48 <Figs> Rodger, no offense meant, but you should either (a) combine functions and arrays or (b) make the syntax distinct ;)
01:27:08 <Figs> then I'm confused :P
01:27:33 <oklopol> the syntax is distinct... function: do <> to <>, array var=array[index]
01:27:42 <RodgerTheGreat> when I actually write code, they're distinct. They aren't when I give pseudocode to try to explain how something works and you interpret it as real code
01:28:02 <oklopol> (i'm not sure about the syntax though :))
01:28:12 <Figs> this is kind of fun :D
01:28:25 <Figs> whee. I'm not used to talking to people who find this stuff interesting :)
01:28:31 <RodgerTheGreat> just look at the example code in the spec so far- it is all correct
01:28:35 <SevenInchBread> hmmm... I'm not sure visually distinct concepts makes for good educational languages.
01:28:50 <SevenInchBread> Scheme is really good for learning... and it's completely and utterly uniform
01:29:06 <oklopol> Figs my thoughts exactly when i first came here
01:29:15 <SevenInchBread> Perl makes sure that every concept is visually distinct... but it's consider a complete mess to start off on.
01:29:44 <oklopol> you are wrong there... [03:21:12] <Sukoshi> Maybe.
01:29:44 <Sukoshi> Who in their right mind thinks that making each different programming concept visually distinct helps?
01:30:00 <Sukoshi> That's the very *antithesis* of abstraction!
01:30:37 <oklopol> http://www.nonlogic.org/dump/text/1174856252.html
01:30:50 <Figs> making syntax for different operations visually distinct
01:30:51 <Sukoshi> I've been cramming (and am, and will be) AP test stuff, mostly Physics.
01:31:19 <Sukoshi> I plan on trying to build a magnetic engine after the AP test based on an idea I got.
01:32:06 <Figs> let me see if I can find the examples from before...
01:32:15 <Sukoshi> Did Tesla make a magnetic engine?
01:32:46 <SevenInchBread> ...I actually like some of Perls ideas... and I like a good deal of Schemes ideas too... but are very different.
01:33:11 <Figs> I haven't gotten far in learning perl
01:33:17 <Figs> but that's because I haven't spent much time at it
01:33:21 <Figs> (about 15 minutes?)
01:33:27 <Figs> what I've seen so far, I've liked
01:33:44 <Sukoshi> I had a hard time working with message-passing OOP after having fun with CLOS for so long.
01:34:57 <Figs> ok, here was the example I found that made me think distince syntax was a fairly good idea
01:35:05 <Figs> note, I haven't programmed in the language
01:35:27 <Figs> A(B) supposedly has 5 possible meanings in Turing
01:35:40 <Figs> [1] call function A and pass parameter B
01:35:57 <Figs> [2] dereference pointer B to access an object in collection A
01:35:57 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
01:36:06 <Figs> [3] access the Bth element of array A
01:36:20 <Figs> [4] construct a set of type A with a single element having the value of B
01:36:37 <Figs> [5] create a one-letter substring of the string A consisint of its Bth character
01:36:55 <SevenInchBread> ...I think a lot of languages get a little too caught up in their ideology... like Scheme. Lisp and Smalltalk create religious fanatics.
01:38:13 <SevenInchBread> ...while I like all of their ideas... I don't like how forceful they are about their philosophy.
01:38:25 <Sukoshi> I think there are fanatics of every language.
01:38:30 <Figs> that's part of what's driving my development of Creole
01:38:36 <Sukoshi> Although the ASM fanatics get sparer every generation.
01:38:39 <Figs> the fact that "There are many ways to do things"
01:38:59 <SevenInchBread> Languages like Perl are nice because it doesn't force you to succumb To The Grand and Absoltute Plan.
01:39:10 <Figs> I think it's already been done though
01:39:15 <Figs> I can't remember what
01:39:54 <SevenInchBread> One of Python's mottos is "There should be one obvious way to do it".
01:39:57 <RodgerTheGreat> well, bullet's design philosophy is the creation of failsafe code... I'm not sure that's really an ideology that'll incite fanaticism, just fanaticism for the compiler-writers. :)
01:41:17 <SevenInchBread> I like languages that are fun to play around with... and let you do what you want. The first language I learnt was Python - and I loved it until I discovered other languages. Now Python seems kind of conservative and bland... but I still use it the most because I know it really well.
01:41:30 <Figs> some of the things that I'm trying to do with my language (dunno how well I'll succeed) are: (1) flexibility for extension, (2) good error handling and debugging, (3) documentation after I finish designing the syntax
01:42:14 <Figs> I think error handling is one of the keys to building a really good language.
01:42:26 <Figs> Few languages focus on error handling as well as they should.
01:42:27 <oklopol> i've made one language while we've been talking :)
01:42:48 <SevenInchBread> Sophia's Grand Principle of Construction is: (1) THE AWAKENING OF THE ABSOLUTE MODE OF THOUGHT (2) A LANGUAGE THAT CREATES ORGASMS WHILE DOING THINGS VERY VERY WELL UNDER A SINGLE AND ALL CONSISTENT IDEAL
01:43:54 <Figs> am I in #esoteric or #ecstacy ? :P
01:44:10 <SevenInchBread> ...Homespring is an excellent language - which has already done this: http://web.archive.org/web/20041011092543/http://www.rpi.edu/~bindej/hs.html
01:47:05 <RodgerTheGreat> "Because programming isn't like a river, but it damn well ought to be!"
01:47:35 <Sukoshi> Well, CLers are said to most proficient when under acid.
01:47:58 <Sukoshi> Because even though the underlying brain pattern changes, they can abstract the language to work with their new brain patterns.
01:48:21 <Figs> eh, makes sense :P
01:48:57 <SevenInchBread> ...but now Sophia is the best language to use for anything ever... even though it's incomplete and kind of completely unspecified.
01:48:59 <oklopol> talking about orgasms, http://www.vjn.fi/pb/p115251624.txt i'm pretty sure i had a boner when i finished this
01:49:05 <oklopol> not sure about the rest of the night
01:49:54 <Figs> have fun at the international obfuscated C coding contest :)
01:50:31 <oklopol> i just bruteforced the seeds for the functions and obfuscated manually for 3 hours
01:50:47 <oklopol> python loves to be obfuscated
01:51:12 <SevenInchBread> most of Python obfuscation comes in the form of syntatic substitutions for very very simple things.
01:51:48 <Figs> http://www0.us.ioccc.org/1985/lycklama.c
01:52:21 <Figs> found that on ioccc
01:52:27 <Figs> couldn't find the ball program :\
01:52:43 <oklopol> well, in python you can redefine variable types... so you can have type and value separate... and that gets really kinky
01:53:05 <oklopol> http://www0.us.ioccc.org/1985/lycklama.c
01:53:54 <oklopol> it has a non obfuscated version in the comment
01:54:33 <Figs> I think it scrolls text to the right?
01:54:51 <Figs> compile it and see :P
01:55:07 <RodgerTheGreat> based purely on the defines, it could do a lot of things...
01:55:26 <oklopol> i once had the trouble of manually demacroing such a program
01:55:33 <oklopol> it usually gets quite simple
01:55:43 <oklopol> i mean the lycklama is a define thingie
01:56:07 <Figs> doesn't compile for me :P
01:56:26 <Figs> but I know what's wrong... I think
01:57:30 <Figs> invalid preprocessing directive #o
01:58:27 <oklopol> http://www.vjn.fi/pb/p514653524.txt
01:58:36 <oklopol> read(a,b,c,d), what's that?
01:59:32 <oklopol> it defines a part of the rest of the defines, something c++ seems to deny
02:00:14 <Figs> I thought C supported it
02:00:49 <Figs> http://www0.us.ioccc.org/1985/Makefile
02:00:51 <Figs> makefile for it
02:01:56 <Figs> I assume it's part of a set of these
02:03:57 <RodgerTheGreat> I tried manually translating all the defines for that program, and I just get a mess
02:04:44 <Figs> have you guys read the Crenshaw "Lets make a compiler!" series?
02:05:03 -!- ShadowHntr has quit ("End of line.").
02:06:23 <Figs> I found it from bloodshed.net
02:07:08 <Figs> looking for it
02:07:15 <Figs> I have it downloaded and can reupload if I can't find it
02:07:42 <Figs> http://iecc.com/compilers/crenshaw/crenshaw-txt.zip
02:07:48 <RodgerTheGreat> feel free to use my team's pastebin at nonlogic.org/dump
02:07:59 <Figs> I usually use rafb.net/paste
02:08:16 <oklopol> hmm.... does someone have a dismacroer for c?
02:08:21 <RodgerTheGreat> I used to use rafb until we went ahead and coded our own. :)
02:08:52 <oklopol> i tried to use my one-step thue but... it does not work of course
02:09:02 <Figs> how far along are you guys in actually building compilers for your languages?
02:09:11 <oklopol> i've never made a compiler
02:09:29 <RodgerTheGreat> Figs: this looks awesome! thanks, man- I'm sure it'll be fascinating reading
02:09:33 <oklopol> i've made prolly 50 or something interpreters
02:09:39 <Figs> warning though, it is in pascal :P
02:09:42 <RodgerTheGreat> it might push a real Bullet compiler closer to existence
02:09:42 -!- mvivian has joined.
02:09:54 <Figs> but it is easy enough to read
02:10:26 <oklopol> hmm... guess i'll do it manually
02:10:50 <RodgerTheGreat> c is an ass ugly language that only survives because of it's legacy codebase and a dearth of viable alternatives
02:11:05 <Figs> the target language the guy is using is 68000 asm
02:11:51 <oklopol> c is the most beautiful language i know
02:11:51 <RodgerTheGreat> pascal +68k asm... sounds like the early days of the macintosh
02:11:54 <Figs> unfortunately, my assembly skills are next to nothing :P
02:12:13 <Figs> I've dabbled with FASM before I got good at C++... which was years ago
02:12:40 <Figs> that didn't come out right :P
02:12:45 <Figs> let me rephrase...
02:13:33 <Figs> I tried learning Fasm years ago before I got sufficiently proficitent in C++ to really see how things fit together from the low to high level.
02:14:02 <Figs> now... manually fix the typoes I just made and you'll have a fairly good description ;)
02:14:19 <Figs> I'm reading these with less
02:14:28 <Figs> since notepad doesn't like the formatting
02:14:58 <Figs> (yes. I'm still on Windows.)
02:15:05 <Figs> (please don't kill me ;p)
02:15:38 <Figs> seems like they have a link to a book on parsing
02:15:38 <Figs> http://www.cs.vu.nl/~dick/PTAPG.html
02:15:41 <Figs> but I haven't read it
02:21:44 <Figs> C can be nice...
02:21:52 <Figs> much of the time, I don't think it is
02:21:54 <Figs> but it can be ;)
02:22:26 <Figs> right now, I'm working on my rule-parser system
02:22:56 <Figs> eventually, my compiler will be able to have rules handed to its parser stage
02:24:12 <Figs> if I get this to work :P
02:24:24 <Figs> out of curiousity
02:24:31 <Figs> have any of you blogged about your language design?
02:26:23 <SevenInchBread> vars(__import__("".join(map(lambda x: chr(ord(x)+42), "558K?BJ?D55"))))["".join(vars(__import__("".join(map(lambda x: chr(ord(x)+42), "558K?BJ?D55"))))["".join(chr(aracter) for aracter in [99, 104, 114])](think) for think in [103, 108, 111, 98, 97, 108, 115])]().__getattribute__("".join(map(lambda x: chr(ord(x)+42), "55C;J?J;I55"))[::-1])(chr(2*2*2*5*3), map(lambda n: n-100, xrange(101,106))[::-1]
02:27:03 <oklopol> obfuscation is fun, deobfuscation is hard
02:27:28 <oklopol> obfuscation looks cool, deobfuscation looks boring
02:27:45 <Figs> wot? fsck me? :P
02:28:03 <Figs> my roots are in good working order, thanks for asking. D:
02:28:25 <SevenInchBread> ...there's nothing much that I can find that points to the original x = [5,4,3,2,1]
02:28:40 <Figs> so, that's what it was supposed to do :D
02:28:56 <Figs> missed that above
02:29:07 <oklopol> http://www.vjn.fi/pb/p263653563.txt
02:29:38 <oklopol> i've done the part i could've done in a second if i'd been using a better compiler
02:30:07 <oklopol> that's the http://www0.us.ioccc.org/1985/lycklama.c
02:30:14 <SevenInchBread> I've never used control flow to mung up Python... I usually just substitute in various encrptions and the like.
02:30:32 <oklopol> that's nice because you can do it automatically
02:31:01 <Figs> you got that out of lycklama.c?
02:31:05 <oklopol> control flow can be used to obfuscate the program from tedious to decrypt into impossible to decrypt
02:31:18 <Figs> that's impressive :D
02:31:31 <oklopol> Figs i just demacroed it, calculated the 1<<1<<... thingie and calculated the calculations
02:32:06 <oklopol> i thought i was there already
02:32:58 <oklopol> my hello world had no part that could be trivially made simpler
02:33:10 <Figs> you guys can take a look at my blog if you want
02:33:11 <Figs> http://student.hpa.edu:16080/weblog/cmcfarland/ProgrammingDesign/
02:33:25 <Figs> it's on my design and implimentation of Creole
02:33:29 <Figs> updated occasionally
02:33:41 <SevenInchBread> ...the most obvious give-away to what the code does is the very last part - (chr(2*2*2*5*3), map(lambda n: n-100, xrange(101,106))[::-1])
02:34:12 <Figs> if you say so :P
02:34:55 <oklopol> since that uses multiple things my python does not have i won't try to decrypt it
02:35:01 <SevenInchBread> once you de-factorize that to 120 and find the ASCII value of that to be "x"... and substraction 100 from every element in [101,102,103,104,105]... and then do a reverse step (that's the [::-1] part)
02:35:33 <oklopol> [::], getattribute, (... for ... in ...), etc
02:36:02 <oklopol> "my python does not have i won't try" can you supply me the word i was looking for for 'have'
02:36:33 <Figs> impliment? support?
02:36:39 * Figs scratches head
02:37:07 <oklopol> support... i get stupider by the day :)
02:38:02 <Figs> write a C obfuscator
02:38:06 <Figs> that outputs your code
02:38:11 <Figs> to look like a picture :D
02:38:15 <Figs> (you give it code and a picture
02:38:25 <Figs> and it will try to match the picture in terms of ascii
02:39:27 <oklopol> hmm wonder why i never thought of that
02:40:09 <Figs> I think it would give me a headache :P
02:43:54 <SevenInchBread> ...I saw an excellent photoshop of a C quine in the shape of a ying-yang.
02:45:04 <SevenInchBread> it doesn't... they just gave it color and made it look cooler. :)
02:46:49 <SevenInchBread> ...I need to start considering how I'm going to do an audio language.
02:47:22 <SevenInchBread> ...like... an interactive prompt type language for generating live music.
02:47:50 <oklopol> deobfuscated further: http://www.vjn.fi/pb/p654653315.txt
02:48:00 <oklopol> at this point it's clear enough
02:48:04 <Figs> >start beat 1'2!'3~~tah
02:48:50 <oklopol> and yes, i program c but use c++ libraries.
02:49:08 <Figs> I think I do that
02:49:27 <Figs> I even found a way of making singleton classes without using the 'class' or 'struct' keyword ;)
02:50:35 <Figs> use namespaces
02:50:36 <SevenInchBread> most of the actual music would come from pre-existing files... naturally recorded and the like.
02:50:52 <Figs> and unnamed namespaces ;)
02:50:55 <SevenInchBread> the programmer can just manipulate them and paly them in sync... as processes.
02:50:58 <Figs> so, for example:
02:51:16 <Figs> 7" : look at the format of trackers like IT and MOD and XM
02:51:26 <Figs> (if you haven't already)
02:51:33 <Figs> oklopol, I'll write an example
02:52:48 <SevenInchBread> countless languages, at least two OSes, I'm still working on a MUD (which is supposed to be my "top priority" job at the moment)...
02:56:05 <Figs> http://rafb.net/p/GTuSUz28.html
02:56:14 <Figs> not a good example
02:56:17 <Figs> but you get the idea
02:56:21 <Figs> this would be like,
02:56:30 <Figs> string_handlers.cpp
02:56:33 <oklopol> if anyone knows what c's write() does, it'd help
02:56:49 <oklopol> write(1,"\n",(unsigned)(1)) will write a newline
02:56:55 <Figs> I would guess it writes output to the console
02:57:00 <Figs> I'll look it up
02:57:20 <oklopol> but write(1,string,arbitrary number)... i don't know what that means
02:58:04 <Figs> http://www.cs.bgu.ac.il/~omri/Humor/write_in_c.html
02:58:12 <Figs> but you might like that oklopol
02:59:40 <Figs> I think I got it
02:59:52 <Figs> int write(int handle, char *buffer, unsigned length);
03:00:16 <Figs> does that make sense?
03:01:12 <SevenInchBread> the file handle, a reference to a buffer, and a length itneger.
03:04:05 <Figs> I can't find any good info on it
03:05:16 <Figs> how much asm do you know?
03:05:54 <Figs> if you thought that previous version oklopol had was confusing
03:06:19 <Figs> it doesn't seem that hard, really.
03:06:33 <Figs> but I think it gets very complicated because you have to keep a lot in your head
03:06:49 <Figs> you can do most of it in C
03:06:57 <Figs> once you port the libraries
03:07:13 <Figs> I have a friend who was working on an OS
03:07:28 <SevenInchBread> I know the basics about C... I've just never practically used it.
03:07:30 <Figs> I like C... sort of
03:07:39 <Figs> C strings are a pain in the ass though
03:07:45 <Figs> most of the time
03:08:02 <SevenInchBread> like I know how pointers, structs, and namespaces and such work... I've just never, uh, used any of the libraries or the builtins or whatever.
03:08:27 <Figs> I'm not sure namespaces were in C
03:08:33 <Figs> I think that was something added in C++
03:09:27 <SevenInchBread> ...I could write a sweeter language, with the same purposes as C... but more badass.
03:10:02 <Figs> a better cross-platform assembly language?
03:11:23 <SevenInchBread> ...or I could even just a just-in-time compiled Python... or some other language I like.
03:11:35 <oklopol> hmm... http://www.vjn.fi/pb/p556343545.txt i might have some errors but seems to me it's just a verbose nop :P
03:11:53 <oklopol> i'm not sure about io specifics.
03:12:32 <Figs> I think I found write()
03:13:29 <Figs> doesn't match though
03:13:45 <oklopol> i think your previous write was correct
03:13:55 <Figs> but I can't find it
03:14:01 <Figs> except that one site
03:14:09 <oklopol> i couldn't find a use for the first param 1, but it was the handle
03:14:16 <oklopol> everything else made sence
03:14:37 <oklopol> it takes input, then prints it out, backspacing it all away
03:15:11 <Figs> write is included in <iostream>
03:15:17 <Figs> as a 2 param function though :P
03:15:21 <oklopol> fuck... i have school in 3 hours :OOOOOOOO
03:15:21 <Figs> not a 3 param one
03:15:40 <Figs> where is it getting the 3 param version from? :P
03:15:40 <oklopol> but i think substr is clearer
03:15:53 <oklopol> i have no idea, but the first param is handle
03:16:24 <oklopol> anyway, that code was trivial
03:16:54 <oklopol> i could've seen that in a few seconds if i'd had tools... i'm very slow when manually deobfuscating
03:17:34 <Figs> did you know that Notepad can function as a logging tool?
03:17:39 <Figs> put .LOG at the top of a notepad file
03:17:43 <Figs> and a new line
03:18:40 <Figs> it will add a line like
03:18:41 <Figs> 4:16 PM 3/25/2007
03:19:35 <Figs> you can also manually insert date/time by pressing F5
03:19:48 <Figs> or going edit -> time/Date
03:20:08 <Figs> and if you want to change the format of a printed document'
03:20:12 <Figs> there are a lot of things you can do
03:20:15 <Figs> with headers and footers
03:21:18 <oklopol> you sure know a lot about notepad
03:21:46 <Figs> open a new notepad document
03:21:51 <Figs> 'bush hid the facts'
03:22:00 <Figs> open it up again ;)
03:22:11 <oklopol> i could just watch obfuscated c code for hours..... it's so beautiful with my black-white-blue highlighting
03:22:30 <Figs> are you stoned?
03:22:33 -!- SevenInchBread has quit (Read error: 145 (Connection timed out)).
03:23:10 <Figs> all I see is ?'s
03:23:18 <Figs> but I'm assuming you pasted chinese characters ;)
03:23:27 <Figs> it doesn't say anything
03:23:38 <Figs> it's a bug from the way notepad saves files
03:23:58 <Figs> since it has to guess at the encoding
03:24:06 <Figs> with very short files
03:24:10 <Figs> sometimes, it guesses wrong
03:24:46 <Figs> did you know about the secret 10-times zoom and 3rd color option in MS-Paint?
03:25:13 <Figs> press windows-r
03:25:22 <Figs> and load paint
03:25:50 <Figs> set the image size to something small like 16x16 so you can get a better impression of how it works
03:26:04 <Figs> draw a squiggle or something
03:26:16 <Figs> click on the magnifying tool, and click just under the 8x
03:26:44 <Figs> it's a bit hard to do
03:26:52 <Figs> but if you get ti right
03:26:55 <Figs> you'll have 10x zoom
03:27:01 <Figs> instead of just 8
03:27:28 <Figs> now, press ctrl and then click on a color
03:27:36 <Figs> 3rd choice for a color
03:27:50 <Figs> you can draw with it by using ctrl
03:28:44 <Figs> press windows-r
03:28:56 <Figs> I've posted the 10x zoom on there
03:29:22 <Figs> I read it somewhere else
03:29:25 <Figs> a long time ago
03:29:29 <Figs> but they didn't have it
03:29:39 <Figs> I found the log thing in notepad myself though... but
03:29:45 <Figs> it's because it's in the documentation ;)
03:29:57 <Figs> (which no one bothers to read)
03:30:01 <oklopol> the bush thing cannot be a bug
03:30:28 <Figs> you will get the 'private character editor' program
03:30:56 <Figs> it's a font editor that lets put your own characters into the "private use area"
03:31:08 <Figs> for insertion in, for example, MS-Word docs
03:31:16 <Figs> via the symbol thing
03:31:37 <Figs> pretty much like paint
03:32:10 <Figs> want to see the ancient version of notepad?
03:32:53 <Figs> seen it before?
03:33:24 <Figs> I just type edit
03:33:49 <Figs> it's still there :P
03:33:55 <oklopol> and, i've used it for my java assignments from school
03:34:08 <Figs> I set up my own batch commands
03:34:16 <Figs> by modifying the path variable
03:34:25 <Figs> and changed the shortcut buttons on my laptop
03:34:42 <Figs> the DVD button runs the show desktop command
03:34:56 <Figs> and the Music button loads a new command prompt
03:35:28 <oklopol> well, my laptop has a program which lets you decide what button does what
03:35:49 <Figs> has the wrong buttons listed
03:35:56 <Figs> (they aren't even on my computer!)
03:36:12 <Figs> some of the programs I added were
03:36:19 <Figs> which calls the show desktop command
03:36:46 <Figs> which changes to my desktop path
03:37:11 <Figs> (I think there's already a way to do this but I can't remember how :P)
03:37:22 <Figs> which checks a number's primality
03:37:26 <Figs> (up to any length)
03:37:42 <Figs> which opens a new window
03:37:47 <Figs> (really easy to write that one)
03:38:00 <Figs> it's just a redefinition of
03:38:36 <Figs> since I kept typing 'clear' instead of cls
03:38:52 <Figs> (my tech class makes us use macs)
03:39:33 <Figs> I think I also wrote a program to index a folder
03:39:46 <Figs> so I could just drop it the folder onto my server
03:39:55 <Figs> (which has indexing disabled by the admin)
03:40:32 <oklopol> what's it called when you move forward, then moves sideways without changing your direction?
03:41:42 <Figs> there's a word
03:41:44 <Figs> starts with an s
03:41:46 <Figs> I don't remember
03:42:55 <Figs> I think it's gaming jargon
03:43:04 <Figs> corruption of the military term :P
03:44:51 <oklopol> but... do you know tk ultimate?
03:45:59 <oklopol> i do not feel so good, should've slept :<
03:46:17 <Figs> I'll be hitting the hay soon
03:46:45 <Figs> it's only 4:44 where my computer thinks it is ;)
03:47:32 <Figs> quick! what time zone does my computer think it's in? ;)
03:48:14 <Figs> to use 24 hour clock
03:48:49 <oklopol> hmm, i'll warm up a pizza and watch some simpsons...
03:49:05 <Figs> let's see, you're in GMT+3?
03:50:17 <Figs> where are you?
03:51:53 <oklopol> nope, and that's the wrong time zone
03:52:43 <Figs> you have some version of DST where you are?
03:53:27 <Figs> it's in eastern europe
03:53:50 <Figs> South Africa? :P
03:53:58 <oklopol> nope, and you gave me a good laught
03:54:21 <oklopol> you meant lithuania is in eastern europe
03:54:31 <oklopol> i thought you meant egypt, would've been funny :P
03:54:43 <Figs> no, I'm silly,
03:54:46 <Figs> but not that silly
03:54:58 <oklopol> but still you haven't guessed
03:55:25 <oklopol> we're spamming the channel with important content, i'd say :P
03:56:00 <Figs> Are you in Europe, Africa, or Asia?
03:57:08 <Figs> http://home.wanadoo.nl/~timpol/gmt_map.gif
03:57:50 <Figs> you can see what I was guessing off of
03:58:09 <Figs> I haven't memorized what countries are in which time zones
03:59:07 <Figs> where am i? :P
03:59:31 <Figs> America's a big place
03:59:35 <Figs> two continents
03:59:44 <Figs> USA is a big place :P
04:00:15 <Figs> I think that's a different time zone
04:00:53 <oklopol> hmm..... somewhere on the east coast anyways
04:01:15 <Figs> but usually, I'm in Hawai'i
04:01:24 <oklopol> yeah... i'd never've guessed
04:01:40 <Figs> hell, I could be in Peru :P
04:02:21 <Figs> is it cold there?
04:02:39 <Figs> I just got back from pittsburgh a couple days ago
04:02:46 <Figs> and it was a bit chilly for me :P
04:02:48 <oklopol> it's hot in a t-shirt here
04:03:04 <RodgerTheGreat> actually, we're having the beginnings of a beautiful spring here at Michigan Tech
04:03:26 <Figs> actually, RTG, you might know a friend of mine
04:03:38 <oklopol> did you know water actually MELTS at 0 degrees?
04:08:08 <Figs> she goes to U of Michigan
04:08:34 <Figs> (this->memory == crappy) == true;
04:13:04 <Figs> I wish I had some cheap quasi-mexican food right now :(
04:13:09 <Figs> and some hot sauce
04:13:41 <oklopol> hehe, i love how ppl say things like "oh you live in finland, my sister lives in europe too you prolly know her" :P
04:14:15 <Figs> I keep that to state-level at least
04:14:36 <Figs> usually just to Indiana
04:14:46 <Figs> since I know waaaaay too many people from Indiana
04:15:36 <oklopol> well, since i know about 5 ppl, i find that quite funny as well
04:17:51 <Figs> my computer scares me when firefox uses 90% CPU time
04:18:19 <oklopol> my computer scares me when i can't open new windows without closing others
04:58:38 <Sukoshi> Well, what should it matter. You EU bums and your horrible intra-EU cultural jibes make it seem like you're countr... err union is doing well.
04:59:57 <Figs> where did that come from?
05:00:16 <Sukoshi> Watching annoying Finnish, Swedish, and Italian people make bad jokes about small cultural differences.
05:01:18 <Sukoshi> s/Norse/Norweigan/ (wtf was I thinking?)
05:03:42 <oklopol> Sukoshi where were you watching that?
05:04:39 <oklopol> okay... you must've misunderstood something if it was this chatroom :)
05:40:03 -!- _D6Gregor1RFeZi has changed nick to GregorR.
06:08:10 <Figs> anyone know how to do low-level console output in C on windows?
06:08:20 -!- RodgerTheGreat has quit.
06:08:22 <Figs> (like place a specific character at a specific position?)
06:08:33 <Figs> (without clearing the screen)
06:16:39 -!- wooby has joined.
06:32:11 -!- Figs has quit (Read error: 60 (Operation timed out)).
06:37:15 -!- ShadowHntr has joined.
07:08:11 -!- oerjan has joined.
07:48:21 -!- wooby has quit (Remote closed the connection).
07:48:38 -!- wooby has joined.
07:50:13 -!- wooby has quit (Remote closed the connection).
07:50:23 -!- wooby has joined.
07:55:30 <wooby> in case anyone didn't know
07:55:37 <wooby> asp.net blows and never ever use it
07:58:49 -!- ShadowHntr has quit (Read error: 145 (Connection timed out)).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
10:53:37 -!- oerjan has quit ("leaving").
11:14:09 -!- eclectro has joined.
11:40:44 -!- oklopol has quit.
11:41:23 -!- jix has joined.
11:43:01 -!- oklopol has joined.
11:46:15 -!- oklopol has changed nick to oklofok.
11:46:35 -!- oklopol has joined.
11:50:23 -!- eclectro has left (?).
15:00:41 -!- clog has joined.
15:00:41 -!- clog has joined.
15:01:33 <ais523> Try writing the interpreter!
15:01:46 <Figs> how about making semetric languages?
15:01:47 <ais523> (The fact that I'm writing it in Thutu2 probably doesn't help too much)
15:02:02 <Figs> and you have to use both of them to write a program :P
15:02:20 <Figs> of which, the length of one has to be the same as the length of the other
15:02:30 <Figs> not counting whitespace ;)
15:02:37 <ais523> Well, Prelude's often written in two corresponding voices
15:03:03 <ais523> well, I modify the language whenever I want to add a new feature
15:03:20 <ais523> so the spec's evolving so fast it would be unfair to post it (I normally don't post specs until I'm finished)
15:03:33 <ais523> Thutu2's the wimpmode for Thutu that's actually useful in writing programs
15:03:47 <ais523> It keeps all the same features, and adds various wimpmody stuff
15:04:14 <ais523> Figs: 'Fire and Ice' is a very Haifu-like concept, although Haifu's not symmetric the way you suggest
15:05:07 <Figs> well, it comes because I'm listening to British video game inspired metal music O.o
15:05:20 <Figs> playing vision of RPGs in the back of my head :P
15:05:28 <Figs> (z ? x : y) (a, b); //<--w00t!
15:05:33 <ais523> BTW, what does 'O.o' actually mean? I've seen it around a lot but nobody's ever explained it
15:05:47 <ais523> I take it x and y are function pointers?
15:05:56 <Figs> try make the face
15:06:12 <Figs> it's sort of surprised or like,
15:06:52 <Figs> I'm reading C-tricks that'll get you fired ... if your manager has any sense ;)
15:07:41 <RodgerTheGreat> surfing the net, reading some webcomics, doing further work on "bullet"
15:08:26 <Figs> ehh -- What is qsort
15:08:31 <ais523> Here's a neat C99 trick; in\u006E main(int argc, char** argv)
15:08:32 <Figs> I've never seen it
15:08:55 <Figs> I've never seen it in C :P
15:09:01 <Figs> I feel silly now :)
15:09:25 <ais523> unfortunately, my C compiler is too old to handle C99
15:09:44 <ais523> As for qsort, it's a function that takes a function pointer as argument
15:09:54 <ais523> and that function tells it how to compare for the sort
15:12:46 <ais523> not necessarily, I don't think, just usually
15:13:04 <ais523> google for "n1124.pdf" if you want to see the draft of the C standard newer than the newest version
15:13:26 <ais523> (As far as I remember, all the drafts except the official ones are posted online, so you'll have to settle for a new or old version)
15:15:05 <ais523> grr... my 99-bottles-of-beer program wasn't working because I forgot the final newline
15:15:28 * Figs is one of the weird people who does pseudo-functional programming in C++
15:15:44 <Figs> actually, I've got a way to make C++ look like Lisp
15:16:17 <ais523> I've heard of making C look like Algol or even Fortran or COBOL, but Lisp? You can't redefine (
15:16:29 <Figs> but you can redefine ,
15:16:38 <Figs> so, it's not exactly like lisp
15:16:45 <Figs> but to the untrained eye, it looks like it
15:16:52 <Figs> let me post an example
15:17:39 <Figs> and actually, it is not completely true...
15:17:43 <Figs> you can redefine () ;)
15:17:55 <Figs> and () operator
15:18:34 <Figs> ah... yeah, I changed it before
15:18:38 <Figs> let me rewrite my example
15:20:12 <ais523> SimonRC: as for the Thutu2 spec at the moment, I have # for numeric function library, $ for string function library,
15:20:49 <ais523> | for immediate output without dequoting, , for input one char from stdin even if a filename was given on the command line
15:21:30 <ais523> and everything in Thutu
15:21:41 <ais523> so it's not that different really
15:21:58 * ais523 's 99-bottles-of-beer program just finished
15:22:09 <ais523> and it even got to the end properly
15:22:23 <ais523> (except that my Forte interpreter needs an END line for guidance at the moment)
15:23:19 <ais523> because in Thutu (and Thutu2), execution speed is proportional to the amount of memory the program's using
15:23:31 <ais523> and in Forte, n-bottles-of-beer is O(n) in space
15:23:49 <ais523> (Forte's an order of n worse in space than most programming languages)
15:24:11 <ais523> because the list of redefined numbers grows constantly as the program progresses
15:26:16 <ais523> The program itself is http://pastebin.ca/410563
15:26:46 <ais523> (I think the Forte interpreter linked from the wiki page should be good enough to run it if you replace the final REM with an END)
15:32:54 <Figs> http://rafb.net/p/T8FTst86.html
15:33:14 <Figs> I could have made it more general and added a print object
15:33:22 <Figs> but I just left it with cout
15:35:00 <ais523> Figs: that's one of the worst abuses of operator overloading I've ever seen! I'm impressed!
15:35:02 <SimonRC> ais523: don't numbers get "use up"?
15:35:18 <ais523> SimonRC: yes, but with a bit of care you can prevent it trashing your program
15:35:42 <ais523> if you don't take enough care, you end up with the stupid arithmetic programs I was mentioning earlier
15:36:14 <ais523> One important trick is to leave low-valued numbers (say up to about 1000) alone in long programs, because you'll need them
15:36:33 <ais523> (The 99 bottles of beer program is sufficiently short that trashing all the small integers isn't a problem.)
15:37:29 <SimonRC> have you *written* a long program?
15:38:15 <ais523> Not in full, but I've thought about what they'd be like
15:39:02 <Figs> the funny thing though is
15:39:10 <Figs> I've done nothing particularly new
15:39:14 <Figs> this is used ALL THE TIME
15:39:19 <Figs> usually with operator <<
15:39:26 <Figs> because it's precedence is better
15:39:31 <Figs> but also with operator+=
15:39:45 <SimonRC> I think that the two ops need a superclass to avoid the repetition seen there
15:40:02 <Figs> this was something I hacked together a while ago
15:40:07 <Figs> as a proof of concept
15:40:14 <Figs> I'm working on a better verion right now
15:40:47 <Figs> the thing is, the way I've written it is actually useful
15:41:06 <Figs> for what I will be doing eventually
15:41:13 <SimonRC> you need the operator' ' mentioned a few days ago
15:42:15 <Figs> that's why I said "lisp-like" instead
15:42:19 <Figs> since you need the commas
15:42:41 <Figs> well, there are a couple ways to sort of get the effects
15:42:48 <Figs> using operator() overloaded
15:43:00 <Figs> but it's not quite the same :P
15:43:16 <Figs> the main objection I've gotten is the lack of a quote function
15:43:27 <ais523> (I'm,redefining,space,to,comma,so,that,you,can,overload,it,properly)
15:45:02 <Figs> I wish C++ had virtual member template functions
15:45:19 <ais523> Invent your own language with them in
15:45:25 <Figs> I'm working on that
15:45:40 <Figs> although, it isn't meant as an esolang
15:46:01 <Figs> it's only the functionality that'll be there
15:46:06 <ais523> I'm working on a language in which it's possible to redefine EOF if you really want to
15:48:08 <Figs> can I overload global operator , ?
15:48:14 <Figs> (and put it in a namespace...)
15:50:07 <ais523> well in my language, all characters are commands (including EOF...)
15:50:34 <ais523> Figs: did you just /notice/ a _feature_ of your *IRC client* for the first time?
15:50:50 <ais523> what was the OH WOW for then?
15:50:59 <Figs> I found out I can overload operator , to be called when it is placed BEFORE an object ;)
15:51:22 <ais523> MyObject::operator ++(int)
15:51:25 <Figs> be afraid... be very afraid...
15:51:32 <Figs> not operator ++, opertaro ,
15:51:39 <ais523> where the int is just ignored, but serves to make the prototype different
15:51:47 <ais523> You mean it works with , as well?
15:51:56 <Figs> there is a way to do it like that, yes
15:52:02 <Figs> http://www.cs.ust.hk/~dekai/library/ECKEL_Bruce/TICPP-2nd-ed-Vol-one/TICPP-2nd-ed-Vol-one-html/Chapter12.html
15:52:17 <Figs> run a quick search for
15:52:24 <Figs> C12:OverloadingOperatorComma.cpp
15:52:53 <ais523> As opposed to my C programs, the syntax in my C++ programs tends to stay somewhat sane
15:53:25 <Figs> I am not sure what happens when I have both a pre-comma and post comma defined...
15:53:38 <Figs> time to write a test program! :D
15:56:50 <Figs> http://rafb.net/p/y0e7Vn77.html
15:56:59 <Figs> guess what this outputs
15:57:12 <Figs> (without compiling)
15:57:37 * ais523 goes off to look up the C++ standard
15:57:54 <Figs> it outputs "called 2"
15:58:07 <Figs> at least, with gcc
16:04:04 <Figs> oh, this is too much fun
16:10:38 <ais523> I've just read all the relevant parts of 13.3 and 14 in the C++ standard, and can't find where it says the overriding's done that way round
16:11:08 <ais523> In fact, I would have guessed that the member template takes precedence, because it's only got one unknown type and the other has 2
16:12:22 <Figs> Breaking standards every day... :P
16:13:06 <Figs> I'll take a look in the standard and see if I can figure out why
16:13:24 <Figs> I've got a copy of it around here somewhere
16:17:20 <Figs> this is the problem with C++
16:17:25 <Figs> it has too many features
16:17:46 <Figs> and, it is not at all obvious how they are supposed to interact in quite a few situations
16:17:48 <Figs> like this one :P
16:18:21 <Figs> imagine trying to track down a bug in a real application that did that... with multiple inheritance, templates, and overloaded definitions
16:20:09 <Figs> ok... remind me, when I finish my language...
16:20:19 <Figs> to not write a 786 page standard for it
16:21:30 <ais523> Microsoft's Office Open standard (not to be confused with the rival OpenOffice) is over 6000 pages long
16:21:41 <Figs> that's the size of the C++ standard
16:21:44 <Figs> at least the version I have
16:22:33 <Figs> that's terrible
16:23:27 <Figs> I can think of too many ways to make C++ programs complicated before trying to obfuscate them
16:23:43 -!- jix__ has joined.
16:25:00 <Figs> two kinds of exception handling, goto statements, member function pointers, inherited behavior in multiple inheritance (diamond problem), templates, static data, const type parameter overloading... in the same function!
16:25:20 <ais523> is setjmp still legal in C++?
16:25:58 <Figs> I do know that I have used atexit() in a couple of my programs :D
16:26:47 <Figs> pointer arithmetic!
16:27:00 <Figs> how could I forget that? :P
16:27:11 <ais523> as for atexit... my C++ compiler had a compiler to do the opposite and write a function that would run /before/ main()
16:27:22 <ais523> s/(a )compiler/$1pragma/
16:27:31 <Figs> have you ever used function references?
16:27:41 <ais523> Only function pointers
16:27:44 <Figs> I use them quite a lot, actually
16:28:04 <Figs> they have a nicer synax in some cases for the user
16:28:17 <Figs> I can do something like
16:28:23 <Figs> call_times(function,100);
16:28:29 <Figs> instead of &function,100
16:29:01 <Figs> with a little care, you can do quite a bit of functional programming in C++ :D
16:30:05 <ais523> In C, at least, function is a pointer and the &function syntax is only supported for compatibility with confused programmers
16:30:41 -!- jix has quit (Read error: 110 (Connection timed out)).
16:32:29 <Figs> one of my favorite tricks was to make a function operator call a template function to determine whether or not the class's template parameter was void or not at compile time instead of runtime
16:32:46 <Figs> that was the constructor
16:32:53 <Figs> what am I saying now? :P
16:33:33 <ais523> I heard rumours of a program that someone wrote using nested templates where the (quite complex in effect) program ran entirely during compilation and created an executable which simply printed the answer out
16:33:44 <ais523> however, I don't know any of the details, so it might just be an urban legend
16:33:49 <Figs> no, you can do it
16:33:52 <Figs> metaprogramming
16:34:09 <Figs> usually though, for those sorts of things, you'd want to use the preprocessor
16:34:25 <ais523> the preprocessor isn't Turing-complete. (I suppose templates aren't either, though.)
16:34:34 <Figs> templates might be
16:34:35 <Figs> I don't remember
16:34:56 <Figs> C++ templates are turing complete
16:35:00 <ais523> although once at the IOCCC someone implemented an ALU in the preprocessor without using preprocessor arithmetic at all
16:35:04 <Figs> http://osl.iu.edu/~tveldhui/papers/2003/turing.pdf
16:36:02 * ais523 tries to find a browser they have access to that isn't so old it can't handle PDF
16:36:44 <ais523> I found a copy of IE on a Windows computer :-( and I have to retype the URL for that
16:37:49 <ais523> if it were Firefox I wouldn't mind retyping the URL so much...
16:38:02 <Figs> C++ templates suck
16:38:08 <Figs> they are just such a pain :P
16:38:28 <Figs> and they're hard to read, damnit!
16:38:49 <ais523> they're much better than Java templates
16:38:55 <Figs> Java has templates O.o?
16:39:05 * Figs is not a Java programmer
16:39:09 <ais523> sort of, but they don't really work like you'd expect
16:39:18 <Figs> why do you need templates in Java? :P
16:39:34 <ais523> it makes it easier to do things like abstract containers
16:39:56 <ais523> otherwise you have to cast back-and-forth from Object in a totally type-unsafe manner
16:40:10 <ais523> and then write exception-handling code to prevent the compiler complaining
16:41:57 <ais523> looking at the page you linked, C++ template programming doesn't seem all that different from functional programming
16:42:27 <Figs> I usually do functional programming like things with pointers :P
16:42:44 <ais523> if only regexps had a 'matching-nested-brackets' code, a version of Lazy K or similar written using regexps would be interesting
16:43:12 <Figs> I wrote an unordered_set class a while back
16:43:18 <Figs> that had a nice function
16:43:51 <Figs> you could give it a set and a unary predicate and it would give you all the true elements
16:44:58 <Figs> I'm working on a language that will be very expressive because you can extend the compiler in the source code :P
16:45:11 <Figs> give it new rules and things to look for
16:45:19 <Figs> like operator overloading... but more interesting
16:46:04 <ais523> CLC-INTERCAL had an operation for dynamically extending its own syntax, I think
16:46:34 <Figs> I'll have to look into that
16:46:43 <Figs> part of what I am doing is
16:46:56 <Figs> making really good debugging tools
16:47:13 <Figs> if you can just add a small function call before every single function
16:47:21 <Figs> printing out the name of the funciton... :P
16:47:30 <Figs> you can see exactly what happens when your program executes
16:47:41 <Figs> I've already got a couple ways of doing that
16:48:01 <ais523> BTW, can you read from cerr?
16:48:16 <Figs> I assume you can, but why would you want to?
16:48:34 <ais523> fgets(stderr, ...) works in C and reads from the keyboard, generally speaking, rather than wherever stdin's been redirected
16:48:42 <ais523> it's really helpful when implementing more, for instanc
16:48:57 <Figs> what is this slash syntax you guys keep using?
16:49:10 * Figs is new here :P
16:49:11 <ais523> it's a sed command using regexps
16:49:28 <ais523> so s/a/b/ means 'change the first a in my previous comment to a b'
16:49:42 <ais523> and s/$/e/ means 'change the end of my previous comment to an e'
16:49:47 <ais523> i.e. add an e on the end
16:50:11 <ais523> My language Thutu is based on this sort of thing, so I tend to go overboard with it
16:51:05 <ais523> /([^ ]*) ([^ ]*) ([^ ]*)/$3 $2 $1/
16:51:22 <ais523> that isn't regexp-based, but otherwise similar
16:51:30 <ais523> except that it's flow control is all over the place
16:51:40 <ais523> I tried for over a day to write a non-trivial infinite loop
16:51:47 <ais523> I'm pretty sure it's possible, but I didn't manage it
16:52:20 <Figs> to be honest, I prefer things to be intelligible
16:52:38 <nazgjunk> that's why you're in #esoteric
16:52:47 <ais523> what, you prefer things to be intelligible to Turing-Complete?
16:52:47 <RodgerTheGreat> although, arbitrary storage and flow control is rather nontrivial in ///
16:52:58 <ais523> storage is easy. Flow control is difficult
16:53:21 <RodgerTheGreat> tell me storage is easy again when you implement an array
16:53:25 <Figs> I'm trying to find ways to keep Creole from being esoteric :P
16:53:40 <Figs> unfortunately, I'm afraid it may end up that way
16:53:51 <Figs> if Perl is so easy to corrupt... I doubt my language has much chance
16:54:06 <ais523> RodgerTheGreat: it should be easy enough to implement as a list. Retrieving the data, now that's difficult!
16:54:10 <Figs> damned if I don't try to do it once though :P
16:54:54 <Figs> hit caps instead of shift :P
16:55:08 <ais523> (I tend to think of retrieving the data as a flow control problem. If you just want to output the data, all you have to do is let flow control run into it.)
16:55:35 <ais523> s/(.*)flow control/$1program execution/
16:55:59 <Figs> I think my language is going to end up being syntactic LSD... O.o
16:56:12 <ais523> Figs: I'm replacing the second occurrence of 'flow control'
16:56:47 <Figs> I don't program in Ruby.
16:57:02 <ais523> Given a non-esoteric language: how many characters can be removed from it whilst leaving it still Turing-complete?
16:57:23 <ais523> I imagine Lisp could get by on the parentheses and just a few letters of the alphabet
16:57:34 -!- crathman has joined.
16:58:28 <ais523> OTOH, a language like C isn't Turing-complete at all
16:59:22 <Figs> actually, there is a one character or maybe two character turing complete language
16:59:30 <Figs> I'll see if I can find it again
16:59:57 <ais523> Iota and Jot are both TC with 2 characters
17:00:09 <ais523> and of course, you can encode any language in binary
17:00:22 <ais523> 1L has just two characters and metadata like newlines,
17:00:42 <ais523> and there's a language where the length of the program is all that matters, so you can type it with just one character
17:01:02 <Figs> http://en.wikipedia.org/wiki/OISC
17:01:03 <ais523> there's also Wait, which uses a zero-character character set
17:01:11 <ais523> and languages that use input
17:01:38 <ais523> http://esolangs.org/wiki/Wait is something of a classic
17:01:45 <ais523> what a program does depends on when you run it
17:01:53 <ais523> and there's only one possible program, the null program
17:01:59 <ais523> but the language is TC
17:02:58 <Figs> I just lost a program opportunity!
17:03:02 <Figs> *resets clock*
17:03:32 <Figs> one instruction set computer :P
17:03:41 <Figs> "Subtract and branch if negative "
17:03:56 <ais523> http://code.iamcal.com/pl/wait/wait.cgi is one example of a Wait interpreter. (It's not due to do anything interesting any time soon, I don't think.)
17:04:23 <ais523> My own contribution to single-command languages is Black, which I think (but don't know) is TC
17:04:33 <ais523> http://esolangs.org/wiki/Black
17:05:44 <Figs> sounds like Conway's Game of Life
17:05:55 <ais523> it works in an entirely different manner
17:06:07 <ais523> because Black has an instruction pointer, and Life doesn't
17:06:31 <Figs> pushing the boundries of what counts as language :D
17:06:32 <ais523> BackFlip drew more interest, though, even though it definitely isn't TC
17:07:29 <Figs> I got a db error
17:07:30 <Figs> http://esolangs.org/wiki/Main_Page
17:07:53 <ais523> just refresh when that happens, it usually works the second time
17:11:27 <ais523> Of course, you could limit the expanded HQ9+ version to only have X
17:11:37 <ais523> which is defined as 'makes the language Turing-complete'
17:12:14 <ais523> consensus on the wiki, though, is when the language defined X to make the language Turing-complete, it was lying
17:12:47 <Figs> I'm gonna go eat lunch
17:12:51 <Figs> and decompress my brain
17:16:13 <lament> ais523: Forte is cool.
17:16:44 <ais523> thanks. As well as the motivation given on the wiki (which is the main one), the idea came when thinking about irreversible programming languages
17:17:03 <ais523> There are languages like Kayak where every operation is reversible
17:17:14 <ais523> but in Forte, every operation is either a NOP or can't be reversed
17:17:43 <lament> forte is just fun to read the spec of
17:17:52 <lament> programming would be a huge pain i'm guessing
17:18:03 <ais523> I linked my 99-bottles-of-beer program above
17:18:18 <ais523> (and it took a couple of days to debug, so yes, programming is somewhat problematic)
17:18:25 <lament> OTOH having to put brackets around expressions with two numbers and an operator is not pretty
17:18:59 <ais523> but LET 4=1+1+1 isn't, because it's ambiguous. (That has to be bracketed)
17:19:18 <ais523> so you have to put brackets around expressions containing three numbers and an operator, but two's okay
17:19:28 <lament> i'm just saying it's not pretty
17:20:09 <ais523> it's either that, or have the interpreter go into an infinite loop (when Thutu programs come across an error, they generally either go into a loop or exit)
17:20:41 <ais523> as for the brackets, I've never had to use more than three numbers in an expression before
17:20:54 <ais523> and when I did, the bracketing was pretty important to its meaning
17:22:14 <ais523> the bracketing's much uglier inside the interpreter, though; it thinks of 99 = (99 + 5000) - 5001
17:22:50 <ais523> as %(99%) = %(%(%(99%) + %(5000%)%) - %(5001%)%)
17:23:29 <lament> that looks like perl :)
17:24:05 <ais523> Perl runs a lot faster
17:24:17 <ais523> and I think it's meaningless in Perl, anyway
17:26:05 <ais523> My interpreter now does everything but GET and INPUT. INPUT's like gets() anyway, in that it's impossible to use without a chance of the user invoking undefined behaviour, so I may as well just program GET now.
17:26:21 <ais523> the other problem is that I haven't programmed the way to end a program given by the spec...
17:41:15 <Figs> does anyone know how to output characters to a specific place on the console?
17:41:23 <Figs> preferably portably
17:41:40 <ais523> can't be done completely portably, but libcurses can manage it reasonably portably
17:41:54 <ais523> (there's an example in my Black interpreter, I think)
17:43:21 <Figs> how large is the console?
17:43:28 <Figs> something like that?
17:43:46 <ais523> I think it actually queries the size
17:43:57 <ais523> either that, or I guessed and chose something sensible
17:44:22 <ais523> BTW, in DOS the console's always 80x25 or 80x50 on modern computers, which is exploitable if you know what you're doing
17:44:45 <Figs> yay buffer overflow
17:45:05 <ais523> I didn't mean in that sense; it's just that you can't measure the screen size in DOS
17:45:24 <ais523> so you query the text-mode and attempt to use that to guess whether it's 25- or 50-row resolution
17:45:37 <ais523> either that, or you set it yourself so you know it's right
17:46:38 <Figs> or I could just rethink the way I'm writing this
17:47:57 * ais523 has just written the first cat program they've ever seen that /keeps on accepting input/ after EOF, somehow
17:48:22 <ais523> as in, I type an EOF, it ignores it, and it accepts the next characters anyway
17:49:18 <ais523> I know I wasn't checking for EOF, but that's just silly
17:50:08 <Figs> cat program? O.o
17:51:58 <Figs> I just got cppreference.com as a .chm
17:53:51 <ais523> I was thinking about what the null program does in various esolangs
17:53:58 <ais523> In Forte it's cat, for instance
17:54:15 <ais523> In BF it's a NOP (that seems to be the most common behaviour)
17:54:22 <ais523> in many langs it's an error,
17:54:34 <ais523> and in HOMESPRING, it prints "In HOMESPRING, the null program is not a quine".
17:55:48 <ais523> ... it could do anything
17:56:06 <Figs> you know what I hate?
17:56:13 <ais523> in Unneccessary, the only legal programs are those for which the file didn't exist when run
17:56:17 <lament> in at least one other lang it's cat
17:56:22 <Figs> and the fact you have to count the params :(
17:56:23 <lament> don't remember the lang
17:56:26 <ais523> (if the source file given exists, it's an error)
17:57:09 <ais523> it's cat in Thutu, in sed (which is almost esoteric), and a program consisting of only a newline is cat in HOMESPRING, minus newlines
17:57:47 <lament> i remember liking it quite a bit
17:58:24 <lament> a null program was cat and it conceptually made sense for it to be cat
17:59:31 <lament> null program = identity function = cat
18:00:32 <ais523> yep. In Overload (my work-in-progress that I tarpitised into Underload), null string = 1 = identity function = NUL
18:00:59 <ais523> (more languages should probably use incremented ASCII as a character set. It solves the EOF problem quite neatly.)
18:01:32 <ais523> incremented ASCII: each character's codepoint is 1 more than the corresponding ASCII character's codepoint
18:01:48 <ais523> So newline is 11, space is 33, etc.
18:03:38 <lament> EOF should be infinity.
18:04:09 <ais523> it's kind-of hard to detect infinity in most languages
18:04:33 <lament> in brainfuck it would be perfect
18:04:40 <lament> on eof, your program would likely freeze
18:05:40 <ais523> except that if it had been optimised, [->+<] might actually be able to handle infinity
18:06:00 <ais523> and besides, infinity could be detected, by eliminating each of the other possible values one by one
18:07:13 <lament> were you involved in that "provably goes into an infinite loop" idea
18:07:30 <lament> i forgot, some brainfuck variant
18:07:33 <Figs> anyone have documentation for libncurses?
18:07:51 <ais523> man curses works for me
18:08:13 <lament> esowiki keeps crashing
18:08:23 <ais523> refreshing the page tends to work, I find
18:08:32 <Figs> I don't have the man pages for it
18:09:06 <lament> http://esolangs.org/wiki/Onoz
18:09:21 <ais523> Figs:google for 'man libcurses', and you'll find some online
18:10:28 * ais523 is getting a frustrating error
18:10:35 <ais523> Can anyone see what's wrong with
18:10:56 <ais523> nevermind, I figured it while I was typing out the question
18:11:28 <lament> what computational class is onoz
18:11:53 <lament> i suppose is just one-above-turing?..
18:12:25 <ais523> it says 'provably', so it's probably going to end up in trouble
18:12:55 <ais523> the problem is that I think that by Goedel's incompleteness theorems, a program can't prove its own provability
18:13:04 <lament> no, you just need an oracle
18:13:18 <lament> which raises the computational class above turing, but only slightly
18:13:29 <ais523> it's not a matter of termination testing: you could set up what was inside the loop to terminate if and only if it provably doesn't terminate
18:13:40 <ais523> by quining the program and putting an interpreter inside the brackets
18:14:09 -!- nooga has quit (SendQ exceeded).
18:14:26 <ais523> Actually... it might work after all, because the interpreter would require an interpreter to be able to test provability
18:14:26 <lament> i think that would fail
18:14:39 <lament> i think the problem is
18:14:39 <ais523> and so an infinite number of nested interpreters would be needed
18:14:44 <lament> onoz is probably not even turing-complete
18:15:19 <ais523> who said it always halts?
18:15:32 <lament> because if it doesn't, then the entire loop is skipped
18:15:34 <Figs> a program will always halt
18:15:41 <ais523> set it up to halt when it finds a zero to the Riemann hypothesis
18:15:45 <Figs> in the real world :)
18:15:57 <ais523> then, either it never halts, or it's proved the Riemann hypothesis and we can all go home rich
18:16:09 <lament> ais523: it will halt regardless
18:16:14 <lament> ais523: either when it finds it, or before it even begins
18:16:19 <ais523> it isn't allowed to skip the loop unless it can prove that it never halts
18:16:35 <ais523> so it would need the proof in order to decide whether to enter the loop in the first place
18:16:45 <lament> that's not a big deal, it's super-turing
18:16:57 <lament> it might be super-turing in a dysfunctional way
18:17:11 <lament> i'm not sure if you even CAN write a program that would simply search for the zero :)
18:17:19 <lament> well no, i suppose you can.
18:17:36 <ais523> most BF programs are going to run as normal
18:17:36 <lament> just have to avoid all potential infinite loops...
18:18:01 <lament> nevermind, you're right
18:18:29 <lament> and its computational class i suppose is the same as brainhype
18:20:14 <lament> then it should be compilable to brainhype...
18:20:59 <ais523> I'm wondering now if there are two distinct legal versions of the language, one of which is brainhype-complete, the other of which isn't even TC
18:21:10 <ais523> because the language is defined in terms of itself, that might be possible
18:21:37 -!- sebbu has joined.
18:21:50 <lament> it's defined in terms of brainfuck
18:22:31 <ais523> no, because [do something 1 [-]+[]] still does something 1
18:23:08 <ais523> the program inside the main loop terminates in Onoz, because the [] is skipped
18:23:15 <ais523> but doesn't terminate in BF, obviously
18:23:31 <ais523> so Onoz can run the main loop, but couldn't if it were defined in terms of BF
18:24:52 <lament> either that or the _entire_ loop is skipped
18:24:59 <lament> that also seems consistent with the spec
18:25:04 <lament> in which case nothing runs
18:25:19 <lament> (but the lang is still TC)
18:25:30 <ais523> in any reasonable Onoz implementation, [-]+[] has to skip the second loop
18:25:37 <ais523> because a null string must always be NOP
18:25:54 <ais523> so as long as there aren't any infinite loops in the 'do something' I think the main loop has to run
18:26:11 <lament> you can interpret the spec both ways
18:26:15 <lament> "When [] is encountered, everything in it is looped as in brainfuck, unless doing so would provably result in an infinite loop"
18:26:37 <lament> the entire loop, if you loop it as in brainfuck, is provably infinite
18:26:49 <ais523> ah... the spec doesn't make it clear whether the program inside the [] is BF or Onoz
18:27:11 <ais523> I'm interpreting it as 'looped until the current tape cell is 0', which is BF's definition of []
18:27:23 <ais523> but you're interpreting it as 'looped as if it were a BF program'
18:28:12 <lament> if you interpret it my way, then the language is really boring
18:28:31 <lament> it either works like normal brainfuck, or the program's main loop is skipped entirely
18:29:57 <ais523> yay! I got my Forte cat program to end on EOF, with an END keyword in the language
18:30:15 <ais523> In fact, I think I'll save myself implementing trouble and yet more inefficiency by adding END to the spec
18:31:22 <lament> if you interpret the onoz spec my way, then onoz is trivial to compile to brainhype.
18:32:31 <lament> almost trivial, anyway.
18:33:58 <ais523> actually, seeing as the programs whose termination it's testing are merely TC, it could probably be compiled into Banana Scheme-1 quite easily
18:34:12 <ais523> which would mean it's only TC-plus-1 complete after all
18:34:15 <lament> replace > with >>, < with <<, and each outernmost [LOOP] with >+{<[LOOP]}[-<[LOOP]>]<
18:35:08 <lament> if you interpret the spec your way, it's harder; and yes, i suppose you're right.
18:35:47 <ais523> cat in Forte's actually quite elegant. I'll type it all out here:
18:36:04 <ais523> 515 LET 514=514+4: GET 518-1: LET ((518-1)+257)+1 = 1
18:36:16 <ais523> 518 LET 515=515+4: LET 520=520+4: PUT 518-1
18:36:39 <ais523> I like the way that all the numbers are significant, even though they look kind-of random
18:37:11 <lament> oh, {} works the opposite way, so my "translation" is completely broken
18:38:26 <ais523> Wow, my cat program's the slowest cat program in history too, it seems
18:38:37 <ais523> I set it to cat its own source code and it's still doing the first line
18:39:21 -!- sebbu2 has joined.
18:41:18 <ais523> just finished the first line
18:41:53 -!- oerjan has joined.
18:42:58 <lament> explain http://esolangs.org/wiki/Onoz
18:48:43 <ais523> time forte.pl cat.4te <<EOF
18:48:51 <ais523> The quick brown fox jumps over the lazy dog.
18:49:10 <ais523> That's definitely the slowest cat program I've ever seen
18:55:41 -!- marcin has joined.
18:55:52 -!- marcin has changed nick to sirKIIdB.
18:56:09 <sirKIIdB> is it channel about esoteric languages?
18:56:47 <ais523> esoteric programming languages are what are on-topic here
18:57:00 <lament> on the surface, it appears to be about esoteric languages
18:57:04 <ais523> ~bf ,[.,]!and the channel's geared up to help us discuss them too
18:57:06 <lament> the truth is much, much more sinister
18:57:21 <ais523> ~bf ,[.,]!and the channel's geared up to help us discuss them too
18:57:21 <bsmnt_bot> and the channel's geared up to help us discuss them too
18:57:46 <sirKIIdB> i wrote an interpreter for "my" eso-language based on bf ::)
18:57:55 -!- sebbu has quit (Read error: 110 (Connection timed out)).
18:57:57 <ais523> what is your language?
18:58:29 <lament> That's fine, i don't think we have a nameless one yet.
18:58:43 <sirKIIdB> but i think "T" is very good name 4 it
18:58:44 <lament> Is it different from brainfuck in any way? :)
18:59:39 <ais523> is it Turing-complete?
19:00:30 <ais523> does it have an infinite amount of storage and the ability to manage all conventional flow control patterns somehow?
19:00:43 <ais523> (If the answer is yes to both, then it's probably, but not necessarily, Turing-complete.)
19:02:23 <ais523> ~bf >,[>,]<[.<]!Brainfuck manages Turing-completeness by having an infinite tape
19:02:23 <bsmnt_bot> epat etinifni na gnivah yb ssenetelpmoc-gniruT seganam kcufniarB
19:03:48 <ais523> one sure test: if you can compile Brainfuck into a language, that language must be Turing-complete
19:04:23 <ais523> I wonder why the bot's ignoring you?
19:04:27 <ais523> ~bf >,[>,]<[.<]!Kcufniarb
19:05:09 <ais523> there's a space at the start of your commands
19:05:13 <ais523> the bot doesn't like that
19:06:34 <ais523> EgoBot seems not to be here at the moment, which is a pity as it knows more languages than bsmnt_bot does
19:06:55 <sirKIIdB> in which eso-language do you "speak"
19:07:27 <ais523> Well, I wrote quite a few
19:07:28 <ais523> Underload's one of the more elegant of them
19:07:43 <ais523> and I'm busy on a Forte interpreter at the moment
19:07:58 <ais523> http://esolangs.org/wiki/Forte
19:08:20 <ais523> (that URL will serve to answer your questions about most esolangs if you change the bit at the end)
19:09:29 <ais523> it was designed to be as similar to BASIC as reasonable
19:09:45 <ais523> because flow-control is based on redefining line numbers
19:09:46 <sirKIIdB> i wrote simple basic interpretator
19:10:05 <ais523> so I wanted something that seemed familiar until the 'WTF?' reaction when you realise what it's actually doing
19:11:07 <sirKIIdB> Polish "WTF" is "O co kurwa łazi?"
19:11:28 <lament> reverse polish "WTF" is FTW.
19:12:02 <ais523> or `W`TF in Unlambda notation, I suppose
19:12:17 <GregorR> Or rather, WFT ... I forget which is reverse X-P
19:12:20 <ais523> it depends on which words are operands and which are operators
19:12:39 <ais523> if 'the' and 'what' are both unary operators, then lament was right
19:12:53 <sirKIIdB> what do you think about intercal?
19:13:08 <ais523> I released the most recent version of the C-INTERCAL compiler
19:13:20 <ais523> I started with some existing code and added features like multithreading and backtracking
19:13:38 <sirKIIdB> in wich languages do you program?
19:13:55 <ais523> well, the C-INTERCAL compiler's written in C, as the name would suggest
19:14:18 <ais523> but I'm using C++, Perl, and Thutu2 to write implementations for various esolangs in at the moment
19:14:36 <ais523> and I wrote bsmnt_bot's Brainfuck interpreter in Python
19:14:49 <ais523> Thutu2's incredibly inefficient, but not too bad when you get used to it
19:15:04 <sirKIIdB> I'm using c++ or sometime pascal
19:15:09 <ais523> it's an esolang itself, a wimpmode for Thutu, which I use to write other esolangs in
19:15:26 <ais523> I wrote a Thue implementation in sed once
19:15:38 <ais523> it compiled Thue to sed, and was written in sed itself
19:15:39 <GregorR> ... Pascal? Are you logging into IRC via a time machine?
19:15:44 <ais523> I think it had several bugs, though
19:15:56 <ais523> GregorR: I still use Pascal on occasion
19:16:04 <ais523> (only when maintaining old Pascal programs, though)
19:16:21 <ais523> what? It's not as bad as COBOL
19:16:22 <lament> intercal is older than pascal, isn't it.
19:17:22 <ais523> Pascal was 1970 it seems, so INTERCAL's two years younger
19:18:14 <ais523> One thing that I do know is that a Pascal program I was maintaining was about 5 times faster than its C equivalent
19:18:25 <ais523> which probably says something about the quality of the compilers...
19:18:41 <ais523> sirKIIdB: I haven't noticed any problems with it yet
19:19:10 <ais523> you know, apart from the B and the lack of backquotes, your nick's almost legal Unlambda
19:19:28 <ais523> I wonder if ``````sirkiid does anything interesting?
19:20:02 <ais523> it seems to be just a NOP, unfortunately
19:20:22 <ais523> no wait... it prints a single newline
19:22:24 <ais523> this Internet connection is a Solaris terminal running under Windows (not through choice).
19:22:58 <ais523> At home, I use DJGPP running on top of Windows; again, the Windows isn't through choice, and it's the closest to Linux/UNIX syntax I can reasonably get
19:23:09 <oerjan> ``````sirkiid -> `````ik`rkiid -> ````k`rkiid ->(\n) ````kkiid -> ``kid -> i
19:23:20 <ais523> or sometimes, when Windows is acting up too much, I use DOS
19:25:16 -!- ais523 has quit ("the clocks have changed, and I've got about half-an-hour late without realising").
19:29:05 <oerjan> right, you talk like mad until i've _just_ managed to finish the logs, then you stop. :/
19:30:16 <oerjan> it's not my language, but let me take a look.
19:33:17 <oerjan> hm, seems i must have had a hand in it somehow...
19:33:37 <lament> yepyep! it's all YOUR fault.
19:34:28 <oerjan> anyway i take the word "provable" to mean that there exists an actual written proof. So while the language is super-Turing, it is only one class above, a simple halting oracle suffices.
19:36:39 <oerjan> i also take "as in brainfuck" to mean just the loop itself, not the contents, so the contents are essentially in onoz.
19:37:56 <oerjan> there is also a question of what mathematical foundation the proof should be in. I have a vague recollection that we discussed it at the time.
19:39:09 <oerjan> however as long as it contains Peano arithmetic or thereabouts, the whole system should still be super-Turing.
19:39:54 -!- jix__ has changed nick to jix.
19:41:49 <lament> oerjan: so it can still go into an infinite loop
19:41:54 <lament> oerjan: thanks to goedel
19:42:44 <sirKIIdB> because tape in turing's machine
19:43:27 <sirKIIdB> e.g int tablica[ and what here ? ]
19:43:56 <oerjan> you could use a linked list
19:45:45 <oerjan> let each cell contain a pointer or reference to the next. If you get to a null pointer, allocate more.
19:46:22 <oerjan> make that a doubly linked list. Pointers both backward and forward
19:46:57 <sirKIIdB> but can I go backward or only forward on list?
19:48:28 <oerjan> A Turing tape allows you to go both ways. If not it wouldn't be Turing complete for exactly the reason you write.
19:49:25 <oerjan> Nothing can be Turing complete if memory is bounded in size.
19:50:22 <oerjan> The tape must be able to grow, but at each point in time it can be finite.
19:52:58 <oerjan> Of course it is finite. You would delete the old tablica[0] when you wrap.
19:54:22 <oerjan> Only if the Turing machine uses a lot of tape.
19:56:35 <oerjan> You don't need pointers for every cell however. You can have an array in each struct.
19:57:56 <GregorR> Have we discovered that Turing machines are not efficient? Wooooooooow :-P
19:57:57 <sirKIIdB> I don't know how to make array like that in c++...
20:00:09 <lament> C++ is the language of the devil, anyway
20:00:27 <oerjan> Something like: struct node { struct node *forward; struct node *back; int contents[30] } *tablica;
20:00:41 <oerjan> except my C is a bit rusty
20:04:24 <oerjan> But doubly linked lists can be a bit difficult so you should look up the algorithms.
20:06:23 <oerjan> lament: Who do you know that uses b****fuck? :D
20:22:04 <lament> there was a joke about that on the esolang list a long time ago. I forgot the details.
20:22:21 <lament> somebody considered the word 'brain' to be offensive.
20:25:33 <oerjan> Creationists probably.
20:25:59 -!- Arrogant has joined.
20:33:17 * oerjan guesses you mean "game"
20:46:43 <lament> i believe the english word is still 'game'.
20:52:43 -!- Arrogant has quit ("Leaving").
21:33:51 -!- sirKIIdB has quit ("Sleeping and ...").
21:35:23 <Figs> what rhymes with purple?
21:49:25 <oerjan> http://en.wiktionary.org/wiki/Rhymes:English:-%C9%9C%CB%90%28r%29p%C9%99l
21:57:52 -!- SevenInchBread has joined.
22:29:28 <SevenInchBread> MY LATEST MASTERPIECE: http://esoteric.voxelperfect.net/wiki/Sprout#99BoB
22:35:12 <lament> i don't understand the description of the semantics at all.
22:36:39 <lament> it seems there's quite a lot of built-ins
22:36:43 <lament> and you never describe what they are
22:37:35 <lament> well, the problem is, your description of semantics doesn't even leave any room for builtins.
22:37:57 -!- crashmatrix has joined.
22:38:24 <SevenInchBread> the builtins are... macros basically... although I cheat a little and give some of them a little more power like speak and die.
22:38:56 <SevenInchBread> : is something along the lines of a macro call... and # is something like a macro def... they can both work that way.
22:40:41 <lament> so how is your language different from lisp?
22:41:50 <SevenInchBread> the main difference is that # also serves as a "point of substitition"... change allows you to modify the source code at all the points marked by a certain label.
22:42:11 <lament> SevenInchBread: you haven't described change at all.
22:42:26 <SevenInchBread> and... : isn't strictly deterministic... it randomly selects one of the labelled expressions.
22:42:50 <SevenInchBread> lament: pfft, so demanding with your "explain fundamental parts of the language" stuff.
22:43:37 <SevenInchBread> change is a macro that takes a label name and a little chunk of code... and basically substitutes the code in place of every expression in the source marked by the label.
22:43:57 <SevenInchBread> ...the only time the examples really show this is in 99BaB
22:44:16 <SevenInchBread> ...guess I could factor out some of the builtins... makes it a little too Lispy.
22:45:00 <RodgerTheGreat> and being simple doesn't keep a language from being esoteric
22:47:10 <SevenInchBread> if I took out all of the lispy builtins and added a few more commands... I could probably make it way weirder.
22:54:43 <RodgerTheGreat> the best esoteric languages are those whose complete semantics can be described in a few setences, yet still manage to make people's brains hurt
22:55:53 <SevenInchBread> well... the basic idea here is really neat... I just need to work on the actual specification a bit.
22:56:55 <RodgerTheGreat> crashmatrix: BF, ///, SevenInchBread's earlier project dupdog, OISC, etc
22:59:25 <crashmatrix> Idea: promote dupdog to make engineers go wow instead of Vista :)
23:00:25 <RodgerTheGreat> ais523 and I made some significant inroads to doing something useful with that language, but it's still a tough nut to crack
23:03:56 <lament> i'm still not certain whether it's completely impossible to program in, or just kinda difficult
23:04:29 <crashmatrix> not completely impossible, you wrote hello world in dupdog, didn't you?
23:05:22 <lament> yeah, but that program never actually has to duplicate stuff
23:05:45 <crashmatrix> ah, I didn't get to the part of trying to interpret the code yet
23:05:46 <lament> thanks to wrapping mod 257
23:07:33 <RodgerTheGreat> the *really* tough part we've been trying to wrap our heads around is truly useable conditional branching
23:08:08 <lament> what would it condition on?
23:09:03 <lament> fun fact: all vowels are on odd-numbered positions in the alphabet.
23:09:31 <lament> coincidence? i think not!
23:10:44 <crashmatrix> conspiracy? it's more likely then you think
23:11:08 <lament> anybody got the dupdog interpreter?
23:12:09 <oerjan> Probability 1/32 and sometimes 1/64.
23:12:25 -!- nazgjunk has changed nick to na[zZz]gjunk.
23:13:10 <lament> i have no idea how to use that interpreter.
23:13:56 <RodgerTheGreat> and I have no godly idea how it works, because it was compiled into perl.
23:15:13 <oerjan> I could upload my half-finished Haskell interpreter.
23:15:32 <lament> the perl thing seems to work, just feed the program as stdin
23:15:45 <crashmatrix> now there is a esoteric language for ya (well, me actually)... I never got my head around it properly :(
23:16:26 <RodgerTheGreat> perl itself isn't too bad, but whatever compiler created that interpreter is a machine of pain
23:17:35 <SevenInchBread> dupdog was spawned in about a minute... I put no thought whatsoever on how it could be used.
23:17:50 <lament> but how did you come up with the names for sub-interpreters? :)
23:19:36 <SevenInchBread> eh... I'll continue Sprout another day. I want to do like a "structured self-modification". Where you can give bits of the parse tree a label and then say "replace everything at x with SomeCode"
23:21:27 <lament> looks like the perl interpreter is broken after all
23:22:46 <lament> my programs fail and i'm not sure why
23:23:32 <lament> for the purposes of counting evenness/oddness, it does not include the currently read character.
23:24:23 <lament> i wonder if i can work around that
23:24:30 <SevenInchBread> -nod- that sounds right... that part of the spec was invented as I was writing the interpreter... so it's not actually a requirement to be "pure dupdog" - or whatever.
23:28:03 <SevenInchBread> ....so... I'd like to get Kallisti started... maybe I should eso-factory-ize it.. instead of requiring interpreters to be made by the folks.
23:28:08 <oerjan> the Hello World program worked in my interpreter
23:28:20 <oklopol> "<ais523> OTOH, a language like C isn't Turing-complete at all" ?
23:28:40 <lament> oerjan: for example, ?~
23:29:04 <lament> oerjan: it's supposed to produce no output; it outputs 1
23:29:19 <lament> because the evenness/oddness is counted wrongly
23:30:42 <SevenInchBread> hmmm... the only real conditional instruction seems to be ?
23:33:51 <lament> oerjan: can you try running http://pastebin.ca/411254 with wrapping 128?
23:36:13 <SevenInchBread> maybe Mfit, instead of spitting out the decimal representation of the length... should spit out the base-5 representation of the number, starting at 1 instead of 0
23:36:23 <lament> SevenInchBread: yes, '?' is a conditional instruction and it already works in a fashion; i just don't think 'length of program' is a useful condition
23:37:22 <oerjan> Should the line breaks be removed?
23:37:29 <lament> oerjan: i see no line breaks
23:39:42 <oerjan> It writes "Awesome100"
23:40:18 <lament> of course it only works because all those characters have the same parity
23:40:28 <lament> so you can write 'awesome', but not 'hello world'
23:40:31 <SevenInchBread> Maybe incorporate some new stuff into Kallisti to make it bearably workable.
23:41:02 <oerjan> lament: Can you run Haskell?
23:41:43 <lament> i also have my own dupdog interpreter in python
23:41:54 <lament> i just want third-party confirmation :)
23:41:58 <SevenInchBread> like... instead of checking source-code evenness... ? could check the character in front of it for some condition.
23:42:24 <oerjan> The files are oerjan.nvg.org/esoteric/Dupdog.hs and oerjan.nvg.org/esoteric/FingerTree.hs (third party module)
23:42:45 <oerjan> but its interface is atrocious at the moment
23:43:07 <oerjan> however, it uses shared datastructures for duplication
23:43:23 <lament> so is it super-efficient?
23:43:52 <oerjan> probably not, but it should be miles above a string-based one
23:45:01 <lament> my interpreter: z3.ca/~lament/dupdog.py
23:45:20 <oerjan> it also contains a tracer, but the actual debugging commands and command-line options are not implemented
23:45:25 <SevenInchBread> ...or you could make other changes... like have instructions that alter the number at which the length calculation wraps. ...but I'd like the new ideas to go into the construction of Kallisti.
23:48:35 <oerjan> Most importantly it should support many duplications without running out of memory, although I haven't tested it
23:49:05 <SevenInchBread> ...yeah... with Python at least... huge string modifications take forever... because of the non-in-placicity.
23:51:51 <oerjan> Also I am clever about substitution and reversal
23:52:16 <oerjan> No actual change of program, just a couple of status flags
23:53:13 <SevenInchBread> yeah... there's only three substitution states possible... and two reversal states.
23:55:07 <SevenInchBread> heh.... since dupdog reverses its source code often... does that make it reversible?
23:57:16 <oklopol> whew... took like an hour to read the logz 8||
23:58:56 <oklopol> i woke up an hour ago, it's 2 am now
23:59:41 <oerjan> FWIW, the command to actually run a dupdog program is like: runStateT (runErrorT (runLoop (tracer 30 []) 0)) (initPState (DS "" "?~" 257 0 0 30 [] False True))