←2007-07-21 2007-07-22 2007-07-23→ ↑2007 ↑all
00:00:39 <oklofok> OMG, i actually compiled a hello world! :D
00:02:22 <SimonRC> oerjan: "What I tell you three times is true."
00:02:40 <oerjan> SimonRC: if you say so.
00:02:51 <oklofok> ...three times
00:02:54 <oerjan> that did not fit the current context, however.
00:03:09 <oklofok> it did if you applied my joke.
00:03:47 <oerjan> ... in the original form
00:03:55 <SimonRC> did I show you people the weird language+IDE with the thermonuclear copy+paste?
00:03:59 <SimonRC> what was it called?
00:06:05 -!- jix has quit (Nick collision from services.).
00:06:19 -!- jix has joined.
00:07:49 -!- jix has quit (Client Quit).
00:10:25 <oklofok> hey, i could actually write a loop :D
00:10:27 <oklofok> no fibonacci.
00:10:29 <oklofok> *now
00:10:49 <oklofok> ...perhaps printing numbers first
00:11:00 <bsmntbombdood> how could you make a bloom-filter-like structure, but with no false positives possible, only false negatives?
00:11:57 <oerjan> store the complement set?
00:12:22 <bsmntbombdood> too large, not possible
00:13:20 <SimonRC> define "bloom filter"
00:13:31 <oerjan> ic. well iirc this is the first time i hear about them.
00:13:43 <RodgerTheGreat> oklofok: awaken and read your PMs!
00:13:43 <oerjan> SimonRC: wikipedia
00:14:34 <SimonRC> bah
00:15:03 <oerjan> i would paste the link if i hadn't already closed the window
00:29:14 <ihope> http://en.wikipedia.org/wiki/Bloom_filter
00:29:46 <ihope> bsmntbombdood: reverse the definitions of "positive" and "negative"? :-P
00:31:27 <ihope> I guess that's what the complement is doing.
00:31:50 <bsmntbombdood> actually
00:32:03 -!- ehird` has quit (Read error: 104 (Connection reset by peer)).
00:33:27 <bsmntbombdood> hrm
00:34:54 <SimonRC> zzzzzz
00:45:18 <ihope> announce/reply, and if something gets caught in a reply, it needs to refactor itself...
00:45:37 <ihope> ...of course?
00:45:55 <ihope> Hmm.
00:47:05 <ihope> First, announce it. If you get a reply, do it refactoredly. If you don't, do it normally.
00:47:17 <ihope> (Wow, spellcheck accepts "refactoredly" but not "okay".)
00:47:17 <Sukoshi> oklobot: No it's not.
00:47:27 <Sukoshi> You do now how emulators tend to work, right?
00:48:18 <oklofok> ah
00:48:21 <oklofok> it's just a conversion
00:48:22 <oklofok> ?
00:48:34 <oklofok> i do not *know*
00:48:37 <oklofok> i may guess right.
00:49:20 <oklofok> Sukoshi: i recommend you use one of *my* nicks, not my bot's ;=)
00:49:55 <oklofok> i guess i should've given the bot a more inventive name
00:49:55 <ihope> Hmm, my intuition is now reverting to the non-monadic.
00:50:18 <ihope> oklofok: how many of you are there, exactly?
00:50:26 <ihope> And how many of you are bots?
00:50:49 <oklopol> o
00:50:50 <oklofok> o
00:50:59 <oklofok> ololobot and oklobot are bots.
00:51:07 <ihope> Where'd oklokok go?
00:51:16 <oklofok> he's rarely seen :)
00:52:15 <oklofok> Sukoshi: i know what emulators do, but no, i've never read an emulator's source
00:54:33 <Sukoshi> oklobot: No, because of all these names, I don't care *what* tab-complete gives me :P
00:54:43 <Sukoshi> Make a Chip8 emulator for very basic practice.
00:55:41 <bsmntbombdood> i found a dead mouse!
00:59:11 <oklofok> Sukoshi: should that be done by converting from instruction set to another or via interpretation of some sort?
00:59:19 <oklofok> i've never made an emulator
00:59:29 <oklofok> nor know how you actually go about doing them
01:11:46 <Sukoshi> You read each opcode from the rom file, and then you have to emulate the changes to a machine of those specs.
01:11:55 <Sukoshi> So it's interpretation.
01:13:17 <oklopol> you consider writing that in asm very basic practice? :)
01:13:21 <oklopol> err
01:13:34 <oklopol> you mean using a language i know already
01:13:37 <oklopol> ?
01:13:43 <oklopol> that shouldn't be too hard
01:14:47 <Sukoshi> Writing in C.
01:14:52 * oerjan notes that he is the only nick on o which doesn't belong to oklopol. Scary stuff.
01:14:59 <Sukoshi> You use ASM to optimize often-called routines.
01:15:19 <oklopol> Sukoshi: have you done that?
01:15:40 <ihope> /nick ohipe
01:15:46 <Sukoshi> oklobot: Chip8 ?
01:15:47 <oklopol> you need sound output and all... i can't say i know how to do that.
01:15:49 <oklopol> in C
01:15:57 <Sukoshi> Read over the SDL docs.
01:16:00 <oklopol> and i can use sdl for images
01:16:03 <oklopol> and yeah
01:16:07 <oklopol> indeed, sounds too
01:16:25 <oklopol> Sukoshi: how much more complex is nes?
01:16:41 <Sukoshi> oklobot: Not *that* bad, but still.
01:16:53 <oklopol> would be nicer if i actually had a decent c compiler
01:17:01 <Sukoshi> ... What OS do you run ... ?
01:17:04 <oklopol> i'm using a 20-year-old microsoft one
01:17:06 <Sukoshi> gcc works fine.
01:17:08 <oklopol> win
01:17:16 <Sukoshi> gcc works on your toaster, man.
01:17:22 <oklopol> heh
01:17:27 <oklopol> kay, i'll dl it
01:18:06 <oklopol> i'm a decent c coder, but i'm definately not a good c compiler installer
01:18:10 <oklopol> so this might take a while,
01:19:11 <Sukoshi> Grabbing a GCC binary shouldn't be too hard.
01:19:42 <oklofok> it shouldn't, i admit that.
01:19:50 <oklofok> http://gcc.gnu.org/
01:19:56 <oklofok> what i see here is random text.
01:19:57 <oklofok> :)
01:20:09 <oklofok> i'll search... perhaps i'll find someday.
01:20:27 <oklofok> http://gcc.gnu.org/install/binaries.html
01:20:31 <oklofok> this looks better
01:20:36 <oklofok> i'll click on a blue button.
01:20:51 * oerjan watches oklofok explode.
01:21:32 <oklopol> did it!
01:21:40 * oklopol dances a bit
01:23:30 <oklopol> argh then an installation of sdl
01:23:34 <oklopol> i need a secretary
01:25:51 <oerjan> shouldn't two bots be enough? :D
01:26:05 <oklopol> >>> install sdl
01:26:10 <oklopol> no?
01:26:23 <oklopol> i guess i could extend that.
01:27:14 <oklopol> >>> install sdl
01:27:15 <ololobot> sdl succesfully installed.
01:27:32 * oklopol is a helluva coder
01:27:36 <bsmntbombdood> APT-GET INSTALL GCC
01:27:55 <oklopol> hmm
01:29:53 <oklofok> still installing... must be a great program.
01:30:16 <bsmntbombdood> oklofok, oklopol, and ololobot?
01:30:25 <oklofok> bsmntbombdood: ?
01:31:01 <oerjan> bsmntbombdood: my theory is he is trying to crowd out the letter o to get rid of me.
01:31:22 <oerjan> or even worse, to steal my nick!
01:31:33 <oklopol> oerjan: you guessed correctly, actually both
01:31:49 -!- bsmntbombdood has changed nick to obsmntbombdood.
01:32:17 <ihope> If you don't have APT, then mdo apt-get install apt
01:32:25 <oklopol> i think i've also been oklopok at some point
01:32:38 <oklopol> and also oklodok when i made an irc client
01:33:24 <obsmntbombdood> what is an oklopol, anyway?
01:34:12 <oklopol> it's a substance with a very bitter after taste
01:35:11 <obsmntbombdood> Käyttäjäryhmä: Peruskäyttäjä?
01:35:19 <oklopol> 8|
01:35:26 <oklopol> user group, basic user
01:35:31 <oklopol> that's finnish
01:35:40 <obsmntbombdood> i can has polylingual too?
01:35:58 <oklopol> err... seven?
01:36:29 <oklopol> i don't want to sound as stupid as i am, but how do i compile with cygwin?
01:37:07 <oklopol> obsmntbombdood: where did you find those words?
01:37:31 <oklopol> ah
01:37:33 <oklopol> google
01:37:46 <oklopol> didn't know i'm a user somewhere
01:38:34 <oklopol> and god i was frightened when you pasted that.
01:38:50 <obsmntbombdood> why?
01:38:58 <oklopol> i do that sometimes
01:39:41 <oklopol> i thought i was seeing the words wrong
01:39:45 <oklopol> nothing serious
01:39:52 <pikhq> oklopol: Do you have gcc installed in Cygwin?
01:40:01 <oklopol> err...
01:40:11 <oklopol> perhaps i'll show you which button i pushed,.
01:40:18 <oklopol> hmm
01:40:21 <oklopol> i'd say no, actually
01:40:35 <pikhq> Use the Cygwin installer to install gcc.
01:40:51 <pikhq> See if you can get it to install all build-essential packages, actually. . .
01:41:09 <oklopol> okay...
01:41:16 <oklopol> which command is that? :)
01:41:32 <pikhq> The GUI installer. . .
01:41:36 <pikhq> cygwin-setup.exe
01:42:23 <oklopol> i... don't have that
01:42:41 <oklopol> looks like a windows-ed bash
01:42:50 <oklopol> cygwin.exe
01:44:40 <oklofok> here, you see, i pressed "The Cygwin Project": http://gcc.gnu.org/install/binaries.html
01:44:51 <oklofok> and i downloaded it and run cygwin.exe
01:49:42 <oklopol> *ran
01:49:57 <oklofok> ...thank you.
01:50:06 <oklopol> yw
01:56:25 -!- obsmntbombdood has changed nick to bsmntbombdood.
01:57:21 <Sukoshi> You download the Cygwin installer and do it.
01:57:37 <bsmntbombdood> on windows!
01:58:14 <oklopol> hmm
01:58:23 <oklopol> bsmntbombdood's way sounded doable, i'll try that
01:58:31 <oklopol> but then i can't use my laptop :<
01:59:35 <Sukoshi> Is this your first ever experience with Windows, by the way?
01:59:45 <oklopol> Sukoshi: no.
01:59:52 <oklopol> i've been using it for >13 years :)
02:00:01 <oklopol> well, dos at first
02:00:02 <Sukoshi> Then how come you don't know how to install a C compiler?!
02:00:21 <oklopol> :)
02:00:33 <oklopol> i don't know
02:00:43 <Sukoshi> .... :P
02:00:54 <Sukoshi> If you use Windows, then you'll have to write somewhat different ASM from me.
02:00:59 <oklopol> i'm really bad at software stuff unless i know exactly what to do.
02:01:05 <oklopol> i'll use ubuntu.
02:01:23 <oklopol> because the install could actually be done
02:01:47 <Sukoshi> I used to be really big into sysadminning too, but nowadays it's getting annoying.
02:01:58 <Sukoshi> I want to just program and not care about my system's idiotic hick-ups.
02:02:17 <oklopol> that's always been my logic
02:02:19 <Sukoshi> Still, I do like compiling most things, and I run Slack on this box. I may be getting a new box soon, and if I do, it'll run Gentoo.
02:03:01 <oklopol> gentoo is a linux distro, i have no idea about slack
02:03:13 <oklopol> anyway, let's check whether i can actually *use* gcc
02:03:23 <Sukoshi> Slack == Slackware.
02:04:39 <oklopol> the problem with the installation was that i just couldn't find any other "cygwin installer" than cygwin.exe, which was bash for windows.
02:04:49 <Sukoshi> .....
02:05:07 <oklopol> and no, i do not know whether it's supposed to be bash for windows :)
02:05:26 <oklopol> anyway, it's all right now, i've got it
02:05:28 <Sukoshi> You seriously have never used C in Windows before?
02:05:54 <oklopol> i think i have some 100 programs
02:06:29 <oklopol> (made)
02:06:49 <oklopol> does that mean i have to have heard of cygwin?
02:08:02 <Sukoshi> Well, I'm assuming if you use Windows on a day-to-day basis, you have heard of the utilities necessary to live in a dev environment in it.
02:08:21 <oklopol> i've used microsoft visual c++ 6
02:08:26 <Sukoshi> ......
02:08:32 <oklopol> :D
02:08:43 <oklopol> this is why i haven't been doing c++ for a while.
02:08:55 <Sukoshi> Emacs + GCC == Win.
02:09:00 <Sukoshi> Emacs + JVM == Win.
02:09:10 <Sukoshi> Emacs + Slime + SBCL/CLISP == Win.
02:09:14 <oklopol> Win == Lose. ?
02:09:17 <Sukoshi> Emacs + * == Win.
02:09:18 <Sukoshi> no
02:09:36 <oklopol> as an lvalue it means windows.
02:09:38 <Sukoshi> Win(Emacs, X). X=*
02:09:55 <Sukoshi> Well, it's Japanese time. Have fun mah dev friends.
02:10:15 <oklopol> gcc test.c will not compile :P
02:10:17 <oklopol> okay
02:10:19 <oklopol> bye
02:10:30 <oklopol> i'll be trying to install this for the next 24 hours, most likely.
02:10:35 <oklopol> i mean, get it working
02:11:25 <oklopol> ville@ville-desktop:~/cstuff$ dir
02:11:26 <oklopol> test.c
02:11:26 <oklopol> ville@ville-desktop:~/cstuff$ gcc test.c
02:11:26 <oklopol> /usr/bin/ld: crt1.o: No such file: No such file or directory
02:11:26 <oklopol> collect2: ld returned 1 exit status
02:11:30 <oklopol> once again my intuition fails.
02:12:17 <oklopol> if someone wants to tell me how to use that, be my guest
02:13:13 <Sukoshi> ``gcc -o test test.c'', assuming you're using things like stdio.h
02:13:17 <Sukoshi> Well, Japanese time.
02:14:11 <oklopol> ville@ville-desktop:~/cstuff$ gcc -o test test.c
02:14:11 <oklopol> /usr/bin/ld: crt1.o: No such file: No such file or directory
02:14:11 <oklopol> collect2: ld returned 1 exit status
02:14:27 <oklopol> have fun @ your japans.
02:16:54 -!- immibis has joined.
02:23:07 -!- GreaseMonkey has joined.
02:39:05 -!- GregorR-L has joined.
02:46:23 <Sukoshi> Why is it asking for crt1.o?
02:46:29 <Sukoshi> What's it linking against?
02:46:56 <oklopol> i've done apt-get and written what you told me to
02:47:05 <oklopol> i don't know that crt1.o is
02:47:11 <Sukoshi> Wait. In Windows?
02:47:17 <oklopol> no
02:47:18 <oklopol> in ubuntu
02:47:31 <Sukoshi> What's the contents of test.c ?
02:47:35 <pikhq> Sukoshi: It should be linking against libc and GCC's support library. . .
02:47:35 <oklopol> empty
02:47:42 <GregorR-L> oklobot: You're missing either libc-devel or libgcc-devel
02:47:59 <oklopol> just give me the necessary lines :)
02:48:02 <Sukoshi> Well, crt1.o is part of libc, IIRC.
02:48:14 <Sukoshi> oklopol: ....
02:48:15 <pikhq> Odd. I don't *have* crt1.o
02:48:18 <GregorR-L> Sukoshi: I've seen it put into all sorts of strange packages :P
02:48:27 <GregorR-L> Sukoshi: But yeah, it comes with glibc
02:48:27 <pikhq> Oh. I located for crt1.so. XD
02:48:33 <Sukoshi> oklopol: Learn to use your computer at least *somewhat* please?
02:48:55 <oklopol> i know enough, usually.
02:48:56 <Sukoshi> In Ubuntu, there was a specific apt-get you use to get this stuff, but I forget what it was.
02:49:01 <GregorR-L> oklobot: Just run your favorite GUI package manager and you won't have to do any nasty typing that hurts boo-hoo
02:49:07 <pikhq> apt-get build-essential
02:49:11 <pikhq> Err.
02:49:13 <Sukoshi> There we are.
02:49:13 <oklopol> i already typed the boo-hoo
02:49:14 <pikhq> apt-get install build-essential
02:49:20 <oklopol> will a graphical one do it better?
02:49:29 <oklopol> i'll install that huh?
02:49:44 <pikhq> Yeah; that provides a full build environment in *buntu.
02:49:58 <oklopol> Sukoshi: memorizing package names isn't really learning to use a computer
02:50:17 <oklopol> but i'll read if you give me a computer tutorial :)
02:50:24 <immibis> try 'apt-get upgrade libc-devel'
02:50:30 <oklopol> anyway, build-essential does not work.
02:50:35 <oklopol> whoops
02:50:38 <immibis> not sure if the command is upgrade, though, it might be something else
02:51:15 <oklopol> apt-get update iirc
02:51:24 <oklopol> but i never recall correctly.
02:51:31 <immibis> isn't update for updating the list of available packages?
02:51:38 <oklopol> ah
02:51:40 <immibis> apt-get upgrade PACKAGENAME
02:51:45 <immibis> or install if you don't have it
02:51:45 <oklopol> i see
02:51:59 <oklopol> anyway
02:52:02 <Sukoshi> oklobot: Then learn to use Google? :P
02:52:04 <oklopol> i installed gcc an hour ago.
02:52:13 <immibis> you didn't have gcc?
02:52:16 <Sukoshi> apt-get build-essentials ?
02:52:18 <oklopol> Sukoshi: i know how to use it, that doesn't help.
02:52:19 <immibis> how can anyone survive without gcc?
02:52:25 <pikhq> immibis: Magic.
02:52:32 <Sukoshi> See. I don't understand how he lives without gcc.
02:52:49 <oklopol> i don't use this computer for programming
02:52:49 <pikhq> I use Gentoo. . . You can't even *install* anything without gcc.
02:52:58 <immibis> what is gcc?
02:53:02 <immibis> oops wrong channel
02:53:03 <oklopol> and the windows machine has visual c++ 6, as i said :)
02:53:05 <immibis> i was testing toboge
02:53:09 <pikhq> GNU Compiler Collection.
02:53:13 <pikhq> Oh.
02:53:21 <oerjan> immibis: hah, that is what you want us to think
02:53:27 <immibis> i knew that
02:53:34 <pikhq> oklopol: Eeeew.
02:53:41 <Sukoshi> Meh. I have dev environments on all the machines I access.
02:53:41 <immibis> what is gcc?
02:53:50 <immibis> oops toboge isn't on this channel
02:53:52 <oklopol> what the fuck, it actually worked.
02:53:55 -!- toBogE has joined.
02:53:59 <immibis> what is gcc?
02:53:59 <toBogE> gcc is a necessity of life
02:53:59 <oklopol> thanks all, i'll do some programming now
02:54:17 <immibis> see, it IS a necessity of life
02:54:17 <pikhq> oklopol: gcc is a much nicer compiler, IMO. . .
02:54:31 <immibis> and? visual c++ 6 has an ide.
02:54:59 <GregorR-L> RodgerTheGreat: (06:53:25 PM) ---: Ah - well you can tell him his work received props
02:55:07 * pikhq couldn't live without constructs like (int []){1, 2, 3}; or case '0'...'9'
02:55:07 <GregorR-L> RodgerTheGreat: [re your avatar]
02:55:15 <pikhq> immibis: I'm no IDE man. ;)
02:55:18 <RodgerTheGreat> cool
02:56:30 <pikhq> oklopol: You can do some really, really evil stuff if you just assume GNU C.
02:56:56 <RodgerTheGreat> thanks, GregorR-L
02:57:12 <oklopol> pikhq: i don't know what gnu is :)
02:57:17 <immibis> gnu's not unix.
02:57:19 <oklopol> i assume it's a company
02:57:25 <immibis> toboge, gnu is not unix
02:57:27 <immibis> what is gnu?
02:57:28 <toBogE> gnu is not unix
02:57:45 <GregorR-L> oklobot: Ow.
02:57:45 <oklopol> toboge, everything is dark right now
02:57:49 <pikhq> oklopol: GNU is an operating system and a project around making that operating system.
02:57:52 <oklopol> what is everything?
02:57:52 <toBogE> everything is dark right now
02:57:52 <GregorR-L> Erm
02:58:08 <oklopol> pikhq: interesting.
02:58:35 <pikhq> You are currently using a large part of that operating system. . . It's properly called GNU/Linux in most people's case.
02:58:52 <ihope> toboge, is gnu not unix?
02:59:02 <pikhq> The GNU project has written things like GCC, bash, libc, etc.
02:59:05 <immibis> it does not do natural language parsing, ihope
02:59:18 <immibis> i programmed it with a regex to understand 'toboge, X is Y' and similiar things.
02:59:26 <immibis> also it understands 'what is X?'
02:59:27 <ihope> immibis: add that next, then.
02:59:34 <pikhq> what is gnu?
02:59:34 <toBogE> gnu is not unix
02:59:42 <immibis> isn't natural language parsing supposed to be impossible?
02:59:47 <immibis> what is ihope?
02:59:47 <toBogE> ihope is a user on IRC. See Ihope127.
02:59:53 <pikhq> immibis: Not really.
02:59:54 <ihope> Supposed to be?
03:00:00 * immibis shrugs
03:00:01 <ihope> Really hard, maybe...
03:00:09 <pikhq> Lojban parsing is trivial.
03:00:16 <immibis> !regex who-is [wW][hH][oO] [iI][sS] ([^ ]*)? replace ?$1
03:00:19 <immibis> who is ihope?
03:00:20 <EgoBot> Huh?
03:00:20 <toBogE> No such factoid ihope?
03:00:27 <immibis> !delregex who-is
03:00:30 <EgoBot> Huh?
03:00:32 <immibis> !regex who-is [wW][hH][oO] [iI][sS] ([^ ]*)\? replace ?$1
03:00:34 <EgoBot> Huh?
03:00:35 <immibis> who is ihope?
03:00:36 <toBogE> ihope is a user on IRC. See Ihope127.
03:00:40 <immibis> who is Ihope127?
03:00:41 <toBogE> No such factoid Ihope127
03:00:48 <immibis> toboge, Ihope127 is >ihope.
03:00:53 <immibis> who is Ihope127?
03:00:53 <toBogE> No such factoid Ihope127
03:00:58 <immibis> toboge, Ihope127 is >ihope
03:01:00 <immibis> who is Ihope127?
03:01:00 <toBogE> Ihope127->ihope
03:01:00 <toBogE> ihope is a user on IRC. See Ihope127.
03:01:04 <pikhq> !daemon bf regex +[,]
03:01:04 <toBogE> Caught a java.lang.ClassNotFoundException! toboge.Execer_daemon
03:01:04 <immibis> finally
03:01:06 <EgoBot> Huh?
03:01:06 <Sukoshi> Bot spam. Yet again :P
03:01:07 <pikhq> !daemon bf delregex +[,]
03:01:07 <toBogE> Caught a java.lang.ClassNotFoundException! toboge.Execer_daemon
03:01:10 <EgoBot> Huh?
03:01:23 <immibis> !daemon regex bf +[,]
03:01:24 <toBogE> Caught a java.lang.ClassNotFoundException! toboge.Execer_daemon
03:01:26 <immibis> !daemon delregex bf +[,]
03:01:26 <toBogE> Caught a java.lang.ClassNotFoundException! toboge.Execer_daemon
03:01:28 <pikhq> Dankon.
03:01:43 <immibis> !regex THIS SHOULD BE IGNORED BY EGOBOT replace yes, it should.
03:01:43 <oklopol> having had linux for a few months, how do i *run* a program after compiling it? :)
03:01:43 -!- EgoBot has quit (Read error: 104 (Connection reset by peer)).
03:01:53 -!- EgoBot has joined.
03:01:56 <pikhq> oklopol: What was the argument to -o?
03:01:58 <oklopol> or am i getting kickbanned for noobity soon?
03:02:03 <oklopol> pikhq: huh?
03:02:10 <immibis> in a terminal: go to where it is, chmod +x PROGRAM_NAME then ./PROGRAM_NAME
03:02:11 <oklopol> err
03:02:11 <pikhq> "gcc -o foo foo.c"
03:02:15 <immibis> where PROGRAM_NAME is the output
03:02:16 <oklopol> test
03:02:19 <immibis> by default it is a.out
03:02:20 <pikhq> ./foo
03:02:26 <oklopol> i know what the file is named...
03:02:29 <pikhq> immibis: No need. gcc does +x by default.
03:02:34 <immibis> oh, ok
03:02:36 <oklopol> ./ name?
03:02:39 <oklopol> okay.
03:02:40 <immibis> no space
03:02:41 <pikhq> Yeah.
03:02:45 <Sukoshi> oklobot: ``man gcc''
03:02:46 <pikhq> Since it's in your current directory.
03:02:50 <Sukoshi> Reading, it's what you do ;)
03:03:09 <immibis> i haven't used linux for ages because the only linux computer i have has a 4GB hard drive, 64MB of ram, runs ubuntu linux 5, and takes about 10mins to start.
03:03:31 <oklopol> Sukoshi: i don't wanna learn anything anymore, i have a working c compiler :)
03:03:32 <Sukoshi> Then uh, get a better Linux machine? :P
03:03:37 <Sukoshi> oklobot: ....
03:03:43 <oklopol> \o/
03:03:46 <oklopol> Sukoshi: ?
03:04:02 <immibis> oklobot: ``man gcc"
03:04:04 <Sukoshi> Learning isn't neccesarily a bad thing :P
03:04:08 <immibis> what does oklobot do?
03:04:13 <immibis> what is oklobot?
03:04:14 <toBogE> No such factoid oklobot
03:04:15 <oklopol> why learn more about gcc than compiling?
03:04:45 <Sukoshi> So you can optimize, make it unroll loops for you, profile, enable GDB symbols, do advanced linking, inline assembly, make C99 compatible, etc. ?
03:04:47 <oklopol> i'll check what it optimizes if i make something big.
03:04:50 <oklopol> don't see what else
03:05:06 <immibis> who is oklobot?
03:05:06 <toBogE> oklobot is oklobot!n=oklobot@, a user on irc.freenode.net
03:05:10 <pikhq> Learn about the GNU C extensions?
03:05:14 <oklopol> those are things i can quickly check if i need them.
03:05:17 <immibis> who is ololobot?
03:05:17 <toBogE> ololobot is ololobot!n=ololobot@, a user on irc.freenode.net
03:05:26 <Sukoshi> And also so that you can be a learned person?
03:05:33 <Sukoshi> Who values learning and knowledge and employs it in practice?
03:05:41 <immibis> and why do you have so many nicks from the same ip - freenode has a maximum number of simultaneous connections from the same ip.
03:06:03 <oklopol> Sukoshi: everyone know so much more about unix i might as well just stay noob.
03:06:06 <oklopol> *knows
03:06:20 <Sukoshi> Lots of people know about Electrics and CS, doesen't stop me from wanting to know myself ;)
03:06:31 <oklopol> learning about a random program isn't interesting to me
03:06:44 <oklopol> well, i guess in the same sense that learning a random sequence of numbers is
03:06:52 <pikhq> Replace unix with anything else (like "living outside of mom's basement"), and you'll see the uselessness of your argument.
03:07:03 <oklopol> but why learn the same random sequence everyone else is memorizing
03:07:10 <pikhq> BTW, you don't have to go at it in one go. . .
03:07:18 <Sukoshi> It's not random because you'll be using your tools on a regular basis. Ever heard the saying ``Know your tools and they will work wonders for you'' ?
03:07:24 <pikhq> I find the best way to learn UNIX is to just use it.
03:07:46 <oklopol> pikhq: i doubt my mom's basement is the only thing i know a lot about :)
03:07:55 <oklopol> if that's what you meant
03:08:00 <pikhq> (for me, "using it" involves toying once in a while with features I don't know about, just for the sake of it)
03:08:27 <pikhq> oklopol: No, I'm just saying that that argument, applied to its logical conclusion, will live you right there.
03:08:42 <pikhq> s/live/leave/
03:08:48 <oklopol> well, okay, it was a bad argument
03:09:21 <oklopol> anyway, of course i'd know a lot about linux if i'd wanted to learn about it sometime
03:09:29 <oklopol> but i've never wanted
03:09:42 <Sukoshi> Why though? I know a lot about Windows too.
03:09:50 <oklopol> me too.
03:10:04 <oklopol> because i've been interested
03:10:39 <Sukoshi> I know what benefits me every day. I know basic shell scripting, because I use it to automate tasks. I know a lot of ZSH-foo because I use ZSH. *Sure* I could use Linux like a dumb user but then, what makes you unique in that?
03:10:58 <Sukoshi> Be the best at what you do, I say. And being the best involves knowing how to do things better than other people.
03:11:26 <oklopol> perhaps someday i'll understand what's good in this os and read about it.
03:11:39 <oklopol> sofar i've seen slight enhancing of windows
03:11:50 <pikhq> Understanding what's good is hard to do without *learning* it.
03:12:07 <Sukoshi> You don't care hackability, customizability, security, etc. ?
03:12:10 <Sukoshi> *about
03:12:25 <oklopol> yeah, but hey, i'm not gonna need your help anymore, please let me do what i *am* interested in, and code, kay? :)
03:12:41 <pikhq> The UI layer is easy to do that with. With other layers, it's hard to understand what's better. . .
03:12:45 <oklopol> Sukoshi: yes, i'm interested in those
03:12:54 <oklopol> as concepts
03:13:06 <Sukoshi> But in the end, you just want to point and click?
03:13:11 <oklopol> ?
03:13:12 <toBogE> No such factoid
03:13:29 <immibis> toboge, is !
03:13:31 <immibis> ?
03:13:32 <toBogE> No such factoid
03:13:35 <pikhq> (really, without knowing about kernels, how are you supposed to know how, say, the Linux scheduler is better than the Windows one?)
03:13:53 <Sukoshi> The source code is all there. There are dozens of APIs at every level to insert your code in whatever language you want to do whatever you want. It's a darn lot of fun living in a world where hacking is encouraged.
03:13:53 <oklofok> Sukoshi: i hate if i don't have to do something myself.
03:13:56 <pikhq> oklopol: In the UNIX world, these aren't concepts. . . These are things we try to make our software do.
03:14:22 <oklofok> pikhq: i'm interested in doing them, i just don't see a connection between that and linux
03:14:34 <pikhq> The whole system is designed around it.
03:14:59 <oerjan> what is ?
03:15:00 <oklofok> err okay, well i don't like open source, i like doing things myself
03:15:00 <toBogE> No such factoid
03:15:29 <oklofok> and i don't like to point and click, it's just it'd take long to program a c interpreter in bash.
03:15:35 <oklofok> so i'll dl it
03:15:49 <pikhq> Hell. . . Applications include a scripting language as par for the course.
03:15:55 <oklofok> that isn't done in a decent language in linux, so why would i want to learn the language?
03:16:14 <oklofok> i really do not see your point
03:16:18 <oklofok> i don't care about linux
03:16:20 <oklofok> period.
03:16:30 <oklofok> what so evil about that?
03:16:46 <pikhq> Nothing, if you don't want to learn.
03:17:13 <immibis> people who don't use kde aren't evil so people who don't use linux aren't evil
03:17:16 <immibis> its just another choice
03:17:23 <oklofok> well, i'd like to learn linux, but it's not my first choise for a thing to learn.
03:18:14 <oklofok> i use linux every day, but i am interested in programming, not linux, so why would i want to learn that when there are programming concepts to be learned?
03:18:34 <immibis> can you write bash scripts on windows?
03:18:36 <immibis> perl?
03:18:38 <immibis> python?
03:18:42 <immibis> ok, maybe perl and python
03:18:48 <immibis> but probably not bash
03:18:48 <ihope> toboge, is !
03:18:49 <oklofok> i have a python interpreter.
03:18:50 <ihope> ?
03:18:52 <toBogE> No such factoid
03:18:56 <oklofok> and i have a perl interpreter.
03:18:59 <pikhq> immibis: He's got cygwin.
03:19:00 <ihope> You can write bash scripts if you have bash...
03:19:04 <immibis> oh, ok
03:19:10 <Sukoshi> oklofok: The answer to that is simple.
03:19:15 <ihope> Though Windows doesn't quite handle shebangs.
03:19:32 <oklofok> Sukoshi: please tell.
03:19:45 <Sukoshi> Think of it like this: Many years ago, artists used to all have to mix their own pigments.
03:19:55 <oklofok> err yes
03:20:02 <immibis> ihope: the solution to that is to name all your bash scripts with the extension .bash and to associate .bash with bash
03:20:06 <pikhq> oklofok: Imagine if you decided "I don't want to learn tools; I'm interested in construction concepts, not tools."
03:20:11 <immibis> !!
03:20:12 <toBogE> Caught a java.lang.ClassNotFoundException! toboge.Execer_!
03:20:14 <EgoBot> Huh?
03:20:20 <immibis> !!
03:20:30 <Sukoshi> Nowadays, most nobody does. But there are some people who do make their own pigments (maybe not from scratch, but, still themselves). It's called pride in workmanship.
03:20:46 <oklofok> err okay.
03:20:58 <immibis> !toboge, question marks and exclamation marks is !? ? ! ! ? ! ? ! ? ! ? ! ? !? ?! ? ! ! !
03:20:58 <toBogE> Caught a java.lang.ClassNotFoundException! toboge.Execer_toboge,
03:20:59 <oklofok> so i have pride.
03:21:00 <EgoBot> Huh?
03:21:01 <immibis> toboge, question marks and exclamation marks is !? ? ! ! ? ! ? ! ? ! ? ! ? !? ?! ? ! ! !
03:21:02 <oklofok> is that bad?
03:21:08 <Sukoshi> Huh?
03:21:09 <immibis> is what bad?
03:21:13 <Sukoshi> You *don't* have pride in workmanship.
03:21:34 <Sukoshi> For an intellectual to create the tools to test their concept themselves is a pride in themself. Just the same as the engineers who either order cheap low-wage workers to do their job for them, while they focus only on the engineering, or they build models at home themselves that work on a smaller scale.
03:21:35 -!- oklobot has quit (Read error: 104 (Connection reset by peer)).
03:21:36 <oklofok> ...because i'd rather write my c compiler myself rather than learn how to do it the easy way?
03:21:40 <oklofok> oklobot sucks <3
03:21:57 <pikhq> oklofok: http://www.thomasscoville.com/PCarticle.html
03:22:14 <immibis> you still haven't answered my question "what does oklobot do?"
03:22:25 <oklofok> immibis: runs the oklobot language.
03:22:37 <immibis> ~help()
03:22:41 <Sukoshi> It's what rubs me about most engineering professions but electrical -- you have no pride in workmanship. You can't build a system up with your hands.
03:23:03 <Sukoshi> It's a show of true intellectual prowess to display that you have enough knowledge not to rely on the knowledge of others.
03:23:39 <oklofok> oaky.
03:23:47 <Sukoshi> It's basically the hacker mentality. Hacking it together *yourself*.
03:23:47 <oklofok> i do rely on other people's things
03:23:52 <oklofok> i didn't invent numbers
03:23:56 <oklofok> and such
03:24:16 <Sukoshi> But you should take a day some day to investigate number systems and maybe rewrite the math axioms from the axioms, no? ;)
03:24:29 <oklofok> yeah
03:24:31 <Sukoshi> *math relationships from the axioms
03:24:38 <oklofok> and i should make my own os some day as well
03:24:45 <Sukoshi> As a concept, yeah.
03:24:53 <oklofok> a real os. that'd be cool
03:25:44 <oklofok> anyway, i still don't know your point
03:25:57 <oklofok> it seems you have somewhat misunderstood me somewhere, but hey, that's life
03:26:10 <pikhq> UNIX is the OS for people who think like that. . .
03:26:23 <Sukoshi> Exactly.
03:26:28 <oklofok> who think like what?
03:26:33 <oklofok> that making an os would be cool?
03:26:36 <ihope> We all have our own imaginary operating systems and programming languages, don't we?
03:26:51 <oklofok> ihope: oklotalk & okloOS
03:26:51 <Sukoshi> For people who find pride in building things from the ground themselves.
03:26:54 <oklofok> ;)
03:27:13 <immibis> um, i have a real operating system and programming language
03:27:17 <immibis> although neither is very good
03:27:29 <ihope> oklofok: how imaginary is oklotalk?
03:27:36 <oklofok> Sukoshi: okay, unix seems to be just *made* for me... does it make me a bad person i don't think it'd actually make my life any better?
03:27:39 <oklofok> still
03:27:49 <immibis> oklofok: if you want to make an os, i suggest you join #osdev and browse to http://osdever.net/bkerndev/
03:27:55 <oklofok> ihope: it is in the sense it's not real yet.
03:28:01 <oklofok> numbda is kinda close to it
03:28:06 <oklofok> but it's a long way still :)
03:28:12 <Sukoshi> oklofok: Do you use an OS as a tool or do you use it as a way of life?
03:28:17 <oklofok> (plus numbda is a bit different in other ways too)
03:28:34 <oklofok> Sukoshi: tool, unless someone makes a good one some day
03:28:45 <oklofok> i mean, one i find good.
03:28:54 <Sukoshi> There's the distinction.
03:28:59 <oklofok> i haven't seen aything good about unic, about which i'm sorry
03:29:04 <oklofok> *unix
03:29:13 <Sukoshi> Most UNIX hackers use it as a way of life, for which Windows is a failure.
03:29:41 <GregorR-L> There is no one killer app that makes UNIX superior.
03:29:44 <oklofok> immibis: i actually joined already :)
03:29:49 <GregorR-L> UNIX is a superior system, not a system with a superior tool.
03:30:48 <oklofok> err... sure
03:31:01 <immibis> toboge, Linux is superior to UNIX.
03:31:03 <immibis> toboge, Linux is superior to UNIX
03:31:08 <immibis> toboge, UNIX is inferior to Linux
03:31:16 <GregorR-L> Well, there's some truth to that too :P
03:31:29 <immibis> what is Linux?
03:31:29 <toBogE> Linux is superior to UNIX
03:31:32 <Sukoshi> immibis: Sounds like you need Prolog.
03:31:39 <oklofok> heeh
03:31:41 <immibis> what is prolog?
03:31:41 <oklofok> *heh
03:31:42 <toBogE> No such factoid prolog
03:31:43 <Sukoshi> superior(Linux, UNIX).
03:31:55 <Sukoshi> inferior(UNIX, Linux).
03:31:57 <oklofok> hmm
03:32:07 <immibis> sukoshi: what
03:32:17 <immibis> superior(Linux, Windows).
03:32:21 <immibis> superior(UNIX, Windows).
03:32:25 <immibis> superior(MacOS, Windows).
03:32:28 <immibis> superior(BSD, Windows).
03:32:31 <immibis> superior(Hurd, Windows).
03:32:32 <Sukoshi> better(X,Y) :- superior(X, Y), inferior (Y, X).
03:32:38 <pikhq> superior(DOS, Windows)
03:32:43 <immibis> wtf
03:32:47 <immibis> superior(Windows, DOS)
03:32:49 <Sukoshi> better(DOS, Windows).
03:32:58 <immibis> windows may be inferior to a lot of things, but not dos!
03:33:04 <oklofok> Sukoshi: i think lowercase is for atoms
03:33:08 <immibis> better(Windows, DOS)
03:33:14 * pikhq listens to Pink Floyd - The Wall
03:33:23 <oklofok> err
03:33:26 <oklofok> no they aren't.
03:33:29 <immibis> worse(Y,X) :- better(X, Y)
03:33:35 <immibis> worse(DOS, Windows)
03:33:41 <Sukoshi> You're forgetting the `.'
03:33:43 <Sukoshi> ;)
03:33:45 <oklofok> err
03:33:47 <oklofok> yes they are.
03:33:47 <pikhq> immibis: I'd much rather use DOS than Windows.
03:33:59 <immibis> 1) start windows
03:33:59 <oklofok> superior(windows,dos). then
03:34:01 <pikhq> (and yes, I *have* done so)
03:34:05 <immibis> 2) start -> run -> command.com
03:34:12 <immibis> 3) press alt-enter
03:34:43 <immibis> better(windows,dos)
03:34:45 <immibis> better(windows,dos).
03:34:49 <immibis> better(linux,windows).
03:34:54 <Sukoshi> Learn Prolog y'all!
03:34:58 <immibis> better(unix,windows).
03:35:02 <immibis> better(macos,windows).
03:35:06 <oklofok> everyone knows prolog!
03:35:06 <immibis> better(bsd,windows).
03:35:09 <immibis> better(hurd,windows).
03:35:13 <immibis> wtf is prolog?
03:35:17 <Sukoshi> immibis: .... :P
03:35:29 <Sukoshi> That's like saying ``WUTZ LISP?!''
03:35:30 <immibis> better(windows,hurd).
03:35:34 <oklofok> even my father's 60-year-old professor friend knows prolog
03:35:36 <immibis> good question. what is lisp?
03:35:58 <oklofok> immibis: those are two programming languages, old, but kinda nice
03:36:01 <Sukoshi> better(linux, X). X={unix, windows, dos).
03:36:18 <immibis> better(windows,dos).
03:36:23 <Sukoshi> Errr X={unix, windows, dos}.
03:36:25 <immibis> better(oklofok,sukoshi).
03:36:27 <oklofok> Sukoshi: you sure about that?
03:36:43 <oklofok> errrrrrrrrrrr you should be sure about it
03:36:47 <oklofok> immibis: the question.
03:37:01 <oklofok> *same
03:37:05 <immibis> what question?
03:37:12 <oklofok> you sure about that?
03:37:22 <immibis> better(ubuntu6,debian3). ubuntu6=linux. debian3=linux.
03:37:23 <oklofok> i've just been trying to install gcc for 2 ohurs.
03:37:34 <oklofok> you don't make me arg1 of better() ;)
03:37:39 <oklofok> *hours
03:37:53 <immibis> don't you need gcc to install gcc?
03:37:57 <immibis> ok then
03:38:02 <immibis> better(sukoshi,oklofok).
03:38:08 <immibis> better(X,Y). X=Y. Y=X.
03:38:33 <immibis> oklofok, how do you ask oklobot which is better out of a set of two things?
03:38:45 <oerjan> that is not correct Prolog.
03:39:05 <immibis> oklobot uses prolog?
03:39:12 <oklofok> immibis: your code isn't
03:39:15 <immibis> oklofok said it used oklobotspeak.
03:39:26 <immibis> better(X,Y). X=linux. Y=linux.
03:39:29 <immibis> is that?
03:39:30 <oklofok> we tried to let you away with it, but oerjan just couldn't :)
03:39:31 <immibis> i don't know prolog
03:39:48 <oerjan> and Sukoshi's wasn't correct either.
03:39:52 <oklofok> immibis: i don't have an in-built better-than function.
03:39:52 <immibis> print X.
03:39:55 <immibis> print linux.
03:40:04 <oerjan> Now if i could just remember what the correct way was...
03:40:05 <oklofok> oerjan, you need :-?
03:40:20 <ihope> I think better(X,Y) declares that better always gives yes.
03:40:20 <immibis> better(X,Y). X :- Y. Y :- X.
03:40:22 <oerjan> :- and commas
03:40:28 <immibis> better(X,Y). X :- Y, Y :- X.
03:40:30 <oklofok> s(A,B):-A,B.
03:40:31 <ihope> better(linux,linux)
03:40:40 <oklofok> , is &
03:40:41 <immibis> s(linux,linux)
03:40:43 <oklofok> ; is |
03:40:44 <oklofok> & is and
03:40:46 <oklofok> | is or
03:40:54 <oerjan> periods at the end of statements
03:41:01 <immibis> how to output?
03:41:09 <oklofok> immibis: you usually don't
03:41:15 <oklofok> but "print"?
03:41:18 <oklofok> i don't remember
03:41:19 <immibis> then whats the point.
03:41:23 <immibis> print "Hello".
03:41:32 <immibis> print "Hello World!"
03:41:35 <immibis> print "Hello World!".
03:41:39 <oerjan> you probably need parentheses
03:41:40 <oklofok> immibis: it brute forces you results and gives them to you :)
03:41:47 <immibis> print("Hello World!").
03:41:51 <oklofok> not strictly brute forces
03:41:53 <immibis> print(Hello World!).
03:41:58 <oklofok> but it seems it does
03:42:03 <oklofok> it's magic you know
03:42:05 <immibis> print(i suck if i can't output!).
03:42:15 <oklofok> print("Hello World!"). i'd say
03:42:22 <toBogE> i suck if i can't output!
03:42:34 <toBogE> Hello World!
03:42:54 <immibis> print("Hello World!").
03:42:54 <oklofok> aaaa
03:43:00 <oklofok> it's not print
03:43:02 <oklofok> it's write.
03:43:05 <immibis> printf("Hello World1");
03:43:09 <immibis> write("Hello World!");
03:43:10 <immibis> write("Hello World!").
03:43:15 <immibis> write "Hello World!"
03:43:16 <immibis> write "Hello World!".
03:43:24 <immibis> write(X). X=linux
03:43:26 <immibis> write(X). X=linux.
03:43:37 <oklofok> immibis: wrong again
03:43:40 <immibis> is prolog an esoteric language?
03:43:43 <oklofok> no
03:43:49 <oklofok> it's a logic language
03:43:54 <oerjan> X=linux, write(X).
03:43:55 <oklofok> one of the dying categories
03:44:02 <ihope> write(hello).?
03:44:03 <immibis> X=linux, write(X).
03:44:06 <immibis> write(hello).
03:44:09 <oklofok> ihope: 'hello'
03:44:13 <oerjan> logic languages are not dying!
03:44:15 <immibis> write('hello')
03:44:16 <ihope> write('hello').?
03:44:16 <immibis> write('hello').
03:44:23 <immibis> X='hello', write(X).
03:44:26 <oklofok> oerjan: oh
03:44:41 <oklofok> i thought functional languages addressed all their positive shitz.
03:44:51 <oklofok> hmm
03:45:02 <oklofok> parsers are actually hellishly easy to make in prolog
03:45:13 <oklofok> they seem to be even simpler than haskell ones
03:45:18 <oerjan> logical variables are awkward in functional languages.
03:45:25 <ihope> Hellish ease is nice.
03:45:55 <oklofok> oerjan: are there logic languages used widely?
03:46:17 <oklofok> i have no idea what's going on, really, i just predict and miss.
03:46:17 <oklofok> :P
03:46:31 <oerjan> i don't know what's big.
03:47:07 <oerjan> Haskell is still smaller than Prolog, i believe.
03:47:09 <immibis> a char[1024*1024*1024*1024] is big
03:47:16 <ihope> Smaller than Prolog?
03:47:20 <ihope> As in less used?
03:47:32 <oklofok> 21 users on #prolog, 340 on #haskell
03:47:37 <pikhq> a char[SIZE_T_MAX] is big. ;)
03:47:40 <ihope> I thought Prolog wasn't a practical language.
03:47:49 <oerjan> someone posted a link of some comparison
03:47:56 <oerjan> site
03:48:35 <immibis> what is size_t_max?
03:48:36 <toBogE> No such factoid size_t_max
03:48:48 <immibis> actually there were 20, oklofok.
03:48:51 <oklofok> oerjan: you know other logic languages?
03:48:54 <oklofok> immibis: i was one.
03:49:01 <oklofok> just got out fast before you came.
03:49:08 <pikhq> immibis: The maximum size of a size_t.
03:49:25 <pikhq> (size_t being the return type of the sizeof operator)
03:49:36 <immibis> actually, a char[1024*1024*1024*1024] is so big you need a 64-bit processor.
03:49:43 <oklofok> heh
03:49:44 <immibis> one terabyte.
03:49:51 <pikhq> SIZE_T_MAX scales with bits.
03:49:55 <oerjan> Mercury, Curry (based on Haskell)
03:50:01 <ihope> ...Scales with bits?
03:50:05 <ihope> What's Mercury?
03:50:06 <pikhq> On my system, that's a char[pow(2,64)]
03:50:12 <immibis> the more the bits, the bigger it is.
03:50:23 <oerjan> a pure logical language, statically typed
03:50:24 <oklofok> that guy has gotten quite a lot of stuff after his name
03:50:26 <ihope> The bits don't change size, you mean?
03:50:33 <ihope> ...oh.
03:50:37 <immibis> er, no
03:50:53 <ihope> SIZE_T_MAX depends on the bittage of the processor?
03:51:07 <ihope> (Eek, spellcheck things "bittage" is a word but "okay" isn't.)
03:51:11 <immibis> the bittage of the processor gcc was compiled on, more likely.
03:51:37 <ihope> Oh, spellcheck isn't enabled.
03:51:53 <ihope> No wonder it wasn't saying "no, not a word".
03:52:01 <ihope> Indeed, it rejects.
03:52:07 <immibis> a long long[1000000000][1125899906842624] is amazingly big.
03:52:09 <oklofok> hmm
03:52:23 <immibis> eight billion petabytes
03:52:28 <oklofok> mercury seems to be a bit more purer about output
03:52:32 <oklofok> *-more
03:52:36 <immibis> what is mercury?
03:52:36 <toBogE> No such factoid mercury
03:52:38 <ihope> immibis: pff, tiny.
03:52:43 <ihope> It will be, that is.
03:52:49 <pikhq> The bittage of the target arch, actually.
03:53:32 <immibis> ok, 2.076918743413931051412198531688e+34 is 2^64
03:53:39 <immibis> is that big?
03:53:46 <immibis> what is 1 + 1?
03:53:46 <toBogE> 1 + 1 is 2, but that's all i'll ever calculate.
03:53:51 <immibis> what is 2 + 2?
03:53:51 <toBogE> 2 + 2 is not compute.
03:54:42 <immibis> what is 3 + 3?
03:54:43 <toBogE> No such factoid 3 + 3
03:54:50 <immibis> toboge, 3 + 3 is 65536
03:55:07 <oerjan> also Oz is a multiparadigm language with logical bits, used in the quite well-received textbook Concepts, Techniques, and Models of Computer Programming (which i haven't read)
03:56:29 <oerjan> mercury made me wonder if definite clause grammars (which mercury uses to wrap up i/o) is some logical version of monads.
03:56:37 <oklofok> oerjan: of those languages i've just bumped into prolog and most programmers i know have no idea about that even; hence my "dying category" definition
03:56:40 <oerjan> couldn't find anything about it though.
03:56:48 <immibis> toboge, Oz is a multiparadigm language with logical bits, used in the quite well-received textbook Concepts, Techniques, and Models of Computer Programming (which oerjan hasn't read)
03:56:53 <oklofok> yeah, i had that exact thought myself
03:57:08 <oklofok> but i don't actually know monads that well, so...
03:57:08 <oklofok> :P
03:58:22 -!- GregorR-L has quit (Read error: 110 (Connection timed out)).
03:58:27 <oklofok> Sukoshi: making that interpreter shouldn't take that long (if i get sdl installed... which i doubt), but it'll have to wait till i get new batteries for my keyboard
03:58:32 <oklofok> it died just now
03:58:43 <ihope> Ha. http://en.wikipedia.org/wiki/Orders_of_magnitude_%28data%29
03:58:48 <oklofok> i do have another keyboard though, so forget what i said.
03:58:52 <ihope> The biggest thing there is "amount of information which can be stored in 1 gram of DNA"
03:59:02 <ihope> 2.25 zettaoctets...
03:59:21 <Sukoshi> oklofok: ;P
03:59:45 <pikhq> Not quite.
03:59:52 <ihope> So we won't run out of storage space any time soon.
03:59:53 * pikhq imagines 1kg of DNA
04:00:00 <Sukoshi> I'm gonna have to resume Esperanto studies before college, so I can Esperanto-localize everything before I leave, so that nobody can understand my desktop in the off-chance it's unlocked when they are there.
04:00:14 <oerjan> since categorical monads exist in a lot of categories other than functions...
04:00:41 <oerjan> but i know just about nothing about those
04:02:52 <oklofok> i've been thinking about creating myself a font with no connection to this one and learning to read and write it
04:02:56 <oklofok> that'd be fun
04:03:14 <oklofok> connection=similarity
04:03:38 <ihope> How easy would English be if word order were reversed?
04:03:44 <oklofok> now co[dk]e ->
04:04:11 <oerjan> Say i'ld, easy pretty.
04:04:17 <oklofok> ihope: easier to learn for me, a *lot* easier to crack
04:04:34 <immibis> is it wise to install every single extension when you upgrade php?
04:04:36 * pikhq shrugs
04:04:51 <ihope> oerjan: "i'ld"?
04:05:31 * ihope suddenly goes to bed
04:07:36 * oerjan thought that was the correct contraction for "I would"
04:07:46 <oklofok> oerjan: i'd
04:07:47 <oklofok> err
04:07:53 <oklofok> that's not what i was gonna say
04:08:21 <oklofok> oerjan: state variables in mercury, they anywhere near monads ?
04:08:33 <oklofok> i guess you don't remember that language fully, though.
04:08:58 <oerjan> indeed not.
04:09:14 <oklofok> which one?
04:09:52 <oklofok> i'll assume the latter and keep reading.
04:11:09 * oerjan wonders how he could have messed up such an elementary part of english grammar.
04:11:42 <oklofok> you do io_action(arg, io_state1, io_state2), io_action(arg, io_state2, io_state3) normally to chain the action in the correct sequence
04:11:46 <Sukoshi> oerjan: Did your parser miss a case?
04:12:52 <oklofok> and you can have a state variable !var that can be used like io_action(arg, !IO), io_action(arg, !IO)
04:12:59 <oerjan> actually it seems to have added one that wasn't there :)
04:13:00 <oklofok> for a syntactic sugar for the chaining
04:13:56 <oklofok> oerjan: do you use contractions?
04:14:04 <oklofok> normally
04:14:17 <oklofok> i don't recall you using that before
04:14:42 <oerjan> well i use don't and can't and such, at least
04:14:58 <oklofok> i use "i'd've" pretty often
04:15:04 <oklofok> it's my favorite
04:15:46 <oklofok> "i'll've" beats it though, but that's even iffier and i've never seen it used :)
04:16:59 <immibis> what about "i'll've'nt"?
04:17:06 <immibis> i will have not
04:17:20 <immibis> err, "i'll'ven't"
04:17:24 <oklofok> it's "i will not have"
04:17:25 <oklofok> yeah
04:17:30 <oklofok> err
04:17:31 <oklofok> no
04:17:47 <oklofok> "'nt" must end the contraction
04:17:51 <oklofok> (imo)
04:18:03 <oklofok> this is a matter of opinion, obviously.
04:18:06 <immibis> i'll is i will
04:18:16 <oklofok> anyway, where is my code, where is my coke?
04:18:17 <immibis> 've is have
04:18:20 <immibis> and n't is not
04:18:22 <oklofok> not here, i say.
04:18:33 <oklofok> immibis: sorry, "n't" must be last
04:18:36 <oklofok> i
04:18:37 <oklofok> ..
04:18:48 <oklofok> i'lln't've
04:18:55 <oklofok> not i'll'ven't
04:19:05 <immibis> i will not have
04:19:14 <oklofok> yeah
04:19:28 <oklofok> i will not have had = i'lln't've'd
04:20:09 <oklofok> i'm pretty sure i'lln't've'd sex before i'm 40
04:20:25 <oklofok> because i use comtraction extensively
04:20:43 <oklofok> *contractions
04:24:05 -!- ihope has quit (Connection timed out).
04:51:04 -!- immibis has quit (Excess Flood).
04:51:21 -!- immibis has joined.
05:01:20 -!- suifur has quit ("leaving").
05:12:10 -!- immibis_ has joined.
05:12:58 -!- immibis has quit (Nick collision from services.).
05:13:01 -!- immibis_ has changed nick to immibis.
05:16:14 -!- toBogE has quit (Nick collision from services.).
05:16:42 -!- toBogE has joined.
05:23:28 <immibis> !bf_txtgen ACTION is a bot. Didn't you know that?
05:23:28 <toBogE> Caught a java.lang.ClassNotFoundException! toboge.Execer_bf_txtgen
05:24:50 <EgoBot> 331 ++++++++++++[>+++++++>+++++>+++>+++++<<<<-]>>+++++.++.<.>++++++.++++++.-.>----.<<+++++++++++++++++++++.++++++++++.>>.<+++++++++++++++++++.>.<+.<----.+++++.>>>--------------.<.>++++++++++++++++++++++.<<<-----------.>++.<+++++.>>+++++++.<++++++++++++++++.>-------.<+++++.<+.>----.>.<<----.+++.+.>++.>.<---.<-------.-------.>.>>-----. [948]
05:25:42 <oerjan> !bf8 ++++++++++++[>+++++++>+++++>+++>+++++<<<<-]>>+++++.++.<.>++++++.++++++.-.>----.<<+++++++++++++++++++++.++++++++++.>>.<+++++++++++++++++++.>.<+.<----.+++++.>>>--------------.<.>++++++++++++++++++++++.<<<-----------.>++.<+++++.>>+++++++.<++++++++++++++++.>-------.<+++++.<+.>----.>.<<----.+++.+.>++.>.<---.<-------.-------.>.>>-----.
05:25:43 <toBogE> ACTION is a bot. Didn't you know that?
05:25:44 <EgoBot> ACTION is a bot. Didn't you know that?
05:26:22 <immibis> !bf8 +.+++++++++++[>+++++++>+++++>+++>+++++<<<<-]>>+++++.++.<.>++++++.++++++.-.>----.<<+++++++++++++++++++++.++++++++++.>>.<+++++++++++++++++++.>.<+.<----.+++++.>>>--------------.<.>++++++++++++++++++++++.<<<-----------.>++.<+++++.>>+++++++.<++++++++++++++++.>------ -.<+++++.<+.>----.>.<<----.+++.+.>++.>.<---.<-------.-------.>.>>-----.[-]+.
05:26:23 * toBogE is a bot. Didn't you know that?
05:26:26 * EgoBot is a bot. Didn't you know that?
05:26:29 <immibis> that was what i originally wanted it for
05:27:26 <oerjan> i guessed as much.
05:28:50 <GreaseMonkey> niiice
05:29:09 <GreaseMonkey> "wouldn't've'd to've"
05:29:39 <GreaseMonkey> !help
05:29:39 <toBogE> All known commands: !bf !bf8 !binascii !chanlist !delregex
05:29:41 <toBogE> !factoid !hello !help !irp !magritte !minimum !nil
05:29:42 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
05:29:43 <toBogE> !persist !raw !regex !rot13 !userlist
05:29:44 <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
05:29:46 <EgoBot> Huh?
05:29:48 <EgoBot> Huh?
05:30:35 <immibis> !help is what you should not say at the beginning of a line
05:30:35 <toBogE> All known commands: !bf !bf8 !binascii !chanlist !delregex
05:30:37 <toBogE> !factoid !hello !help !irp !magritte !minimum !nil
05:30:38 <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.
05:30:39 <toBogE> !persist !raw !regex !rot13 !userlist
05:30:40 <EgoBot> Huh?
05:30:42 <EgoBot> Huh?
05:31:41 <oerjan> it might be a good idea to have toBogE use a different command prefix.
05:32:22 <immibis> or make egobot ignore it
05:32:35 <immibis> !daemon factoid +[,[-]+]
05:32:35 <toBogE> Caught a java.lang.ClassNotFoundException! toboge.Execer_daemon
05:32:41 <Sukoshi> But EgoBot was here first.
05:32:41 <immibis> !daemon persist +[,[-]+]
05:32:42 <toBogE> Caught a java.lang.ClassNotFoundException! toboge.Execer_daemon
05:32:52 <immibis> but toboge was here before egobot joined, as well
05:33:00 <immibis> !help
05:33:00 <toBogE> All known commands: !bf !bf8 !binascii !chanlist !delregex
05:33:02 <toBogE> !factoid !hello !help !irp !magritte !minimum !nil
05:33:02 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
05:33:04 <toBogE> !persist !raw !regex !rot13 !userlist
05:33:04 <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
05:33:06 <EgoBot> Huh?
05:33:08 <EgoBot> Huh?
05:33:11 <Sukoshi> EgoBot's been in this channel for ages.
05:33:21 <immibis> yes but i wrote toboge when it wasn't.
05:33:26 <immibis> !raw PART #esoteric
05:33:28 -!- toBogE has left (?).
05:33:44 <Sukoshi> Are you being idiotic on purpose? :P
05:34:08 <GreaseMonkey> i say so
05:34:27 <Sukoshi> So this is weird. One element is randomly not being added to the hash table.
05:34:32 <Sukoshi> And I have absolutely no idea why.
05:34:57 <Sukoshi> It's being read and parsed, but not being added, for reasons I can't understand.
05:35:19 <immibis> is it already in the hash table?
05:35:44 <Sukoshi> No.
05:36:03 <Sukoshi> Stupid faulty hash table implementations. *Grumble*. That's what you get for relying on others.
05:37:59 <oerjan> and a randomly changing element, too?
05:41:08 <Sukoshi> Yeah.
05:43:24 -!- pikhq has quit (Read error: 110 (Connection timed out)).
06:11:46 -!- Sgeo has quit ("Ex-Chat").
07:10:27 -!- oerjan has quit ("leaving").
07:23:33 <RodgerTheGreat> 'night, guys
07:23:41 <Sukoshi> LIke you talked a lot :P
07:23:50 <RodgerTheGreat> <:/
07:23:58 <RodgerTheGreat> silence can be a virtue...
07:24:13 <Sukoshi> virtue(silence) -> no.
07:24:16 <RodgerTheGreat> would you prefer I babble mindlessly?
07:24:31 <Sukoshi> Yes. Like immibis and his bot testing.
07:25:00 <RodgerTheGreat> well, then, I'll start bringing Archos, my chatterbot, in here more often
07:25:19 <Sukoshi> Yes. Do it. And spam!!!
07:25:41 <Sukoshi> By the way, this Hashtable seems to randomly place null instead of one element each time I use it.
07:25:47 <Sukoshi> And the element changes each time it runs.
07:25:47 <RodgerTheGreat> your will is my command, oh queen of #Esoteric
07:26:18 -!- RodgerTheGreat has quit.
07:46:18 <Haikz> uprhghg'
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:40:54 -!- sebbu has joined.
08:48:45 -!- edwardk has left (?).
09:29:17 -!- immibis has quit ("Man who run behind car get exhausted").
10:33:58 -!- jix has joined.
10:38:36 <GreaseMonkey> night all
10:39:07 -!- GreaseMonkey has quit ("MULTIPLAYER NOTEPAD IS WORKING! :D Will release it tomorrow.").
11:51:29 -!- ehird` has joined.
12:06:07 -!- jix has quit (Nick collision from services.).
12:06:21 -!- jix has joined.
13:20:30 -!- ihope__ has joined.
13:20:48 -!- ihope__ has changed nick to ihope.
13:29:12 <ihope> Well, I've figured out just what it is I want with this lambda/SKI and monad stuff.
13:30:47 <ihope> I want to be able to pretend that every lambda calculus construct has an equivalent SKI calculus construct.
13:31:30 <ehird`> it does
13:34:05 <oklopol> ihope: ololobot has a convertor for that
13:35:08 <ihope> That to convert \x.E to SKI, you can convert E to SKI and return something that includes the result.
13:35:57 <oklopol> i don't understand
13:36:06 <oklopol> >>> pl ^xE
13:36:07 <ololobot> `kE
13:36:27 <ihope> Where E is some expression that may or may not contain x.
13:36:56 <oklopol> you want to convert any expression from lambda to ski?
13:37:10 <ihope> Yup.
13:37:15 <oklopol> pl.
13:37:18 <ehird`> >>> pl ^xx
13:37:18 <ololobot> `kx
13:37:21 <ehird`> >>> pl ^xy
13:37:21 <ololobot> `ky
13:37:27 <ehird`> >>> pl s
13:37:28 <ololobot> s
13:37:30 <ehird`> >>> pl `ss
13:37:30 <ololobot> `ss
13:37:33 <ihope> It translates ^xx to `kx?
13:37:42 <ehird`> oh
13:37:44 <ehird`> it uses $
13:37:44 <oklopol> >>> pl ^a^b^c``$c$b$c
13:37:45 <ololobot> ``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s`kk`ki``s``s`ks``s`kk`kk`ki``s`kk`ki
13:37:47 <ehird`> >>> pl ^x$x
13:37:48 <ololobot> i
13:37:51 <oklopol> it has no optimization
13:37:53 <ehird`> >>> pl ^x^y`$x$y
13:37:54 <ololobot> ``s``s`ks``s`kki`ki
13:38:01 <ihope> >>> pl ^x$x
13:38:02 <ololobot> i
13:38:03 <ehird`> ``s``s`ks``s`kki`ki is the apply function. i didn't know that.
13:38:11 <ihope> Why does it do that?
13:38:13 <ehird`> >>> pl ^x^y^z``$x$y$z
13:38:14 <ololobot> ``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kki``s``s`ks``s`kk`kk`ki``s`kk`ki
13:38:15 <ihope> ehird`: the apply function?
13:38:23 <ehird`> >>> pl ^x^y^z``$x$z`$y$z
13:38:24 <ihope> Oh, hmm.
13:38:24 <ololobot> ``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kki``s`kk`ki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk`ki``s`kk`ki
13:38:29 <ehird`> why doesn't that optimize to S
13:38:29 <ihope> Indeed, that's sort of bad.
13:38:45 <oklopol> ehird`: it does *not* optimize *anything*
13:38:55 <ehird`> >>> pl ``^x^y^z``$x$z`$y$z^x^y$x^x^y$x
13:38:55 <ololobot> ``^x^y^z``$x$z`$y$z^x^y$x^x^y$x
13:38:56 <oklopol> i have a list of lenght optimizationsi gathered
13:39:02 <ehird`> ... that is broken
13:39:03 <oklopol> but didn't implement yet
13:39:07 <ehird`> >>> pl ``^x^y^z``$x$z`$y$z^x^y$x^x^y$x # broken
13:39:08 <ololobot> ``^x^y^z``$x$z`$y$z^x^y$x^x^y$x
13:39:16 <oklopol> hmm
13:39:16 <ihope> ``xz`yz -> ``sxy -> `sx -> s
13:39:22 <oklopol> it seems so
13:39:26 <ehird`> ihope, 'xactly
13:39:30 <ehird`> that's SKK, aka I
13:39:37 <ihope> x -> `kx -> k
13:39:38 <ehird`> but, it doesn't even fully convert
13:39:42 <oklopol> i've always kept separately application and lambda creation
13:39:46 <oklopol> shouldn't be hard to fix
13:40:13 <oklopol> ehird`: it seems i don't recurse on application.
13:40:16 <oklopol> i'll try and fix that now
13:40:19 <ehird`> :P
13:41:24 <ehird`> oklopol, back to optimization/compilation/interpretation: would you be happy if pl reduced the whole lambda expression, then just gave you the >result< of evaluating it in SKI?
13:41:28 <ehird`> it wouldn't be a compiler would it? :)
13:42:16 <oklopol> that's a convertor, not a compiler :|
13:42:25 <ihope> Same thing, really.
13:42:36 <ihope> Except that with a compiler, you're generally converting downward.
13:42:38 <oklopol> ehird`: also, it returnsthe result
13:42:44 <oklopol> *returns the
13:42:58 <oklopol> it should, that is.
13:43:04 <ehird`> ihope, i was responding to how oklopol said that a brainfuck compiler should optimize so much, that anything without input should be optimized to its result
13:43:21 <ehird`> so e.g. a factorial function called with hardcoded 7 would be compiled as just "7"... it'd execute at compiletime
13:43:30 <ihope> ++++++++++++++++++++++++++++++++++++++++[.]
13:43:54 <ehird`> well, if you wrote a factorial for 7 - code to do it - in BF
13:43:57 <ehird`> then compiled that
13:44:00 <ehird`> the resulting c code would be like
13:44:13 <ehird`> "*p = 5040; putchar(*p);"
13:44:17 <ehird`> and it'd have run at compile time
13:44:19 <ehird`> i think that's absurd.
13:45:10 -!- RedDak has joined.
13:47:55 <oklofok> no wonder
13:47:57 <oklofok> elif a[1][0]!='`':
13:47:57 <oklofok> ret=["`",["k"],a[1]]
13:48:10 <oklofok> it effectively just returns whatever was given unless it's a lambda.
13:48:29 <ihope> Whoa.
13:48:29 <oklofok> >>> pl `^x$xi
13:48:31 <ololobot> `^x$xi
13:48:38 <oklofok> actually
13:48:40 <ihope> >>> pl `hello, world!
13:48:40 <ololobot> `he
13:48:44 <ihope> Darn.
13:48:54 <oklofok> why not `k^x$xi?
13:49:24 <oklofok> ihope: normal application applied still, though :)
13:49:27 <ehird`> >>> pl ^x^y^z``$x$z`$y$z
13:49:28 <ololobot> ``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk``s`kki``s`kk`ki``s``s`ks``s``s`ks``s`kk`ks``s``s`ks``s`kk`kk`ki``s`kk`ki
13:49:37 <oklofok> beware excess flood...
13:49:45 <ehird`> >>> pl ``^x^y^z``$x$z`$y$z^x^y$x^x^y$x
13:49:46 <ololobot> ``^x^y^z``$x$z`$y$z^x^y$x^x^y$x
13:49:49 <ehird`> :/
13:49:50 <oklofok> ski is a bit verbose, especially unoptimized and autoconverted
13:49:53 <ihope> oklofok: er, does `k^x$xi make sense?
13:50:16 <oklofok> ihope: that'd be wrong, indeed.
13:50:23 <ihope> >>> pl ^x```sksk
13:50:24 <ololobot> ``s``s``s`ks`kk`ks`kk
13:50:31 <oklofok> haha
13:50:37 <oklofok> oh, may be correct
13:50:40 <ehird`> that's muddled
13:50:42 <ihope> >>> pl ^x`s`s`s`s`s`s`s`ss
13:50:42 <ehird`> heh
13:50:43 <ololobot> ``s`ks``s`ks``s`ks``s`ks``s`ks``s`ks``s`ks``s`ks`ks
13:50:48 <ihope> Yah, fix.
13:50:49 <oklofok> sksk does what?
13:50:53 <ehird`> SKSK=K
13:50:59 <oklofok> >>> pl ^x```sksk
13:51:00 <ololobot> ``s``s``s`ks`kk`ks`kk
13:51:03 <ehird`> oh no wait
13:51:05 <ehird`> SK(SK) = K
13:51:05 <ihope> ```sksk -> ``kk`sk -> k
13:51:06 <ehird`> >>> pl ^x`$x$x
13:51:07 <ololobot> ``sii
13:51:14 <ehird`> ihope, it's ``sk`sk
13:51:14 <oklofok> >>> ul ````s``s``s`ks`kk`ks`kk i i
13:51:15 <ololobot> -> ('k', 'i')
13:51:17 <ehird`> >>> pl ^x`$x$x
13:51:17 <ololobot> ``sii
13:51:21 <ehird`> well that works!
13:51:21 <oklofok> >>> ul ````s``s``s`ks`kk`ks`kk A B
13:51:22 <ololobot> -> ('k', 'B')
13:51:26 <ihope> ehird`: um, I have it ```sksk.
13:51:26 <oklofok> hmm...
13:51:30 <ehird`> >>> pl `^x`$x$x^x`$x$x
13:51:31 <ololobot> `^x`$x$x^x`$x$x
13:51:35 <ehird`> ihope, well, that's wrong i think =p
13:51:38 <oklofok> >>> ul `````s``s``s`ks`kk`ks`kk A B C
13:51:39 <ololobot> -> B
13:51:44 <ihope> Wrong?
13:51:47 <ehird`> >>> pl `^x`$x$x^x`$x$x <-- should translate to ```sii``sii
13:51:48 <ololobot> `^x`$x$x^x`$x$x
13:51:52 <ehird`> >>> pl ^x`$x$x
13:51:53 <ololobot> ``sii
13:51:57 <ehird`> but ` is still borked.
13:52:00 <ehird`> you need to recurse
13:52:04 <oklofok> okay, i'm pretty sure that works correctly unless you actually apply a lambda :)
13:52:08 <oklofok> yeah
13:52:23 <ihope> I think we've concluded that the bot is terribly horribly not well very badly broken.
13:52:42 <ehird`> and cue....
13:52:50 <ihope> And cue?
13:52:55 <ehird`> and cue...
13:53:04 -!- blahbot` has joined.
13:53:19 <blahbot`> blahbot to the rescue!
13:53:32 <oklofok> ah, *now* i found the problem
13:53:39 <oklofok> else:
13:53:40 <oklofok> ret=a
13:53:42 <blahbot`> my bad influence?
13:53:49 <oklofok> it effectively just returns with *no* conversion.
13:54:12 <blahbot`> i like bots!
13:54:16 <blahbot`> >>> pl ``sii
13:54:17 <ololobot> ``sii
13:54:29 <blahbot`> >>> pl ^x^y$y
13:54:30 <ololobot> `ki
13:54:57 <blahbot`> >>> pl ^x^y^z^a^b^c``$x$a``$b$c$z
13:54:58 -!- ololobot has quit (Excess Flood).
13:55:00 <ehird`> heh
13:55:14 <ehird`> how long was that
13:56:41 <oklopol> hmm
13:56:45 <oklopol> i cantry on console
13:56:51 <oklopol> *can try
13:58:15 <oklopol> oph btw
13:58:23 <oklopol> it should be fixed
13:59:03 <ehird`> restart it
13:59:11 <oklopol> oh
13:59:12 <oklopol> hehe
13:59:15 <oklopol> wait
13:59:37 <oklopol> i should really make threading and autoreconnect...
14:00:00 <ehird`> threading is simple
14:00:03 <ehird`> what language is ololobot in
14:00:08 <oklofok> http://www.vjn.fi/pb/p652565215.txt
14:00:08 <ehird`> if ruby, then killing threads is really easy
14:00:10 <oklofok> c++
14:00:12 <ehird`> ewww
14:00:13 <oklofok> err
14:00:17 <oklofok> it's python.
14:00:21 <ehird`> oh
14:00:26 <ehird`> it's easy in ruby
14:00:29 <ehird`> ps = Thread.list
14:00:29 <oklofok> anyway, there's your lambda
14:00:32 <oklofok> i mean
14:00:33 <oklofok> ski
14:00:34 <ehird`> kill = Thread.list[x].kill
14:00:40 <ehird`> thats an insane lambda
14:00:44 <ehird`> %cmds
14:00:45 <blahbot`> quit, eval, ps, kill, cmds, help, reload, join, part, send, topic, raw, bf, parse, reduce (use %help for argument information)
14:00:45 <oklofok> yeah, not that easy in python, but almost
14:00:51 <ehird`> i should get rid of reduce
14:00:52 <ehird`> it doesn't work
14:00:54 <oklofok> hmm
14:00:59 * ehird` wonders what to add to it
14:01:02 <oklofok> i should make >>> help me
14:01:06 <ehird`> any particularly interesting languages>
14:01:08 <ehird`> >>> help
14:01:10 <ehird`> >>> commands
14:01:24 <ehird`> %bf +++++++.
14:01:30 <ehird`> %bf +[]
14:01:31 <ehird`> %ps
14:01:32 <blahbot`> 0. bf +[]
14:01:32 <blahbot`> 1. ps
14:01:34 <ehird`> %kill 0
14:01:48 <oklofok> i'd love to add stuff to my bot if you gimme btw, any python program that has a function run() that takes a string and returns a string
14:01:50 <ehird`> !help
14:01:53 <EgoBot> help ps kill i eof flush show ls bf_txtgen usertrig daemon undaemon
14:01:55 <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
14:02:20 <ehird`> i assume malbolge uses an external interp
14:02:26 <oklofok> (though i'll change it to take as arguments a string and give it an object to use for message passing or something alike)
14:02:35 <oklofok> ehird`: they all do
14:02:47 <ehird`> i embedded a BF interpreter for my bot
14:02:51 <oklofok> whooops
14:02:52 <ehird`> more elegant i think considering its simplicity
14:03:00 <oklofok> forgot to join the bot here
14:03:16 -!- ololobot has joined.
14:03:28 <oklofok> >>> `^x$xi
14:03:35 <oklofok> >>> pl `^x$xi
14:03:36 <ololobot> `ii
14:04:03 <ehird`> >>> pl `^x`$x$x^x`$x$x
14:04:03 <ololobot> ```sii``sii
14:04:06 <ehird`> good
14:04:12 <oklofok> test its correctness will you? i can't test my own programs, i'm just too empathetic about hem...
14:04:13 <oklofok> *them
14:04:16 <oklofok> nice
14:05:04 <ehird`> Hmmmmmmmmmm
14:05:29 <ihope> >>> pl ^x$x
14:05:30 <ololobot> i
14:05:35 <ihope> >>> pl ^x^y$x
14:05:36 <ololobot> ``s`kki
14:05:41 <ihope> Wrong. :-P
14:05:42 <ehird`> A brainfuck with two bignums is turing-complete, right?
14:06:06 <ehird`> with +, -, *, / (* / = +- for second int), and [] and {}
14:06:13 <oklofok> err nope
14:06:15 <oklofok> ah
14:06:22 <oklofok> then it might just be
14:06:37 <ehird`> minksy machine or something
14:06:44 <oklofok> minsky isn't tc
14:07:02 <ehird`> it is, isn't it?
14:07:02 <oklofok> hmm
14:07:13 <ehird`> http://esoteric.voxelperfect.net/wiki/Minsky_machine
14:07:15 <oklofok> i could make the bot upload long returns automatically
14:07:16 <ehird`> Minsky machines with two or more registers have been shown to be in the same computational class as Turing machines. Because of this, and because of their simplicity, they can be used to prove several esoteric programming languages to be Turing-complete as well.
14:08:02 <oklofok> okay, sorry, i confuse terms quite often.
14:08:10 <oklofok> well, anyway, some machine was not tc.
14:08:49 <oklofok> hmm
14:08:56 <oklofok> actually you don't even need * and /
14:09:08 <ehird`> you don't have < > so yes you do
14:09:22 <ehird`> +-*/[]{}
14:10:04 <oklofok> not according to that page
14:10:24 <ehird`> why not
14:10:31 <ehird`> >+ -> *
14:10:36 <ehird`> >- -> /
14:10:42 <ehird`> >[ -> {
14:10:54 <ehird`> i guess maybe you need to wrap the poiner
14:11:38 <oklofok> according to that page you need two numbers, + and -
14:13:13 * ehird` keeps thinking what language to botify
14:14:43 <oklofok> ehird`: wanna tell me how to list all files in a folder in python?
14:14:50 <oklofok> guess i could google.
14:15:06 <ehird`> !ls
14:15:09 <EgoBot> bf/, glass/, linguine/
14:15:11 <ehird`> wtf!
14:15:15 <ehird`> egobot exposes the fs?!
14:15:18 <ehird`> !ls bf
14:15:21 <EgoBot> LostKng.b, numwarp.b
14:15:44 <ehird`> !ls `echo hi > bf/hello`
14:15:47 <EgoBot> /bin/ls: ./files/`echo hi > bf/hello`: No such file or directory
14:15:53 <ehird`> !ls $(echo hi > bf/hello)
14:15:55 <EgoBot> /bin/ls: ./files/$(echo hi > bf/hello): No such file or directory
14:15:58 <ehird`> !ls ;echo hi > bf/hello
14:16:01 <EgoBot> /bin/ls: ./files/;echo hi > bf/hello: No such file or directory
14:16:11 <ehird`> !ls --help
14:16:15 <EgoBot> /bin/ls: ./files/--help: No such file or directory
14:17:31 <ehird`> hmm
14:17:42 <ehird`> is a language comprising of this TC:
14:18:19 <ehird`> ? - if the next char in the source code is greater than \000, jump one character after it and ignore the next ?. Otherwise, jump to after the next ?.
14:18:22 <ehird`> anything else - nop
14:18:35 <ehird`> maybe anything else - add to tape
14:18:45 <ehird`> no i don't think it is...
14:18:52 <ehird`> maybe if you had ! replace the next char with the previous one
14:19:37 -!- pikhq has joined.
14:19:38 <oklopol> it's not tc
14:19:41 <oklopol> it's finite
14:19:53 <ehird`> ah yes
14:19:57 <ehird`> you'd need infinite source code
14:21:34 <oklopol> hehe, you could add a metalanguage to that
14:22:05 <oklopol> hmm... a finite language that produces a new code in it to run
14:22:10 <oklopol> and yes,i realized that's been done.
14:22:31 <oklopol> what's it callednow...
14:23:42 <ehird`> i'm working on a spec
14:23:58 -!- RedDak has quit (Remote closed the connection).
14:25:28 <ehird`> http://pastie.caboo.se/81136 this should be able to do something
14:25:56 <ehird`> wait, also : duplicate tape head
14:27:56 <ehird`> http://pastie.caboo.se/81137 new spec
14:29:24 <oklopol> >>> help programs
14:29:25 <ololobot> bf, bs, expr, help, install, numbda, otools, pl, pybooot, ul
14:29:34 <oklopol> you can't have just help yet
14:29:47 <oklopol> also
14:29:59 <oklopol> that also shows the bot and otools.
14:30:10 <oklopol> neither of which is usable... i hope :P
14:31:14 <oklopol> hmm, pybooot should return "".
14:31:18 <oklopol> >>> pybooot okokokokokokokoko
14:31:53 <oklopol> err... except it also reconnects the bot xxxxxxxxxxxxxD
14:32:19 <oklopol> perhaps... i make a separate folder for external programs...
14:32:26 -!- ololobot has quit (Read error: 104 (Connection reset by peer)).
14:34:50 <ehird`> %reload
14:34:50 <blahbot`> Reloaded.
14:34:52 <ehird`> %cmds
14:34:52 <blahbot`> quit, eval, ps, kill, cmds, help, reload, join, part, send, topic, raw, bf, parse, reduce, wapr (use %help for argument information)
14:34:57 <ehird`> %wapr A
14:34:57 -!- blahbot` has quit (Remote closed the connection).
14:35:24 -!- blahbot` has joined.
14:35:27 <ehird`> %wapr A
14:35:50 <ehird`> %wapr A
14:35:53 <ehird`> %cmds
14:35:53 <blahbot`> quit, eval, ps, kill, cmds, help, reload, join, part, send, topic, raw, bf, parse, reduce, wapr (use %help for argument information)
14:35:54 <ehird`> %wapr 2
14:36:02 <ehird`> %ps
14:36:02 <blahbot`> 0. wapr 2
14:36:02 <blahbot`> 1. wapr A
14:36:02 <blahbot`> 2. wapr A
14:36:02 <blahbot`> 3. ps
14:36:05 <ehird`> %kill 0 1 2
14:36:07 <ehird`> %kill 0
14:36:08 <ehird`> %kill 1
14:36:10 <ehird`> %kill 2
14:36:10 <blahbot`> PID 2 out of range
14:36:11 <ehird`> %ps
14:36:11 <blahbot`> 0. wapr A
14:36:11 <blahbot`> 1. ps
14:36:13 <ehird`> %kill 0
14:36:17 <ehird`> %ps
14:36:17 <blahbot`> 0. ps
14:36:21 <ehird`> %wapr 2
14:36:23 <ehird`> %ps
14:36:23 <blahbot`> 0. wapr 2
14:36:23 <blahbot`> 1. ps
14:36:25 <ehird`> %kill 0
14:36:26 <ehird`> %reload
14:36:26 <blahbot`> Reloaded.
14:36:28 <ehird`> %wapr 2
14:36:28 <blahbot`> [18]
14:36:52 <ehird`> %wapr ~
14:36:52 <blahbot`> [94]
14:36:57 <ehird`> %wapr ~~+
14:36:57 <blahbot`> [188]
14:37:22 <ehird`> %wapr "?
14:37:24 <ehird`> %ps
14:37:24 <blahbot`> 0. wapr "?
14:37:24 <blahbot`> 1. ps
14:37:26 <ehird`> %kill 0
14:37:40 <ehird`> ok, " #?" (anything apart from space for #, well apart from ? - ! + :)
14:37:43 <ehird`> is an infinite loop
14:37:49 <ehird`> because # is above 0
14:37:52 <ehird`> and the spaces are 0
14:37:56 <ehird`> so it jumps to 0, and repeats
14:38:03 <ehird`> so, this thing can do infinite loops
14:38:13 <ehird`> %wapr #
14:38:13 <blahbot`> [3]
14:38:15 <ehird`> %wapr ##+
14:38:15 <blahbot`> [6]
14:38:20 <ehird`> %wapr #:-+
14:38:20 <blahbot`> [0]
14:38:29 <ehird`> %wapr #,.
14:38:29 <blahbot`> [3, 12, 14]
14:39:43 <ehird`> %reload
14:39:43 <blahbot`> Reloaded.
14:40:14 <ehird`> %wapr %
14:40:14 <blahbot`> [10]
14:40:27 <ehird`> %reload
14:40:28 <blahbot`> Reloaded.
14:40:28 <ehird`> %wapr %
14:40:28 <blahbot`> [17]
14:40:37 <ehird`> %reload
14:40:38 <blahbot`> Reloaded.
14:40:38 <ehird`> %wapr %
14:40:38 <blahbot`> [nil]
14:40:44 <ehird`> %reload
14:40:45 <blahbot`> Reloaded.
14:40:45 <ehird`> %wapr %
14:40:46 <blahbot`> [nil]
14:40:55 <ehird`> %reload
14:40:55 <blahbot`> Reloaded.
14:40:57 <ehird`> %wapr a
14:40:57 <blahbot`> [60]
14:40:59 <ehird`> %wapr %
14:40:59 <blahbot`> [nil]
14:41:02 <ehird`> %wapr &
14:41:02 <blahbot`> [1]
14:41:05 <ehird`> %wapr %
14:41:05 <blahbot`> [nil]
14:41:12 <ehird`> %eval ?%
14:41:13 <blahbot`> => 37
14:41:19 <ehird`> %eval (?% % 127)
14:41:19 <blahbot`> => 37
14:41:21 <ehird`> %eval (?% % 127) - 37
14:41:21 <blahbot`> => 0
14:41:26 <ehird`> so WHY is it pushing nil...
14:41:26 <ehird`> OH
14:41:49 <ehird`> %reload
14:41:49 <blahbot`> Reloaded.
14:41:51 <ehird`> %wapr %
14:41:51 <blahbot`> [0]
14:41:56 <ehird`> %wapr &+
14:41:56 <blahbot`> [1, 6]
14:41:59 <ehird`> %wapr &
14:42:00 <blahbot`> [1]
14:42:23 <ehird`> %eval s = [1]; x, y = s.pop, s.pop; puts y + x
14:42:23 <blahbot`> NoMethodError: undefined method `+' for nil:NilClass
14:42:26 <ehird`> odd
14:42:28 <ehird`> oh well
14:42:55 <ehird`> %wapr %%&
14:42:55 <blahbot`> [0, 0, 1]
14:42:57 <ehird`> grr
14:43:32 <ehird`> %reload
14:43:32 <blahbot`> Reloaded.
14:43:36 <ehird`> %wapr &
14:43:51 <ehird`> %ps
14:43:51 <blahbot`> 0. ps
14:44:36 <ehird`> %reload
14:44:36 <blahbot`> Reloaded.
14:44:37 <ehird`> %wapr &
14:44:37 <blahbot`> [2]
14:44:43 <ehird`> %reload
14:44:43 <blahbot`> Reloaded.
14:44:44 <ehird`> %wapr &
14:44:44 <blahbot`> [1]
14:44:49 <ehird`> %reload
14:44:50 <blahbot`> Reloaded.
14:44:54 <ehird`> %reload
14:44:54 <blahbot`> Reloaded.
14:45:08 <ehird`> %reload
14:45:08 <blahbot`> Reloaded.
14:45:16 <ehird`> %reload
14:45:16 <blahbot`> Reloaded.
14:45:22 <ehird`> %wapr a a
14:45:23 <blahbot`> [59, 59]
14:45:25 <ehird`> good
14:45:39 <ehird`> %wapr &
14:45:40 <blahbot`> [0]
14:45:49 <ehird`> %wapr &&'!
14:45:50 <ehird`> %ps
14:45:51 <blahbot`> 0. wapr &&'!
14:45:51 <blahbot`> 1. ps
14:45:52 <ehird`> %kill 0
14:48:09 <ehird`> ok final wapr spec: http://pastie.caboo.se/81141
14:48:29 <ehird`> first person to write tape = [hello world] wins :)
14:48:43 <ehird`> (You can even do something silly like 0=h,1=e...)
14:49:08 -!- pikhq has quit (Read error: 110 (Connection timed out)).
14:49:12 <oklofok> hmm
14:49:54 <oklofok> for a second i was hoping the name of the language was "jumping to -1 is exciting"
14:49:57 <oklofok> :D
14:50:00 <ehird`> haha
14:50:01 <ehird`> ok
14:50:04 <ehird`> that is its name
14:50:06 <ehird`> and all in lowercase
14:50:22 <ehird`> ([0,1,2,2,3,4,5,3,6,2,7] -> 0=h,1=e,2=l,3=o,4=space,5=w,6=r,7=d)
14:50:35 <ehird`> (As long as you didn't just write the values for that in its literals...)
14:50:39 <ehird`> (Calculation :P)
14:51:15 <oklopol> how does jump work?
14:51:56 <ehird`> well
14:51:59 <ehird`> jump X jumps to X position in code
14:52:05 <ehird`> first char = 0, second char = 1 etc.
14:52:20 <ehird`> maybe, i will add a "continuation" function, which appends the current character to the tape)
14:52:51 <oklofok> i can't print, hard to do hello world
14:53:59 <ehird`> ([0,1,2,2,3,4,5,3,6,2,7] -> 0=h,1=e,2=l,3=o,4=space,5=w,6=r,7=d)
14:54:01 <ehird`> produce that tape
14:54:06 <ehird`> also: http://esoteric.voxelperfect.net/wiki/Jumping_to_-1_is_exciting
14:54:23 <ehird`> i think it's TC
14:54:31 <oklopol> the problem is i can't see output
14:54:51 <ehird`> yes you can
14:54:55 <ehird`> the tape is displayed at the end
14:55:03 <ehird`> %wapr ''+
14:55:03 <blahbot`> [1, 1, 5]
14:55:06 <oklopol> ah
14:55:07 <ehird`> hm wtf
14:55:08 <ehird`> that's wrong
14:55:14 <ehird`> oh
14:55:17 <ehird`> i got the commands wrong
14:55:20 <ehird`> %wapr ''$
14:55:20 <blahbot`> [2]
14:55:21 <oklopol> well, you know, i'm blind.
14:55:34 <oklopol> i'llplay with that soon
14:55:41 <ehird`> you're IRCing while blind and with no screen reader? :P
14:55:45 <ehird`> 1337 sk1llz!
14:55:57 <ehird`> brairclle
14:56:02 <oklopol> i'm brainblind
14:56:12 <ehird`> hehe
14:56:18 <ehird`> just use the rules 0=h,1=e,2=l,3=o,4=space,5=w,6=r,7=d
14:56:26 <ehird`> which means you want to produce the tape [0,1,2,2,3,4,5,3,6,2,7]
14:56:31 <ehird`> but without just using the literals ;) that's cheating
14:56:37 <ehird`> with literals it's
14:57:10 <ehird`> %wapr &'(()*+),'-
14:57:11 <blahbot`> [0, 1, 2, 2, 3, 4, 5, 3, 6, 1, 7]
14:57:18 <ehird`> err
14:57:21 <ehird`> %wapr &'(()*+),(-
14:57:22 <blahbot`> [0, 1, 2, 2, 3, 4, 5, 3, 6, 2, 7]
14:57:28 <ehird`> but, to do it programmatically... :)
14:58:19 <oklofok> what do you mean programmatically?
14:58:26 <ehird`> well you could write a BF hello like
14:58:34 <ehird`> add up to H>add up to e.......
14:58:42 <ehird`> but instead, you use loops etc to shorten the program
14:59:08 <oklofok> i'll can the ascii codes
14:59:10 <oklofok> *make
14:59:58 <ehird`> %wapr &&'"$&!
15:00:00 <ehird`> %ps
15:00:00 <blahbot`> 0. ps
15:00:01 <ehird`> good
15:00:05 <ehird`> jump -1 works
15:02:55 <ehird`> i am inclined to think it is turing complete
15:02:58 <ehird`> i think i can compile BF into it
15:03:22 <ehird`> Well maybe a bit hard because of the pointer
15:03:25 <ehird`> but i think it's possible
15:03:28 <ehird`> if the pointer is the top of the stack
15:03:41 <ehird`> and you keep using # to grab from the tape itself
15:04:05 <ehird`> + is just GETPOINTER&#'$ and then putting it back
15:04:24 <oklofok> def curry(f):return (lambda x:eval(reduce(lambda a,b:a+b,["lambda "+i+":"for i in x])+f.__name__+"("+",".join(x)+")"))(__import__("pydoc").inspect.getargspec(f)[0])
15:04:37 <ehird`> is that a python currier
15:04:43 <oklofok> somewhat
15:04:44 -!- pikhq has joined.
15:04:51 <oklofok> it can't curry a lambda yet
15:05:17 <oklofok> def k(a,b):return a
15:05:22 <oklofok> curry(k)(5)(2) >>> 5
15:05:43 <ehird`> %eval def curry(f, x); proc {|y| f(x, y);}; end; curry(puts, "Hello")
15:05:43 <blahbot`> => #<Proc:0x05018858@(eval):1>
15:05:52 <ehird`> %eval def curry(f, x); proc {|y| f(x, y);}; end; curry(method(:puts), "Hello")
15:05:52 <blahbot`> => #<Proc:0x05017f20@(eval):1>
15:05:55 <ehird`> %eval def curry(f, x); proc {|y| f(x, y);}; end; curry(method(:puts), "Hello").call("world")
15:05:55 <blahbot`> NoMethodError: undefined method `f' for #<Blahbot:0x28e4db8>
15:05:57 <ehird`> hmmmm
15:06:05 <oklofok> i do it really badly, don't know how to do assembly in python
15:06:06 <oklofok> i mean
15:06:09 <oklofok> python bytecode
15:06:19 <ehird`> %eval def curry(f, x); proc {|y| f.call(x, y);}; end; curry(method(:puts), "hello").call("world")
15:06:19 <blahbot`> hello
15:06:19 <blahbot`> world
15:06:19 <blahbot`> => nil
15:06:39 <ehird`> %eval def curry(f, x); proc {|y| method(:f).call(x, y);}; end; curry(:puts, "hello").call("world") # prettier
15:06:39 <blahbot`> NameError: (eval):1:in `method': undefined method `f' for class `Blahbot'
15:06:41 <ehird`> er.
15:06:43 <ehird`> oh whatever
15:06:45 <ehird`> you get the idea
15:06:54 <ehird`> hmmm
15:06:58 <oklofok> err
15:07:00 <oklofok> wait
15:07:31 <oklofok> you want a function that takes a function as argument and returns the curried function.
15:07:37 <ehird`> %eval class Proc; alias :old_call :call; def call(*args); if args.length < arity; proc {|x| self.call(*args, x)}; else; old_call(*args); end; end
15:07:37 <blahbot`> SyntaxError: (eval):1: syntax error, unexpected tIDENTIFIER, expecting tAMPER
15:07:59 <ehird`> %eval class Proc; alias :old_call :call; def call(*args); if args.length < arity; proc {|x| call(*args, x)}; else; old_call(*args); end; end
15:07:59 <blahbot`> SyntaxError: (eval):1: syntax error, unexpected tIDENTIFIER, expecting tAMPER
15:08:02 <ehird`> %eval class Proc; alias :old_call :call; def call(*args); if args.length < arity; proc {|x| call(*args, x)}; else; old_call(*args); end; end; end
15:08:02 <blahbot`> SyntaxError: (eval):1: syntax error, unexpected tIDENTIFIER, expecting tAMPER
15:08:05 <ehird`> %eval class Proc; alias :old_call :call; def call(*args); if args.length < arity; proc {|x| call(*args, x)}; else; old_call(*args); end; end
15:08:05 <blahbot`> SyntaxError: (eval):1: syntax error, unexpected tIDENTIFIER, expecting tAMPER
15:09:20 <ehird`> %eval class Proc; alias :old_call :call; def call(*args); if args.length < arity; proc {|x| call(*args, x)}; else; old_call(*args); end; end
15:09:21 <blahbot`> SyntaxError: (eval):1: syntax error, unexpected tIDENTIFIER, expecting tAMPER
15:09:22 <ehird`> %eval class Proc; alias :old_call :call; def call(*args); if args.length < arity; proc {|x| call(*args, x)}; else; old_call(*args); end; end; end
15:09:23 <blahbot`> SyntaxError: (eval):1: syntax error, unexpected tIDENTIFIER, expecting tAMPER
15:09:24 <ehird`> hmm
15:09:43 <oklofok> can you ask a function how many arguments it takes in ruby?
15:10:08 <oklofok> actually i could just do the currying "the right wya"
15:10:10 <oklofok> *way
15:10:13 <oklofok> i'll do it now
15:10:46 <ehird`> yes you can
15:10:50 <ehird`> it's called arity
15:11:05 <ehird`> %eval proc {|x,y|x}.arity
15:11:05 <blahbot`> => 2
15:11:09 <ehird`> %eval proc {|*a|a}.arity
15:11:09 <blahbot`> => -1
15:11:11 <ehird`> %eval proc {|x,*a|a}.arity
15:11:12 <blahbot`> => -2
15:11:17 <ehird`> %eval proc {|x,y,a=2|a}.arity
15:11:17 <blahbot`> SyntaxError: (eval):1: syntax error, unexpected '=', expecting '|'
15:11:19 <ehird`> er
15:11:20 <oklofok> actually, i don't think you can do that in python without eva
15:11:21 <oklofok> *eval
15:11:26 <oklofok> you don't have atoms.
15:11:33 <oklofok> -> impussible
15:11:54 <ehird`> you do have atoms
15:12:02 <ehird`> strings are atoms in python
15:12:06 <ehird`> do you mean rubys symbols?
15:12:07 <ehird`> :x
15:12:13 <ehird`> that's more like smalltalk's #x symbols
15:12:17 <ehird`> not lisp's (quote x) or 'x
15:14:36 <oklofok> well, strings aren't really atoms...
15:14:46 <oklofok> they can be used as such in python, yeah
15:15:24 <oklofok> i don't know ruby that well, all i know is what you taught me some days ago.
15:16:30 <ehird`> hmmmmmmm
15:16:54 <ehird`> %eval def compose(x, y); proc {|*args| x.call(y.call(*args))}; end
15:16:54 <blahbot`> => nil
15:17:03 <ehird`> hmmm, i want to write a @pl
15:17:04 <ehird`> but for what lanuage.
15:17:06 <ehird`> *language
15:19:14 <ehird`> someone should make a board game based on cellular automata
15:19:32 <ehird`> but like, where you can move peices according to rules
15:19:37 <ehird`> and... don't say "Game of Life" :P
15:19:45 <ehird`> because thats cheesy
15:21:01 <ihope> Game of Life where you can modify the board a little bit when it's your turn? :-P
15:21:19 <ehird`> heh
15:21:30 <ehird`> im thinking of colours for cells
15:21:43 <ehird`> and you arrange an initial pattern, then you can move each cell and it's subjected to the death/birth rules etc
15:21:46 <ehird`> and maybe an extra rule for capture
15:21:47 <ehird`> or something
15:21:53 <ihope> Game of Life with colors where you can modify the board a little bit when it's your turn? :-P
15:21:58 <ehird`> heh
15:22:09 <oklopol> hmm, ehird`: did you make currying?
15:22:20 <ehird`> oklopol, currying in ruby is simple, relaly
15:22:22 <ehird`> *really
15:22:30 <ehird`> well, the
15:22:32 <oklopol> can i see it in action? :))
15:22:36 <ehird`> curry(f, x).call(y) -> f(x, y) type
15:22:55 <ehird`> the curry(f).call(x).call(y) -> f(x, y) type requires that ruby extension allowing you to see methods parsetrees
15:23:38 <oklopol> all i care about is whether you can show me that :P
15:23:39 <ehird`> try and implement it yourself, all you need is to override Proc#call, while alias :old_call :call, and use Proc#arity, to check if enough arguments
15:23:39 <ehird`> also
15:23:47 <ehird`> def m(*a) makes a a list of all the arguments
15:23:55 <ehird`> for some reason, mine syntax errors on one line
15:23:55 <oklopol> hmm
15:24:41 <oklopol> and you think *i* might do better with my unbelievable ruby experience :D
15:24:54 <oklopol> hmm
15:25:10 <oklopol> how do i get the arity of a function?
15:25:42 <ehird`> i told you - Proc#arity
15:25:52 <ehird`> Class#method means (an_instance_of_Class).method
15:26:01 <oklopol> aaaa
15:26:33 <oklopol> %eval def test(n);3;end
15:26:33 <blahbot`> => nil
15:26:39 <oklopol> %eval def test(n);3;end;test(4)
15:26:39 <blahbot`> => 3
15:26:58 <oklopol> %eval def test(n);Proc#arity(n);end;test(4)
15:26:58 <blahbot`> SyntaxError: (eval):1: syntax error, unexpected $end, expecting kEND
15:27:10 <ehird`> Class#method means Class_instance.method
15:27:12 <oklopol> %eval def test(n);n.arity;end;test(4)
15:27:12 <blahbot`> NoMethodError: undefined method `arity' for 4:Fixnum
15:27:18 <oklopol> ...
15:27:22 <ehird`> 4 is a number...
15:27:23 <oklopol> %eval def test(n);test.arity;end;test(4)
15:27:23 <blahbot`> ArgumentError: (eval):1:in `test': wrong number of arguments (0 for 1)
15:27:23 <ehird`> not a function.
15:27:28 <ehird`> oh
15:27:30 <ehird`> you want
15:27:33 <ehird`> method(:test).arity
15:27:38 <ehird`> test.arity is test().arity
15:27:53 <oklopol> ehird`: do not correct me right away, i get it as fast as you but it takes a second to fix
15:27:55 <oklopol> :P
15:27:56 <ehird`> :P
15:28:06 <oklopol> %eval def test(n);test.arity();end;test(4)
15:28:07 <blahbot`> ArgumentError: (eval):1:in `test': wrong number of arguments (0 for 1)
15:28:09 <oklopol> %eval def test(n);test.arity(test);end;test(4)
15:28:09 <blahbot`> ArgumentError: (eval):1:in `test': wrong number of arguments (0 for 1)
15:28:25 <oklopol> now you can correct me.
15:28:37 <oklopol> %eval def test(n);test.arity(3);end;test(4)
15:28:37 <blahbot`> ArgumentError: (eval):1:in `test': wrong number of arguments (0 for 1)
15:28:41 <ehird`> method(:test).arity
15:28:47 <ehird`> guess i did need to correct you..
15:28:51 <oklopol> %eval def test(n);method(:test).arity(3);end;test(4)
15:28:52 <blahbot`> ArgumentError: (eval):1:in `arity': wrong number of arguments (1 for 0)
15:28:55 <ehird`> why (3)
15:28:56 <oklopol> ...
15:28:58 <oklopol> %eval def test(n);method(:test).arity();end;test(4)
15:28:58 <blahbot`> => 1
15:29:04 <oklopol> because i suck!
15:29:05 <oklopol> :P
15:29:12 <oklopol> copypaste.
15:29:14 <ehird`> %eval def test(n); method(:test).arity; end; test(4)
15:29:14 <blahbot`> => 1
15:29:16 <ehird`> %eval def test(n, x=2); method(:test).arity; end; test(4)
15:29:17 <blahbot`> => -2
15:29:22 <ehird`> %eval def test(n, x=2, *args); method(:test).arity; end; test(4)
15:29:22 <blahbot`> => -2
15:29:26 <ehird`> %eval def test(n, *args); method(:test).arity; end; test(4)
15:29:26 <blahbot`> => -2
15:29:31 <ehird`> %eval def test(n, x=2, y=3); method(:test).arity; end; test(4)
15:29:31 <blahbot`> => -2
15:29:38 <ehird`> %eval def test(n, b, x=2, y=3); method(:test).arity; end; test(4)
15:29:38 <blahbot`> ArgumentError: (eval):1:in `test': wrong number of arguments (1 for 2)
15:29:42 <ehird`> %eval def test(n, b, x=2, y=3); method(:test).arity; end; test(4, 2)
15:29:42 <blahbot`> => -3
15:29:49 <ehird`> see how that works?
15:29:53 <ehird`> with optional arguments, arity is:
15:29:54 <oklopol> it doens't have to account for * or = in argument lists
15:29:55 <oklopol> err
15:29:58 <ehird`> -(number of required arguments + 1)
15:30:08 <ehird`> otherwise, it's (number of arguments)
15:30:17 <ehird`> %eval def test(n); method(:test).arity; end; test(4, 2)
15:30:17 <blahbot`> ArgumentError: (eval):1:in `test': wrong number of arguments (2 for 1)
15:30:19 <ehird`> %eval def test(n, bmethod(:test).arity; end; test(4, 2)
15:30:19 <blahbot`> SyntaxError: (eval):1: syntax error, unexpected '(', expecting ')'
15:30:24 <ehird`> %eval def test(n, b); method(:test).arity; end; test(4)
15:30:25 <blahbot`> ArgumentError: (eval):1:in `test': wrong number of arguments (1 for 2)
15:30:25 <oklopol> i see, i'm not going to care about those.
15:30:26 <ehird`> %eval def test(n, b); method(:test).arity; end; test(4, 2)
15:30:26 <blahbot`> => 2
15:30:26 <oklopol> though
15:30:29 <ehird`> OK
15:30:39 <oklopol> unless you can tell me how to react to them when currying
15:31:04 <oklopol> i'm not making a lazy() function to make it possible to curry a variable number of arguments into a function...
15:31:39 <ehird`> convert this into a oneliner:
15:32:02 <ehird`> http://pastie.caboo.se/81146
15:32:20 <oklopol> what is *args for?
15:32:43 <ehird`> %eval def x(*args); args; end x(34324, 2, 3, 3)
15:32:43 <blahbot`> SyntaxError: (eval):1: syntax error, unexpected tIDENTIFIER, expecting $end
15:32:47 <ehird`> %eval def x(*args); args; end; x(34324, 2, 3, 3)
15:32:47 <blahbot`> => [34324, 2, 3, 3]
15:32:52 <ehird`> %eval def x(*args); args; end; x()
15:32:52 <blahbot`> => []
15:32:53 <ehird`> %eval def x(*args); args; end; x(2)
15:32:53 <blahbot`> => [2]
15:33:00 <ehird`> %eval def x(a, b, *args); args; end; x(2, 3, 4, 5)
15:33:01 <blahbot`> => [4, 5]
15:33:03 <ehird`> you see
15:33:05 <ehird`> va-args.
15:33:16 <ehird`> also that #call doesn't support va-args, yet, but meh
15:33:24 <oklopol> i see now
15:33:41 <oklopol> you can make currying implicit in ruby
15:33:59 <oklopol> i mean
15:34:12 <oklopol> hm
15:34:13 <oklopol> hmm
15:34:16 <ehird`> yes
15:34:18 <ehird`> my mod makes
15:34:33 <ehird`> def hello(x, y, z); z; end; method(:hello).call(1, 2).call(3) -> 3
15:34:34 <oklopol> can you really do x([list],another_arg)?
15:34:46 <oklopol> if x takes a variable number of args
15:35:00 <oklopol> i mean, that should make it x([list,another_arg])
15:35:06 <oklopol> which is wrong when currying
15:35:15 <ehird`> def x(*args); args; end; x([1,2],3)
15:35:19 <ehird`> lists are nested
15:35:21 <ehird`> %eval def x(*args); args; end; x([1,2],3)
15:35:21 <blahbot`> => [[1, 2], 3]
15:35:36 <oklopol> proc {|x| call(*args, x)} -> proc {|x| call(*args+[x])} ?
15:35:57 <ehird`> ah - thanks for finding my bug
15:36:00 <oklopol> if *argsis a list
15:36:04 <ehird`> you're right, it should be *(args + [x])
15:36:06 <oklopol> yar
15:36:11 <oklopol> ah that way around
15:36:26 <ehird`> that is the bug i think
15:36:28 <ehird`> it should work now
15:36:34 <ehird`> replcae the newlines with ; and try it
15:36:38 <oklopol> kay
15:37:27 <oklopol> %eval class Proc;alias :old_call :call;def call(*args);if args.length < arity;proc {|x| call(*args, x)};else;old_call(*args);end;end;end
15:37:28 <blahbot`> SyntaxError: (eval):1: syntax error, unexpected tIDENTIFIER, expecting tAMPER
15:37:34 <oklopol> tAMPER?
15:37:38 <ehird`> tAMPER = &
15:37:48 <ehird`> you didn't fix the bug
15:37:51 <ehird`> ity;proc {|x| call(*args, x)}
15:37:54 <oklopol> %eval class Proc;alias :old_call :call;def call(*args);if args.length < arity;proc {|x| call(*(args+[x])};else;old_call(*args);end;end;end
15:37:54 <blahbot`> SyntaxError: (eval):1: syntax error, unexpected '}', expecting ')'
15:38:00 <oklopol> %eval class Proc;alias :old_call :call;def call(*args);if args.length < arity;proc {|x| call(&(args+[x])};else;old_call(*args);end;end;end
15:38:00 <blahbot`> SyntaxError: (eval):1: syntax error, unexpected '}', expecting ')'
15:38:05 <ehird`> get rid of &
15:38:06 <ehird`> you want *
15:38:13 <oklopol> %eval class Proc;alias :old_call :call;def call(*args);if args.length < arity;proc {|x| call(*(args+[x])};else;old_call(*args);end;end;end
15:38:13 <blahbot`> SyntaxError: (eval):1: syntax error, unexpected '}', expecting ')'
15:38:16 <oklopol> just tried.
15:38:25 <oklopol> because it asker for the ampersandorz
15:38:28 <oklopol> *asked
15:38:37 <ehird`> %eval class Proc;alias :old_call :call;def call(*args);if args.length < arity;proc {|x| call(*(args+[x]))};else;old_call(*args);end;end;end
15:38:37 <blahbot`> NameError: (eval):1:in `cmd_eval': undefined method `call' for class `Blahbot::Proc'
15:38:59 <ehird`> hmm
15:39:24 <ehird`> %eval class Proc;alias :old_call :call;def call(*args);if args.length < arity;proc {|x| call(*(args+[x]))};else;old_call(*args);end;end;end; Proc
15:39:24 <blahbot`> NameError: (eval):1:in `cmd_eval': undefined method `call' for class `Blahbot::Proc'
15:39:29 <ehird`> somethign is wrong
15:39:57 <oklopol> hard to say... what's alias
15:39:57 <oklopol> ?=
15:40:12 <ehird`> class X; alias :x :y; end; X.x -> X.y
15:40:32 <oklopol> hmm
15:40:33 <ehird`> that code works in irb
15:40:37 <ehird`> just not on the bot
15:40:42 <ehird`> probably i need an extra thread
15:40:43 <oklopol> oh
15:41:10 <oklopol> but it curries every function when you do that?
15:41:15 <oklopol> that's like insanely cool
15:41:18 <ehird`> well
15:41:25 <ehird`> you can't do func(blah) to curry
15:41:27 <ehird`> because I changed Proc
15:41:33 <ehird`> you need method(:func).call(blah)
15:41:35 <ehird`> which is a but ugly
15:41:38 <ehird`> but yeah
15:41:39 <ehird`> apart from that.
15:42:06 <oklopol> heh nice
15:42:13 <ehird`> irb(main):024:0> proc {|x,y|x}.call(2).call(3)
15:42:14 <ehird`> => 2
15:44:29 <oklopol> god i wish i had oklotalk...
15:44:44 <ehird`> implement it :)
15:44:52 <oklopol> doing file io in *any* language is a pita
15:45:20 <ehird`> in which sense - implementing the IO for oklotalk is why you're not implementing oklotalk? or the fact that you want to do file IO only in oklotalk and that's why you want it
15:45:45 <oklopol> errr... hmm
15:45:56 <oklopol> latter
15:46:18 <ehird`> i'm willing to implement oklotalk :P
15:46:21 <ehird`> if you can give me a rough spec..
15:46:47 <oklopol> meh, i'm making progress, and as long as i am, i
15:46:51 <oklopol> 'd rather do it myself.
15:46:59 <oklopol> so it's mine.
15:47:02 <ehird`> ok then
15:47:12 <oklopol> i'd implement my own anyway :)
15:47:22 <ehird`> still, you'd have it sooner for the time being
15:47:41 <oklopol> you think you'd implement it fast? :)
15:48:05 <oklopol> i can tell you it's harder than c to parse.
15:48:26 <ehird`> parser generators work wonders, sometimes
15:48:32 <ehird`> especially if you can manually extend them
15:49:00 <oklopol> well, try oklotalkspec @ www.vjn.fi/mb
15:49:11 <oklopol> ask me if you don't get something
15:50:04 <ehird`> how on earth do you work that
15:50:08 <oklopol> :P
15:50:12 <ehird`> ah, i see
15:50:16 <ehird`> shitty interface =p
15:50:29 <oklopol> it's removed
15:50:39 <oklopol> what's wrong with the interface?
15:50:43 <ehird`> Any '"' will begin a character array ending in another '"', '\' can be used for escapes. '\n' for linefeed, '\\' for '\', more added as needed, most likely the same ones as in other langs. <-- why not have " as a command
15:50:47 <oklopol> you specify project name and press load.
15:50:57 <oklopol> as a command?
15:51:30 <oklopol> i do not understand.
15:51:36 <oklopol> what's wrong with the interface?
15:51:42 <ehird`> For example "($$: :." would be tokenized into ["($$:", ":", "."]. <-- don't tell people how to tokenize, or how their parse tree should look... just describe the syntax ;)
15:51:45 <ehird`> it's better
15:51:52 <ehird`> oklopol, i wasn't talking about the interface
15:52:11 <oklopol> <ehird`> shitty interface =p
15:52:37 <oklopol> ehird`: how should i describe syntax then?=
15:52:38 <ehird`> wow, you "fix" misplaced brackets
15:52:40 <ehird`> that's insane!
15:52:54 <ehird`> oklopol, just... don't tell people how their final picture should look, just say what is valid and what is not
15:53:21 <oklopol> in oklotalk, everythingis legal.
15:53:25 <oklopol> *everything is
15:53:27 <oklopol> so...
15:53:32 <oklopol> i can rewrite the spec for you
15:53:45 <oklopol> .* <- check for that regex
15:53:46 <oklopol> :P
15:54:18 <oklopol> ture
15:54:32 <oklopol> you can make the parser faster than me.
15:54:41 <oklopol> because i want to do it a bit differently than that.
15:57:35 <oklopol> ehird`: that's the basic guidelines, the spec is not complete
15:58:22 <oklopol> also, that is oklotalk 1, in oklotalk 2, there's also typing and real-time parsing, which kinda affect parsing.
15:58:36 <oklopol> oklotalk 1 was so that i could actually get something done.
15:58:50 <oklopol> i design about 100 times faster than i implement
16:03:28 <ehird`> i think i might put down, in words, my syntax-morphing language,
16:03:32 <ehird`> and my functional language
16:03:53 <oklopol> that spec is wrong in saying the tokenization isn't always greedy
16:04:06 <oklopol> the concept i actually mean i think doesn't have a term
16:04:17 <oklopol> ehird`: go for it
16:04:37 <ehird`> Tokenizing is the easy part
16:04:54 <ehird`> i just need to write a list of terminals, and some extra rules
16:06:21 <oklopol> i see.
16:06:48 <oklopol> tokenizing is easy, i wasn't saying it isn't
16:07:05 <oklopol> i'm just saying one sentence was wrong
16:09:07 -!- ololobot has joined.
16:09:14 <oklopol> okay,got it working
16:09:21 <oklopol> but not the way i wanted to :|
16:10:26 <oklopol> ehird`: what languages have you implemented?
16:10:38 <ehird`> a few
16:10:44 <oklopol> what?
16:10:53 <ehird`> i've implemented a few. which one do you mean?
16:10:57 <oklopol> there's a bit of a difference between languages :=)
16:10:59 <oklopol> i mean
16:11:01 <oklopol> what languages :D
16:11:04 <oklopol> list a few
16:11:11 <ehird`> i don't know, i implement languages all the time
16:11:17 <ehird`> esoteric or non-?
16:11:24 <oklopol> non
16:11:31 <oklopol> esotericones are usually trivial
16:11:37 <oklopol> *' '
16:11:57 <oklopol> i mean, do you know your parsing, oklotalk has the hardest parsing i know of
16:12:12 <ehird`> parsing is trivial
16:12:19 <oklopol> i see.
16:12:48 <oklopol> what have you implemented, now out of curiousness?
16:13:07 <ehird`> i don't understand. i implement lots of languages, why do you want a complete list?
16:13:15 <oklopol> :|
16:13:22 <oklopol> a random example.
16:13:24 <oklopol> no reason
16:13:28 <oklopol> just asked
16:13:34 <oklopol> you don't have to tell me :D
16:13:39 <ehird`> well, i've implemented lots, mostly simple
16:13:57 <ehird`> lots of stack-based ones, a Lua-alike called slang for Simple Languge
16:13:59 <ehird`> those are the main ones
16:14:02 <oklopol> i just never found parsing trivial.
16:14:04 <ehird`> i'm generally minimalistic in syntax, though
16:14:09 <ehird`> but i can parse more complex things
16:14:12 <ehird`> oklotalk isn't easy, though
16:14:28 <oklopol> then again, i don't use regexes or parser generators of course, might make it trivial
16:14:33 <oklopol> and skill as well.
16:15:45 <oklopol> i mean, you can't know parsing is trivial if you never tried, so i asked if you ever tried.
16:17:18 <ehird`> (on an unrelated note, here's an example of my self-morphing parser: http://pastie.caboo.se/81154)
16:17:23 <ehird`> (it can even create tokens on the fly)|
16:17:49 <ehird`> error in there, you need e.g. cond<bracketed_expr> instead of <bracketed_expr>
16:17:55 <ehird`> <bracketed_expr>cond, maybe better
16:17:58 <ehird`> but you know what i mean
16:19:07 <oklopol> tokenization isn't fully free there, but of course, it can never be.
16:19:30 <oklopol> hmm
16:19:32 <ehird`> why not?
16:19:33 <oklopol> yes it can
16:19:36 <ehird`> you can delete tokens and everything
16:19:52 <ehird`> you could, for example, replace the whole syntax with lisp s-expressions
16:19:58 <ehird`> and make everything else illegal
16:20:03 <oklopol> anyway, that isn't fully extendable
16:20:06 <oklopol> or is it?
16:20:07 <ehird`> yes it is
16:20:13 <ehird`> see above
16:20:30 <oklopol> make if BEGIN END mean if { }
16:20:41 <ehird`> ok:
16:21:36 <ehird`> tokens("BEGIN", "END"); syntax begin_end = ("BEGIN", exprs<expr*>, "END") = <block>;
16:21:43 <ehird`> actually, make that
16:21:45 <ehird`> tokens("BEGIN", "END"); syntax begin_end = ("BEGIN", exprs<expr*>, "END") = block;
16:21:49 <ehird`> you get the idea, though
16:22:24 <ehird`> actually, you could drop exprs<expr*> and make it <expr*>
16:22:29 <ehird`> since it's just passing the params to block
16:22:58 <oklopol> expr?
16:23:08 <ehird`> <expr> is like <block>
16:23:09 <oklopol> the pointer to the upmost rule?
16:23:21 <ehird`> syntax X = (blah); lets you use <X>
16:23:24 <ehird`> in other syntaxes.
16:23:30 <ehird`> it's just a reference to a rule
16:23:44 <ehird`> although, for BEGIN->END you probably want <state*>
16:23:46 <ehird`> which is statements
16:23:49 <ehird`> (For the ; seperation)
16:24:06 <ehird`> (Statements are just expressions with a seperator)
16:25:59 <oklopol> write a parser for it and i'll learn it fully :)
16:26:07 <oklopol> i'll be coding now, see ya! ->
16:26:12 <oklopol> !/gh
16:26:15 <EgoBot> Huh?
16:27:16 <ehird`> i don't see why i need to parse that for you to understand it :P
16:28:06 <oklopol> i don't see why i'llneedto understand it if no one will parse it for me :P
16:28:12 <oklopol> *i'd need to
16:28:31 <oklopol> i do understand that much, of course
16:28:49 <oklopol> that's a pretty straightforward c-style syntaxextension :|
16:28:53 <oklopol> anyway, gooone ->
16:29:11 <ehird`> how come? the whole syntax, is definable in terms of the syntax objects
16:29:15 <ehird`> you can manipulate them, change them, etc
16:29:21 <ehird`> you could even change the "syntax" syntax
16:29:26 <oklopol> hmm
16:29:50 <oklopol> a syntax command will affect parsing after it?
16:30:00 <oklopol> you didn't tell me *what* parsing it affects
16:33:41 <oklopol> i "got the main idea", i do *not* know the spesifics
16:34:24 <oklopol> and i'm pretty sure the complete spesification wasn't implicit in the few examples you showed :)
16:34:32 <oklopol> but really, code.
16:43:11 <ehird`> yes, it will
16:43:14 <ehird`> it affects all parsing
16:43:29 <ehird`> that example is a program
16:43:32 <ehird`> well, if you get rid of the initial "if"
16:43:34 <oklopol> "all parsing" ...after that line
16:43:36 <ehird`> it parses fine
16:43:41 <oklopol> there'sa crucial difference
16:43:54 <oklopol> *there's a
16:43:59 <ehird`> as soon as you run tokens() you can use those tokens in the "syntax" syntax
16:44:06 <ehird`> the "syntax" syntax, after it, adds that syntax to the parser.
16:46:28 <oklopol> will everything be parsed once or can you affect the parser in a loop?
16:46:48 <oklopol> there's a million things i don't know yet based on your explanation :)
16:47:50 <oklopol> void*(*matchers[])(char*)={num_match,oper_match}; you gotta love c
16:54:40 <ehird`> everything is parsed as much as possible
16:54:44 <ehird`> yes you could do it in a loop
16:54:55 <ehird`> the speed penalty doesn't matter much, today's interpreters/compilers can optimize to hell
16:55:18 <ehird`> also
16:55:26 <ehird`> void*(*matchers[])(char*)={num_match,oper_match}; does that actually change c's syntax?
16:55:32 <ehird`> because im 99% sure c's syntax is fixed
16:55:49 <oklopol> ..huh?
16:55:53 <oklopol> that was just c code :)
16:56:08 <oklopol> i should use <unrelated></unrelated>
16:57:29 <ehird`> =P
16:57:35 <ehird`> oh is that from the oklotalk parser
16:57:46 <oklopol> i'm making numbda in cfirst
16:57:49 <ehird`> ah
16:57:49 <oklopol> *c first
16:58:00 <ehird`> i suggest using something like, ML for oklotalk parsing
16:58:05 <ehird`> it'd make things a lot simpler
16:58:14 <oklopol> doesn't sound like something i would do :)
16:58:18 <oklopol> ML?
16:58:35 <oklopol> aaa
16:58:54 <ehird`> SML
16:58:59 <ehird`> i like SML
16:59:01 <ehird`> i dont like ocaml
16:59:04 <oklopol> i'm making it in c, it has to be low.
16:59:40 <oklopol> i'd make it if in asm, but i've become a coward after using so much python the whole summer
16:59:57 <ehird`> why does it have to be low? SML can be compiled.
17:00:01 <oklopol> >>> numbda ulkiuliuli
17:00:01 <ehird`> nonsensical
17:00:02 <ololobot> error:no-such-variable:ulkiuliuli(-1)
17:00:28 <oklopol> ehird`: anyway, i do not care what is sensible, i'll make it in c.
17:00:42 <oklopol> i just want to code, the harder the better
17:00:44 <oklopol> naturally
17:09:54 <oklopol> i forgot how unbelievably great this language is<3
17:10:01 <oklopol> (c)
17:17:56 <oklopol> haha, segmentation fault
17:18:02 <oklopol> this language is great
17:19:25 <ehird`> C sucks =P
17:19:57 <oklopol> yeah, perhaps
17:20:02 <oklopol> but i kinda like it
17:20:40 <oklopol> hmm... i can't imagine anything more fun than making a generic list construct in c.
17:20:48 <oklopol> i'll make it now
17:23:48 <ehird`> heh
17:24:07 <ehird`> SML ftw
17:25:12 <oklopol> sml looks easy to learn
17:29:51 <oklopol> c is actually pretty functional, i wonder why i was so afraid of function pointers when i was little
17:31:29 <ehird`> SML combines the nice syntax of Haskell with the imperativeness of scheme
17:31:38 <ehird`> beware the evil OCaml
17:34:19 <oklopol> why?
17:34:23 <ehird`> because it is horrid
17:34:35 <ehird`> # let rec fact n =
17:34:36 <ehird`> if n =/ Int 0 then Int 1 else n */ fact(n -/ Int 1);;
17:34:40 <oklopol> oh, it killed your father and raped your mother?
17:34:42 <ehird`> don't tell me that looks nice.
17:34:53 <oklopol> hey, i love every language :)
17:35:07 <SimonRC> hehehe
17:35:09 <oklopol> why the /?
17:35:15 <ehird`> you have to use different operators for floating-point stuff too
17:35:19 <ehird`> 3 / 1.0 MMMNOPE
17:35:20 <oklopol> .+
17:35:25 <ehird`> 3 ./ 1.0 ewwww
17:35:25 <oklopol> +. i mean
17:35:25 <oklopol> ?
17:35:26 <ehird`> exactly
17:35:29 <ehird`> +.
17:35:32 <ehird`> 3.0 +. 1.0
17:35:35 <SimonRC> I just realised that functional programmers don't often suffer from the exit-from-middle-of-loop problem
17:35:58 <ehird`> Also ".<fun x -> .~(power 5 .<x>.)>.;;" do you like how that looks.
17:35:59 <oklopol> true
17:36:44 <ehird`> what about:
17:36:47 <oklopol> i don't understand that
17:36:51 <oklopol> code
17:36:55 <ehird`> let rec init n f = if n=0 then [] else init (n-1) f @ [f n];;
17:37:21 <oklopol> what's that do?
17:37:29 <ehird`> Ah, this is the best example:
17:37:31 <oklopol> i can't quite figure the end
17:37:39 <ehird`> Compare http://www.codecodex.com/wiki/index.php?title=Insertion_sort#OCaml and http://www.codecodex.com/wiki/index.php?title=Insertion_sort#Standard_ML
17:37:43 <ehird`> the standard ML one is much nicer/.
17:38:56 <ehird`> What about, calculating, say, e?
17:38:57 <ehird`> # let rec e ?(fact=1) ?(i=1) = function
17:38:58 <ehird`> | 0 -> 0.
17:38:58 <ehird`> | n -> 1. /. float fact +. e ~fact:(i*fact) ~i:(i+1) (n-1);;
17:38:58 <ehird`> val e : ?fact:int -> ?i:int -> int -> float = <fun>
17:39:01 <ehird`> that's some ugly code.
17:39:18 <ehird`> so, yes, beware of OCaml, don't beware of SML.
17:40:04 <oklopol> float = <fun>... that's what a lazy swimmer would say
17:40:13 <ehird`> hahaha
17:40:46 <oklopol> to be honest i don't mind it's looks, but i can't imagine a syntax i wouldn't like :)(
17:40:47 <oklopol> :)
17:40:52 <oklopol> *its
17:41:12 <ehird`> more fuel: http://www.podval.org/~sds/ocaml-sucks.html
17:41:15 <ehird`> why ocaml sucks :P
17:41:53 <ehird`> most of the more serious of those problems do not exist in SML
17:45:04 <oklopol> good for him :)
17:49:34 <oklopol> i'll use sml if i ever have to choose between those two.
17:50:08 <ehird`> SML is a good language for implementing languages :)
17:54:13 -!- Sgeo has joined.
18:08:02 <oklopol> c is hard to debug though, unless i actually get a debugger
18:08:14 <oklopol> (or already have one and start using it.)
18:10:31 <ehird`> gdb, i guess
18:10:45 <ehird`> but hooray for debugging-is-just-loading-your-program-and-running-a-repl languages
18:10:48 <ehird`> (Forth, Lisp, etc)
18:45:26 -!- RodgerTheGreat has joined.
19:02:59 <bsmntbombdood> GregorR: your egobot's brainfuck code is really, really, terrible
19:08:03 <RodgerTheGreat> ?
19:09:33 <bsmntbombdood> he uses global variables to pass parameters to functions
19:09:46 <oklopol> his brainfuck-interpreter?
19:09:50 <oklopol> *--
19:14:41 <Sukoshi> But SML is a weenie-only language :(
19:15:13 <oklopol> just for boys?
19:16:01 <ehird`> SML is rock language!
19:16:05 <ehird`> :P
19:18:43 <Sukoshi> Weenies == Those who get nothing but algorithms done in life (goes the joke).
19:19:58 <oklopol> hmm
19:20:04 <oklopol> that's a funny one
19:20:06 <oklopol> :)
19:28:45 <pikhq> bsmntbombdood: I assume you mean egobfi?
19:28:51 <bsmntbombdood> yes
19:29:07 <pikhq> I'd say that it's a damned efficient interpreter. . .
19:29:15 <pikhq> Although it's tempting to rewrite some bits.
19:29:17 <bsmntbombdood> it all compiles the same
19:37:53 <Sukoshi> I'm a little confused here. Why is one entry not being added to the Hashtable?! Is the implementation not perfect, or something?
19:38:11 <Sukoshi> I *know* it's being attempted to be added, the table just doesen't want it though.
19:38:23 <Sukoshi> Grrrr!
19:39:06 <RodgerTheGreat> are you using the wrong form of datastructure? Possibly using a Map when you want a Dictionary?
19:39:20 <RodgerTheGreat> not to insult your intelligence or anything, but it's an easy mistake to make
19:39:51 <bsmntbombdood> isn't a map a dictionary?
19:40:00 <RodgerTheGreat> a map is a dictionary
19:40:05 <RodgerTheGreat> a dictionary is not a map
19:40:15 <RodgerTheGreat> map (1 key to one result)
19:40:29 <RodgerTheGreat> dictionary (1 key to several results)
19:40:34 <Sukoshi> Well, it could be, because I'm not certain what the equivalent Java classes are. But conventionally, I'd use a hash table that accepts an object as a key and then I get a value.
19:40:45 <Sukoshi> No. 1 key to 1 result.
19:41:01 <RodgerTheGreat> ok, then a HashMap is what you want. hm...
19:41:05 <Sukoshi> That's what a hash table *is* after all.
19:41:25 <bsmntbombdood> use an alist!
19:41:35 <Sukoshi> ... :P
19:41:42 <pikhq> Use a binary tree!
19:42:02 <Sukoshi> I may just use an alist because the elements aren't too huge.
19:42:12 <Sukoshi> But a hash table should scale infinitely huge, if neccessary.
19:42:20 <Sukoshi> (Which is why I want it.)
19:42:31 <bsmntbombdood> size of elements doesn't matter, just number of them
19:42:38 <Sukoshi> Obviously.
19:42:49 <bsmntbombdood> that's not what you said
19:42:51 <Sukoshi> Since pointers are probably stored in the table anyways.
19:43:00 <Sukoshi> *number of elements aren't too huge.
19:43:56 <Sukoshi> In the interface to the HashTable I have the key to be added printed out before its added, so I can tell it's *trying* to be added, but then when I loop through the Enumeration containing the keys, the Enumeration gives me the correct number of elements, but one of these elements is null.
19:44:01 <bsmntbombdood> scheme48 has a function named ASS, hurr hurr
19:44:16 <Sukoshi> Programatically, it seems that I'm doing nothing wrong.
19:45:00 <Sukoshi> Also bsmntbombdood, size *does* matter, because the hashing algorithm has to able to operate on something the size of the element that is the key.
19:45:20 <oklopol> ?
19:45:25 <bsmntbombdood> not in an alist
19:45:37 <oklopol> Sukoshi: java?
19:45:38 <Sukoshi> An alist isn't a HashTable.
19:45:41 <Sukoshi> oklofok: Yeah.
19:46:00 <oklopol> it uses the addressof the object as the hashvalua
19:46:03 <oklopol> *hashvalue
19:46:09 <oklopol> *address of
19:46:32 <Sukoshi> Yeah, but a larger pointer will not fit into an algorithm meant for a smaller one :P
19:46:50 <bsmntbombdood> so java's builtin hashtables don't work?
19:47:05 <oklopol> Sukoshi: huh? :)
20:06:53 <Sukoshi> I'm guessing so?
20:07:22 <oklopol> a larger pointer?
20:07:35 <Sukoshi> oklofok: 64-bit pointer vs. 32-bit pointer.
20:07:59 <oklopol> i... kinda think only one type is used at a time
20:08:42 <Sukoshi> Well you know, just in case.
20:08:44 <Sukoshi> ;P
20:11:25 <oklopol> err... sounds feasible. i haven't read *every* jvm's binary.
20:12:58 <bsmntbombdood> 128 bit pointers for wins
20:13:49 <oklopol> bignum pointers
20:21:23 <bsmntbombdood> new proccessors should have 128 bit addresses and 260 bit words
20:22:23 <oklopol> 260?
20:22:28 <oklopol> err why?
20:22:47 <bsmntbombdood> 4 tag bits and 256 data bits
20:25:08 <oklopol> i see
20:25:38 <pikhq> New processors should have scaling pointers.
20:34:10 <ihope> Scaling pointers?
20:34:32 <ihope> Wouldn't you have to store their length somewhere?
20:35:09 -!- Sgeo has quit (Read error: 104 (Connection reset by peer)).
20:38:25 -!- GregorR-L has joined.
20:40:31 -!- Sgeo has joined.
20:42:35 <pikhq> ihope: It works via magic, of course.
20:42:50 <ihope> Ah.
20:42:56 <ihope> Bigpointers!
20:43:01 <ihope> Actually, bigpoints!
20:43:12 <pikhq> I know one way for it to work. . .
20:43:22 <pikhq> 0-delimited unary. :p
20:43:45 -!- atrapado has joined.
20:49:21 <Sukoshi> Now I can sit down and code again.
20:49:37 <Sukoshi> So, either I get this Hashtable to work or I have to write an AList class.
20:50:44 -!- RedDak has joined.
20:59:03 <oklopol> is an infinite board go tc if considered a multiway system?
20:59:17 <SimonRC> hmm
20:59:40 <SimonRC> Where did this myth that languages cannot be sow come from?
20:59:51 <SimonRC> Languages can be slow.
20:59:58 <pikhq> Doubtful, since one has no control over the two players. Now, if you specify how the two players play, it might be.
21:00:07 <SimonRC> For example Oroogu is a slow language, as is BF
21:00:14 <oklopol> pikhq: do you know what a multiway system is?
21:00:20 <pikhq> oklopol: Apparently not.
21:00:41 <pikhq> SimonRC: Brainfuck's not terribly slow, actually. .
21:00:41 <oklopol> it means *every* *single* way to play it is simultaneously played.
21:00:47 <pikhq> Oh.
21:00:53 <pikhq> Possible.
21:01:10 <SimonRC> A slow language is one for which it is a PITA or even impossible to create a fast implemtation.
21:01:15 * pikhq is interested in how one could test it
21:01:22 <oklopol> hmm
21:01:27 <pikhq> SimonRC: Define "fast".
21:01:44 <oklopol> i think ankos had some multiway system proofs... or just one... i could check there how to do it
21:02:01 <SimonRC> I mean that the program goes (almost) as fast and anything one could write by hand.
21:02:16 <SimonRC> A good C or LISP compiler is "fast"
21:02:35 <SimonRC> it produces asm as good as or better then humans
21:02:47 <pikhq> Ah.
21:02:57 * pikhq would argue that Egobfc is fast, then
21:03:09 <SimonRC> OTOH, Python is not as fast, especially in the OO areas.
21:03:13 <oklopol> SimonRC: any language that has the same level operators the underlying system has is *fast*.
21:03:27 <SimonRC> yes
21:03:31 <SimonRC> but not just those
21:04:16 <oklopol> well, if you must somehow do thing *harder* than the asm will, the ocmputer cannot always convert it to the fastest possible asm
21:04:21 <oklopol> *things
21:04:25 <oklopol> *computer
21:04:36 <SimonRC> but often nearly gets there
21:04:37 <oklopol> if not that, then it most likely can
21:04:50 <oklopol> yes, but i'm talking in theory
21:04:54 <oklopol> and i am very very hungry
21:04:55 <SimonRC> Python is non-fast because you often need lots of work to prove that (e.g.) methods can be resolved at compiler time.
21:05:11 <oklopol> yeah, which asm doesn't have to do
21:05:39 <SimonRC> The more you can fuck around with things at runtime, the slower the language will be, roughly.
21:05:40 <RodgerTheGreat> BF is difficult but entirely possible to optimize via compiler, generating fast code. I'd gauge "slowness" of a language by the difficult in efficiently translating the language into machinecode (when compiled).
21:05:41 <pikhq> Assembly notation is fast. ;)
21:05:55 <RodgerTheGreat> *difficulty
21:06:24 <pikhq> RodgerTheGreat: As proven by Gregor's Egobfc, which does a whole lot of loop unrolling, detects copy loops, etc...
21:06:28 <Sukoshi> Now that I'm implementing an AssocList class in Java, I'm finding less and less reason not to use Lisp :P
21:06:52 <Sukoshi> Also, would someone mind testing for me if gcj supports the generics when specifying LinkedLists ?
21:07:00 <Sukoshi> (Or other such things.)
21:07:44 <oklopol> it's fairly easy detecting stuff like copying and carrying a value aroung in the memory, but once you start doing stuff like division, the compiler is screwed
21:08:48 <SimonRC> oklopol: yes
21:09:14 <oklopol> then again, division isn't all that fast on the asm level either
21:09:27 <oklopol> if you've seen the stuff people do to avoid it...
21:09:47 <oklopol> like 20 lines of assembly to avoid a division
21:09:55 <SimonRC> Ah, I have discovered why laziness sucks.
21:10:02 <oklopol> ?
21:10:09 <oklopol> why?
21:10:21 <SimonRC> Forget all the talk about space and time usage, and unpredicatbility...
21:10:33 <oklopol> forgotten.
21:10:56 <SimonRC> It stops you from re-defining things at run-time!
21:11:07 <SimonRC> you can't change function definitions at run-time
21:11:20 <SimonRC> you can't change classes at run-time
21:11:20 <SimonRC> etc
21:11:24 <oklopol> sure you can
21:11:54 <oklopol> the function will check it's location in memory, if there is a pointer to it, it will not mutate in-place,
21:12:00 <oklopol> that simple
21:12:01 <oklopol> no?
21:12:20 <RodgerTheGreat> pikhq: yes- the entire challenge of good BF optimized compiling is *recognizing* the structures you can translate into higher-level (and faster) operations
21:12:25 <SimonRC> oklopol: well...
21:12:33 <SimonRC> suppose you have:
21:12:40 <Sukoshi> Here's an oddity. A Hashtable shouldn't even accept a null value.
21:12:43 <RodgerTheGreat> the language allows for the creation of these things, but they're harder to pick out than, say, C or BASIC.
21:12:45 <pikhq> RodgerTheGreat: My method for doing that is cheating. . .
21:12:47 <Sukoshi> Grr.
21:12:52 <SimonRC> foo = zipWith bar xs ys
21:13:05 <pikhq> I've just got a higher-level language, wherein you just say that you're using those structures. ;)
21:13:06 <oklopol> SimonRC: o
21:13:13 <pikhq> Makes it easier to recognise when compiling to C.
21:13:26 <SimonRC> now, after having read a few elements of foo, you change the definition of bar...
21:13:31 <RodgerTheGreat> pikhq: naturally, if you use libraries to *create* these synthetic high-level things, you know exactly how to recognize and translate them
21:13:42 <oklopol> pikhq: why don't ya secretly ignore the assembly completely ;)
21:13:46 <oklopol> err
21:13:49 <RodgerTheGreat> haha
21:13:54 <oklopol> s/assembly/braeinfuk
21:13:55 <oklopol> ,.,
21:14:02 <RodgerTheGreat> we all got what you meant
21:14:04 <SimonRC> would you use the new or old definition when you look at new elemnts of foo
21:14:05 <oklopol> okay, i can't type
21:14:07 <oklopol> yeah
21:14:08 <oklopol> :P
21:14:09 <SimonRC> what about old elements of foo?
21:14:22 <oklopol> SimonRC: old
21:14:25 <SimonRC> right
21:14:42 <SimonRC> so, we have static lexical scope
21:14:49 <oklopol> err yeah
21:14:57 <oklopol> heh scoping in assignation
21:15:02 <oklopol> err
21:15:10 <SimonRC> therefore, when you load a new definition of a function, no-one will use it, making it a bit pointless
21:15:11 <oklopol> anyway, something funny i found about that.
21:15:31 <oklopol> you can just use it after changing it.
21:15:43 <oklopol> or allow mutators
21:16:08 <SimonRC> define "using" it
21:16:23 <pikhq> RodgerTheGreat: Like I said: cheating.
21:16:29 <RodgerTheGreat> yeah
21:16:31 <oklopol> err... redoing foo= bar etc zippers
21:16:41 <SimonRC> ok...
21:16:48 <oklopol> i mean
21:16:53 <oklopol> it's there for efficiency
21:17:01 <SimonRC> what if the function is used in 12 places in your program...
21:17:02 <oklopol> you want it to behave as if it didn't exist
21:17:11 <SimonRC> hih?
21:17:14 <SimonRC> huh?
21:17:22 <oklopol> err... that is why you don't mutate. functions
21:17:25 <oklopol> *-.
21:17:38 <oklopol> because it gets hard to read
21:17:47 <SimonRC> you will need to re-define everything that uses it to get the new definition to be used
21:17:59 <oklopol> no, if you allow mutators
21:18:05 <oklopol> this isn't lazinesses problem
21:18:17 <oklopol> that exact same thing happens lazy or not.
21:18:20 <SimonRC> ah, ok
21:18:44 <oklopol> anyway, laziness lets you do more complete in-place mutation
21:18:49 <oklopol> if you wanna do it
21:18:51 <SimonRC> erm...
21:18:54 <oklopol> and who doesn't.
21:19:20 <oklopol> of course it does, you can even mutate a calculation that was done in the past if it wasn't actually done.
21:19:26 <oklopol> but lazied out.
21:19:39 <SimonRC> in some languages, you can re-define a function and the new definition gets used immediately, because the idea of whether a function call has taken place at a particular time makes sense.
21:19:57 <oklopol> that works for laziness as well.
21:20:00 <SimonRC> oklopol: you aren't making much sense.
21:20:02 <oklopol> well, in that case
21:20:03 <oklopol> waiut.
21:20:05 <oklopol> wait.
21:20:12 <oklopol> you can just evaluate, then change.
21:20:18 <oklopol> be lazy when you need to.
21:20:25 <oklopol> don't be if it hurts you
21:20:30 <oklopol> i mean
21:20:43 <oklopol> you can evaluate whatever had the function non evaluated
21:20:46 <SimonRC> <oklopol> you can just evaluate, then change. <-- what exactly does that mean
21:20:53 <oklopol> argh
21:21:03 <oklopol> so hard to type i'm concentrating on that :P
21:21:07 <oklopol> okay
21:21:08 <SimonRC> <SimonRC> oklopol: you aren't making much sense.
21:21:12 <oklopol> hmm, let me collect my thoughts.
21:21:51 <SimonRC> and a good compiler for a lazy language will spot strictness in lots of places, so the amount of optimisation will affect the behaviour of the program!
21:21:59 <oklopol> so... why does it matter if a function changes its meaning in a lazy language?
21:22:29 <SimonRC> because laziness is fundamentally about not knowing when a function call has been evaluated yet
21:22:29 <oklopol> you can use the old definition if you do as i said and just not change it in-place
21:23:03 * SimonRC tpyes
21:23:17 <oklopol> well, i've always thought about it as an optimizing technique and a way to have infinite structures, what are you referring to about it ?
21:23:26 <oklopol> i mean
21:23:33 <SimonRC> let me finish!
21:23:39 <oklopol> i'm referring to stuff where the programmer need not know it's there
21:24:03 <SimonRC> But if you don't mutate in-place, then you can only update to use the new version by re-defining the things that use it. And the things that use those. And so on, so you end up needing a mechanism to re-define lots of things.
21:24:21 <SimonRC> I am talking about laziness that is in the language, not just the implementation
21:24:25 <SimonRC> e.g. Haskell
21:24:26 <oklopol> and you don't need that if you'd already evaluated those things?
21:24:48 <oklopol> hmm
21:25:12 <SimonRC> yes
21:25:16 <SimonRC> I think
21:25:28 <oklopol> well, i don't see how it can ever be a problem, you just have a way to tell what kinda mutation to use at each assignation
21:25:41 <SimonRC> erm...
21:25:43 <SimonRC> um...
21:26:16 <oklopol> in-place (all the thing you know aren't evaluated, will evaluate the new way) or out-of-place evaluation
21:26:17 <SimonRC> that doesn;t help much
21:26:24 <oklopol> wwwwwwwwhy?
21:26:41 <SimonRC> because you often don't know what has been evaluated
21:26:59 <SimonRC> and different compilers will do different optimisations
21:27:04 <oklopol> then you don't have the laziness as a usable helper in the language.
21:27:10 <oklopol> if you don't always know whether it's being used
21:27:15 <SimonRC> why?
21:28:04 <oklopol> hey
21:28:07 <oklopol> argh
21:28:08 <oklopol> very hard
21:28:11 <oklopol> to explain
21:28:17 <oklopol> when typing is like aoeirjhg
21:28:26 <oklopol> my keyboard is not my favorite.
21:28:30 <SimonRC> ah, ok
21:28:37 <oklopol> err... i'll try to rephrase
21:29:44 <oklopol> i think most languages have lazyness in such a way that the programmer need never get vad consequences out of it, right? they can code as they would without lazyness, BUT they can also do stuff they couldn't do without it, like infinite stuff, right?=
21:29:54 <oklopol> *bad
21:30:33 <SimonRC> correct
21:30:52 <oklopol> so basically you can just have *everything* be done as if nothing was lazy and the language just happened to have infinite storage, because the laziness is just something to keep the infinite math fun going.
21:31:06 <SimonRC> yes
21:31:08 <oklopol> (infinite math fun... stuff that can't exist but can be toyed sith)
21:31:10 <oklopol> yeah
21:31:27 <oklopol> okay, well then just have everything not mutate in-place as you would without laziness
21:31:38 <oklopol> so that everything is *as if* it had been evaluated
21:31:48 <oklopol> even though the advanced programmer knows it's not.
21:32:44 <SimonRC> ok...
21:32:56 <SimonRC> suppose bar uses foo, and you re-define foo.
21:33:16 <SimonRC> do you ned to re-define bar to get it to use the new version of foo?
21:33:30 <oklopol> if you *want* to change a function so that something will be affected somewhere else (because there were copies of that function unevaluated), you're in a luck, you *can* do that in a lazy language if you know exactly what hasn't been evaluated
21:33:48 <Sukoshi> I win \o/
21:33:52 <oklopol> SimonRC: either yes or know, lazy or not.
21:34:03 <Sukoshi> Hashtable is faulty, someone needs to tell Java about that. HashMap works fine though.
21:34:10 <oklopol> Sukoshi: me and SimonRC's conversation?
21:34:11 <oklopol> oh
21:34:25 <oklopol> Sukoshi: you tell those bastards
21:34:31 <SimonRC> oklopol: when yes and when no?
21:34:32 <Sukoshi> oklofok:Alright. I will.
21:34:40 <oklopol> is it faulty in all implementations?
21:34:44 <oklopol> you said you tried multiple
21:35:05 <oklopol> SimonRC: whichever you want in a lazy language
21:35:13 <SimonRC> right
21:35:17 <oklopol> laziness only gives you another possibility
21:35:25 <SimonRC> There is a replacement for the Haskell list functions that uses stream fusion. This ultimately means that you can write a function that is completely strict where it can be and lazy to some degree otherwise. The programmer cannot be expected to know where it is strict and where it is lazy.
21:35:40 <SimonRC> but the possibility is uncontrollable ^^^ so you can't really use id
21:36:18 <oklopol> yes, so he'll just use everything as if it had been evaluated
21:36:46 <oklopol> only if you know it hasn't been evaluated will you be able to mutate in-place
21:36:51 <SimonRC> I don't call that a useful form of re-definition.
21:37:01 <oklopol> well you don't have to do that
21:37:02 <SimonRC> oklopol: if *who* kows?
21:37:05 <oklopol> but you *can*
21:37:09 <oklopol> the programmer...
21:37:25 <SimonRC> the programmer *can't* know
21:37:29 <SimonRC> almost never can know
21:37:50 <SimonRC> evaluation can be anywhere from speculative to completely optimised away
21:37:55 <oklopol> if it isn't useful, why did you say <SimonRC> you will need to re-define everything that uses it to get the new definition to be used
21:38:11 <SimonRC> so anything that depends on the order of evaluation sux
21:38:18 <Sukoshi> Gawd. The more I use Java, the more I'm missing dynamic languages ;-;
21:38:21 <SimonRC> oklopol: to check which you meant
21:38:32 <oklopol> i see
21:39:05 <oklopol> anyway, you don't have to use that and it doesn't sound like something you want to do (and if you do, you'll most likely want to mark it lazy *explicitly*)
21:39:19 <ehird`> Sukoshi, the cry of the lisp -- do you hear it?
21:39:29 <ehird`> it says "metapatterns, metapatterns"
21:39:30 <oklopol> i just said it can be done in lazy evaluation, because you said it has *less* mutating capability
21:39:40 <oklopol> while in fact it has more imo
21:39:44 <ehird`> and cars which fortook. <more bad lisp poetry>
21:39:47 <Sukoshi> ehird`: Actually, it's saying ``REPL, REPLLLLL''
21:39:49 <SimonRC> So you have one option (use old defs) that doesn't really count as "re-defining" and one option (replacing things that are not yet evaluated) that is unpredictable.
21:39:57 <ehird`> Sukoshi, Syntax error :r1 Abooooooort
21:40:04 <Sukoshi> :(
21:40:07 <oklopol> SimonRC: then just use the first one
21:40:12 <Sukoshi> I want my SLIME inspector to inspect data structures on the fly.
21:40:26 <Sukoshi> Having to run j/gdb is a PITA compared to on the fly debugging.
21:40:27 <SimonRC> oklopol: right
21:41:05 <oklopol> the latter can be used if you *know* what's not evaluated - and you sometimes do - usually you don't, in which case just pretend it's already evaluated and use it as if it was.
21:41:30 <oklopol> i hate water, why don't i have a coke tap.
21:41:33 <Sukoshi> 608 lines and going.
21:41:42 <SimonRC> you can never be certain something in Haskell isn't evaluated
21:42:05 <oklopol> SimonRC: well you were the one saying laziness is somehow inherent in it
21:42:10 <SimonRC> oklopol: Anyway, we have just concluded that there is something LISP can do that lazy languages will never be able to do sanely. Therefore, laziness sucks (even if only a bit).
21:42:12 <Sukoshi> oklofok: Because Haskell is st00pd! *leaves quickly*.
21:42:32 <oklopol> err
21:42:37 <oklopol> what can it do more sanely?
21:42:47 <SimonRC> LISP can
21:42:50 <oklopol> laziness can always simulate non laziness, that's what i've been saying
21:42:56 <SimonRC> no
21:43:01 <Sukoshi> oklofok: No, other way 'round.
21:43:02 <oklopol> errr
21:43:07 <oklopol> tell me an example
21:43:08 <SimonRC> even better, Smalltalk can
21:43:19 <Sukoshi> oklofok: Read the SICP exercise that implements lazy streams in Scheme.
21:43:32 <oklopol> i'm not sure i will :)
21:43:34 <oklopol> you can gimme alink
21:43:36 <oklopol> *a link
21:43:38 <Sukoshi> .... :P
21:43:42 <oklopol> and i might
21:43:50 <oklopol> otherwise, doubt it :)
21:44:05 <SimonRC> in smalltalk, all method lookup is dynamic
21:44:05 <oklopol> i have a lot of stuff to do, not important, but a lot
21:44:17 <Sukoshi> Smalltalk :33
21:44:25 <oklopol> whn can't laziness simulate strictness?
21:44:27 <SimonRC> if you re-define a method, everything instantlyswitches to the new version
21:44:28 <oklopol> *when
21:44:44 <oklopol> SimonRC: there's no problem in laziness with that
21:45:03 <SimonRC> because with strictness you have a defined order of evaluation and with laziness you don't
21:45:12 <SimonRC> oklopol: yes there is
21:45:20 <oklopol> just evaluate the stuff that was lazy and you have everything as if strict evaluation had been used all along.
21:45:41 <oklopol> laziness will just not do it if not necessary.
21:45:45 <oklopol> that's the idea.
21:46:02 <oklopol> mutation can always be simulated in it, any way.
21:46:15 <SimonRC> oklopol: if you computer something with the old version, then switch to the new version, in a not-explicitly-lazy language you would expect the computation to use the old version
21:46:53 <oklopol> in a strict language the old one would be used?
21:47:02 <oklopol> well, you can do that in a lazy language as well.,
21:47:23 <Sukoshi> oklofok: http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-24.html#%_sec_3.5
21:47:48 <Sukoshi> Shame shame if you haven't read SICP.
21:47:52 <oklopol> SimonRC: am i wrong in what i said?
21:47:53 <oklopol> heh
21:47:57 <oklopol> i don't know lisp
21:48:03 <Sukoshi> But it's SICP!!!
21:48:36 <SimonRC> hmm
21:48:38 <Sukoshi> SICP is incredible in how it teaches your basic, interested, lay person how to think about computer programs in terms of abstractions and computations.
21:48:46 <Sukoshi> It's lovely in that way, in fact.
21:48:57 <SimonRC> I think I may have got a bit confused, but only a bit...
21:49:22 <oklopol> Sukoshi: you think i lack basics or..?
21:49:30 <oklopol> i will read that, sure, but why?
21:49:38 <oklopol> i know what laziness is
21:49:51 <Sukoshi> Practice != theory.
21:49:58 <oklopol> err
21:49:59 <oklopol> anyway
21:50:30 <SimonRC> if you do do { r1 <- comp ; change_foo ; r2 <- comp ; return (r1, r2) } ...
21:50:38 <Sukoshi> You do SICP for the same reason you do brain teases -- to keep your mind sharp.
21:51:11 <SimonRC> then it is a PITA to sort out where you should use the new and old definitions of foo
21:51:16 <oklopol> err okay, anyway, in what case is lazy evaluation unable to carry out what strict evaluation would?
21:51:45 <SimonRC> actually, it is able to do so
21:52:02 <SimonRC> it is just difficult to implement
21:52:07 <oklopol> SimonRC: i think in my first sentence i explained how to make that code do the exact same thing lazy or not.
21:52:17 <oklopol> first sentence in this thread of lazying
21:53:08 <SimonRC> I was mentally editing it into something that could be implemented sanely
21:53:22 <SimonRC> to be able to do do { r1 <- comp ; change_foo ; r2 <- comp ; return (r1, r2) } ...
21:53:23 <oklopol> Sukoshi: i can assure you i read enough theory to keep my brain teased.
21:53:46 <oklopol> Sukoshi: i've *never* used laziness in practice
21:53:52 <oklopol> i misread what you said earlier
21:53:57 <SimonRC> ... you must track down every reference to foo and figure out if it should point to the new version.
21:54:29 <oklopol> err no
21:54:53 <oklopol> the old function definition will be left alone, the new one finds some other place in memory
21:55:08 <oklopol> once the old functions are evaluated, they are gc'd
21:55:31 <oklopol> and if you don't want that, you just evaluate every copy of the function when you change the function.
21:55:59 <oklopol> no, it's not that much more inefficient, you just do what you didn't do earlier
21:56:06 <SimonRC> should the runtime create a second version of comp that uses te new version of foo?
21:56:23 <SimonRC> suppose that there are an infinite number of invocations of foo possible...
21:56:59 <oklopol> i see what you mean now, anyway, here you'd have to evaluate all lazy things.
21:57:32 <oklopol> the copying thing doesn't always work with globals
21:57:46 <oklopol> well not globals, but external variables
21:58:11 <ehird`> globals don't exist in many lazy languages.
21:58:17 <SimonRC> If comp uses bar, and bar uses foo, then after loading the new version of foo you would have two copies of each function lying around, until r1 was GCed
21:58:56 <oklopol> SimonRC: okay, i admit that's a problem, however, most problems of that kind can be fixed at compile time
21:59:23 <oklopol> a function using non-argument variables would give a warning that it can't be lazy
21:59:42 <oklopol> and that's it.
21:59:49 <SimonRC> of couse, there is a silly way around it...
22:00:30 <ehird`> how many functional language interpreters lambda lift all functions then convert them to macros?
22:00:34 <ehird`> with pattern matching
22:00:36 <ehird`> i.e. a list of replacements
22:00:50 <ehird`> it seems like that's not a conventional way, mostly interps seem to use a call stack... traditional way
22:00:54 <SimonRC> I suspect you can write wrapersthat do all the lookup at runtime by reading IORefs, assuming that you are only redefining IO action functions
22:02:54 <oklopol> Sukoshi: i now see that is structure and interpretation of computer languages and not a random article
22:03:00 <oklopol> i mean, the book
22:03:09 <ehird`> :/
22:03:15 <oklopol> i do know *that*, but apparently not it's acronym
22:03:53 <oklopol> i admit i should read that, sorry, everyone should read that :)
22:04:12 <oklopol> also ankos, you should read it
22:05:52 <ehird`> i guess its not common
22:06:13 <ehird`> (also with rewrite rules like that youd need to convert "if"s to inner functions with pattern matching)
22:07:25 <Sukoshi> Yeah. SICP is Structure and Interpretation of Computer Programs.
22:07:32 <oklofok> didn't realize that
22:08:27 <oklofok> i'll read it now
22:09:39 <Sukoshi> Do the exercises.
22:10:12 <oklofok> yes, ma'm.
22:10:45 <oklofok> i'm pretty sure i won't get a lisp interpreter :)
22:11:00 <Sukoshi> It introduces you to Scheme along the way.
22:11:11 <ehird`> oklofok, SICP makes you write a scheme interpreter in a scheme interpreter
22:11:15 <ehird`> that is what it is all about
22:11:18 <oklofok> also, i'm pretty sure i know lisp already, just from reading stuff over the years.
22:11:21 <ehird`> you >must< follow it along, step by step.
22:11:24 <ehird`> it's enlightening
22:11:31 <oklofok> heh
22:11:34 <oklofok> sounds fun
22:11:51 <ehird`> eventually, you used a highly structured, metaprogramming-supporting language to implement itself, peice by peice reimplementing everything
22:11:53 <ehird`> it's nice
22:12:11 <oklofok> i admit that sounds cool
22:12:15 <Sukoshi> By the end of SICP, you'll realize why all the dynamic languages suck.
22:12:21 <oklofok> but isn't scheme insanely easy to implement anyway?
22:12:32 <Sukoshi> In *theory* ;)
22:12:39 <oklofok> i see.
22:12:41 <oklofok> :\
22:12:55 <ehird`> Sukoshi, dynamic languages don't suck :)
22:13:01 <ehird`> dynamic languages lend themselves to metaprogramming
22:13:02 <oklofok> scheme has static scoping or...?
22:13:04 <ehird`> metaprogramming can be very useful
22:13:06 <ehird`> oklofok, of course
22:13:15 <ehird`> scheme is a modern language used in both academia and production.
22:13:32 <oklofok> i like dynamic more.
22:13:35 <Sukoshi> s/suck/don\'t suck/
22:13:36 <Sukoshi> Sorry.
22:13:38 <ehird`> scheme is dynamic :P
22:13:39 <ehird`> Sukoshi, ah
22:13:45 <ehird`> scheme is far more well-designed and "pure" than common lisp (ugly!)
22:13:48 <Sukoshi> I meant why all the static languages suck.
22:13:55 <Sukoshi> I love CL. Moret than Scheme.
22:14:04 <ehird`> if you're not quite uptodate on scheme, read http://en.wikipedia.org/wiki/Scheme_%28programming_language%29
22:14:21 <Sukoshi> The brevity of Scheme seems to make it more useful for academic purposes, and its SRFIs destroy it.
22:14:36 <ehird`> no way, Sukoshi
22:14:40 <ehird`> srfis are golden
22:14:54 <ehird`> all of scheme is a wonderful little powerful gem
22:15:03 <ehird`> common lisp is a sprawling, over-engineered system of doom
22:15:13 <Sukoshi> Purity almost *never* translates into an oft-used-language.
22:15:22 <Sukoshi> Because real world problems are ugly. :)
22:15:33 <ehird`> scheme allows you to express ugliness purely. :)
22:15:48 <Sukoshi> If you want to program and go ``Oooh. Aaah. Beautiful.'' use Scheme, if you want to program and get things done, use CL, says I.
22:15:59 <ehird`> That's what Paul Graham says. Incidentally, he's wrong.
22:16:07 <ehird`> Scheme is a beauty to get things done in.
22:16:16 <ehird`> Don't dismiss it because of its academic roots
22:16:18 <pikhq> If you want to program and go "Oooh. Aaah. Beautiful." use combinator logic.
22:16:35 <Sukoshi> I'm not dismissing it because of its roots, I'm dismissing it because *I've* gotten a lot more done in CL than I have in Scheme.
22:16:39 <ehird`> pikhq, haha
22:16:50 <ehird`> if you want to program and go "Oooh. Aaah. Beautiful" use iota.
22:16:57 <ehird`> it's so nice and simple and elegant ;)
22:16:57 <pikhq> You see?
22:17:16 <ehird`> Sukoshi, Maybe because you didn't really try.
22:17:24 <Sukoshi> ehird`: Why does *everyone* say that? :P
22:17:44 <Sukoshi> Plus Scheme pushes functional style too much over imperative style.
22:17:53 <ehird`> Sukoshi, Because everybody that everybody knows who has really tried scheme loved it.
22:17:56 <ehird`> The rest didn't really bother.
22:18:03 <ehird`> And Scheme is an imperative language...
22:18:06 <ehird`> It just has a functional core.
22:18:07 <Sukoshi> ehird`: I love it too ... for academic purposes.
22:18:34 <ehird`> i ought to write a lengthy rant about scheme not being just for academic purposes.
22:18:35 <ehird`> :P
22:18:35 <Sukoshi> But the lack of standardization of anything *but* the language core kills a lot.
22:18:43 <ehird`> SRFIs are basically standards.
22:18:56 <Sukoshi> ... Which different implementations implement differently :P
22:19:17 <ehird`> The main implementations implement the vast majority of *useful* SRFIs in much the same way
22:19:27 <ehird`> Most scheme interpreters are just someone's toy
22:19:46 * oklofok likes every languages, some for the easy programming, some for the challenge in it
22:19:49 <oklofok> *language
22:20:01 <ehird`> i like... well most languages with PHP being a notable exception
22:20:08 <Sukoshi> Plus there are even fewer libraries written in Scheme than there are in CL.
22:20:53 <ehird`> CL suffers from library creep. :)
22:21:01 <Sukoshi> And Scheme doesen't even include a default object system or any functions for binary data manipulation!
22:21:11 <Sukoshi> (To change somewhat in R6RS, I know.)
22:21:28 <Sukoshi> Anyways, I think it's time we drop this, before we restart the ages old Scheme vs. CL debate.
22:21:32 -!- jix has quit (Remote closed the connection).
22:21:34 <pikhq> Tcl doesn't include a default object system, but that doesn't make it useless. . .
22:21:45 <pikhq> (although you may argue that point. :p)
22:21:51 <ehird`> object systems are generally not needed by default..
22:21:58 <ehird`> especially in lisps.
22:22:07 <Sukoshi> Neither are hash tables, huh? ;D
22:22:10 <Sukoshi> Suuure.
22:22:22 <Sukoshi> Implement everything in a list and make everything O(n) and slow. Suuure.
22:22:24 <ehird`> hash tables are in an srfi
22:22:49 <Sukoshi> Anyways, this debate is pointless, because I like CL more than Scheme and you like Scheme more than CL.
22:23:13 <Sukoshi> And I think both of us have used the two enough to realize that this petty argument won't change our opinions.
22:25:38 -!- jix has joined.
22:26:47 <SimonRC> what is the difference between oklofok and oklopol
22:27:06 <oklofok> computer.
22:27:46 <oklofok> i have two now, but i usually have fullscreen irc only on the other
22:27:55 <SimonRC> have you not heard of ssh?
22:28:20 <SimonRC> :-)
22:30:27 <oklofok> SimonRC: yes
22:30:31 <oklofok> a lot
22:30:36 <ihope> SimonRC: klo^3(fk-lp)
22:30:37 <oklofok> what is it?
22:30:49 <oklofok> a way to communicate between computers?
22:31:07 <oklofok> ah
22:31:08 <ihope> oklofok: pretty much, I'd say.
22:31:16 * ihope nods
22:31:18 <oklofok> takes me a while, i know exactly what it is.
22:31:35 <oklofok> anyway, what good would that be?
22:31:39 <oklofok> i'd have one nick :O
22:31:45 <ihope> :O?
22:31:50 <oklofok> i'd feel like i was buried alive.
22:31:54 <Sukoshi> Oh noes. The unspammage.
22:32:08 <oklofok> i'd feel like i was buried alive.
22:32:10 <oklofok> all i can say
22:32:11 <ihope> oklofok: you'd feel trapped?
22:32:13 <oklofok> yes
22:32:15 <oklofok> very.
22:32:17 <ihope> Like atrapado over there?
22:32:30 <atrapado> :)
22:32:58 <oklofok> Sukoshi: spammage?
22:33:05 <oklofok> is it spamming to have multiple nicks :)
22:33:18 <oklofok> but yes, i couldn't live without spamming
22:33:20 <Sukoshi> Yup. Reffered to as nick spamming on lots of networks.
22:33:28 <ihope> Spamming the nick list!
22:33:37 <oklofok> that's not spamming.
22:33:38 <ihope> What's it do that's bad?
22:36:57 <oklofok> oh my god i've been an idiot...
22:37:20 <oklofok> just realized what i didn't manage to do yesterday with numbda could be done by a dead monkey
22:37:31 <oklofok> Sukoshi: how long is this book?
22:39:35 <ehird`> oklofok, long, i guess: http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html
22:39:41 <ehird`> certainly not for one reading
22:40:08 <oklofok> that doesn't look all that long to me...
22:40:18 <oklofok> if it's < 500, i'll prolly read it tonight
22:40:29 <oklofok> unless people start harrassing me about something :)
22:40:44 <Sukoshi> Do the exercises!
22:40:48 * oklofok likes his bots <3
22:40:56 <oklofok> Sukoshi: i promise i might
22:41:27 <oklofok> i can try and find a scheme interpreter if it's that important to you
22:41:30 <oklofok> but you owe me.
22:42:18 <oklofok> Sukoshi: since i'd do every exercise in my head otherwise, that can only speed up the process.
22:42:18 <ehird`> chicken
22:42:24 <ehird`> haha
22:42:29 <oklofok> err
22:42:29 <ehird`> evaluating an interpreter in your head.
22:42:31 <Sukoshi> Suuure.
22:42:33 <Sukoshi> :P
22:42:36 <Sukoshi> Yeah. Chicken is awesome.
22:42:37 <oklofok> and i have no idea what my point was
22:42:38 <ehird`> http://www.call-with-current-continuation.org/chicken.html chicken scheme
22:42:51 <ehird`> or i guess http://www.gnu.org/software/mit-scheme/ if you're crazy
22:43:03 <Sukoshi> Hey. That's the implementation I started with.
22:43:05 <Sukoshi> I liked it a lot too.
22:43:12 <ehird`> yeah but chicken is nicer, i think,
22:43:16 <Sukoshi> It is.
22:43:19 <ehird`> not so much on the debugging side, but on the other sides.
22:43:25 <oklofok> Sukoshi: well, i tend to do everything except the stuff that aren't about "coming up with a solution" but rather about keeping it together, since my head has quite limited memory.
22:43:39 <ehird`> What I miss, is something like a cross between Forth and the CLISP implementation
22:43:40 <oklofok> "keeping it together"
22:43:42 -!- jix has quit ("CommandQ").
22:43:47 <ehird`> You can debug and fix on the fly
22:43:58 <Sukoshi> You can do that in SBCL also!
22:44:01 <ehird`> Chicken sucks at it, MIT only marginally better
22:44:10 <Sukoshi> oklofok: You don't actually learn something until you do the exercises.
22:44:11 <ehird`> Forth is basically the best at it
22:44:17 <ehird`> Forth debugging, well, IS forth
22:44:21 <oklofok> Sukoshi: i do not think that is true.
22:44:29 <ehird`> And, I guess for the cynical, you can say Forth = Forth debugging :)
22:44:35 <Sukoshi> Reading makes you like, a historian. Like an Art Historian, or a Military Historian.
22:44:35 <ehird`> oklofok, SICP is different
22:44:52 <ehird`> oklofok, SICP is all about EVAL :)
22:45:18 <oklofok> well, why don't you stop trying to make me think that way by *saying it's so* and just let me dl the interpreter and do it? i *did* promise i will
22:45:40 <Sukoshi> Switch windows? :P
22:46:42 <oklofok> err.. god idea, perhaps it isn't entirely your responsibility.
22:46:50 <oklofok> whether i read
22:47:00 <oklofok> *switch!*
22:48:14 <oklofok> Sukoshi: how long is the book?
22:48:22 <oklofok> i assume you know that
22:48:28 <oklofok> because 1) you've read it
22:48:35 <oklofok> and 2) you've read a live version of it
22:48:57 <Sukoshi> I haven't done 2.
22:49:04 <Sukoshi> With the exercises? It takes a while.
22:49:24 <oklofok> i just care about lenght, how much time you and me take may be different.
22:49:35 <oklofok> (i'm slower prolly, that is)
22:49:48 <SimonRC> I like the commenting fomat that SICP reocmmends.
22:49:58 <ehird`> hey, lambda-lifted rewrite rules are awesome for interpretation
22:50:05 <oklofok> but if you read online, then most likely you don't know, bye again ->
22:50:06 <ehird`> tail-recursion optimization? absolutely free!
22:50:09 <SimonRC> It recommends that you mput in the information that you would put in a Haskell type sig.
22:50:12 <SimonRC> :-P
22:50:19 <ehird`> complex call stacks? all gone!
22:50:21 -!- RedDak has quit (Read error: 104 (Connection reset by peer)).
22:50:24 <Sukoshi> Ewww. Haskell.
22:50:31 <ehird`> plus you can inspect a program replacement by replacement
22:50:36 <ehird`> that's gotta be a useful debugging tool!
22:50:40 * Sukoshi likes saying that over and over again for comic effect.
22:52:30 <SimonRC> tried it?
22:53:51 <Sukoshi> Yeah.
22:54:09 <Sukoshi> Not bad, for its domains. And invaluable, IMO, for realizing just what state is useful for.
22:54:27 <ehird`> so i say to hell with lambda calculus! to hell with beta-reduction and alpha-conversion!
22:54:35 <ehird`> long live rewrite rules!
22:54:37 <Sukoshi> Then you throw that away and say, ``Holy Jeebus thank Turing for state!''
22:55:36 <ehird`> holy jeebus thank rewrite for rules!
22:56:08 <ehird`> why didn't i think of rewrite rules before!
22:56:31 <ehird`> :p
22:56:45 <Sukoshi> Haskell made me a much better programmer, and I have to thank it for that.
22:56:51 <Sukoshi> I never programmed imperatively the same way again.
23:00:22 <oklofok> hmm... now i feel like writing a partial lisp interpreter into my bot :P
23:00:36 <oklofok> concentrate, oklofok, concentrate.
23:01:10 <ehird`> lisp is easy
23:01:30 <ehird`> it's basically lambda calculus with multiple arguments and macros.
23:01:36 <ehird`> and variables.
23:04:12 <pikhq> Well, of course Lisp is a superset of Lambda calculus. . .
23:04:16 <ehird`> Sure.
23:04:18 <ehird`> But it's not much more.
23:04:30 <ehird`> core lisp is simple
23:04:43 <pikhq> Most of the stuff in Lisp is trivial to do in Lambda calculus. . .
23:04:58 <pikhq> I think if you just add named functions and variables, the rest comes naturally.
23:05:20 <pikhq> Well, that *and* do it in sexp syntax.
23:06:03 <ehird`> named functions and variables - you only need the latter
23:06:14 <ehird`> just (set var func)
23:06:17 <pikhq> Well, yeah. . .
23:06:25 <pikhq> Sorry.
23:08:56 <ehird`> So, add some simple scoping, add macros, and add multiple function arguments..
23:09:02 <ehird`> And parse it with sexps.
23:09:04 <ehird`> Tada, lisp, done.
23:09:46 <pikhq> If you're going to be really anal, implement some of Lisp's usual builtin functions.
23:10:06 <pikhq> Still, not all that hard. . .
23:10:18 <Sukoshi> Another disadvantage of Scheme: Only stupid Europeans use it ;) (This is a joke, if you don't understand.)
23:10:22 <pikhq> It's almost like doing Brainfuck in terms of P''.
23:11:13 <ehird`> pikhq, Sure -- Oh, you'll also want lists and atoms
23:11:17 <ehird`> Which are stupidly simple to implement.
23:13:06 -!- atrapado has quit ("e").
23:16:08 <oklofok> lisp has arrays, strings and hashmaps, no?
23:16:15 <ehird`> hashmaps are not in core core lisp.
23:16:17 <ehird`> nor strings
23:16:25 <ehird`> nor arrays - lisp never uses arrays
23:16:30 <ehird`> lisp is drunk on linked lists
23:16:30 <oklofok> i think they all were in common lisp.......
23:16:40 <ehird`> common lisp is not core lisp...
23:16:43 <ehird`> common lisp is bloated lisp
23:16:43 <oklofok> i see
23:16:46 <oklofok> oh
23:16:53 <oklofok> i thought it was teh olde one.
23:17:03 <ehird`> common lisp is quite modern
23:17:24 <ehird`> it was standardized by ansi in 94
23:17:52 <Sukoshi> ehird`: No, CL uses arrays.
23:17:56 <Sukoshi> Quite regularly.
23:18:00 <ehird`> Sukoshi, Common Lisp Is Not Core Lisp!
23:18:05 <Sukoshi> Oh, Core Lisp.
23:18:12 <Sukoshi> Yeah. Core Lisp does not have arrays.
23:18:18 <ehird`> Common Lisp Is Not A Pure, Functional Lisp That You Might Implement For A Simple IRC Bot! (TM)
23:18:27 <ehird`> I Hate People WHo Talk Like This.
23:58:37 <SimonRC> The Python triple-quote convention is great for real life too.
←2007-07-21 2007-07-22 2007-07-23→ ↑2007 ↑all