00:00:10 <Figs> I have a fun one for you guys
00:00:10 <Figs> http://weblog.raganwald.com/2006/12/just-because-we-can.html
00:00:15 <Figs> what does this program do...
00:00:19 <Figs> in 10 different languages!
00:02:46 <oerjan> (set 30 to 0 to turn off tracing, 257 to your output wrapping, and "?~" is the program.)
00:03:50 <Figs> is it the same as #?
00:06:01 <Figs> and that's the only thing I can think of
00:06:05 <Figs> but I'm not familiar with it
00:06:54 -!- crathman has quit (Read error: 113 (No route to host)).
00:09:45 <Figs> is there wiki software for local use?
00:09:49 <Figs> or blog software?
00:11:42 <Figs> http://www.funny-jokes.net/funny-pictures/imgs/177.jpg
00:14:27 <RodgerTheGreat> http://www.trichotomy.ca/images/cats/whatisthispwnedyouspeakofandwhyamiabouttogetsome.jpg
00:14:29 <SevenInchBread> SUBMIT SUBMIT SUBMIT - http://esoteric.voxelperfect.net/wiki/Kallisti (changes made, SUBMIT)
00:15:00 <SevenInchBread> ...is the eso wiki supposed to automatically log me out very frequently.
00:15:47 <oklopol> http://osl.iu.edu/~tveldhui/papers/2003/turing.pdf <<<<< this seems like something one could do for brainfuck as well
00:16:24 <Figs> preferably without having to run a webserver locally.. :|
00:18:53 <oerjan> SevenInchBread: Have you set it to remember your password?
00:19:47 <oerjan> I had the same problem before I did that
00:22:10 -!- atrapado has joined.
00:22:28 <oklopol> c++ has two turing complete langs and one almost turing complete, and i hear haskell's type system is turing complete too.... wonder if you could make a non turing complete lang with a non turing complete type system such that they together make up a turing complete system
00:25:12 <lament> oklopol: yes, very easily. Brainfuck with limited tape size, unbounded cells.
00:25:21 <SevenInchBread> if dupdog were Turing complete... I'm sure it's very likely that mfit or shanty alone isn't
00:28:17 <oklopol> hmm... it's pretty hard to do any kind of factorization in brainfuck but that'd be one way to do it i guess?
00:28:29 <oklopol> though no question mark, since i DO guess.
00:34:45 <Figs> Why can't anyone fucking program!?!?!??!?!?!!
00:35:02 * Figs wants to kill the idiot who wrote his school's webmail interface
00:35:24 <lament> Figs: it is very difficult to program while fucking. Can't concentrate.
00:35:34 <Figs> maybe for you :P
00:36:12 <oerjan> This reminds me of an xkcd strip
00:37:00 <lament> oerjan: i suppose any combination of 'program' and 'fuck' in the same sentence would.
00:37:22 <oerjan> actually i don't think it was about programming.
00:38:52 <lament> but its mention serves as a catalyst.
00:40:42 -!- sebbu2 has quit ("@+").
00:40:53 <oklodok> hmmm.... not a good idea to idle here with oklodok... two mircs kinda mess up logs being the same executable :)
00:41:06 <Figs> http://www.lojban.org/tiki/tiki-index.php?page=Home+Page&bl
00:41:11 <Figs> different kind of language
00:41:23 -!- oklodok has left (?).
00:41:47 <lament> oklopol: even one mirc is a bit sketchy
00:42:55 <oklopol> i know, but they all seem to suck so i'll make my own when i see fit
00:47:17 -!- jix has quit ("Bitte waehlen Sie eine Beerdigungnachricht").
00:47:24 <oklopol> hmm.... is there another way to do string -> bf output
00:49:11 <Figs> ^.*(?=.{10,})(?=.*\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=]).*$
00:53:55 <Figs> that's a regular expression
00:53:58 <Figs> not sure what language
00:57:06 -!- atrapado has quit ("l3nz").
01:00:08 <Figs> http://img467.imageshack.us/my.php?image=1579dx8.jpg
01:01:16 <oklopol> hmmm has there been any proof on shortest possible ways to create a string in bf?
01:02:04 <oerjan> in general there cannot be - Kolmogorov complexity, so undecidable
01:02:52 <oklopol> well... i guess it's understandable i couldn't do it then :)
01:04:34 <lament> that's right. nevermind.
01:07:58 <Figs> http://fukung.net/images/527/DeadeyeDick.jpg
01:09:01 <SevenInchBread> I seriously need to gather a band of conspiracy pirates to make A MOST EXCELLENT SYSTEM OF OPERATING.
01:09:26 <Figs> I have a friend from Lithuania who might be interested
01:10:52 <Figs> Showing BF to be turing-complete
01:10:52 <Figs> http://www.iwriteiam.nl/Ha_bf_Turing.html
01:12:36 <lament> bf is turing complete. That page is like a decade old.
01:13:31 <RodgerTheGreat> we had pretty advanced plans for an OS a while back, then gregor did his usual buzzkill and the fervor kinda died down
01:13:33 <SevenInchBread> well... I was also thinking about doing a lot of distributed stuff.... like cryptography, stenography, and stuff across a decentralized network... functioning as one OS.
01:13:38 <Figs> I'm just stumbling
01:14:06 <Figs> "Analyze license agreements for interesting words and phrases"
01:14:17 <RodgerTheGreat> but the entire discussion did produce one of my nicer creations: Def-BF! It's Brainfuck with pointers! woo
01:14:30 <oerjan> there are two different ways in which BF can be Turing complete. either you can have unbounded tape length, or you can have unbounded cell size.
01:14:38 <SevenInchBread> ...and like... a less boring operating system. BASED ON THE WILL OF GODDESS.
01:22:57 <SevenInchBread> hmm... so... taking a tip from Erlang here... any sort of process will have message passing in cues...
01:24:44 <SevenInchBread> ...aaaand... files are more like hash tables than actual files... HASH TABLES OF LINKED LISTS... IF YOU'D LIKE
01:29:27 -!- calamari has joined.
01:31:56 <oerjan> speaking of cue-based message systems...
01:33:47 <Figs> like, cue ball? :P
01:36:05 <oklopol> cue-based.... isn't that like event based?
01:36:25 <oerjan> hm... guess you are right
01:36:42 <oerjan> too boring. balls it is then.
01:37:05 <oklopol> i'm reading a book called programming the universe
01:37:05 <Figs> http://www.cartalk.com/content/features/hell/Bestof/mit-letter.html
01:37:19 <Figs> cue as in... actions O.o
01:37:43 <SevenInchBread> the main problem with hash tables and stuff is that hard disks have slower seeking times than active memory.
01:37:55 <SevenInchBread> so... pointer-based structures are inherently slower to traverse.
01:38:06 <Figs> http://www.m-w.com/cgi-bin/dictionary?va=cue
01:38:16 <SevenInchBread> ...but, it shouldn't be hard to stuff all the data close to each other...
01:38:55 <Figs> http://www.m-w.com/cgi-bin/dictionary?va=queue
01:47:03 <oklopol> hmmmm.... i just figured out why it's impossible to make a general algorithm for the shortest possible way to produce a string
01:47:25 <oklopol> and.... i now see i was quite stupid to take so long :D
01:50:11 <SevenInchBread> I BELIEVE I WILL NEED TO MINDS OF MANY GENII TO PULL THIS ONE OFF
01:50:21 <SevenInchBread> MAINLY BECAUSE I KNOW NOTHING ABOUT ASSEMBLY OR HARDWARE.
01:52:21 <oklopol> i think i read the first 100 or something pages of http://www.intel.com/design/pentium/manuals/24319101.pdf
01:52:53 <Figs> "What does a dog do that a man steps into?"
01:53:00 <Figs> I don't get it.
01:53:25 <oklopol> panting is the act of making an inhaling sound and drooling
01:54:00 <SevenInchBread> oklopol, ....that's far too much boring crap for me to read.
01:54:33 <oklopol> but i didn't understand it anymore at some point
01:54:41 <RodgerTheGreat> if you guys help me create a Bullet -> x86 compiler, I shall gladly write you a Kernel for this brave new operating system!
01:54:59 <oklopol> you make the spec first :)
01:56:29 <RodgerTheGreat> and I'm contemplating the inclusion of labels and gotos. They're useful and simple to compile, but most people don't use them properly
01:56:33 <SevenInchBread> ...I was thinking about doing some nifty self-modifying crap.... like Synthesis.
01:56:52 <RodgerTheGreat> they might end up morphing into a better version of break statements
01:57:53 <SevenInchBread> ...the only reason assembly is sane to code in is macros.
01:57:58 <RodgerTheGreat> I'm trying to weigh the benefits of having them with the havoc shitty programmers would cause with them
01:58:14 <oklopol> asm is a pretty good language
01:58:23 <Figs> I need to learn asm :P
01:58:23 <RodgerTheGreat> GOTOs are almost as dangerous as pointers, but for a different reason
01:58:32 <Figs> I forgot it all
01:58:41 <SevenInchBread> RodgerTheGreat, Never restrict anything just cause people might use them. ;)
01:59:22 <Figs> RTG: Assembly is ALL goto statements ;D
01:59:28 <Figs> (and some other stuff)
01:59:36 <RodgerTheGreat> the most useful things you can do with gotos are computed jumps (fuck pointers) and escaping from deep logic.
01:59:36 <oklopol> loops have been there for ages
01:59:48 <oklopol> plus, actually, for_eaches
01:59:49 <RodgerTheGreat> so I might make more specialized versions for those two purposes
02:00:06 <Figs> oklopol... are we talking about the same assembly language?
02:00:11 <oklopol> well... there are functions.
02:00:20 <oklopol> i don't know what macros are
02:00:49 <oklopol> a function is a number indicating the position of a function in the memory
02:01:04 <oklopol> you just stuff stuff on the stack and change execution to that function
02:01:22 <oklopol> then when returning, put stuff on the stack or in a register
02:01:39 <RodgerTheGreat> function pointers seem really useful to manipulate at runtime, but insanely easy to fuck up in subtle ways
02:01:39 <oklopol> returning: store current code pointer on the stack when calling the funciton
02:01:54 <oklopol> fucking up is a matter of debugging
02:02:06 <Figs> what asm are you using?
02:02:29 <oklopol> well... when i was little i made a program that beeped randomly
02:03:08 <oklopol> and i've read a few books about asm, though mostly about the technical part
02:03:18 <oklopol> BUT you are wrong to say asm hasn't got functions
02:03:52 <oklopol> it has concurrency (because of quite a direct metaprogramming) as well
02:04:53 <oklopol> in asm it's very easy to do continuations too
02:05:04 <oklopol> functional programming is easy
02:05:33 <Figs> I wrote a hello world program once
02:05:34 <oklopol> i've been thinking of making darkasm, an interpreted asm-like programming language
02:06:23 <oklopol> i don't know asm spesifics well
02:06:32 <oklopol> i couldn't make a compiling program
02:06:39 <Figs> why not compile to C?
02:06:41 <oklopol> unless the empty program is legal
02:06:45 <Figs> it's more portable, anyway
02:07:10 <oklopol> bullet -> c -> asm at least
02:07:16 <oklopol> asm because it's for the os
02:07:29 <Figs> you can do system programming in C
02:07:39 <Figs> it's meant to be portable assembly
02:07:49 <RodgerTheGreat> you guys *do* realize bullet is meant as a *replacement* for C, right?
02:07:56 <SevenInchBread> hmmm... interesting... I've never seen functions in what little I've touched of asm.
02:08:08 <oklopol> yes, but we also realize c has good compilers
02:08:27 <Figs> I don't think Asm has functions...
02:08:30 <Figs> but you can make them :D
02:08:35 <oklopol> it's a substitute for c programming, compilation is different
02:08:42 <Figs> I think it has proceedure calls :P
02:08:57 <RodgerTheGreat> I made bullet because I thought C had antiquated syntax and compiler technology
02:08:57 <Figs> if I remember right
02:08:59 <SevenInchBread> ...I'm fine with C myself... it might be fun to actually use it once.
02:09:21 <oklopol> that will autodo all address savings etc
02:09:49 <oklopol> procedure==function if you can access the call stack directly
02:10:16 <oklopol> RodgerTheGreat i understand, but i'm afraid none of us know any asm really
02:10:35 <oklopol> since i feel like i know most of us.... and i don't know any
02:10:56 <oklopol> now... what's an asm macro?
02:11:14 <SevenInchBread> it's just like... a thing that takes args, and substitutes in some code.
02:11:18 <RodgerTheGreat> I have a fairly good understanding of ASM programming in general, I just don't have much platform-specific instruction set knowledge
02:11:49 <oklopol> but anyway, that's not necessary
02:12:25 <Figs> I guess what I'm saying is
02:12:27 <oklopol> RodgerTheGreat well, you prolly have about the same backround as me then
02:12:32 <SevenInchBread> well... sometimes functions arne't necessary... macros have the benefit of being compiled before execution.
02:12:38 <Figs> you have to manually impliment calling convention
02:13:05 <oklopol> SevenInchBread you can use a calculator / paper for that
02:13:22 <oklopol> handy, maybe, but redundant
02:13:31 <RodgerTheGreat> I guess we could use a bullet->c compiler as a proof of concept for the language, and then we'd be able to play with the language as I tackle the slower task of building an actual compiler.
02:13:46 -!- mvivian has left (?).
02:14:06 <oklopol> well, if someone was to set me up an asm compiler, i might learn the language quite quickly
02:14:21 <Figs> it's very easy to use
02:14:50 <Figs> http://flatassembler.net/
02:15:58 <Figs> the problem of course though is
02:16:10 <Figs> you'll need an assembler at some point :P
02:16:15 <Figs> and maybe a linker
02:16:19 <Figs> depending what you're doing
02:16:54 <Figs> http://www.iecc.com/linker/
02:16:57 <Figs> a book on linking and loading
02:17:11 <oklopol> http://class.ece.iastate.edu/cpre211/lectures/assembly_functions.htm asm functions.... though i have no idea what this page talks about
02:17:57 <oklopol> Figs you give me a fasm link and say i will also need an assembler?
02:18:25 <Figs> if you make it compile to asm
02:18:31 <Figs> you will still need an assembler
02:19:14 <Figs> if I could learn x86 opcodes
02:19:18 <Figs> then we'd be in business
02:19:30 <Figs> if I remember right
02:19:44 <Figs> I don't know all the specifics, but I do know at least 2 ways to call functions
02:19:46 <oklopol> hmm... i could try and make a bf compiler
02:20:05 <Figs> what really matters is who cleans up the stack
02:20:11 <SevenInchBread> I'd imagine so.... functions are actually using assembly to do its magic... where macros are substituted in during assembling.
02:20:51 <oklopol> cdecl == caller clears, stdcall == callee clears iiird
02:20:52 <Figs> does the function clean up the stack after itself, or does the caller clean up the stack after calling the function?
02:21:27 <oklopol> cdecl changed the convention for varargs
02:21:53 <oklopol> all my sentences will, from now on, have an implicit iirc, for the rest of my life.
02:21:54 <Figs> the number of args (variable vs fixed) is one consideration
02:22:17 <oerjan> and thereby ruined tail call optimisation
02:22:46 <oklopol> Figs: if i recall correctly
02:23:13 <oklopol> macros are nothing special
02:23:38 <oklopol> any decent ide should have a general purpose macro system.
02:24:04 <oklopol> though, from what i've seen there is no such thing today as a decent ide
02:24:42 <oklopol> oerjan you can make exceptions though, since you can use stdcalls in c
02:24:58 <Figs> if you do that, you need to make the hardware too :P
02:25:18 <SevenInchBread> no no I mean... an assembler... basically a compiler into assembly opcodes.
02:25:35 <oklopol> that'd be like saying you have to breed your own population of people to be able to create a new esperanto
02:26:30 <Figs> it'd be more interesting if we had to figure out how to make his hardware work
02:26:43 <oklopol> a friend of mine created this language called zx3, he's thinking of adopting a few chinese kids now to teach it to
02:26:48 <Figs> send pulses into the bus...
02:26:55 * SevenInchBread tries to think at stuff he's good at in making an OS...
02:27:33 <SevenInchBread> ..ummm... basically just parsing and networking... and code obfuscators.
02:28:48 <Figs> you're good at networking? :D
02:29:51 <SevenInchBread> and I can make a kickass text-based adventure game... for like a GUI or something.
02:30:25 <oerjan> is stdcall part of the C standard?
02:30:40 <oklopol> oerjan __stdcall int func(args){}
02:30:44 <Figs> I don't think so
02:31:00 <Figs> but it is important for practical programming
02:31:01 <oklopol> hmm... might be a part of the c++ standard actually :)
02:31:10 <Figs> I very much doubt it
02:31:23 <SevenInchBread> ...but... the only language I've honestly ever used for anything practical is Python.
02:31:23 <oklopol> and... might be it's c but it's not standard
02:31:23 <oklopol> i think the last one ^^^^^^^^
02:31:29 <SevenInchBread> I simply know how the rest of them work... but I have no experience using them.
02:32:08 <Figs> it's, and I quote, "Microsoft Specific"
02:32:21 <Figs> http://msdn2.microsoft.com/en-us/library/zxk0tw93.aspx
02:34:01 <Figs> __cdecl is the default convention
02:34:57 <Figs> it would seem there is also __fastcall
02:36:57 <Figs> http://en.wikipedia.org/wiki/Calling_convention
02:37:49 <oklopol> can't compile towers of hanoi
02:38:13 <SevenInchBread> so... here's what I've got so far... some ideas that probably won't be around till much later.
02:38:56 <oerjan> ah. stdcall and cdecl are available in gcc for i386
02:39:21 <Figs> there is also fastcall
02:40:49 <oklopol> wow something actually compiled
02:41:10 <Figs> did you make a .com?
02:41:25 <oklopol> 30 lines, an msgbox hello world, exe
02:42:23 <oklopol> exactly 30 actually, i just picked a random number
02:42:44 <Figs> http://en.wikipedia.org/wiki/Name_decoration
02:43:02 <oklopol> this is the main code, it seems :P
02:43:21 <oklopol> now... where have i seen this before...
02:43:37 <Figs> that would call the Windows API MessageBox() function with 4 args
02:43:48 <Figs> 0, _caption, _mesage, and 0
02:43:56 <Figs> if I remember correctly,
02:43:59 <Figs> the first is the parent
02:44:01 <Figs> second is caption
02:44:03 -!- oklobot has joined.
02:44:03 <Figs> 3rd is message
02:44:12 <Figs> and 4th is the style
02:44:19 <oklopol> !exec "caption" "message" PrntNl
02:44:36 <oklopol> i just realized there are no msgboxes neither in oklobot nor in irc
02:45:05 <Figs> http://en.wikipedia.org/wiki/Name_decoration
02:45:15 <Figs> it's like MB_OK
02:45:29 <Figs> you can binary OR styles together
02:45:33 <Figs> to create more complex styles
02:45:41 <Figs> but I don't remember any of them :P
02:47:00 <Figs> MSDN is so friggen slow :P
02:47:33 <SevenInchBread> ...a good thing to set up first would be a way to spit out info to the screen... for the crumbing of breads.
02:47:52 <Figs> if you're doing COM programming
02:47:57 <Figs> just use int 21h
02:48:06 <Figs> it's old but it works
02:48:15 <Figs> I don't remember the variable
02:48:22 <Figs> but it gives you $ terminated strings
02:49:27 <Figs> try setting the style to
02:49:30 <Figs> MB_YESNOCANCEL
02:49:37 <Figs> or MB_ICONERROR
02:50:56 <oklopol> !exec "!exec ""34ChrDblRotAddDblAddRotRotAddDblAddSwpAddPrntNl"34ChrDblRotAddDblAddRotRotAddDblAddSwpAddPrntNl
02:50:57 <oklobot> !exec "!exec ""34ChrDblRotAddDblAddRotRotAddDblAddSwpAddPrntNl"34ChrDblRotAddDblAddRotRotAddDblAddSwpAddPrntNl
02:51:32 <oklopol> SevenInchBread "int" means interruption, it's a kind of a function in asm...
02:51:37 <Figs> !exec "MessageBox" PrintNl
02:52:08 <oklopol> do not omit Nl for multiple prints per line.
02:52:24 <oklopol> !exec "asd ""foo"AddPrntNl
02:52:24 <Figs> !exec "Hello World" PrntNl
02:52:43 <Figs> 5 second latency
02:53:07 <oklopol> !exec 1 1 8[RotRotDblRotAddRot1SubDbl]Drp""Rot[RotRotSwpDbl"-"SwpAddRotAddRotRotSwpDblRotSwpSubSwpRotRotDbl]DrpAddPrntNl
02:53:19 <oklopol> !exec 0 10[Dbl1SubDbl]Drp[MulSwpDbl]DrpPrntNl
02:53:27 <oklopol> !exec 0 2[Dbl1SubDbl]Drp[MulSwpDbl]DrpPrntNl
02:53:30 <oklopol> !exec 0 3[Dbl1SubDbl]Drp[MulSwpDbl]DrpPrntNl
02:53:42 <Figs> !exec 2[Dbl]PrntNl
02:53:44 <SevenInchBread> I was just... generally confused about what we were talking about.
02:54:09 <Figs> !exec 0 2[Dbl]DrpPrntNl
02:54:30 <oklopol> SevenInchBread he just said you can output with interruption 21h
02:54:43 <Figs> it's a DOS command
02:54:48 <Figs> to output characters to the string
02:54:56 <Figs> (among other things)
02:55:01 <Figs> int 21h does a crap load of stuff
02:55:09 <SevenInchBread> the apple - it's like a pear... but shaped differently.
02:55:17 <oklopol> that's exactly what my book said
02:55:45 <oklopol> Figs i think it's the OS int
02:56:13 <Figs> to quit the program
02:57:31 <oklopol> can you write me a non windowed hello world?
02:58:04 <Figs> let me fire up fasm
02:58:07 <Figs> it has been ages...
02:58:19 <oklopol> like... mov ax, smth \n int 21h \n data db "Hello, world!",0 ?
02:58:26 <SevenInchBread> memory management could probably draw on some spiffy mathematical properties... to associate virtual to physical memory.
02:58:27 <oklopol> but then you need a lot of weird stuff
02:59:10 <SevenInchBread> ...anything in programming that can be solely described in some form of arithmetic is usually blindingly fast.
02:59:42 <SevenInchBread> anytime you need a number... use a number related in some way to 5.
03:01:20 <Figs> what is the ascii for 'a'?
03:02:14 <oerjan> this reminds me of the old puzzle - to write any number from 1 up to something using 4 4's
03:02:53 <Figs> I got a way to put an 'a' on the screen
03:03:10 <Figs> sure, but it is a poor way of doing things :P
03:03:31 <Figs> http://rafb.net/p/Psz7PD47.html
03:03:43 <Figs> no... I didn't use the other thing
03:04:16 <Figs> I am working on a slightly better way
03:04:37 -!- Sukoshi has quit (".").
03:06:02 <SevenInchBread> 11100000 is a beautiful number... as is 10101000 and all its various adjustments.
03:06:15 <oklopol> oerjan can you use any lambdas in that game?
03:06:37 <oklopol> <insert lambda> 4 <insert lambda> 4 <insert lambda> 4 <insert lambda> 4
03:08:12 <oerjan> well the usual version starts with arithmetic. if you put on to many operations you eventually reach the point where you can make a trivial recursive pattern to get everything.
03:09:33 <Figs> almost got it now...
03:09:38 <Figs> just need to remember how to do pointer arithmetic
03:14:36 <Figs> we're trying to print "Hello World!"
03:15:10 <Figs> it doesn't like me
03:15:17 <Figs> illegal instruction
03:15:58 <Figs> that's what I'm doing
03:16:22 <Figs> or did that not make sense?
03:16:27 <Figs> ok... what I'm trying to do is:
03:16:36 <Figs> define a sequence of bytes
03:16:42 <Figs> "Hello World!\0"
03:16:47 <SevenInchBread> I think if you had a sort of thin language atop assembly to deal with large amounts of data... like a high-level macro-language for plotting out assembly instructions... you could do some nifty stuff.
03:16:47 <Figs> and print that
03:17:08 <Figs> that's the idea behind C, I think...
03:17:10 <oklopol> SevenInchBread it's called c
03:17:29 <Figs> you have direct access to assembly
03:17:43 <oklopol> that compiler when you select something and click ctrl
03:18:52 <oklopol> 4-4+4/4, 4/4+4/4, (4+4+4)/4, 4*(4-4)+4, 4!/4-4/4, (4+4)/4+4, 4+4-4/4, 4*4-4-4, 4+4+4/4, 4*4-(4!/4), (4!+4)/4+4
03:19:16 <SevenInchBread> basically... you're still writing assembly... but you also have a macro language with some high-level constructs for substituting in instructions... like you could have an entire "string" macro of some sort... to make strings by using macro loops and stuff.
03:19:17 <oklopol> i couldn't think of another way to do 5
03:19:53 <Figs> 4+4+4 doesn't work for you?
03:19:58 <oklopol> but.... SevenInchBread i think c is kinda thattish
03:20:14 <oklopol> otherwise it's ridiculously trivial
03:20:27 <oklopol> (4/4)*n, where n is teh num
03:21:06 <SevenInchBread> basically what this would be is... the instructions for how you want your code to compile to assembly...
03:21:22 <oklopol> int dbl(int a){_asm mov ax,a;_asm mul ax,2;_asm mov a,ax;return a}
03:21:26 <oklopol> int dbl(int a){_asm mov ax,a;_asm mul ax,2;_asm mov a,ax;return a;}
03:21:37 <Figs> actually, it is asm {}, I think
03:21:40 <oerjan> oh right - you can use things like 44 as well.
03:21:43 <Figs> but i have never used it
03:22:03 <Figs> I could be wrong
03:22:06 <oklopol> Figs _asm <instruction>; or _asm {instruction \n instruction \n etc} in microsoft at least
03:22:19 <Figs> yeah, I don't use microsoft
03:22:25 <Figs> I may be thinking of C++'s asm
03:22:39 <Figs> that is 5 fours, oklopol
03:22:40 <SevenInchBread> The macros would be like a string manipulation language of sorts... with the return value being the assembly instructions...
03:23:44 <oerjan> of course when doing this as a "family" puzzle some of the point is to know the most operations, but I think in present company that constitutes overkill
03:23:48 <oklopol> 11 i have already... if ! is ok
03:23:57 <Figs> 4*4-(sqrt 4)-(sqrt 4)
03:24:29 <oklopol> or, at least if it is, ! is definately ok
03:24:43 <Figs> so, is it multiples of 4?
03:24:56 <oklopol> anyway, i was a lot faster than you, and that's the most important
03:25:04 <Figs> I only just started :P
03:25:16 <oerjan> i don't remember exactly. It may be that it is up to 4 4's, but definitely not more
03:25:44 <SevenInchBread> hopefully this has nothing to do with the OS... I will NOT permit the rampant use of 4s in the OS.
03:25:50 <oklopol> don't jump to easy numbers
03:26:16 <oklopol> SevenInchBread i'm sorry to tell you this but it's going to consist entirely of fours :\
03:27:23 <Figs> I think I remember doing this in 5th grade
03:27:41 <oklopol> i think i got up to 8 or smth
03:27:41 <Figs> we did a lot of puzzle type math in 6th grade
03:27:44 <Figs> and it got annoying
03:28:08 <oklopol> energy drinks kill the brain
03:28:45 <Figs> another way to get 12
03:29:13 <Figs> let's see here :P
03:29:26 <oklopol> 44/((4+4)/4)=4*4-(sqrt 4)-(sqrt 4)=4!-4-4-4
03:29:46 <Figs> 16 is easy too
03:29:55 <Figs> 17 you did already
03:30:39 <Figs> 4! -4 -sqrt(4)
03:31:09 <oklopol> if less than 4 can be used, which indeed is the case i guess :P
03:31:27 <Figs> let's do 18 again
03:31:30 <Figs> and do it right
03:33:41 <Figs> 44/4*sqrt(4)-4
03:34:04 <Figs> 44/4+4+4 = 19, btw
03:36:23 <Figs> (4^4)/(4!)*4 = 42.666...
03:36:44 <Figs> we're trying to get 18
03:36:49 <Figs> I already did 19
03:37:00 <Figs> right above [16:32:10] Figs: 44/4+4+4 = 19, btw
03:37:01 <Figs> [16:32:47] * SevenInchBread wins.
03:37:01 <Figs> [16:33:28] SevenInchBread: ...23 is al
03:38:51 <Figs> 4!-4-4+sqrt(4)
03:39:37 <oklopol> ...i thought we tried to do without sqrt
03:39:45 <oklopol> i found that sqrt thing :\
03:39:56 <oklopol> but.... hey Figs found this already
03:40:28 <oklopol> i found it just now, but thought it's no good
03:40:37 <Figs> I'm using sqrt
03:40:37 <oklopol> because that was the thing we decided to make better
03:40:44 <Figs> since I can't think of another way
03:40:53 <Figs> but no cubed rutes
03:42:05 <Figs> I think we did 23 already
03:43:10 <SevenInchBread> http://en.wikipedia.org/wiki/Register_Transfer_Language
03:44:12 <Figs> in any case... 4!-(sqrt(4))+4/4
03:47:13 <Figs> I like mine better :P
03:47:28 <Figs> is that right?
03:47:59 <Figs> 4!+s(4)+s(4)+s(4)
03:50:43 <Figs> (4!)/4+(4!)/4 = 12
03:51:14 <Figs> I LIKE TALKING IN CAPS LOCK TOO :D
03:51:31 <Figs> I AM NOT INTO GUYS
03:51:54 <Figs> help us solve 31
03:52:41 <Figs> 44/4 + 4! = 35
03:53:04 -!- wooby has quit.
03:53:06 <Figs> f(4)/4 * f(4)/4 = 36
03:53:21 <Figs> 4!+4!-(4*4) = 32
03:53:25 <oklopol> f(4)+4+4+4 = 36, f(4)+4+4+s(4) = 24
03:54:09 <Figs> f(4)+(f(4)/4)+4 = 24
03:56:20 <Figs> we need to finish 31
03:56:52 <oklopol> i've done that a million times :P
03:57:01 <oklopol> but though OH HE DID IT DAMN!
03:58:17 <Figs> sqrt(4)*4^2 - (4/4)
03:58:26 <Figs> if you allow ^2
03:59:11 <Figs> let's see if there's another way
03:59:26 <oklopol> all my attempts crash at 4*4 taking 2 numbers
03:59:36 <oklopol> oerjan comes in and pwns us all :)
04:00:12 * oerjan has been reading lots of mad science webcomics
04:01:44 <Figs> 44-(4!-4) = 24 :p
04:02:22 <Figs> I'm tempted to say we allow ^2
04:02:29 <Figs> just so we can move on
04:02:44 <oklopol> well, it's obvious we'll have to constantly increase the amount of operators
04:02:50 <oerjan> nah. definitely nothing is allowed whose mathematical notation contains a digit other than 4
04:03:18 <oklopol> oerjan now give us 31 or stop ruining our fun :)
04:03:46 <Figs> 4!^(4-(4/4)) = 13,824
04:04:29 <Figs> but it's probably useless :P
04:05:03 <Figs> got another idea
04:05:08 <Figs> if you find a way to do something w/ 3
04:05:17 <Figs> use derivative :P
04:07:02 -!- ShadowHntr has joined.
04:08:21 <Figs> I looked up a way to do it
04:08:32 <Figs> it required a different operator
04:08:54 <Figs> if we allow .4
04:08:56 <Figs> it is possible
04:09:04 <Figs> but you will have to figure out how
04:09:20 <Figs> (and that version allowed ^2 for somethings, but I don't think used it for that)
04:09:52 <Figs> no, that uses a 4
04:10:05 <Figs> only uses 1 four
04:10:14 <Figs> I forgot the solution already
04:10:23 <Figs> *tries to figure it out*
04:10:34 <oklopol> we'll try until you REMEMBER or we others figure it out
04:10:41 <oklopol> because you figuring it out now
04:10:46 <oklopol> would be merely remembering.
04:11:13 <Figs> yeah I got it again
04:11:25 <Figs> 4!+sqrt(4)+(sqrt(4)/.4) = 31
04:12:05 <oklopol> yeah... 5 is one of the numbers i've been wanting
04:12:11 -!- sekhmet has quit ("omgp90").
04:12:20 <Figs> s(4)/0.4 * 4/4
04:12:36 <Figs> do we have 33?
04:12:46 <Figs> I have a solution
04:12:56 <Figs> 4!+4+(sqrt(4)/.4)
04:14:00 <oklopol> (i just pasted 32 35 and 36 here)
04:14:45 -!- SevenInchBread has quit (Read error: 113 (No route to host)).
04:15:26 <Figs> 4*4/0.4 -s(4) = 38
04:16:11 <Figs> let's see if we can get to 100
04:17:13 <Figs> hmm, let's make this more readable
04:22:48 <Figs> 4^2 +4^2 + 5 = 37
04:22:54 <Figs> if we allow ^2
04:23:15 <Figs> what if we allowed bar?
04:23:27 <Figs> .444444.........
04:23:43 <Figs> usually you put a - over the 4
04:23:49 <Figs> we could do .4`
04:24:01 <oklopol> i thought like foo's brother bar
04:26:31 <Figs> (24 / .4` ) - (4*4) = 38
04:27:22 <oklopol> (lambda a:2**a+a)(s(4)/(.4))
04:27:59 <Figs> I think I did a way requireing only square as the weird thing we disallowed
04:28:22 <oklopol> yeah, that's make it trivial
04:28:34 <Figs> 4^2 +4^2 + s(4) / .4
04:28:55 <oklopol> yeah, exactly that actually :D
04:29:35 <oklopol> well.... we'll allow that and let oerjan slap us with his large trout if he doesn't like it! :D
04:29:45 <Figs> so we can do ^2?
04:29:53 <Figs> I think we'll need it higher up
04:29:55 <oklopol> though i'm pretty sure that's a mirc feature
04:30:15 * oerjan slaps oklopol with a large trout
04:30:26 <Figs> do you have a better way oerjan
04:30:28 <oklopol> well... i kinda like the idea of having lambdas... THOUGH might get quite easy :DD
04:31:15 <Figs> Z(4,4,4,4) = 37
04:31:47 <oklopol> hmm... does unlambda have a wimpmode like `p4 -> 4, ``s``a424 -> 2?
04:32:54 <oklopol> now 38, we'll stick with that 37.
04:32:56 <Figs> 44/(.4')-4 = 95
04:33:51 <Figs> yeah... I just got mixed up
04:34:09 <Figs> so, assuming we can use squares
04:34:14 <Figs> I'll use @ to mean square
04:36:07 <Figs> I know it is ^2, but what word?
04:36:29 <Figs> so, we have 40 next!
04:36:30 <oklopol> felt right... but i don't know
04:37:16 -!- sekhmet has joined.
04:37:38 <Figs> I used 5 fours
04:38:46 <Figs> one letter functions are single ops, right?
04:39:13 <Figs> d(4)/b(4) = 36
04:40:29 <Figs> 44... I did 44 didn't I?
04:42:23 <oklopol> i'm afraid of oerjan since this is his game, i feel like we are raping him while he's not watching
04:42:38 <Figs> the version I looked up had d() in it
04:42:43 <oerjan> it's not like i invented it or anything :)
04:42:51 <Figs> yeah, I've played it before
04:42:56 <Figs> though I think I only went to 20
04:43:01 <Figs> that was a pain in the ass :P
04:43:37 <oklopol> 44+s(4)+s(4) 48 (again prolly)
04:44:00 <oerjan> i was thinking about the combination function for binomial exponents
04:44:42 <oerjan> (n over m) = n!/(m! * (n-m)!)
04:45:03 <Figs> two things at once
04:45:49 <oerjan> for this puzzle i mean
04:46:13 <Figs> what are we up to?
04:46:28 <Figs> oh, that's easy
04:46:51 <Figs> I got a way with 5 by mistake
04:48:17 <Figs> ah so easy! yeah ...
04:50:19 <Figs> f(4)/.4 - 4/b(4) - 51
04:51:20 <Figs> f(4)/b(.4) *4/4 = 54
04:52:08 <oklopol> we have so many numbers it's becoming easy :)
04:54:26 <Figs> ah, I'm too slow :P
04:55:12 <Figs> d(4)*4 - (4/4)
04:55:36 <Figs> d(4)*4 * 4/4 = 64
04:55:57 <Figs> d(4)*4 + 4/4 = 65
04:56:42 <oklopol> "4*4*4" damn that's too long.....
04:57:09 <oklopol> d(4)*4 + 4/s(4) = 66 i mean
04:58:28 <Figs> how to make 60 again?
05:00:54 <Figs> f(4)/b + d(4) - s(4) = 68
05:06:00 <Figs> well, remember, we can use f() d() and b() and s() as functions of other things too
05:07:41 <Figs> I think I got one
05:09:06 <Figs> d(4/b(.4))-(4/b(4)) = 72
05:10:34 <Figs> but I did find something cool
05:11:00 <Figs> 44 / s(b(4)) = 66
05:11:11 <Figs> only uses 3 fours though
05:11:36 <oklopol> darn, i had all the functions in python... now i crashed it :)
05:12:08 <oklopol> oerjan what's your haskell interpreter like btw?
05:12:34 <oklopol> since the reason i'm not using haskell is i can easily use the python interpreter, the haskell interpreter sucks
05:13:53 <oklopol> i'm making a list of the shortest possible way to construct a number
05:14:01 <oklopol> http://pb.vjn.fi/p363163442.txt
05:14:12 <oklopol> i think you can do it with 2
05:14:30 <oklopol> since i'm forgetting some nice ways to do numbers
05:14:41 <Figs> d(4) -( 4 / b(4))
05:15:07 <Figs> b(.4) , I mean
05:15:21 <Figs> well, I guess b(4) makes sense too :P
05:15:27 <Figs> since 44444444.... is useless
05:15:43 <Figs> 44 / s(b(44)) = 66
05:15:58 <Figs> .44 44 44 44 44
05:16:40 <Figs> the rest of the people here are going to hate us :P
05:16:44 <Figs> when they see the size of their logs
05:17:12 <oklopol> i think they'll find this most entertaining
05:18:11 -!- oerjan has quit ("Lost terminal").
05:18:42 -!- RodgerTheGreat has quit.
05:19:15 <oklopol> i think these are pretty good... but i'd like to have allz
05:19:40 <oklopol> wanna copy/paste all from the logs? :X
05:19:53 <Figs> that's the kind of thing that awk and sed should be used for
05:20:13 <Figs> if only we'd been nicer :P
05:20:18 <Figs> and put = on all lines with answers
05:20:35 <Figs> well, let's see
05:20:39 <Figs> did you add that to the file?
05:23:20 <Figs> make rules for 24, 36, 54, 60, and 81
05:23:26 <Figs> since we have those
05:23:36 <Figs> and whatever is obvious from those
05:23:59 <Figs> my server is slow is why
05:25:52 <Figs> http://student.hpa.edu/~cmcfarland/bits.txt
05:28:43 <Figs> that'd give you 5
05:29:14 <oklopol> let's allow lambdas, (lambda a,b,c,d : <function here>)(4,4,4,4)
05:29:20 <Figs> how do I unsuspend a job?
05:29:35 <Figs> I don't understand lambdas :(
05:29:46 <oklopol> lambda is just a nameless function
05:30:37 <oklopol> (\ a, b, c, d -> a + b) 4 4 4 4 would be 8
05:30:50 <oklopol> the lambda is called with 4,4,4 and 4
05:31:23 <oklopol> that was a haskell lambda (almost at least)
05:31:30 <Figs> but I think that's kind of cheating :P
05:31:46 <oklopol> since it actually means infinite 4's
05:32:07 <oklopol> making n (4/4)+(4/4)+(4/4)...
05:32:07 <Figs> well, that's another sort of problem
05:32:10 <Figs> for our next game
05:32:44 <Figs> shortest possible
05:33:01 <Figs> if you can find a way to work it
05:33:04 <oklopol> we can start having unlambda competitions
05:33:07 <Figs> but it adds to the count
05:33:18 <Figs> I could write a simple interpreter for this :D
05:33:42 <Figs> I mean, specifically
05:33:44 <Figs> for the 4's game
05:33:52 <Figs> (with an ini file for the number worked with)
05:34:05 <Figs> once you do something like
05:34:18 <Figs> it counts the number of x's needed to do it
05:34:38 <Figs> and would create a set of observers
05:34:45 <Figs> to update dependancies
05:34:57 <Figs> so if you find a faster way to do 3, for example
05:35:01 <Figs> and 17 relies on 3
05:35:06 <Figs> 17 gets faster :D
05:35:36 <Figs> could get very complicated :P
05:35:50 <Figs> I'll try that later
05:35:53 <Figs> now, let's find 67
05:36:47 <Figs> is there a faster way to do 36 than d(4+s(4))?
05:37:35 <oklopol> you can't do 32 with ONE 4
05:38:31 <oklopol> you might be able to do anything with just one 4
05:39:05 <Figs> you can do it with 2 easily
05:39:39 <oklopol> you have factorization, squareroot and square
05:39:57 <oklopol> you might be able to make any number with those
05:40:15 <oklopol> assuming factorization is generalized for non natural numbers
05:40:26 <Figs> you mean factorial, I presume?
05:40:42 <Figs> factorization is like, 36 = 6*6 = 3*2*3*2...
05:40:51 <oklopol> let's have a factorization function though
05:41:17 <Figs> how did i do 54?
05:41:18 <oklopol> i know what factorization is, i just confuse terms :)
05:41:57 <Figs> no, the short way ;)
05:44:27 <Figs> I'm updating my rules list
05:44:39 <Figs> to include bigger ones
05:45:07 <Figs> can you access it still?
05:45:57 <oklopol> i could make a pagebin on vjn.fi
05:46:07 <oklopol> so you could make pages quickly
05:46:17 <Figs> well, I can update relatively quickly
05:46:19 <oklopol> so... pastebin with mutability
05:46:29 <Figs> it is just a matter of connecting to my school's network
05:46:45 <oklopol> yeah, i mean for general usage
05:47:08 <Figs> this is useful for me for now
05:47:12 <oklopol> and... my usage, i can't connect to your school's network :)
05:47:14 <Figs> that will probably grow faster
05:47:28 <Figs> well, you probably could
05:47:33 <Figs> the security isn't very good
05:47:37 <Figs> but I wouldn't recommend it
05:47:59 <Figs> then I need to go to bed
05:48:04 <oklopol> i wouldn't... but fucking 67
05:48:19 <Figs> I kept you up all night
05:48:20 <oklopol> i'll start reading in a mo
05:49:31 <oklopol> meh... i think i'll go read, i'll make a program to brute me 67 later today ;)
05:55:28 <oklopol> Figs if you know asm && seveninchbread if you making the os, http://www.kernelthread.com/hanoi/ check out hanoi os
05:55:40 <oklopol> (plus of course the others if you haven't yet)
05:55:44 <Figs> my asm is crappy :)
05:55:56 <oklopol> did you finish the hello world?
05:56:03 <Figs> I forgot about that, lol
05:56:07 <Figs> I got so caught up in this :P
05:56:23 <Figs> I can't figure out why
05:56:26 <oklopol> yeah... can't claim i've done anything else either :)
05:56:26 <Figs> mov dl, ptr msg
05:57:52 <Figs> (I have set AH to 02h)
05:57:56 <Figs> it shouldn't matter
05:58:18 <oklopol> so it just prints one char?
05:58:34 <oklopol> but anyway, easy to do it with that
05:58:39 <Figs> http://rafb.net/p/Psz7PD47.html
05:58:48 <Figs> that's the idea
05:59:09 <oklopol> BUT i'm pretty sure there is a way to print a whole string built-in...
05:59:18 <Figs> if you want to terminate wtih $
05:59:20 <Figs> which I didn't want to do
06:00:57 <oklopol> hmm... it'd be fun to do something like hanoimania with another problem
06:00:59 <Figs> I am a fucking idiot!
06:01:30 <Figs> I'm defining it in the code for goodness sakes
06:01:34 <Figs> so it's executing 'a'
06:01:55 <Figs> look where I have it
06:02:10 <Figs> 'a' is the first instruction being called >.<
06:02:14 <Figs> no seperation of code and data :P
06:02:37 <Figs> that just skips some space for like, magic stuff :)
06:02:52 <Figs> (ie, I need it, or it doesn't work, but I don't remember what it does ...)
06:03:25 <oklopol> now why is 'a' the first instruction being called?
06:04:16 <Figs> ok... if I looked at the output
06:04:19 <Figs> it'd be something like
06:04:29 <Figs> a 0xFE 0x21 ...
06:04:51 <Figs> it put the byte, 'a', literally
06:05:02 <Figs> so it see's OH, first instruction is "a"
06:05:32 -!- calamari has quit ("Leaving").
06:05:38 <oklopol> actually... i still don't see why 'a' is the first instruction
06:05:45 <oklopol> or... why would it be an instruction
06:05:56 <Figs> put it in fasm
06:06:02 <Figs> and look at the output
06:06:04 <Figs> with a hex editor ;)
06:06:12 <Figs> you will see 'a' there
06:06:15 <oklopol> i assume you meant you were outputting values at address 97 in memory
06:06:33 <Figs> it will make more sense
06:07:49 <oklopol> it outputs 'a' as it's supposed to :O
06:10:14 <oklopol> B402B261CD21B8004CCD21 is the .com
06:10:32 <Figs> you didn't change it
06:10:48 <Figs> (after org 100h)
06:11:56 <oklopol> msg db 'a' means put 'a' here and substitute this address for every 'msg' in the code?
06:12:10 <Figs> make the byte 'a' in the output
06:12:14 <Figs> and when I refer to msg
06:12:19 <Figs> refer to the address of that byte
06:12:48 <oklopol> isn't that exactly what i said?
06:12:48 <Figs> output = object code
06:13:20 <Figs> I misread it :P
06:13:29 <oklopol> thought so, i wasn't being that clear
06:13:36 <Figs> I thought you wrote "substitute this"
06:13:55 <Figs> (ie, replace msg with 'a' litterally, which it does not do)
06:14:20 <oklopol> yeah, i almost wrote that, but corrected just before saying it
06:15:20 <oklopol> but, i'm gonna go now :) check out the hanoi os if you have a spare machine or smth, i read the source, seems trivial ----->
06:47:55 -!- ShadowHntr has quit ("End of line.").
06:56:33 <Figs> http://rafb.net/p/SWRswb26.html
06:56:42 <Figs> now I am going to bed! :P
06:58:16 -!- na[zZz]gjunk has changed nick to nazgjunk.
07:16:05 -!- Figs has quit (Read error: 110 (Connection timed out)).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
10:16:15 -!- ais523 has joined.
11:07:57 -!- ais523 has quit.
11:09:58 -!- nazgjunk has quit ("going to backup some to prepare for almost full switch to linux").
11:24:18 -!- lament has quit (Read error: 54 (Connection reset by peer)).
11:24:18 -!- lament_ has joined.
11:24:32 -!- nazgjunk has joined.
12:13:51 -!- jix has joined.
12:22:30 -!- nazgjunk has quit (Read error: 131 (Connection reset by peer)).
12:22:50 -!- nazgjunk has joined.
12:27:38 -!- nazgjunk has quit (Read error: 104 (Connection reset by peer)).
12:30:41 -!- nazgjunk has joined.
12:55:32 -!- nazgjunk has quit ("Leaving").
13:04:01 -!- nazgjunk has joined.
13:38:24 -!- nazgjunk has quit ("Bi-la Kaifa").
13:44:08 -!- nazgjunk has joined.
13:51:35 <SimonRC> http://student.hpa.edu/~cmcfarland/bits.txt
14:54:41 -!- sirKIIdC has joined.
14:55:25 <sirKIIdC> how I can give the bot brainfuck-script
15:01:17 <oklopol> ~bf ++++++++[>++++++++<-]>+.
15:01:29 <oklopol> if your mean any bot / bsmnt_bot
15:04:43 <sirKIIdC> ~bf +++++++++++++++++++++++++++++++++++++++++.
15:04:48 <sirKIIdC> ~bf ++++++++++++++++++++++++++++++++++++++++++++++++.
15:04:56 <sirKIIdC> ~bf +++++++++++++++++++++++++++++++++++++++++++++++++.
15:06:21 <oklopol> you seems to be a real brainfuck wiz
15:10:21 -!- crathman has joined.
15:13:08 -!- nazgjunk has quit ("Bi-la Kaifa").
15:52:38 -!- Figs has joined.
15:53:28 <Figs> 40 byte hello world program
15:54:37 -!- RodgerTheGreat has joined.
15:54:55 <oklopol> !exec "Hello, world!"PrntNl
15:55:43 <oklopol> i call it oklobot, since i never really named it
15:56:19 <oklobot> LalaPRIVMSG #esoteric :LalaPRIVMSG #esoteric :Lala
15:56:27 <Figs> oklopol -- did you see? I pasted code last night
15:56:31 <oklopol> it fails if nl's are abused
15:56:37 <oklopol> i did, but i've been reading all day
15:57:11 <oklopol> now once again, oerjan's quine
15:57:12 <oklopol> !exec "!exec ""34ChrDblRotAddDblAddRotRotAddDblAddSwpAddPrntNl"34ChrDblRotAddDblAddRotRotAddDblAddSwpAddPrntNl
15:57:13 <oklobot> !exec "!exec ""34ChrDblRotAddDblAddRotRotAddDblAddSwpAddPrntNl"34ChrDblRotAddDblAddRotRotAddDblAddSwpAddPrntNl
15:57:49 <oklopol> i remember adding something to that while keeping it quine still... but couldn't find a trivial way to do that
15:58:19 <oklopol> something like: "look, an oklobot quine! :P"
15:58:42 <Figs> quines give me headaches :(
15:58:53 <Figs> imagine writing a program to write quines in assembly...
15:59:19 <Figs> I'll bet quines are easy in Lisp
15:59:32 <oklopol> Figs i think not especially
15:59:50 <Figs> http://student.hpa.edu/~cmcfarland/bits.txt
15:59:52 <Figs> RodgerTheGreat
16:00:01 <Figs> some short-ish ways to do various numbers
16:00:06 <Figs> we got stuck on 67
16:01:04 <RodgerTheGreat> are you doing this entirely with 4s to attempt to generate numbers with bit-switching, or just for fun?
16:01:23 <Figs> you must use four 4s
16:01:27 <Figs> to make each number
16:01:43 <Figs> these are just short ways so we can put them together for other ones
16:02:32 <Figs> the short version... yeah
16:02:42 <Figs> but for the game,
16:02:44 <Figs> you would need
16:02:46 <Figs> something like
16:02:54 <Figs> (d(4)+d(4))*4/4
16:07:00 <sirKIIdC> i am writing another interpreter for my language, wich is like whirl - it has two commands - 0 and 1
16:13:56 <Figs> ( d(d(4)) +d(4)-4 ) / 4 = 67
16:15:21 <RodgerTheGreat> does anyone think we could have success by writing a program to bruteforce these combinations?
16:15:45 <Figs> maybe, but I wouldn't recommend it :P
16:16:13 <Figs> you'd have to set up the entire program in a tree
16:16:26 <Figs> with god knows how many levels of depth
16:17:06 <Figs> I thought of another way to make the game last night
16:17:31 <Figs> shortest combinations to get to n
16:17:32 <RodgerTheGreat> I'd just say, 8 possible operations, a limit of nested functions, and a requirement to use 4 4s.
16:17:57 <Figs> don't forget I can do things like
16:18:30 <Figs> (d(d(d(d(d(d(d(d(4)))))))-s(4))*d(4)-d(4)
16:19:06 <RodgerTheGreat> that's part of the "limit of nested functions" thing so the program doesn't i-loop
16:19:10 <Figs> well, if you would like to write the program
16:19:34 <Figs> there are 9 operations
16:20:00 <Figs> +, -, *, /, s,d,f,b,^
16:20:11 <Figs> and you can use 44, .4, etc
16:21:40 <Figs> f(4)+f(4)+f(4)-4 = 68
16:23:58 -!- jix__ has joined.
16:26:33 <Figs> (d(d(4))+f(4)-4)/4 = 69
16:27:21 <Figs> 4*d(4)+4+s(4) = 70
16:28:48 <Figs> (d(d(4))+f(4)+4)/4 = 71
16:28:52 <Figs> we did 42 last night
16:28:54 <Figs> let me look it up
16:29:28 <Figs> it's shortcuts
16:30:14 <Figs> oklopol: f(4)+f(4)-4-s(4) = 42
16:31:37 <Figs> f(4)*(s(4)+4/4) = 72
16:31:44 <RodgerTheGreat> will there ultimately be an esolang based on this concept, seeing as it appears you can use the 4x4 approach for virtually any number, at least <100
16:32:08 -!- jix has quit (Read error: 113 (No route to host)).
16:32:53 <RodgerTheGreat> but remember, the larger you get the more difficult it'll be to obtain precisely the number you need through addition and subtraction of lower power values
16:32:55 <Figs> your task, rodger, should you choose to accept it.... and ye must! ... is to determine whether or not there is a number that cannot be made with our rules
16:33:48 <RodgerTheGreat> very large numbers must be made via factorials or powering.
16:34:14 <RodgerTheGreat> with each increasing term of these functions, their output grows faster
16:34:35 <RodgerTheGreat> thus, there is greater separation between the numbers that can be created with this method
16:35:27 <Figs> the question just seems to be whether or not there are enough tricks to bridge that gap
16:35:35 <Figs> and there probably aren't ... :P
16:35:55 <Figs> where is the first number we cannot derive from 4 fours?
16:36:00 <RodgerTheGreat> how about we try a simpler proof that can be used to prove the larger one?
16:36:22 <RodgerTheGreat> what is the largest series of consecutive numbers that can be generated with 3 fours?
16:36:32 <Figs> I have no idea :P
16:36:44 <RodgerTheGreat> and I mean largest in terms of "most" AND "highest value"
16:37:04 <RodgerTheGreat> because knowing *THIS*, we'll be able to determine what the largest "gap" is we can cross
16:37:07 <Figs> I'm gonna find the rest up to 100
16:38:31 <RodgerTheGreat> see if you can find some type of repeating pattern for generating consecutive numbers
16:38:47 <Figs> (d(d(4))+s(4)/b(4))/4 = 73
16:40:36 <RodgerTheGreat> we could do the "gap" proof recursively, by first proving the largest series of consecutives for one, then 2, and finally 3 4s
16:41:23 <Figs> f(4)+f(4)+f(4)+s(4) = 74
16:42:03 <Figs> (d(d(4))+44)/4 = 75
16:42:06 <RodgerTheGreat> I see the general form of these as always (foo1(4) operator foo2(4) operator foo3(4) operator foo4(4))
16:42:24 <Figs> I think it is a bit more complex
16:42:26 <Figs> since it can be
16:42:35 <Figs> op(op(op.... 4)
16:43:06 <Figs> functions are effectively unary operators
16:43:12 <Figs> and operators are binary operators
16:43:43 <Figs> f(4)+f(4)+f(4)+4 = 76
16:45:03 <Figs> d(4/b(4)) -s(4) - s(4) = 77
16:45:28 <RodgerTheGreat> I think the trick might be a huge number with a difference that's a large multiple of 3 or 7 away from a power or ! of 4.
16:45:49 <Figs> don't forget I can also do d(d(4)) = 256
16:45:50 <oklopol> 67 was indeed trivial once you figured you 268 is close to 256
16:45:58 <oklopol> that was a clever one indeed
16:46:38 <RodgerTheGreat> multiples of 3 and 7 require at least two fours to express, and a third would be dedicated to the large number
16:46:46 <oklopol> clever, though trivial, since i found the answer before i'd read what was inside (...)/4 = 67 :)
16:48:53 <oklopol> oh! let's do 4 i 4 i 4 i 4 i + same ops -> complex natural numbers n + mi :DDDDDDDDDDDDDDDDDDDDDDDDDDDDD
16:49:30 <oklopol> GO oklopol GO -------------------->
16:49:46 <Figs> let's finish 100 first ;D
16:51:52 <Figs> 4*f(4)-(d(4)+s(4))
16:52:05 <Figs> 4*f(4)-(d(4)+s(4)) = 78
16:53:58 <Figs> d(4/b(4))-s(d(4)/4) = 79
16:54:23 <Figs> d(4/b(4))-4/4 = 80
16:54:49 <Figs> that would be 81 - sqrt( 16 / 4 ) = 79 ;)
16:55:35 <Figs> d(4/b(4))+4/4 = 82
16:56:06 <Figs> d(4/b(4)) + s(d(4)/4) = 83
16:56:25 <Figs> d(4/b(4)) * 4/4 = 81 :)
16:57:33 <Figs> 4*(d(4)+s(4)/.4) = 84
16:58:01 <Figs> d(4/b(4)) + s(4) +s(4) = 85
16:58:22 <Figs> d(4/b(4)) + s(4)/.4 = 86
17:01:17 <sirKIIdC> what do cholery are you doing?
17:03:08 <Figs> (d(d(4))+4*f(4))/4 = 88
17:03:50 <Figs> find a combination of 4 fours that make each number up to 100
17:03:57 <Figs> http://student.hpa.edu/~cmcfarland/bits.txt
17:04:02 <Figs> some short ones
17:11:45 <Figs> d(4/b(4)) + 4 + s(4) = 87
17:12:54 <Figs> d( 4/b(4) ) + 4 + 4 = 89
17:13:12 <Figs> 4/.4 * 4/b(4) = 90
17:17:31 <Figs> d(4/b(4)) + 4/.4 = 91
17:17:44 <Figs> 44*s(4)+4 = 92
17:17:50 -!- lament_ has changed nick to lament.
17:19:04 <Figs> d(4/b(4)) + d(4) - 4 = 93
17:19:24 <Figs> I'm almost done
17:21:12 -!- sirKIIdC has quit (Remote closed the connection).
17:21:14 <oklopol> yes, i find it interesting this has taken about 4 hours
17:21:26 <oklopol> well... might be a lot wrong, but gotta check
17:21:43 <oklopol> oh... 100 isn't really anything special
17:21:49 <oklopol> so... it's not interesting
17:22:28 <Figs> http://student.hpa.edu/~cmcfarland/bits.txt
17:24:38 <Figs> 95 = 44/b(4) - 4
17:25:27 <Figs> 97 = 44/b(4) - s(4)
17:25:27 <Figs> 98 = d(4/.4) - s(d(4)/4)
17:25:27 <Figs> 99 = d(4/.4) - 4/4
17:25:27 <Figs> 100 = 4/.4 * 4/.4
17:25:47 <Figs> I found those while I was looking for 94
17:25:58 <oklopol> haha, i found it in 5 secs :)
17:26:16 <Figs> so we got all 100!
17:26:28 <Figs> we have a starting set
17:26:32 <Figs> from which we can optimize
17:26:41 <Figs> ie, we can do 1 - 100 in 4
17:26:46 <Figs> there are better ways to do them
17:26:50 <Figs> for the other game
17:26:53 <oklopol> we oughtta collect them all, plus make another list with the shortest possibilities
17:27:06 <Figs> well, we should make a table
17:27:10 <Figs> 1, 2, 3, 4 ways :P
17:27:22 <Figs> 400 values O_O
17:27:22 <oklopol> YOU should make the table, i should read :)
17:29:38 <Figs> this looks like a job for...
17:29:45 * Figs plays theme music
17:31:39 <lament> hm, what was hte Sprout page?
17:34:37 <Figs> how can I make one out of 3 fours?
18:13:11 <Figs> I fucking hate open office
18:13:15 <Figs> it's slow and buggy!!!
18:13:58 <Figs> I don't want to pay money for another slow buggy program ;P
18:14:43 <Figs> how do I turn off auto-capitalize in Calc?
18:14:48 -!- sebbu has joined.
18:23:05 <Figs> we never got 94
18:23:41 <Figs> d(4/.4)-4-s(4) = 94
18:29:30 <Figs> I have extracted a substantial amount
18:29:32 <Figs> and I am tired now
18:42:37 <SimonRC> ((lambda (x) (list x (list (quote quote) x))) (quote (lambda (x) (list x (list (quote quote) x)))))
18:46:58 <SimonRC> (\s->s++show s)"(\s->s++show s)"
18:47:40 <SimonRC> the haskell one works on almost the same principle as the LISP one
18:49:01 <Figs> I still think Lisp and even further, Haskell are totally hard to read :P
18:49:13 <Figs> maybe I'm just not familiar with them
18:49:23 <Figs> but still... O.o
18:49:46 <Figs> although, I'd be hard pressed to find a language that is always easy to read ;)
18:53:33 <oklopol> [19:21:17] <oklopol> (f(4)+d(4))/b(4)+4
18:54:06 <Figs> lament, you didn't see what 7" bread made then ? :P
18:54:10 <Figs> he obfuscated python
18:54:25 <lament> oh, of course it's possible to obfuscate everything
18:54:38 <lament> obfuscation is implicit in turing-completeness
18:54:50 <Figs> you can't obfuscate wait
18:54:53 <lament> if you want something approaching natural language syntax, try inform 7
18:55:17 <oklopol> you could have a theoretical programming language that disallows obfuscation though
18:55:31 <lament> oklopol: define 'obfuscation'
18:55:42 <lament> once you define it, you can disallow it
18:55:55 <oklopol> one that errs if you try to do something that could be done more simply
18:57:31 <oklopol> hmm... that haskell quine is very easy to read if you know what (\...) is
18:59:25 <Figs> http://edkrebs.com/herb/petoons11/desrt.jpg
19:39:27 <bsmntbombdood> I have a small and pitiful interpreter for FOOS now
19:39:45 <Figs> I am just so tired of my parser
19:50:24 <Figs> I'm just so fucking burned out right now
19:51:29 <Figs> it's really frustrating when you're on revision 14 of what should be an easy project
19:54:19 <bsmntbombdood> @'foo [@'foo-executed %str print] @object %inherit add-method done create foo
19:55:48 <oklopol> "@ - pushes the builtin object onto the stack
19:55:55 <oklopol> i don't understand even the first line :<
19:57:10 <oklopol> what's the builtin object?
20:01:00 <bsmntbombdood> @'foo ["Hello, world" print] @object %inherit add-method done create foo
20:01:12 <oklopol> so... your code makes the stack go <empty> -> bi -> bi "foo" -> bi "foo" [code] -> ??
20:01:23 <Figs> what is the include for boost lambda? O.o
20:01:55 <bsmntbombdood> @ object is the base object, that everything inherits from
20:02:10 <oklopol> @<something> is always a push?
20:02:22 <Figs> you know what is weird?
20:02:29 <Figs> I know exactly how boost::lambda works
20:02:34 <Figs> and I could rewrite it if I needed to
20:03:42 <oklopol> hmm... you have an interpreter?
20:04:25 <oklopol> you may have pasted a link but i don't remember
20:05:59 <oklopol> i just need the basics to work... since i still don't understand how it works :)
20:06:41 <Figs> I just wrote a tokenizer in... 44 lines of code
20:07:05 <lament> def tokenize(s): return s.split(' ')
20:07:12 <oklopol> i can write you a bf tokenizer in conciderably less
20:07:51 <oklopol> well, a nesting parser can be done in less than that
20:08:26 <Figs> nothing magical
20:08:32 <oklopol> i don't see that requiring 44 lines :)
20:08:57 <Figs> from a file? :P
20:09:32 <Figs> I used lambda to output it
20:09:41 <Figs> since I was too lazy to write a new function
20:11:45 <Figs> rapid share sucks
20:13:44 <bsmntbombdood> python looks like it's having trouble with mutual imports
20:15:08 -!- bsmntbombdood has changed nick to xor.
20:24:05 -!- atrapado has joined.
20:27:56 <oklopol> http://www.vjn.fi/pb/p654524162.txt
20:29:35 <Figs> got to take my sister to the park :(
20:30:01 <Figs> I should be back in an hour or so
21:25:45 -!- crathman has quit ("Chatzilla 0.9.77 [Firefox 2.0.0.3/2007030919]").
21:34:51 -!- ShadowHntr has joined.
22:10:21 <xor> I broke my interpreter
22:14:36 <oklopol> though i'd just understood what bsmntbombdood means
22:31:30 -!- Figs has quit (Read error: 60 (Operation timed out)).
22:56:38 -!- Figs has joined.
23:23:26 -!- sebbu has quit ("@+").
23:29:28 <Figs> does anyone know a good open source firewall for windows?
23:30:11 <Figs> I take it not?
23:30:26 <GregorR> Well, certainly I wouldn't, I don't use Windows :P
23:30:38 <Figs> I wish I didn't have to use windows any more
23:31:04 <Figs> if I was more knowledgable of sys. programming
23:31:06 <Figs> I'd do it myself
23:33:33 -!- SevenInchBread has joined.
23:38:46 <SevenInchBread> if I'm computer is connected to the net through a WLAN adapter... would that effect my ability to properly get a webserver going?
23:39:15 <SevenInchBread> ...the IP address everything seems to be getting from me is different from the one my adapter says.
23:39:35 <Figs> is there a way to quit norton?
23:40:21 <oklopol> i guess 1:37 is a good time to start perusing the course book if the exam is at 8?
23:40:32 <Figs> am I still here?
23:41:00 -!- atrapado has quit ("l3nc").
23:41:04 <Figs> finally killed it
23:41:07 <SevenInchBread> hmmm... when I logged into my router to foreward port 80 to my adapters IP I got " NAPT server IP address is not a valid host LAN address."
23:41:08 <Figs> god, that was hard
23:41:54 -!- Figs has left (?).
23:46:07 -!- crashmatrix has quit ("Leaving").
23:50:48 -!- SevenInchBread_ has joined.
23:57:15 -!- SevenInchBread has quit (Read error: 145 (Connection timed out)).