00:03:39 <Slereah_> But, what will the esco dude say! :o
00:16:36 <tusho> Slereah_: 'fuck you'
00:20:35 -!- timotiis has quit (Read error: 110 (Connection timed out)).
00:25:00 -!- jix has joined.
00:34:22 -!- kar8nga has joined.
00:48:07 -!- kar8nga has left (?).
00:54:57 -!- calamari has quit ("Leaving").
01:07:16 -!- Slereah_ has quit (Read error: 104 (Connection reset by peer)).
01:07:24 -!- Slereah_ has joined.
01:42:05 -!- Slereah has joined.
01:42:34 -!- Slereah_ has quit (Read error: 104 (Connection reset by peer)).
01:54:13 -!- jix has quit ("CommandQ").
02:24:06 -!- tusho has quit.
02:53:27 <Slereah> According to the user list
02:53:35 <Slereah> There's 299 dudes on the esowiki :o
02:53:44 <Slereah> We should party for mister 300.
02:56:14 <Slereah> Maybe I should make a phony account.
02:56:21 <Slereah> Something like user:Leonidas
03:16:35 <RodgerTheGreat> does somebody else want to be a text-based adventure game?
03:23:24 -!- ihope has quit (Read error: 110 (Connection timed out)).
03:52:42 -!- Corun has quit ("This computer has gone to sleep").
04:10:09 <RodgerTheGreat> Slereah: only when the players fail utterly at a puzzle
04:11:16 <Slereah> What would be that adventure game?
04:11:27 <Slereah> Does it involve the president being captured by ninjas?
04:12:28 <RodgerTheGreat> the general way to invoke it is to ask an IRP interpreter to execute a statement like "Will you please act as the parser for a text-based adventure game?"
04:14:49 <RodgerTheGreat> ah, here we go- this is a partial transcript: http://nonlogic.org/dump/text/1214072201.html
04:16:45 <Slereah> I just scanned the text. Not one mention of cake!
04:16:54 <RodgerTheGreat> It's kinda like playing D&D except there's no dice or lameass combat systems
04:17:15 <RodgerTheGreat> Slereah: all the more reason to include cake when you act as an interpreter
04:22:23 <Slereah> Well, I already did cake adventures.
04:23:18 <RodgerTheGreat> my next game apparently has to be called "RODGERIA II, THE QUEST FOR THE MYSTERIOUS PINEAPPLE OF THE DEEP"
04:24:07 <Slereah> Is it in the realm of my imagination?
04:26:00 -!- calamari has joined.
04:27:43 <calamari> installing Ubuntu on my dad's new box, trying to get rid of compiz
04:28:29 <RodgerTheGreat> and Slereah and I were discussing the newest fad in IRP- text-based adventure games
04:30:27 <calamari> one of the examples is even me.. lol
04:30:50 <RodgerTheGreat> essentially what we realized is that in IRP, it only takes a handful of commands to create a game, because IRP is one of the most powerful languages for procedural content generation in existence
04:30:56 <Slereah> But me, I'm more into graphical IRP adventures
04:31:39 <Slereah> You -> o o <- Delicious cake
04:32:17 <RodgerTheGreat> in which case "DO NOT EAT THE FUCKING CHEESE IT'S A TRAP"
04:32:22 <Slereah> It's more of a cake challenge graphical adventure
04:33:10 <Slereah> It was just a demonstration
04:34:07 <calamari> Please put an @ shaped hat on my head
04:34:41 <Slereah> I used to do it all in colors
04:34:51 <Slereah> Then I learned that the channel was no colors
04:35:07 -!- bsmntbombdood has quit (Read error: 113 (No route to host)).
04:35:16 <calamari> don't think I want to eat that
04:35:42 <Slereah> It's so delicious and moist!
04:37:02 <RodgerTheGreat> how long do you guys figure it'll remain in the web's collective consciousness?
04:37:40 <RodgerTheGreat> the internet as we know it is only really a couple years old
04:37:44 <Slereah> We're still not over Zerowing.
04:38:16 <Slereah> Were you aware that Mister T devoured my testicles, RodgerTheGreat?
04:38:31 <Slereah> No, Portal the household appliance.
06:46:37 -!- calamari has quit ("Leaving").
07:06:16 -!- poiuy_qwert has joined.
07:30:22 <Slereah> I wonder how many esolangs in the wiki are one shot occurences that will remain unused forever.
07:33:14 <Slereah> (diff) (hist) . . Esme?; 02:54 . . (0) . . Dagoth Ur, Mad God (Talk | contribs) (Undo revision 11873 by Special:Contributions/91.105.124.212 (User talk:91.105.124.212); I prefer "WikiPedia".)
07:49:52 -!- Slereah_ has joined.
07:49:52 -!- Slereah has quit (Read error: 104 (Connection reset by peer)).
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:09:06 -!- poiuy_qwert has quit (Read error: 110 (Connection timed out)).
08:31:48 -!- Slereah has joined.
08:31:48 -!- Slereah_ has quit (Read error: 104 (Connection reset by peer)).
08:42:12 -!- Slereah_ has joined.
08:45:50 -!- Slereah has quit (Read error: 104 (Connection reset by peer)).
09:27:23 -!- Slereah has joined.
09:27:23 -!- Slereah_ has quit (Read error: 104 (Connection reset by peer)).
09:37:10 -!- sebbu2 has quit (Read error: 54 (Connection reset by peer)).
09:49:08 -!- Slereah has quit (Read error: 104 (Connection reset by peer)).
09:50:12 -!- sebbu has joined.
10:01:56 -!- Slereah_ has joined.
10:04:57 -!- Slereah_ has quit (Read error: 104 (Connection reset by peer)).
10:05:25 -!- Slereah_ has joined.
10:17:21 -!- jix has joined.
11:12:40 <Slereah_> http://img.4chan.org/b/src/1214128825215.jpg
11:34:27 -!- RedDak has joined.
12:29:19 -!- Corun has joined.
12:45:10 -!- RedDak has quit (Remote closed the connection).
13:12:24 -!- oklopol has joined.
13:16:57 -!- RedDak has joined.
13:37:24 -!- kar8nga has joined.
13:40:18 -!- Corun has quit ("This computer has gone to sleep").
13:40:44 -!- kar8nga has quit (Client Quit).
14:29:39 -!- jix has quit (Nick collision from services.).
14:29:47 -!- jix has joined.
14:36:41 -!- Corun has joined.
15:08:51 -!- kar8nga has joined.
15:10:58 -!- jix has quit (Nick collision from services.).
15:11:06 -!- jix has joined.
15:20:15 -!- Corun has quit ("This computer has gone to sleep").
15:22:21 -!- Corun has joined.
15:25:51 -!- RedDak has quit (Remote closed the connection).
15:50:57 <RodgerTheGreat> Slereah_: that's the beauty of a wiki. Pages take up a negligible amount of storage, so you can have a virtually infinite supply of such stubs and one-offs just sitting around on the off chance that they'll be needed or referred to
15:52:49 <AnMaster> anyone got a good idea for a simple esoteric language to implement (in C) that will give me a good reason to learn flex?
15:53:44 <RodgerTheGreat> well, most of my favorite languages are stack-based, and for those it's usually just as easy to write the parser/tokenizer by hand
15:54:18 <AnMaster> anyway I like to find some good reason to learn flex
15:54:29 <AnMaster> and the rest of the project should be rather simple
15:55:34 <AnMaster> and no, postscript is too complex to implement
15:56:03 <RodgerTheGreat> here's an online interpreter for one of my languages, if you have JRE installed: http://rodger.nonlogic.org/games/CogEngine/Sprocket1/
15:56:21 <RodgerTheGreat> I meant languages in the family of postscript, not necessarily the language itself
15:56:48 <RodgerTheGreat> when you take away the graphics stuff, PS is basically just a really clean FORTH-like
15:57:01 <AnMaster> I do have JDK but not in the browser
15:57:12 <AnMaster> the plugin doesn't exist for x86_64
15:57:21 <RodgerTheGreat> well, the download link for the console version would work on your computer
16:00:01 <AnMaster> anyway, this doesn't give me a reason to learn flex really
16:00:57 <RodgerTheGreat> I dunno, most esolangs tend to fall into either "trivial parsing" or "murderous parsing"
16:02:16 <AnMaster> and most non-esoteric tends to fall into "reasonable parsing" but "complex in other parts"
16:02:45 <RodgerTheGreat> you could implement a very selective subset of C or Java
16:03:16 <RodgerTheGreat> choose a single looping construct, remove unnecessary nasty things, etc
16:06:55 <RodgerTheGreat> depending on your choices it could become quite esoteric, but you would still learn to work with very practical ideas
16:09:50 <AnMaster> I refuse to compile to asm due to religious reasons (I believe in portability)
16:09:54 <RodgerTheGreat> might be easier to implement that way unless you're handy with ASM, in which case compilation could be a snap
16:10:26 <RodgerTheGreat> or you could compile to bytecode and have twice the fun creating the interpreter
16:11:16 <RodgerTheGreat> oh, even better- you could compile to a bytecode interpreter I invented, thus layering the esotericisim and making your job more challenging and interesting
16:15:05 <RodgerTheGreat> it's pretty fast, and I also have an assembler that targets it
16:15:20 <RodgerTheGreat> I was going to write a language that compiled for it, but I got distracted by other projects
16:16:33 <RodgerTheGreat> but I imagine this would be moderately easy to convert
16:16:45 <AnMaster> RodgerTheGreat, also doesn't java have case?
16:16:58 <AnMaster> else if (instr == 10) {swap(0,x);}
16:16:59 <AnMaster> else if (instr == 11) {stak[sptr-x-soff] = a;}
16:16:59 <AnMaster> else if (instr == 12) {stak[sptr] = stak[sptr-x-soff];}
16:17:00 -!- Corun has quit ("This computer has gone to sleep").
16:17:23 <RodgerTheGreat> it does, but I don't like case statements. They don't actually compile to be faster and I think the syntax looks horrible
16:17:41 <AnMaster> RodgerTheGreat, well I prefer them in C anyway
16:21:44 <RodgerTheGreat> but anyway, this is what a hello world would look like in assembly: http://nonlogic.org/dump/text/1214148012.html
16:23:47 <RodgerTheGreat> some instructions discard the top stack element, so I think I did that because I needed two copies
16:24:04 <oklopol> you just said that, but i forgot alreadcy
16:24:46 <RodgerTheGreat> oh, this one is much more interesting- fibonacci sequence!
16:28:44 <RodgerTheGreat> X is the instruction parameter, A is the topmost stack element
16:29:21 -!- timotiis has joined.
16:35:11 <AnMaster> if (sptr >= STAK_MEMORY) {System.out.println("WARNING: Stack overflow!");halt = true;err = 4;}
16:35:21 <AnMaster> that looks 1) typoed 2) why not dynamic stack size?
16:35:39 <AnMaster> STAK_MEMORY should be STACK_MEMORY right?
16:35:48 <RodgerTheGreat> having a non-dynamic stack size can make it considerably faster
16:35:58 <AnMaster> RodgerTheGreat, well for C it would be same speed
16:36:01 <RodgerTheGreat> and it's STAK_MEMORY- it's uniform throughout my source
16:36:04 -!- Corun has joined.
16:36:05 <AnMaster> except you need to malloc once
16:36:40 <AnMaster> except if it is actually growing (realloc()) it would have same speed
16:36:52 <AnMaster> RodgerTheGreat, can't see how dynamic allocation is a problem?
16:37:30 <RodgerTheGreat> you can do it trivially by replacing the contents of that error message with code to resize and copy the array- that isn't the point
16:38:00 <AnMaster> how is "slight slowdown at one point" worse than "error out on complex program"?
16:39:02 <RodgerTheGreat> it was originally designed to create a microcontroller-like environment- It has a fixed memory size because I wanted it to be like a physical machine
16:39:41 <AnMaster> RodgerTheGreat, memory hotplug ;P
16:39:44 <RodgerTheGreat> and it'll run quite fast if you make program and memory sizes fit nicely in cache blocks
16:40:17 <AnMaster> RodgerTheGreat, what about SMP?
16:41:13 * AnMaster wonders if he maybe should create a micro-computer simulator himself
16:41:33 <AnMaster> just need to write an assembler for it
16:41:34 <RodgerTheGreat> AnMaster: coding it's easy, the hard part is coming up with a good instruction set
16:41:55 <AnMaster> RodgerTheGreat, yep, well I do know PIC12F629 asm
16:42:14 <AnMaster> so my knowledge of it is rusty
16:42:17 <RodgerTheGreat> if you make an assembly language that's anything remotely like I use you could modify my assembler pretty easily, but it's in Java
16:42:38 <AnMaster> RodgerTheGreat, shouldn't be too hard to rewrite in C
16:42:44 <AnMaster> anyway I wouldn't make mine stack based
16:42:47 <RodgerTheGreat> I know a little 6502, and I'm slowly getting better at it
16:43:47 <AnMaster> (also it would have maybe 12 or so registers
16:44:06 <RodgerTheGreat> and it needs a file like this for the language definitions: http://nonlogic.org/dump/text/1214149362.html
16:44:19 <AnMaster> <RodgerTheGreat> http://nonlogic.org/dump/text/1214149325.html <-- that should give me a reason to learn flex or yacc
16:44:31 <RodgerTheGreat> the MOS technologies 6502 was one of the most important 8-bit processors in microcomputer history
16:45:05 <AnMaster> how many registers do MIPS have RodgerTheGreat ?
16:45:31 <AnMaster> RodgerTheGreat, why a reserved 0? that seems pointless
16:45:50 -!- tusho has joined.
16:45:58 <AnMaster> anyway I don't mean stuff like program counter or such, just general purpose registers
16:46:40 <AnMaster> RodgerTheGreat, so 31 usable general purpose registers?
16:46:56 <RodgerTheGreat> some have reserved meanings, but they're just convention
16:47:28 <AnMaster> x86_64 is twice as much as x86 anyway
16:47:30 <RodgerTheGreat> and a handful do special things on certain instructions, like $rt
16:48:06 <tusho> 23:33:14 <Slereah> (diff) (hist) . . Esme?; 02:54 . . (0) . . Dagoth Ur, Mad God (Talk | contribs) (Undo revision 11873 by Special:Contributions/91.105.124.212 (User talk:91.105.124.212); I prefer "WikiPedia".)
16:48:13 <tusho> "I PREFER INCORRECTNESS"
16:48:31 <tusho> I like to spell city as siti, and if you dare change it, I WILL PREFER IT
16:48:42 <tusho> Especially if it's on my shitty, unspecified esolang!
16:48:57 <RodgerTheGreat> yeah, 32 registers, one constant zero, one for return addresses, and one that's bad juju to touch because it's reserved for temporary use by the assembler, so you have 29 general purpose registers
16:49:17 <AnMaster> RodgerTheGreat, ok. and on x86?
16:49:43 <RodgerTheGreat> I think x86 only has one or two "general purpose" registers
16:50:12 <AnMaster> x86_64 got twice as many as x86 anyway
16:50:32 <AnMaster> RodgerTheGreat, yes but you can use them for other stuff "while no one is looking"
16:50:57 <RodgerTheGreat> and the instruction can't uniformly perform operations on all of them equally- that's what I mean when I say "general purpose"
16:51:37 <tusho> 08:09:50 <AnMaster> I refuse to compile to asm due to religious reasons (I believe in portability)
16:51:42 <tusho> AnMaster's religion is crazy.
16:51:47 <tusho> It dictates how you can compile things on a computer.
16:52:04 <tusho> I bet it's the PortabilityOnCompilersigion.
16:52:08 <RodgerTheGreat> tusho: I swear to god you're like a clone of pikhq from two years ago
16:52:18 <AnMaster> RodgerTheGreat, how was pikhq back then?
16:52:37 <tusho> RodgerTheGreat: I was joking, actually
16:52:50 <AnMaster> <RodgerTheGreat> a douche about pretty much everything
16:53:41 <AnMaster> RodgerTheGreat, saw that mips emulator someone in here is working on, don't remember url
16:53:59 <tusho> i need to work some more on that
16:54:08 <tusho> codu.org/jsmips/sh.html for what it's worth
16:54:15 <tusho> dunno if he added my better keyboard code to that example yet
16:54:23 <AnMaster> http://www.codu.org/jsmips/dc.html
16:54:33 <tusho> anyway, if I appear to be a douche about everything that's probably because your sarcasm detector is broken
16:54:41 <tusho> (or it's defaulting to 'serious, then maybe sarcasm' instead of the other way around)
16:55:27 <tusho> RodgerTheGreat: where's that shirt you made captioned 'people from the internet'?
16:55:28 <AnMaster> RodgerTheGreat, what is the use of a NOP instruction?
16:55:30 <tusho> pretty appropriate
16:55:37 <tusho> AnMaster: wasting cycles
16:55:45 <tusho> and NOPing out license key checks
16:55:58 <AnMaster> RodgerTheGreat, I mean in your asm
16:56:36 <AnMaster> what is the bit width of your vm?
16:56:48 <RodgerTheGreat> anything that's data is stored as a NOP instruction so that the VM won't barf if someone forgets to terminate with a HLT
16:57:31 <AnMaster> well what about OOP asm? I got no idea how it would look
16:58:27 <AnMaster> RodgerTheGreat, well anyway I mean for data
16:58:28 <RodgerTheGreat> actually, that's one of the reasons my ASM is stack-based
16:58:40 <tusho> functional asm .. i think that's called lambda calculus
16:58:41 <RodgerTheGreat> implementing function calls and returns is very clean and straightforward
16:58:57 <tusho> OOP asm sounds fun, though
16:59:00 <tusho> think I'll write a vm and try that
16:59:10 <AnMaster> tusho, well I got no idea what OOP asm would look like
16:59:22 <tusho> AnMaster: i dunno, that's why I'm interested
16:59:29 <tusho> i'll hack up an example
16:59:30 <AnMaster> RodgerTheGreat, so program memory is separate from data memory?
16:59:31 <tusho> of what I think it'll look like
16:59:36 <AnMaster> tusho, yes would love to see it
17:00:05 <RodgerTheGreat> it was originally harvard architecture, but it mutated into a mix of harvard and von neumann
17:00:17 <AnMaster> RodgerTheGreat, well I would prefer one shared memory bank
17:00:24 <tusho> neko is kinda crap
17:00:28 <RodgerTheGreat> suffice to say that you can self-modify but you cannot access instruction fields
17:00:48 <tusho> Judofyr: it's just not that interesting
17:00:52 <tusho> also the asm is too high level
17:01:14 <AnMaster> well my asm would have a NX bit
17:01:24 <Judofyr> haXe is pretty cool (IMO) :P
17:01:39 <AnMaster> Judofyr, what about LLVM then?
17:01:49 <AnMaster> I wanted to try LLVM for a long time
17:02:01 <AnMaster> I haven't yet got around to it
17:02:03 <Judofyr> I'm way to high level for it :/
17:02:35 <AnMaster> if I made an asm I know what I will name it:
17:02:58 <tusho> AnMaster: http://nonlogic.org/dump/text/1214150491.html
17:03:01 <tusho> erally abstract, of course
17:03:05 <tusho> but I guess it'd look kinda similar
17:03:15 <tusho> CALLMETH is basically CALL, except it takes an instance on the top of the stack
17:03:24 <tusho> i guess you'd have to push 0
17:03:28 <tusho> to say you're giving it 0 arguments
17:03:37 <AnMaster> yeah virtual functions and so on
17:03:44 <RodgerTheGreat> if you implement OO-ASM, there are good odds that it'll look amusingly similar to JVM bytecode
17:04:15 <tusho> RodgerTheGreat: yeah, probably.
17:04:25 <AnMaster> RodgerTheGreat, what does JAL do exactly
17:04:27 <tusho> i mean, JVM IS oop asm, really :-P
17:04:31 <AnMaster> what do you mean with "and link"
17:04:35 <tusho> JVM bytecode has classes in a seperate thingy
17:04:38 <tusho> instead of 'erasing' them
17:04:39 <AnMaster> RodgerTheGreat, I don't know MIPS
17:04:43 <RodgerTheGreat> you jump to a location and store the return address in a var
17:05:19 -!- kar8nga has left (?).
17:05:26 <AnMaster> RodgerTheGreat, you mean: call
17:05:41 <RodgerTheGreat> it's like GOSUB with a one-level stack, and it's your responsibility to maintain the chain of return addresses as necessary
17:05:52 <RodgerTheGreat> AnMaster: depending on your BASIC interpreter, yes. :)
17:06:00 <AnMaster> RodgerTheGreat, I never did basic
17:06:07 <AnMaster> I did pascal when I was young instead
17:06:25 <Judofyr> is there a way to use LLVM without touching C?
17:06:43 <tusho> Judofyr: yes, use the llvm asm...
17:07:03 <AnMaster> well if you can call library functions I guess, so you could do it from C# with some Platform invoke
17:07:46 <tusho> Judofyr: LLVM asm is lower level than c
17:07:48 <AnMaster> RodgerTheGreat, in your asm definition what does the true and false mean?
17:07:48 <tusho> you'll have to understand c
17:08:07 <Judofyr> better buy some books then...
17:08:54 <AnMaster> RodgerTheGreat, and: JST 03 true// jump to stack <-- executing code on stack!?
17:08:54 <tusho> Judofyr: get K&R second edition if you wanna learn c
17:08:54 <tusho> it's concise as hell and great
17:09:04 <RodgerTheGreat> AnMaster: 1 and 0 implicitly, but I don't have any instructions that explicitly deal with "true or false"
17:09:26 <AnMaster> ah jump to value stored on stack?
17:09:55 <AnMaster> RodgerTheGreat, anyway the true and false in that definition file, sure 1 and 0, but what do they mean?
17:10:21 <Judofyr> right now, I rather buy The Little Schemer
17:11:44 <RodgerTheGreat> although you could overlap it with any instruction that has 0 as a parameter or doesn't use it's parameter
17:11:59 <RodgerTheGreat> there are some really nifty things you can do to optimize for space in this language
17:12:36 <AnMaster> public boolean oparam[];// does this command take parameters?
17:12:48 <AnMaster> so that false means "takes no parameters"
17:13:07 <tusho> AnMaster: he thought you meant
17:13:11 <tusho> 'what do true and false actually MEAN'
17:13:19 <tusho> 'in this case, what does the argument of true/false mean to the opcode?'
17:13:34 <RodgerTheGreat> if you'd said you were talking about the language definition file I could've answered easily
17:13:46 <AnMaster> RodgerTheGreat, I did copy and paste from that file
17:13:49 <AnMaster> <AnMaster> RodgerTheGreat, anyway the true and false in that definition file, sure 1 and 0, but what do they mean?
17:14:28 * AnMaster is writing up some ideas for his asm
17:15:48 <RodgerTheGreat> the active stack/ passive stack concept is one of my favorite aspects of my ASM- it provides a means to allow expressions in RPN pretty raw translation into ASM while avoiding accidental stack-smashing
17:16:30 <RodgerTheGreat> syscalls are a good way to define all your I/O, because in a real assembly language it wouldn't make sense to have those operations be part of the instruction set
17:19:07 <tusho> *i'm gonna let the OS provide syscall monikers
17:19:13 <tusho> so you can do 'SYSCALL putchar'
17:19:28 <tusho> it'd make them sweeter
17:19:37 <tusho> oh, and mine will be stack based
17:19:43 <tusho> and have a kind of fuzzy everything-is-everywhere stack
17:19:48 <RodgerTheGreat> so the ASM would just have some kind of hooking mechanism?
17:19:49 <tusho> well, two stacks of course
17:19:57 <tusho> or i could just divide a stack in two...
17:20:03 <tusho> that'd be closer to the machine
17:20:14 <RodgerTheGreat> tusho: that's generally how it works- start at both ends and grow towards the center
17:20:14 <tusho> RodgerTheGreat: pretty much, you'd provide implementations of syscalls and names for them
17:20:17 <tusho> like built-in functions, really
17:20:25 <tusho> i could make them functions but that'd be bad for performance
17:20:31 <tusho> so no call stack will be involved
17:20:46 <tusho> (i.e. they'll be goto'd and given an address to goto back, and if they want a stack they'd better handle it themselves)
17:24:44 <RodgerTheGreat> tusho: here's that image you wanted, btw: http://nonlogic.org/dump/images/1203125875-tetsuoooo.png
17:25:11 <tusho> yes, pretend I pasted that link ages ago :-P
17:35:14 * tusho writes some asm and then makes it work
17:35:17 <tusho> best way to develop software ever
17:37:33 <tusho> RodgerTheGreat: think I should have less-than-or-equal-to?
17:37:39 <tusho> it's common enough for another instruction, i'd say
17:37:44 <tusho> instead of manually or'ing it
17:45:32 <AnMaster> RodgerTheGreat, hm I got something written up here. not complete: http://rafb.net/p/dovpGA97.html
17:46:01 <AnMaster> very early draft of instruction set
17:48:12 * AnMaster take the name LDC for his load constant instruction
17:55:11 <tusho> AnMaster: I AM SUING YOU FOR COPYRIGHT INFRINGEMENT
17:55:39 <AnMaster> mine will have a syntax that is a mix of AT&T and Intel
17:55:49 <AnMaster> just to make *everyone* get a headache!
17:56:09 <tusho> now I want to make you feel pain
17:56:12 <tusho> that was not a clever thing to say ;)
17:56:21 <tusho> are you going to swap them each instruction or something
17:56:27 <tusho> they're bad enough seperately as it is
17:57:06 <AnMaster> I mean some parts with be done as in gas (like the prefix for register names), while other will be done as in intel (not yet decided)
18:04:29 <AnMaster> http://rafb.net/p/pFtjP117.html
18:30:27 <AnMaster> RodgerTheGreat, tusho: http://rafb.net/p/MYYzRr37.html
18:30:38 <tusho> AnMaster: it looks good
18:30:42 <tusho> ID is a bit odd though
18:30:48 <tusho> don't think it's needed
18:31:00 <tusho> AnMaster: also, you'll wanna trim that down a bit
18:31:06 <AnMaster> future compatibility (why do I bother)
18:31:09 <tusho> it's verging into CISC far too much ;)
18:31:18 <tusho> also, i have never seen a future compatible cpu arch
18:31:20 <AnMaster> tusho, hm I did leave out FTAN as it can be done with FSIN and FCOS
18:31:30 <tusho> AnMaster: there are RISCs with 32 instructions
18:31:49 <tusho> yeah, just saying that you might wanna minimalise ;)
18:31:56 <tusho> e.g. NEG is pretty pointless
18:31:58 <tusho> you can just do 0 -
18:32:09 <AnMaster> tusho, hm true, maybe for speed reasons?
18:32:24 <tusho> AnMaster: can't think why it'd be much faster
18:32:37 <tusho> AnMaster: can't you do it with a XOR
18:32:52 <AnMaster> well two's complement is what I plan for
18:33:01 <tusho> AnMaster: two's complement:
18:33:02 <AnMaster> as to begin with I will write interpreter in C
18:33:17 <tusho> former is likely quicker
18:33:23 <AnMaster> I do lack bitwise NOT it seems
18:33:34 <tusho> yeah, replace neg with BNT
18:33:42 <tusho> then {BNT,INC} is NEG
18:33:46 <tusho> and a darn fast neg at that
18:34:34 <tusho> AnMaster: i'd keep to 3-char mnemonics
18:34:40 <AnMaster> tusho, I can't do that everywhere
18:34:42 <tusho> I'd personally call it NOT, boolean not is lame
18:35:14 <tusho> AnMaster: also, boolean not is:
18:35:20 <AnMaster> all of NOT/XOR/OR/AND should be bitwise
18:35:43 <tusho> boolean versions can be built trivially from it
18:35:51 <AnMaster> OMG HOW DO I MAKE THE "OR" instruction 3 chars long?!
18:36:25 <tusho> AnMaster: suggestion - FTRUNC -> FTNC
18:36:51 <AnMaster> what about the other long ones?
18:36:59 <tusho> AnMaster: FFLOOR -> FFLR, probably
18:37:18 <tusho> it's okay as it is
18:37:44 <tusho> just leave PUSH as it is :-P
18:37:46 <tusho> really, just leave em as is
18:37:54 <tusho> PSH isn't mnemonic
18:38:05 <tusho> AnMaster: okay, okay, fine, I was wrong when I said 3 chars
18:38:07 <tusho> just leave it as it is :-P
18:38:11 <tusho> anyway PUSH is better because it's a real word
18:38:20 <tusho> PSH could be Poppy Shaver Hair
18:38:25 <AnMaster> what about: SUB -> SUBSTRACT then?
18:38:32 <tusho> because SUB is widely understood :-P
18:38:54 <tusho> perl uses 'sub' for functions
18:39:15 <tusho> AnMaster: you can do crazy things with perl function prototypes:
18:39:21 <tusho> sub L(\&) { shift }
18:39:27 <AnMaster> well you can do crazy things in perl I know...
18:39:29 <tusho> L { $_[0] + $_[1] } <-- a closure lambda thingy
18:39:38 <tusho> AnMaster: explanation - the prototypes can change how the arguments are influenced,
18:39:43 <tusho> perl doesn't require parens around function calls,
18:39:48 <tusho> and \X means 'reference to something of X'
18:39:53 <tusho> e.g. \@ is a listref
18:40:00 <tusho> and, & means 'subroutine'
18:40:06 <AnMaster> well I know perl is mad and I don't know perl apart from a very basic level
18:40:11 <tusho> so: sub L(\&) is saying that the argument is a subroutine reference
18:40:18 <tusho> thus, if we pass in a block of code, it gets returned as a reference
18:40:22 <tusho> and we have a function creator
18:40:29 <tusho> sub sub(\&) { shift }
18:40:39 <tusho> (though you couldn't do that, obviously, because sub is a keyword)
18:40:46 <AnMaster> was just about to ask about that
18:40:47 <tusho> (and even if you did the resulting 'sub' wouldn't be able to do the prototypes itself, ironically)
18:41:21 <tusho> AnMaster: well, we want L to return the lambda it gets
18:41:29 <tusho> functions arguments are put in the array @_
18:41:35 <tusho> 'shift' shifts a value of the top of an array
18:41:38 <tusho> if no array is given, it assumes @_
18:41:43 <tusho> so for one param functions, you do:
18:41:48 <AnMaster> however no "return" statement?
18:41:53 <tusho> my ($foo, $bar, $baz) = @_;
18:42:02 <tusho> AnMaster: the last expression is implicitly returned... kinda like a functional language
18:42:09 <tusho> it's crazy how perl has convenient closures and all that
18:42:12 <AnMaster> http://rafb.net/p/sAtIyw42.html
18:42:22 <tusho> AnMaster: RDB seems a bit silly
18:42:24 <tusho> does any arch do it like that?
18:42:33 <tusho> if you have 'double' and 'float'
18:42:34 <tusho> in the same program
18:42:39 <tusho> it'll be flipping each time you use them'
18:42:51 <AnMaster> tusho, well you got a better idea
18:42:51 <tusho> also, R8/16/64 is a bit silly
18:42:56 <tusho> machines only ever have N-bit
18:43:11 <tusho> AnMaster: amd64 is crazy, though
18:43:17 <tusho> because it has to deal with backwards compat to an insane degree
18:43:32 <AnMaster> but 64-bit always is just a waste!
18:43:40 <tusho> AnMaster: make it 32-bit then
18:43:40 <AnMaster> so what do you suggest? different ADD instructions?
18:43:42 <tusho> it's never hurt anyone ;)
18:43:49 <AnMaster> tusho, I want the *ability* to use 64-bit
18:44:01 <tusho> AnMaster: then you'll be stuck with bloat or always using 64 bit..
18:44:05 <tusho> i'd just use 32-bit
18:44:11 <tusho> it'll be fine for this :-P
18:44:31 -!- Corun has quit ("This computer has gone to sleep").
18:44:34 <tusho> AnMaster: well exactly
18:44:40 <tusho> you could support 349856794573489573495-bit all the time
18:44:47 <tusho> but 32-bit is probably best for this
18:44:55 <tusho> you can do just about anything, and it's simple enough to code with neatly manually in
18:44:58 <AnMaster> 349856794573489573495 == how many GB?
18:45:38 <tusho> 'You only have Some GB left of your A Lot GB hard-drive! Please delete some files.'
18:45:52 <AnMaster> heh? something actually said that?
18:46:23 <AnMaster> 349856794573489573495 / 8 = 43732099321686196686 bytes
18:46:48 <RodgerTheGreat> make these suckers 8-bit- it'd be way more fun. Anybody can do 32 bit
18:46:58 <tusho> RodgerTheGreat: AnMaster would never sacrifice that much
18:47:04 <AnMaster> (why is bc rounding like that!)
18:48:00 <tusho> 1 shitlytes = 43732099321686196686 bytes
18:48:18 <AnMaster> shitbytes not shitlytes right?
18:48:26 <tusho> AnMaster: i morphed shitload into shitlytes
18:48:52 -!- augur has quit (Read error: 104 (Connection reset by peer)).
18:49:09 -!- augur has joined.
18:49:26 <AnMaster> tusho, anyway I can se a reason for 128-bit computers
18:49:32 <AnMaster> makes it simpler to work with ipv6
18:50:04 <AnMaster> a 32-bit computer can just do one fourth of an ipv6 url in a register
18:50:40 <tusho> AnMaster: base 256 computer!
18:50:55 <tusho> AnMaster: strings are trivial
18:51:11 <tusho> unicode is for hippies
18:51:20 <tusho> i see no reason to accomadate THOSE types.
18:51:25 <AnMaster> ööööööööööööååååååååååääääääääääääääää
18:51:32 <tusho> AnMaster: DIRTY FORNER
18:51:50 <AnMaster> tusho, Så du pratar bara engelska?
18:52:13 <tusho> shush, I was being sarcastic
18:52:25 <tusho> RodgerTheGreat: he's still a DIRTY FORNER.
18:52:33 <AnMaster> RodgerTheGreat, I sent them as utf8
18:52:34 -!- timotiis has quit (Connection timed out).
18:52:47 <tusho> oh, and I know a little bit of lojban, thank YOU :P
18:53:10 -!- Corun has joined.
18:53:29 <tusho> AnMaster: Lojban can't pronounce my name properly. :-P
18:53:35 <tusho> .Eli,at.xrd. approximates it
18:53:48 <tusho> AnMaster: dude, we're talking about lojban the human language here
18:53:48 <AnMaster> tusho, this is a constructed language?
18:54:04 <tusho> the most popular geeky one nowadays
18:54:10 <tusho> (i.e. apart from esparanto & etc)
18:54:37 <AnMaster> btw I think my asm shall have 128 general purpose registers (+ some other like program counter and such)
18:54:49 <tusho> 128?!?!?!?!?!?!?!!?
18:54:55 <tusho> you'll never be able to keep track of that
18:55:12 <tusho> AnMaster: ppc is pretty crazy as is
18:55:19 <tusho> 10 is about as much as you could keep in your head, i imagine
18:55:25 <tusho> as long as you give them decent names
18:55:26 <AnMaster> maybe I'll do like sparc then?
18:55:33 <AnMaster> have a moving register window?
18:55:45 <tusho> i'd just use 10 registers with nice names
18:55:46 <tusho> it's a nice number
18:56:06 <AnMaster> um. I'd use %r1, %r2 and so on
18:56:17 <tusho> yeah, that's not good ;)
18:56:23 <tusho> 10 _well-named_ ones will make programming abreeze
18:56:38 <tusho> AnMaster: 'oh, I need to use %r4 to %r7 the %r3'
18:56:52 <tusho> and I assume you were joking there
18:57:15 <AnMaster> but a lot of registers are good
18:57:26 <tusho> not if you wanna code in it
18:57:27 <AnMaster> maybe I'll write a compiler to this bytecode later
18:57:37 <AnMaster> tusho, why would I need to use them all?
18:57:47 <tusho> but 10 should be _enough_
18:57:55 <AnMaster> tusho, yet x86 is register starved
18:58:04 <AnMaster> amd64 got 16 general purpose registers iirc
18:58:06 -!- bsmntbombdood has joined.
18:58:26 <AnMaster> tusho, how would you name your registers?
18:58:32 <RodgerTheGreat> tusho: Have you ever done any serious coding in a RISC assembly language?
18:58:41 <tusho> RodgerTheGreat: define serious
18:58:54 <tusho> anyway AnMaster's instruction set is pretty big
18:59:10 <RodgerTheGreat> I coded reversi in MIPS- something like 3000 lines of assembly- and I needed every register I had.
18:59:14 <AnMaster> tusho, remove the optional floating point co-processor and it is small!
18:59:27 <RodgerTheGreat> I could've done it with about 3, but it would suck, and it would've been easier with more
18:59:28 <tusho> AnMaster: but read his instruction set
18:59:32 <tusho> 10 should be enough
19:00:00 <AnMaster> anyway have you see the amd64 instruction set?
19:00:22 <tusho> yes, well it's ReallyCISC
19:00:30 <tusho> insanely big instruction set computer
19:00:43 <RodgerTheGreat> AnMaster: you're missing some important stuff and I think the floating-point stuff is a waste, especially this early in the design phase
19:01:02 <AnMaster> RodgerTheGreat, well the floating point co-processor is sold separately!
19:01:11 <AnMaster> RodgerTheGreat, and what important things?
19:01:20 <AnMaster> setting stack base? that will be the st0 register
19:01:28 <AnMaster> and stack top will be another register
19:02:00 <AnMaster> RodgerTheGreat, and yes I need something for heap
19:02:04 <RodgerTheGreat> it's pretty amusing that you have a language wherein the only real storage you have access to is the stack and you can't roll, swap or easily duplicate stack entries
19:02:31 <RodgerTheGreat> what is with you people and heaps? you shouldn't implement heaps at the CPU level
19:02:39 <tusho> RodgerTheGreat: it's pretty amusing that you have a language wherein the only real storage you have access to is the stack and you can't roll, swap or easily duplicate stack entries
19:03:03 <tusho> RodgerTheGreat: i don't know why you're getting so heated about it
19:03:24 <RodgerTheGreat> I'm not flaming, I'm saying he's growing it in the wrong directions
19:03:31 <AnMaster> RodgerTheGreat, so you mean I should simulate a MMU?!
19:03:57 <RodgerTheGreat> I'm saying you should support atomic operations like storing to and loading from an arbitrary memory location
19:04:04 * AnMaster ponders adding a MALLOC instruction just to irritate, (just kidding)
19:05:14 <RodgerTheGreat> and as I said, your stack is crippled in usefulness because you can only touch the top element
19:05:23 <AnMaster> ; from a register or from memory
19:05:36 <AnMaster> RodgerTheGreat, and no you can touch below
19:06:10 <AnMaster> RodgerTheGreat, because you can get stack base from the "special purpose" register st0 or something like that, and stack top from st1
19:07:41 <RodgerTheGreat> there's a difference between "is possible" and "is practical"- it would take 4 or 5 instructions to recall an arbitrary depth from your stack the way the instruction set works now
19:07:48 <AnMaster> MOVRR ; Copy one value from a register to another.
19:07:48 <AnMaster> MOVMR ; Copy one value from the main memory to a register.
19:07:48 <AnMaster> MOVRM ; Copy one value from a register to the main memory.
19:07:48 <AnMaster> MOVMM ; Copy one value within the main memory.
19:08:11 <AnMaster> RodgerTheGreat, and well I will have 128 general purpose registers. ;P
19:09:00 <RodgerTheGreat> it also doesn't make a lot of sense to be able to move values directly between memory locations- that would be an insanely slow operation in real life and it defeats the purpose of having registers in the first place
19:09:38 <AnMaster> ok, just to irritate you all I will add a compare-and-exchange atomic instruction
19:09:40 -!- kar8nga has joined.
19:09:44 <AnMaster> not that I will add SMP for quite a while
19:10:34 <AnMaster> also MOV itself could be asm side, it will select what MOV variable is the correct one to use
19:11:36 <RodgerTheGreat> defining pseudo-ops is another step entirely from designing the assembly language
19:12:12 -!- kar8nga has left (?).
19:12:16 <AnMaster> ; * To get double precision change the prefix F to FD.
19:12:35 <AnMaster> change the instruction name for double
19:12:41 <tusho> AnMaster: probably, yes
19:12:47 <tusho> think of how many bits you need to use for an instruction
19:13:15 <tusho> AnMaster: you could do something like
19:13:36 <AnMaster> tusho, yes? food is ready. will read when I get back in a few minutes
19:32:06 <AnMaster> anyway I will add swap/dup for stack
19:32:44 <tusho> AnMaster: also why not 'dip'
19:32:47 <tusho> you can do it non-functionally:
19:32:54 <tusho> dip = take the top element off the stack
19:32:57 <tusho> undip = put it back
19:33:07 <tusho> to remove the second element on the stack:
19:33:09 <AnMaster> that's push and pop aren't they?
19:33:15 <tusho> AnMaster: well, kinda
19:33:20 <tusho> AnMaster: you can nest
19:33:28 <tusho> dip dip pop undip pop undip
19:33:29 <AnMaster> I was just going to mention another idea: reverse instruction pointer direction
19:33:32 <tusho> remove second and third elements of the stack
19:34:07 <tusho> AnMaster: dip dip pop undip pop undip
19:34:08 <tusho> see how that works?
19:34:19 <tusho> you can build a LOT of stack operations on top of dip/undip
19:36:02 <tusho> AnMaster: i like dip/undip, a lot
19:36:09 <AnMaster> tusho, for each instruction that can take a 32-bit value there is a instruction with the same name but the suffix: 64
19:36:11 <tusho> a b c TOP -> b a c TOP
19:36:31 <AnMaster> tusho, so where does dip/undip put the values?
19:36:49 <tusho> AnMaster: yeah, probably
19:37:03 -!- Corun has quit ("This computer has gone to sleep").
19:37:15 -!- oerjan has joined.
19:37:38 <AnMaster> tusho, what about my "64" suffix idea?
19:37:46 <tusho> AnMaster: you should pick one ;)
19:37:52 <tusho> just do 32-bit, sheesh :P
19:40:03 <tusho> AnMaster: confused endian
19:40:20 <tusho> MOST IMPORTANT LEAST IMPORTANT ... SECONDLEAST IMPORTANT SECONDMOST IMPORTANT
19:40:46 <AnMaster> well the perl configure did check for it
19:41:06 <tusho> AnMaster: what, confused endien?
19:41:25 <tusho> AnMaster: just wow
19:41:31 <AnMaster> it said something like "checking your endianness"
19:41:32 <tusho> it's esoteric, certainly
19:41:40 <AnMaster> and then saying "if output is blah" then big endian
19:41:56 <AnMaster> if different you use mixed endian
19:42:02 <tusho> AnMaster: ok, but I don't think it's mine
19:42:15 <tusho> 5 is most important (largest)
19:42:17 <tusho> mine goes like this:
19:42:18 -!- ihope___ has joined.
19:42:32 -!- ihope___ has changed nick to ihope.
19:42:44 <tusho> AnMaster: well, mine is crazier
19:43:02 <AnMaster> http://en.wikipedia.org/wiki/Endianness#Middle-endian
19:43:23 <tusho> AnMaster: well, that's not mine
19:43:26 <tusho> mine is totally confusing
19:43:34 <AnMaster> tusho, agreed, but it is still "unusual"
19:43:47 <AnMaster> and I'm going for little endian then?
19:44:01 <tusho> for no real reason
19:44:14 <AnMaster> tusho, little is simpler on x86_64
19:44:32 <AnMaster> but I need to check at compile time of interpreter I guess for endianness
19:44:58 <AnMaster> tusho, look network byte order is big endian
19:45:11 <tusho> AnMaster: your machine is 'internet ready'
19:45:13 <AnMaster> so that means a slowdown on little endian systems?
19:45:14 <tusho> if you do big endian
19:45:33 <fizzie> I've used ARM's "feature" of strange rotations on misaligned full-word writes (mentioned in that Wikipedia section) once when writing assembly for the Nintendo DS. (Well, tried to use; the emulator I used actually did it wrong.)
19:45:39 <AnMaster> thus it is only fair that the little endian systems gain a bit of speed elsewhere!
19:45:39 <tusho> i was the one who suggested big endian
19:45:51 <tusho> fizzie: you know, you are the best contributor to #esoteric. :-P
19:47:07 <fizzie> I've forgotten the specifics. I think it was in thumb mode, so actually doing the corresponding rotation would have meant one more instruction.
19:47:52 <fizzie> Thumb mode is the one where the opcodes are 16-bit, instead of the 32-bit "ARM mode".
19:48:07 <tusho> a real world example of it
19:48:18 <tusho> AnMaster: of the thing you were doing
19:48:29 <AnMaster> tusho, well amd64 already have it
19:48:47 <AnMaster> and I dropped it for suffixes after what you said!
19:49:27 <AnMaster> tusho, anyway I will soon need a 64-bit value for the opcode itself ;)
19:49:51 -!- augur_ has joined.
19:49:55 <AnMaster> I think I will use 16 bits for the opcode, for future compatiblity
19:50:05 <tusho> AnMaster: j/k, right?
19:50:25 <tusho> executables will be insanely huge
19:50:29 <AnMaster> what will you do/say if I say 1) yes 2) no
19:50:47 <tusho> 2) no - i will kill you as you sleep
19:51:00 -!- augur_ has changed nick to psygnisfive.
19:54:28 <ihope> Use 16 bits for opcodes, but then make all executables compressed?
19:54:33 <ihope> With very lightweight compression such as Huffman coding or something.
19:55:55 <tusho> AnMaster: that won't fit nicely
19:56:17 <ihope> If 90% of your code consists of one opcode, that one opcode can be 0 and the rest can start with 1.
19:56:53 <ihope> What are you designing, anyway?
19:57:09 <AnMaster> ihope, an assembly language + byte coder interpreter
19:58:18 <AnMaster> anyway what about 8 bits by default, unless the the value is 255, then see next 16 bits for more details?
19:58:29 <AnMaster> I will need variable width for arguments anyway
19:58:29 -!- augur has quit (Connection timed out).
19:59:51 <ihope> So 255 of the opcodes are xxxxxxxx minus a small fraction of a bit, 65536 of them are 11111111xxxxxxxxxxxxxxxx.
20:00:34 <ihope> Do you think that 255/256 of the opcodes in a file will be eight-bit opcodes?
20:01:55 <ihope> More reasonable, I think: there are 240 8-bit opcodes, which are xxxxxxxx where the first four bits are not all 1, and 65536 16-bit opcodes, which are 1111xxxxxxxxxxxxxxxx.
20:02:19 <AnMaster> ihope, for now I don't have that many instructions
20:02:22 <ihope> You lose 15 possible 8-bit opcodes, but then the 16-bit opcodes are four bits smaller.
20:02:33 <AnMaster> ihope, and yes that sounds good
20:02:59 <ihope> Maybe the 16-bit opcodes can be 1111xxxxxxxxxxxx, even, only 12 bits of actual opcode data, but still quite a bit.
20:07:36 -!- sebbu2 has joined.
20:09:36 <AnMaster> ihope, should the program counter register be read only?
20:10:06 <AnMaster> well only way to change would be JMP and such really, wouldn't it?
20:10:32 <ihope> Now you can use a SET (or LOAD or whatever) instead of a JMP and perhaps save... something.
20:10:55 <AnMaster> also we need to support PIC code don't we?
20:12:09 <AnMaster> used in *.so on linux for example
20:12:43 <AnMaster> in fact most arches except x86 *need* PIC in *.so
20:14:52 <AnMaster> tusho, ihope: How much ram (and if "decided at runtime": how to let program find out?)
20:15:01 <tusho> AnMaster: you are bikeshedding a bit
20:15:51 <ihope> Decided at runtime.
20:15:51 <tusho> AnMaster: decided at runtime, and don't let the program find out
20:15:57 <tusho> it never needs to, really
20:16:01 <tusho> i don't know of any arch that can do that
20:16:07 <tusho> maybe x86_64, which can make you toast
20:16:20 <tusho> AnMaster: oh, not sure how that works
20:16:28 <tusho> try and access high memory addresses
20:16:32 <tusho> the first segfault is your limit ;)
20:16:57 <AnMaster> well I vote for ID instruction
20:17:18 <AnMaster> lets say: at least x kb but additional can be available: check with ID instruction?
20:20:16 <tusho> AnMaster: i don't vote
20:20:37 <AnMaster> actually, lets make it a special purpose register
20:21:25 <AnMaster> only special purpose registers that are needed are stack base/top, program counter and exception table
20:21:39 <AnMaster> exception table is a jump table for exceptions
20:22:56 <AnMaster> tusho, anyway I need a way to be able to write to a single byte in the memory or read from one
20:23:06 <AnMaster> so MOV* will have 8 suffixes variants too
20:23:50 -!- sebbu has quit (Read error: 110 (Connection timed out)).
20:42:14 -!- sebbu2 has quit (Read error: 104 (Connection reset by peer)).
20:50:39 -!- timotiis has joined.
20:53:33 <oklopol> 20:35… × AnMaster runs <<< you would probably be a very weird guy to have an irl conversation with.
21:02:00 <AnMaster> +---------------+---------------+-------------------------------+-----
21:02:00 <AnMaster> | 16 bits | 16 bits | 32 bits | ...
21:02:00 <AnMaster> +---------------+---------------+-------------------------------+-----
21:02:00 <AnMaster> | Magic word | Size of table | First Pointer | ...
21:02:00 <AnMaster> +---------------+---------------+-------------------------------+-----
21:02:14 <AnMaster> YAY I ALWAYS WANTED SUCH A DIAGRAM!
21:02:27 <AnMaster> (yes really, I always wanted a bit diagram)
21:03:35 <AnMaster> tusho, anyway this is the page table
21:03:38 -!- Corun has joined.
21:03:52 <AnMaster> where the program jumps on errors
21:04:09 <AnMaster> like: invalid opcode, invalid address, invalid <other>
21:05:27 -!- sebbu has joined.
21:09:28 <tusho> Hmm. More people should use #pfft. :P
21:11:30 -!- calamari has joined.
21:15:31 -!- kar8nga has joined.
21:15:41 <tusho> oklopol: so cool that oklopol won't grace its prescence
21:18:46 -!- Corun has quit ("This computer has gone to sleep").
21:21:59 <AnMaster> tusho, what was that last highlight about?
21:22:14 <tusho> tusho: AnMaster: basically, keeping #esoteric about esolangs.
21:22:23 <tusho> it isn't actually about gay sex, I was making a joke
21:22:26 <tusho> you know, these weird things
21:22:35 <AnMaster> well I don't have time for off topic chat
21:22:51 <tusho> AnMaster: you're much too busy making pointless things? :-P
21:25:12 -!- kar8nga has left (?).
21:26:38 -!- timotiis_ has joined.
21:35:38 <SimonRC> # I wanna limo at the airport / and one at the hotel '
21:35:56 <SimonRC> # A limo for my minder / and my analist as well #
21:36:10 <SimonRC> # A limo for my make-up girl / a limo for my dog #
21:36:25 <SimonRC> # A limo parked beside the bed / to drive me to the bog. #
21:37:17 -!- timotiis has quit (Read error: 113 (No route to host)).
21:37:39 <SimonRC> oops, maybe I repelled him
21:37:53 -!- Corun has joined.
21:37:56 <SimonRC> oops, no, different version
21:43:00 -!- timotiis_ has changed nick to timotiis.
21:44:01 <oklopol> i'm richer than all of you put together
21:44:07 <oklopol> well not really, but you know.
21:44:26 <Slereah_> Even ais and his Turing money? :o
21:44:42 <oklopol> in the sense of not meaning anything by that, yes.
21:51:22 <SimonRC> Slereah_: I thought it was the Wolfram prize?
21:51:56 <Slereah_> It's like blood money, made from blood
21:56:10 <SimonRC> how finely can one draw the line between executable regions and writable regions on the x86?
21:56:26 <Slereah_> I don't even know what that means, I can't help you much
22:09:31 <oerjan> about 7000 nanometers. hope this helps.
22:11:05 <Slereah_> 7000 nanometers is a silly unit
22:11:34 <oerjan> no it isn't. it's exactly the same length.
22:11:45 <SimonRC> I mean, on a byte level or on a page level?
22:12:03 <SimonRC> or to some other degree of granularity?
22:12:14 <Slereah_> So is 7.39916387 10^-22 light years
22:12:20 <Slereah_> That doesn't make it less silly
22:12:54 <SimonRC> 'cause it might be nice to be able to write a Forth where every word was non-executable unti lit was finished, whereupon it became executable but not writable.
22:17:30 <fizzie> I think x86-64 does it on a per-page granularity; while old x86 only has a per-segmet-descriptor memory protection bit, which doesn't really help any.
22:18:24 <fizzie> At least that's what I remeber from the explanations of OpenBSD's "W^X" security feature and why it only works on more sensible hardware.
22:19:11 <fizzie> Wikipedia article of "NX bit" is probably friendly.
22:25:12 -!- Corun has quit ("This computer has gone to sleep").
22:29:37 <tusho> Slereah_: Presumably he spent it on university.
22:29:45 <tusho> That seems an aisy thing to do.
22:37:53 -!- Slereah2 has joined.
22:37:53 -!- Slereah_ has quit (Read error: 104 (Connection reset by peer)).
22:38:13 <Slereah2> How expensive is British university?
22:39:04 <Slereah2> Here, you could get like 500 years of inscription for it for 25.000 euros
22:43:02 <SimonRC> depends on how rich you are
22:43:21 <SimonRC> you get extra cash/loans if you are "poor"
22:43:28 -!- Corun has joined.
22:44:16 <Slereah2> I'm glad to be in this socialist dictatorship.
22:44:57 <tusho> ais would spend it on uni anyway
22:46:11 <SimonRC> you just figure out the complete set of moral values, then follow them
22:47:27 -!- Corun has changed nick to TheFlash.
22:47:32 -!- TheFlash has changed nick to Corun.
22:51:39 -!- ihope has quit (Read error: 60 (Operation timed out)).
22:52:27 <Slereah2> I should try to program shit in Thue.
22:54:39 <SimonRC> ooh, nice: http://llvm.org/demo/
22:56:28 <SimonRC> Slereah2: your could invent a benchmark called "shit"
22:56:39 <SimonRC> then you could literally program shit in Thue
22:57:45 <Slereah2> The shit programming language, to test metalanguages? :o
23:01:50 <Slereah2> Are the ++ used for representing any string?
23:02:02 <Slereah2> I can't really find a complete description of the language
23:17:18 <AnMaster> Slereah2, I wonder same as Slereah2 about Corun
23:17:35 <tusho> Presumably it was a joke in another channel
23:24:16 <Corun> Sorry about the temporary flash...
23:25:26 <Corun> And, it was a joke in another chunnel.
23:25:32 <Corun> tusho is very astute
23:26:32 <tusho> yep just a regular unspecial genius
23:26:34 <tusho> no accomplishments
23:27:18 <Slereah2> Your genius can be recognized, tusho
23:27:34 <tusho> a finite state machine is somethiing I wish I could be a clever as
23:27:51 <Slereah2> You're more of a bounded storage machine kinda guy
23:30:42 -!- olsner has quit ("Leaving").
23:30:54 -!- jix has quit ("This computer has gone to sleep").
23:30:55 -!- GregorR[Prague] has quit ("Leaving").
23:31:04 -!- ihope___ has joined.
23:31:18 -!- ihope___ has changed nick to ihope.
23:31:25 -!- GregorR[Prague] has joined.
23:35:13 -!- oerjan has quit ("Good night").