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: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: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: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:13:31 <oerjan> ic. well iirc this is the first time i hear about them.
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:32:03 -!- ehird` has quit (Read error: 104 (Connection reset by peer)).
00:45:18 <ihope> announce/reply, and if something gets caught in a reply, it needs to refactor itself...
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:27 <Sukoshi> You do now how emulators tend to work, 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:59 <oklofok> ololobot and oklobot are bots.
00:51:07 <ihope> Where'd oklokok go?
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: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:13:17 <oklopol> you consider writing that in asm very basic practice? :)
01:13:34 <oklopol> you mean using a language i know already
01:13:43 <oklopol> that shouldn't be too hard
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:47 <oklopol> you need sound output and all... i can't say i know how to do that.
01:16:00 <oklopol> and i can use sdl for images
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:16 <Sukoshi> gcc works on your toaster, man.
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:56 <oklofok> what i see here is random text.
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:36 <oklofok> i'll click on a blue button.
01:20:51 * oerjan watches oklofok explode.
01:23:30 <oklopol> argh then an installation of sdl
01:25:51 <oerjan> shouldn't two bots be enough? :D
01:26:23 <oklopol> i guess i could extend that.
01:29:53 <oklofok> still installing... must be a great program.
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:34:12 <oklopol> it's a substance with a very bitter after taste
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:46 <oklopol> didn't know i'm a user somewhere
01:38:34 <oklopol> and god i was frightened when you pasted that.
01:39:41 <oklopol> i thought i was seeing the words wrong
01:39:52 <pikhq> oklopol: Do you have gcc installed in Cygwin?
01:40:11 <oklopol> perhaps i'll show you which button i pushed,.
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:32 <pikhq> The GUI installer. . .
01:42:41 <oklopol> looks like a windows-ed bash
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:56:25 -!- obsmntbombdood has changed nick to bsmntbombdood.
01:57:21 <Sukoshi> You download the Cygwin installer and do it.
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:52 <oklopol> i've been using it for >13 years :)
02:00:02 <Sukoshi> Then how come you don't know how to install a C compiler?!
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: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: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: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: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:43 <oklopol> this is why i haven't been doing c++ for a while.
02:09:10 <Sukoshi> Emacs + Slime + SBCL/CLISP == Win.
02:09:36 <oklopol> as an lvalue it means windows.
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:30 <oklopol> i'll be trying to install this for the next 24 hours, most likely.
02:11:25 <oklopol> ville@ville-desktop:~/cstuff$ dir
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: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: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: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: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: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: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: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: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:38 <immibis> not sure if the command is upgrade, though, it might be something else
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:40 <immibis> apt-get upgrade PACKAGENAME
02:51:45 <immibis> or install if you don't have it
02:52:02 <Sukoshi> oklobot: Then learn to use Google? :P
02:52:04 <oklopol> i installed gcc an hour ago.
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: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:53:03 <oklopol> and the windows machine has visual c++ 6, as i said :)
02:53:09 <pikhq> GNU Compiler Collection.
02:53:21 <oerjan> immibis: hah, that is what you want us to think
02:53:41 <Sukoshi> Meh. I have dev environments on all the machines I access.
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 <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:15 <pikhq> immibis: I'm no IDE man. ;)
02:56:30 <pikhq> oklopol: You can do some really, really evil stuff if you just assume GNU C.
02:57:12 <oklopol> pikhq: i don't know what gnu is :)
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 <toBogE> everything is dark right now
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:42 <immibis> isn't natural language parsing supposed to be impossible?
02:59:47 <toBogE> ihope is a user on IRC. See Ihope127.
02:59:53 <pikhq> immibis: Not really.
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:20 <toBogE> No such factoid ihope?
03:00:32 <immibis> !regex who-is [wW][hH][oO] [iI][sS] ([^ ]*)\? replace ?$1
03:00:36 <toBogE> ihope is a user on IRC. See Ihope127.
03:00:41 <toBogE> No such factoid Ihope127
03:00:48 <immibis> toboge, Ihope127 is >ihope.
03:00:53 <toBogE> No such factoid Ihope127
03:00:58 <immibis> toboge, Ihope127 is >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:07 <pikhq> !daemon bf delregex +[,]
03:01:07 <toBogE> Caught a java.lang.ClassNotFoundException! toboge.Execer_daemon
03:01:24 <toBogE> Caught a java.lang.ClassNotFoundException! toboge.Execer_daemon
03:01:26 <toBogE> Caught a java.lang.ClassNotFoundException! toboge.Execer_daemon
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:10 <immibis> in a terminal: go to where it is, chmod +x PROGRAM_NAME then ./PROGRAM_NAME
03:02:11 <pikhq> "gcc -o foo foo.c"
03:02:15 <immibis> where PROGRAM_NAME is the output
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: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:04:04 <Sukoshi> Learning isn't neccesarily a bad thing :P
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:05:06 <toBogE> oklobot is oklobot!n=oklobot@194.251.101.183, 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 <toBogE> ololobot is ololobot!n=ololobot@194.251.101.183, 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: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: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: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:42 <Sukoshi> Why though? I know a lot about Windows 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: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:13:06 <Sukoshi> But in the end, you just want to point and click?
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:15:00 <oklofok> err okay, well i don't like open source, i like doing things myself
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: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: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: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:49 <oklofok> i have a python interpreter.
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:10 <Sukoshi> oklofok: The answer to that is simple.
03:19:15 <ihope> Though Windows doesn't quite handle shebangs.
03:19:45 <Sukoshi> Think of it like this: Many years ago, artists used to all have to mix their own pigments.
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:12 <toBogE> Caught a java.lang.ClassNotFoundException! toboge.Execer_!
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:58 <immibis> !toboge, question marks and exclamation marks is !? ? ! ! ? ! ? ! ? ! ? ! ? !? ?! ? ! ! !
03:20:58 <toBogE> Caught a java.lang.ClassNotFoundException! toboge.Execer_toboge,
03:21:01 <immibis> toboge, question marks and exclamation marks is !? ? ! ! ? ! ? ! ? ! ? ! ? !? ?! ? ! ! !
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: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: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: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: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:31 <Sukoshi> *math relationships from the axioms
03:24:38 <oklofok> and i should make my own os some day as well
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: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 <Sukoshi> For people who find pride in building things from the ground themselves.
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: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:59 <oklofok> i haven't seen aything good about unic, about which i'm sorry
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: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 <toBogE> Linux is superior to UNIX
03:31:32 <Sukoshi> immibis: Sounds like you need Prolog.
03:31:42 <toBogE> No such factoid prolog
03:32:32 <Sukoshi> better(X,Y) :- superior(X, Y), inferior (Y, X).
03:32:38 <pikhq> superior(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:14 * pikhq listens to Pink Floyd - The Wall
03:33:29 <immibis> worse(Y,X) :- better(X, Y)
03:33:47 <pikhq> immibis: I'd much rather use DOS than 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:35:29 <Sukoshi> That's like saying ``WUTZ LISP?!''
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:23 <Sukoshi> Errr X={unix, windows, dos}.
03:36:27 <oklofok> Sukoshi: you sure about that?
03:36:43 <oklofok> errrrrrrrrrrr you should be sure about it
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:53 <immibis> don't you need gcc to install gcc?
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:15 <immibis> oklofok said it used oklobotspeak.
03:39:26 <immibis> better(X,Y). X=linux. Y=linux.
03:39:30 <oklofok> we tried to let you away with it, but oerjan just couldn't :)
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:40:04 <oerjan> Now if i could just remember what the correct way was...
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:28 <immibis> better(X,Y). X :- Y, Y :- X.
03:40:31 <ihope> better(linux,linux)
03:40:54 <oerjan> periods at the end of statements
03:41:09 <oklofok> immibis: you usually don't
03:41:39 <oerjan> you probably need parentheses
03:41:40 <oklofok> immibis: it brute forces you results and gives them to you :)
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:43:40 <immibis> is prolog an esoteric language?
03:43:55 <oklofok> one of the dying categories
03:44:13 <oerjan> logic languages are not dying!
03:44:41 <oklofok> i thought functional languages addressed all their positive shitz.
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: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: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: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: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: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: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: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:28 <oklofok> mercury seems to be a bit more purer about output
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:46 <toBogE> 1 + 1 is 2, but that's all i'll ever calculate.
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: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: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: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:03:38 <ihope> How easy would English be if word order were reversed?
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:05:31 * ihope suddenly goes to bed
04:07:36 * oerjan thought that was the correct contraction for "I would"
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: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: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:46 <oklofok> "i'll've" beats it though, but that's even iffier and i've never seen it used :)
04:17:47 <oklofok> "'nt" must end the contraction
04:18:03 <oklofok> this is a matter of opinion, obviously.
04:18:16 <oklofok> anyway, where is my code, where is my coke?
04:18:33 <oklofok> immibis: sorry, "n't" must be last
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: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: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: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:31:41 <oerjan> it might be a good idea to have toBogE use a different command prefix.
05:32:35 <toBogE> Caught a java.lang.ClassNotFoundException! toboge.Execer_daemon
05:32:41 <Sukoshi> But EgoBot was here first.
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 <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: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:28 -!- toBogE has left (?).
05:33:44 <Sukoshi> Are you being idiotic on purpose? :P
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: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: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: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: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:26:18 -!- RodgerTheGreat has quit.
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: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: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: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:33 <ihope> It translates ^xx to `kx?
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: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: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 <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: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 <ihope> ``xz`yz -> ``sxy -> `sx -> s
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:40:13 <oklopol> ehird`: it seems i don't recurse on application.
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: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: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:48:10 <oklofok> it effectively just returns whatever was given unless it's a lambda.
13:48:40 <ihope> >>> pl `hello, world!
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: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: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:42 <ihope> >>> pl ^x`s`s`s`s`s`s`s`ss
13:50:43 <ololobot> ``s`ks``s`ks``s`ks``s`ks``s`ks``s`ks``s`ks``s`ks`ks
13:51:05 <ihope> ```sksk -> ``kk`sk -> k
13:51:14 <oklofok> >>> ul ````s``s``s`ks`kk`ks`kk i i
13:51:21 <oklofok> >>> ul ````s``s``s`ks`kk`ks`kk A B
13:51:26 <ihope> ehird`: um, I have it ```sksk.
13:51:30 <ehird`> >>> pl `^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:47 <ehird`> >>> pl `^x`$x$x^x`$x$x <-- should translate to ```sii``sii
13:51:57 <ehird`> but ` is still borked.
13:52:04 <oklofok> okay, i'm pretty sure that works correctly unless you actually apply a lambda :)
13:52:23 <ihope> I think we've concluded that the bot is terribly horribly not well very badly broken.
13:53:04 -!- blahbot` has joined.
13:53:32 <oklofok> ah, *now* i found the problem
13:53:49 <oklofok> it effectively just returns with *no* conversion.
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:59:37 <oklopol> i should really make threading and autoreconnect...
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:29 <oklofok> anyway, there's your lambda
14:00:34 <ehird`> kill = Thread.list[x].kill
14:00:40 <ehird`> thats an insane lambda
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:59 * ehird` wonders what to add to it
14:01:06 <ehird`> any particularly interesting languages>
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: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:47 <ehird`> i embedded a BF interpreter for my bot
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:04:03 <ehird`> >>> pl `^x`$x$x^x`$x$x
14:04:12 <oklofok> test its correctness will you? i can't test my own programs, i'm just too empathetic about hem...
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:37 <ehird`> minksy machine or something
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:56 <oklofok> actually you don't even need * and /
14:09:08 <ehird`> you don't have < > so yes you do
14:10:04 <oklofok> not according to that page
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:15:09 <EgoBot> bf/, glass/, linguine/
14:15:15 <ehird`> egobot exposes the fs?!
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:15 <EgoBot> /bin/ls: ./files/--help: No such file or directory
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: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: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: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: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: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: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 -!- blahbot` has quit (Remote closed the connection).
14:35:24 -!- blahbot` has joined.
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:37:40 <ehird`> ok, " #?" (anything apart from space for #, well apart from ? - ! + :)
14:37:56 <ehird`> so it jumps to 0, and repeats
14:38:03 <ehird`> so, this thing can do infinite loops
14:41:26 <ehird`> so WHY is it pushing nil...
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: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:54 <oklofok> for a second i was hoping the name of the language was "jumping to -1 is exciting"
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: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:06 <ehird`> also: http://esoteric.voxelperfect.net/wiki/Jumping_to_-1_is_exciting
14:54:31 <oklopol> the problem is i can't see output
14:54:55 <ehird`> the tape is displayed at the end
14:55:17 <ehird`> i got the commands wrong
14:55:21 <oklopol> well, you know, i'm blind.
14:55:41 <ehird`> you're IRCing while blind and with no screen reader? :P
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:57:11 <blahbot`> [0, 1, 2, 2, 3, 4, 5, 3, 6, 1, 7]
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
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:44 -!- pikhq has joined.
15:04:51 <oklofok> it can't curry a lambda yet
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:06:05 <oklofok> i do it really badly, don't know how to do assembly in python
15:06:19 <ehird`> %eval def curry(f, x); proc {|y| f.call(x, y);}; end; curry(method(:puts), "hello").call("world")
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: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: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:11:05 <ehird`> %eval proc {|x,y|x}.arity
15:11:09 <ehird`> %eval proc {|*a|a}.arity
15:11:11 <ehird`> %eval proc {|x,*a|a}.arity
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:20 <oklofok> actually, i don't think you can do that in python without eva
15:12:02 <ehird`> strings are atoms in python
15:12:06 <ehird`> do you mean rubys symbols?
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:54 <ehird`> %eval def compose(x, y); proc {|*args| x.call(y.call(*args))}; end
15:17:03 <ehird`> hmmm, i want to write a @pl
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:21:01 <ihope> Game of Life where you can modify the board a little bit when it's your turn? :-P
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:53 <ihope> Game of Life with colors where you can modify the board a little bit when it's your turn? :-P
15:22:09 <oklopol> hmm, ehird`: did you make currying?
15:22:20 <ehird`> oklopol, currying in ruby is simple, relaly
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: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:24:41 <oklopol> and you think *i* might do better with my unbelievable ruby experience :D
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:39 <oklopol> %eval def test(n);3;end;test(4)
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: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: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: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: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: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:58 <oklopol> %eval def test(n);method(:test).arity();end;test(4)
15:29:14 <ehird`> %eval def test(n); method(:test).arity; end; test(4)
15:29:16 <ehird`> %eval def test(n, x=2); method(:test).arity; end; test(4)
15:29:22 <ehird`> %eval def test(n, x=2, *args); method(:test).arity; end; test(4)
15:29:26 <ehird`> %eval def test(n, *args); method(:test).arity; end; test(4)
15:29:31 <ehird`> %eval def test(n, x=2, y=3); method(:test).arity; end; test(4)
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:53 <ehird`> with optional arguments, arity is:
15:29:54 <oklopol> it doens't have to account for * or = in argument lists
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: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: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:52 <ehird`> %eval def x(*args); args; end; x()
15:32:53 <ehird`> %eval def x(*args); args; end; x(2)
15:33:00 <ehird`> %eval def x(a, b, *args); args; end; x(2, 3, 4, 5)
15:33:16 <ehird`> also that #call doesn't support va-args, yet, but meh
15:33:41 <oklopol> you can make currying implicit in ruby
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:21 <ehird`> %eval def x(*args); args; end; x([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:04 <ehird`> you're right, it should be *(args + [x])
15:36:26 <ehird`> that is the bug i think
15:36:34 <ehird`> replcae the newlines with ; and try it
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: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: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:25 <oklopol> because it asker for the ampersandorz
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: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:57 <oklopol> hard to say... what's alias
15:40:12 <ehird`> class X; alias :x :y; end; X.x -> X.y
15:40:33 <ehird`> that code works in irb
15:40:42 <ehird`> probably i need an extra thread
15:41:10 <oklopol> but it curries every function when you do that?
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:42:13 <ehird`> irb(main):024:0> proc {|x,y|x}.call(2).call(3)
15:44:29 <oklopol> god i wish i had oklotalk...
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: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: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: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: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: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: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:32 <oklopol> i can rewrite the spec for you
15:53:45 <oklopol> .* <- check for that regex
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: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: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:21 <oklopol> but not the way i wanted to :|
16:10:26 <oklopol> ehird`: what languages have you implemented?
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:11:11 <ehird`> i don't know, i implement languages all the time
16:11:31 <oklopol> esotericones are usually trivial
16:11:57 <oklopol> i mean, do you know your parsing, oklotalk has the hardest parsing i know of
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: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: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: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:30 <oklopol> make if BEGIN END mean if { }
16:21:36 <ehird`> tokens("BEGIN", "END"); syntax begin_end = ("BEGIN", exprs<expr*>, "END") = <block>;
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: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:30 <ehird`> it's just a reference to a rule
16:23:44 <ehird`> although, for BEGIN->END you probably want <state*>
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: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:31 <oklopol> i do understand that much, of course
16:28:49 <oklopol> that's a pretty straightforward c-style syntaxextension :|
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: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: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:41 <oklopol> there'sa crucial difference
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: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:56:08 <oklopol> i should use <unrelated></unrelated>
16:57:35 <ehird`> oh is that from the oklotalk parser
16:57:46 <oklopol> i'm making numbda in cfirst
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: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: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:09:54 <oklopol> i forgot how unbelievably great this language is<3
17:20:40 <oklopol> hmm... i can't imagine anything more fun than making a generic list construct in c.
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: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:15 <ehird`> you have to use different operators for floating-point stuff too
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:36:55 <ehird`> let rec init n f = if n=0 then [] else init (n-1) f @ [f n];;
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`> | 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:46 <oklopol> to be honest i don't mind it's looks, but i can't imagine a syntax i wouldn't like :)(
17:41:12 <ehird`> more fuel: http://www.podval.org/~sds/ocaml-sucks.html
17:41:53 <ehird`> most of the more serious of those problems do not exist in SML
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:45 <ehird`> but hooray for debugging-is-just-loading-your-program-and-running-a-repl languages
18:45:26 -!- RodgerTheGreat has joined.
19:02:59 <bsmntbombdood> GregorR: your egobot's brainfuck code is really, really, terrible
19:09:33 <bsmntbombdood> he uses global variables to pass parameters to functions
19:09:46 <oklopol> his brainfuck-interpreter?
19:14:41 <Sukoshi> But SML is a weenie-only language :(
19:18:43 <Sukoshi> Weenies == Those who get nothing but algorithms done in life (goes the joke).
19:28:45 <pikhq> bsmntbombdood: I assume you mean egobfi?
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: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: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: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:41:05 <Sukoshi> That's what a hash table *is* after all.
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:31 <bsmntbombdood> size of elements doesn't matter, just number of them
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: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:38 <Sukoshi> An alist isn't a HashTable.
19:46:00 <oklopol> it uses the addressof the object as the hashvalua
19:46:32 <Sukoshi> Yeah, but a larger pointer will not fit into an algorithm meant for a smaller one :P
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:11:25 <oklopol> err... sounds feasible. i haven't read *every* jvm's binary.
20:21:23 <bsmntbombdood> new proccessors should have 128 bit addresses and 260 bit words
20:25:38 <pikhq> New processors should have 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: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:40 <SimonRC> Where did this myth that languages cannot be sow come from?
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: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: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: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: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: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: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: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: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: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:21 <SimonRC> Forget all the talk about space and time usage, and unpredicatbility...
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: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: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: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:13:05 <pikhq> I've just got a higher-level language, wherein you just say that you're using those structures. ;)
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:14:04 <SimonRC> would you use the new or old definition when you look at new elemnts of foo
21:14:09 <SimonRC> what about old elements of foo?
21:14:42 <SimonRC> so, we have static lexical scope
21:14:57 <oklopol> heh scoping in assignation
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:16:23 <pikhq> RodgerTheGreat: Like I said: cheating.
21:16:31 <oklopol> err... redoing foo= bar etc zippers
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:22 <oklopol> err... that is why you don't mutate. functions
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:18:05 <oklopol> this isn't lazinesses problem
21:18:17 <oklopol> that exact same thing happens lazy or not.
21:18:44 <oklopol> anyway, laziness lets you do more complete in-place mutation
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: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:12 <oklopol> you can just evaluate, then change.
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:21:03 <oklopol> so hard to type i'm concentrating on that :P
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: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: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:26 <oklopol> and you don't need that if you'd already evaluated those things?
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: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: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:28:17 <oklopol> when typing is like aoeirjhg
21:28:26 <oklopol> my keyboard is not my favorite.
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: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:08 <oklopol> (infinite math fun... stuff that can't exist but can be toyed sith)
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: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: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:25 <oklopol> Sukoshi: you tell those bastards
21:34:31 <SimonRC> oklopol: when yes and when no?
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: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:25 <SimonRC> the programmer *can't* 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: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: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: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: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:37 <oklopol> what can it do more sanely?
21:42:50 <oklopol> laziness can always simulate non laziness, that's what i've been saying
21:43:01 <Sukoshi> oklofok: No, other way 'round.
21:43:08 <SimonRC> even better, Smalltalk can
21:43:19 <Sukoshi> oklofok: Read the SICP exercise that implements lazy streams in Scheme.
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: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: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: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: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: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: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: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: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: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: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: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:51 <ehird`> eventually, you used a highly structured, metaprogramming-supporting language to implement itself, peice by peice reimplementing everything
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: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:15 <ehird`> scheme is a modern language used in both academia and production.
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: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: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: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 <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: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:22:07 <Sukoshi> Neither are hash tables, huh? ;D
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: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:30:36 <ihope> SimonRC: klo^3(fk-lp)
22:30:49 <oklofok> a way to communicate between computers?
22:31:08 <ihope> oklofok: pretty much, I'd say.
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:50 <oklofok> i'd feel like i was buried alive.
22:32:08 <oklofok> i'd feel like i was buried alive.
22:32:11 <ihope> oklofok: you'd feel trapped?
22:32:17 <ihope> Like atrapado over there?
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: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:39 <oklofok> OKLOFOK PLEASE BRING LESS BOTS HERE
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:42:18 <oklofok> Sukoshi: since i'd do every exercise in my head otherwise, that can only speed up the process.
22:42:29 <ehird`> evaluating an interpreter in your head.
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:12 <ehird`> yeah but chicken is nicer, i think,
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: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:46:42 <oklofok> err.. god idea, perhaps it isn't entirely your responsibility.
22:48:14 <oklofok> Sukoshi: how long is the book?
22:48:35 <oklofok> and 2) you've read a live version of it
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:19 <ehird`> complex call stacks? all gone!
22:50:21 -!- RedDak has quit (Read error: 104 (Connection reset by peer)).
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: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: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:30 <ehird`> it's basically lambda calculus with multiple arguments and macros.
23:04:12 <pikhq> Well, of course Lisp is a superset of Lambda calculus. . .
23:04:18 <ehird`> But it's not much more.
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: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: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: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: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:18:00 <ehird`> Sukoshi, Common Lisp Is Not 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.