00:12:43 * oerjan gets this vision of GregorR talking with a soprano voice
00:13:56 <SimonRC> he talks like a nerd, not a geek
00:14:58 <oerjan> i meant, just from your comment, i haven't seen the video
00:17:21 -!- sebbu has quit ("@+").
00:21:58 <GregorR> SimonRC: Yes yes, I have an ultra-nasal voice.
00:24:48 <pikhq> GregorR: You sound a good deal different when singing.
00:27:28 <GregorR> I don't like my voice, but I've decided to live with it :P
00:27:56 * pikhq likes being a bass. ;)
00:28:06 * SimonRC reads how Richard Feynmann killed a guy: http://www.museumofhoaxes.com/comments/papparticle2.html
00:29:12 -!- GreaseMonkey has quit ("rebooting to test config file").
00:47:51 -!- GreaseMonkey has joined.
01:01:21 -!- GreaseMonkey has quit ("testing something, brb").
01:02:48 -!- GreaseMonkey has joined.
01:03:33 <pikhq> http://pikhq.nonlogic.org/bfi.c Yeah, I'm bored.
01:04:58 -!- GreaseMonkey has quit (Client Quit).
01:05:12 <fax> is easier to write a BF compiler in C
01:05:35 <pikhq> More fun to write one in BF.
01:07:56 <RodgerTheGreat> I wonder if there is such a thing as vocal chord plastic surgery.
01:08:02 <fax> I never saw that
01:08:27 -!- GreaseMonkey has joined.
01:12:55 <pikhq> One can simulate the effects by going to China and signing up for an experiment on vocal chord replacement or something. :p
01:16:15 <pikhq> (I'm not donating.)
01:17:06 * GregorR imagines looking at the catalog: "Patrick Stewart, no ... Pavarotti, no ... Aha - yes, I'd like the Mike Rowe. Thank you."
01:17:33 <RodgerTheGreat> I imagine it'd be much easier to just make alterations that to create a specific voice
01:18:13 <RodgerTheGreat> modify voicebox dimensions a bit with the old cut-and-splice tricks in normal surgery, voila.
01:18:14 <GregorR> <GregorR> *joke* <RodgerTheGreat> *disassembles joke into unfunny anecdote*
01:18:42 <RodgerTheGreat> don't even start telling me *I'm* overly analytical, GregorR
01:21:29 <GregorR> http://www.komotv.com/news/local/8355142.html
01:22:13 <Sukoshi> That would be a classic assertion-assertion-defense-counterdefense pattern.
01:26:59 -!- RedDak has quit (Remote closed the connection).
01:31:19 <Sukoshi> suifur: Ah, then my suspicions were correct.
01:38:15 <pikhq> GregorR: I, however, *am* overly analytical.
01:52:38 <RodgerTheGreat> hey, guys- I just put the finishing touches on the game I've been building this week- check it out! http://rodger.nonlogic.org/games/steamlock/
01:54:33 <suifur> Sukoshi: that worked out for you then i assume?
01:55:26 <suifur> RodgerTheGreat: i feel like enemies are almost too fast at times in the game
01:55:48 <RodgerTheGreat> overall, what do you think about the "feel" of gameplay?
01:55:53 <Sukoshi> suifur: Well, it's certainly different.
01:56:06 <Sukoshi> As I'm coding Java, my brain is competing between C-style and dynamic-style.
01:56:09 <suifur> Sukoshi: referring to class hierarchy?
01:56:51 <Sukoshi> I've become accustomed to dynamic OOP, which often allows you to return variable types of objects, but making sure that, as long as your object responds to a certain message, it's alright.
01:56:56 <fax> RodgerTheGreat: cool! I love the graphics
01:56:56 <suifur> Sukoshi: well the biggest thing I always had problems with is I felt like class hiearchies were going to make the code bloated but after studying java more i've realized that classes don't make a terrible impact
01:57:25 <Sukoshi> I can do that here too but, I'd have to use Object types, which is pretty much like a type checked void* .
01:57:28 <GreaseMonkey> ok, my java is b0rked. i'll go try on the family PC.
01:57:34 <Sukoshi> So it feels very ... hackish.
01:57:37 <fax> RodgerTheGreat: cool, im a big fan of pixely graphics and monochrome :p
01:57:52 <suifur> Sukoshi: I've gotten a lot of good experience out of tweaking computational models in java
01:58:11 <fax> RodgerTheGreat: I think the ship moves a lot slower thna most games but its maybe not a bad things, just like it has a lot of intertia
01:58:11 <RodgerTheGreat> fax: you should try out the demo I have online of another game I'm working on: http://rodger.nonlogic.org/games/CRPG/
01:58:32 <pikhq> suifur: Try an adventure game. :p
01:59:44 <suifur> RodgerTheGreat: i like the feel of the gameplay overall, just feel like the enemies are almost too fast
01:59:54 <suifur> \though maybe it should ease into the waves
02:00:11 <fax> I got to make a game :S
02:00:43 <RodgerTheGreat> I'm gathering feedback from everyone that tries it out
02:01:42 <fax> RodgerTheGreat: to make it amazing (the shmup) I would make the actual game canvas bigger and have some bosses at some point
02:02:16 <RodgerTheGreat> many people have asked about bosses- I plan to have them in the multiplayer sequel
02:25:18 <GregorR> The 3D AJAX multiplayer sequel using my JS 3D library.
02:25:45 <RodgerTheGreat> I dunno about that. Javascript multiplayer sounds painful. :[
02:26:09 <RodgerTheGreat> you should definitely make a game out of that thing, though, gregor-
02:28:32 <GreaseMonkey> although for compatibility, it'd be great to have a JavaScript version
02:29:20 <Sukoshi> RodgerTheGreat: Do you think a Smalltalk->JVM-bytecode compiler would be better?
02:30:08 <Sukoshi> RodgerTheGreat: As I was at Borders this afternoon, I loafed in the computer section (yeah, a teenage girl in the computer book section, weird enough), and I read through interesting portions of the Java Cookbook, particularly the portions on Introspection.
02:31:00 <Sukoshi> I was wondering if we could parse directly to Java bytecodes, but that would probably be a lot of work and not as referrentially transparent for the end user.
02:31:15 <RodgerTheGreat> jesus- I can only imagine how painful this would be to make in JS
02:31:54 <oerjan> you don't want Java for referential transparency, try Haskell :D
02:32:09 <Sukoshi> RodgerTheGreat: If it's too tricky, then I think it's a waste of time.
02:32:36 <RodgerTheGreat> well, mainly I just don't know jack about JVM bytecode. We'd have to learn it from scratch
02:33:45 <RodgerTheGreat> I think that doing it in a realtime fashion would be particularly difficult (because Smalltalk seems to typically be programmed with in an interactive fashion, to some extent)
02:34:22 <fax> i should learn a bit of java bytecode :/
02:34:33 <fax> eh? with what?
02:34:35 <Sukoshi> (I'm not in #lispcafe, by the way, for saving RAM.)
02:34:59 <Sukoshi> I've fallen in love a bit with Smalltalk and wanted to do it justice by implementing a Smalltalk VM in Java.
02:35:49 <fax> well what I wanted to do was add the functionality to define new java classes in SISC
02:35:54 <RodgerTheGreat> fax: come, join our crack team of Java-philes and harken in a new era of Smalltalk virtualization!
02:36:07 <fax> wait so this is like a real project? :p
02:36:26 <RodgerTheGreat> what gave you the impression we were just blowing steam?
02:36:59 <oerjan> these projects are _always_ real until they peter out >:)
02:37:18 <fax> well you can upload bytecode directly to the JVM .. at runtime
02:37:25 <fax> just generating it is probably tricky
02:37:40 <RodgerTheGreat> such little faith. I'll bet we get at least the smalltalk VM before we get bored and pick up something else. :)
02:37:59 -!- GregorR-L has joined.
02:38:20 <GregorR-L> HAW HAW HAW, ALL ZE KOOL KEEDS SPEEK IN ZE FEKK FRONSH ACCENT
02:39:01 <pikhq> Screw being cool, then.\
02:39:11 <pikhq> (already said as much)
02:39:19 <fax> one problem .. I dont know any smalltalk :P
02:39:22 <oerjan> VY NOT IN DE FEK SKANDINAVIAN ACCENT?
02:39:26 <fax> (and I assume you'd write it in smalltalk?)
02:39:45 <pikhq> oerjan: FEK IT ES NAWT.
02:39:59 <Sukoshi> fax: Play with a Smalltalk book then.
02:40:11 <fax> its walrus it woody woodpecker!
02:40:18 <pikhq> No' is the British accent.
02:40:39 <oerjan> pikhq: Jolly good chap, wot!
02:40:43 <Sukoshi> fax: http://www.iam.unibe.ch/~ducasse/FreeBooks.html <-- Havas unun bonan tempon kiel vi legos cxi tiujn librojn.
02:41:14 <fax> have you read many? which would you recommened?
02:41:22 <Sukoshi> Have I read many? Heck no.
02:41:30 <Sukoshi> Do I have any to reccomend? Possibly.
02:41:50 <Sukoshi> A Taste of Smalltalk, and Smalltalk by example. And the Squeak specific book if you want to play with Squeak.
02:42:50 <fax> so you have any road/codemap or anything done yeT?
02:44:24 <Sukoshi> pikhq: Estas possebla ke mi malmemorigxas cxi tiu vorto :(
02:44:46 <Sukoshi> fax: I made a rough map earlier with RodgerTheGreat yesterday. He can C/P it to you while I play a bit of TacticsA(J).
02:46:37 <pikhq> Sukoshi: Vidu en Lernu!-an vortaron.
02:46:42 <fax> grr I want books in one gigantic chunk.. not several small pdfs
02:46:54 <pikhq> Kaj la vorto estas "ebla", ne "possebla".
02:47:49 <fax> 'Smalltalk collections are 1 based rather than 0 based' :O
02:49:45 <fax> but I am now confused, how does the JVM come into this?
02:50:08 <oerjan> fax: they want to port smalltalk to it
02:50:54 <fax> oerjan: the link seems to suggest otherwise... :S
02:51:33 <oerjan> by "they", i mean "you" on this channel
02:55:45 <fax> you want to implement a smalltalk *vm* in java
02:55:58 <fax> I thought you were wanting to write a smalltalk compiler to the JVM
03:09:42 -!- GreaseMonkey has quit (Remote closed the connection).
03:10:13 -!- GreaseMonkey has joined.
03:10:48 <fax> yeah why to implement a smalltalk in anything other than smalltalk? :p
03:11:39 <Sukoshi> pikhq: Sed, mi amas lerni Esperanto plej.
03:12:35 <Sukoshi> *Sigh* What part of the words ``a useful project'' did you not understand? :P
03:12:35 <fax> Sukoshi: Am I right in thinking you want to implement a language ontop some new VM written in a language built upon a VM?
03:12:50 <fax> thats crazy :P
03:13:00 <fax> why not just compile smalltalk to java bytecode?
03:13:03 <Sukoshi> fax: Well, would you rather implement a Smalltalk->Java compiler?
03:13:15 <Sukoshi> The thing is, would it give the user as much freedom?
03:13:34 <fax> ..when you could have 3 :P
03:14:02 <suifur> Sukoshi: Out of curiosity, why smalltalk at all? Do you know smalltalk?
03:14:05 <Sukoshi> fax: If you're up to doing the compile, I'm game.
03:14:21 <Sukoshi> suifur: Yeah. I've been playing with it, and I've come to like it more than Lisp (Heathen, yes).
03:14:27 <fax> Sukoshi: well I would not like to say that I am or not before finishing this scheme to c thing
03:14:41 <suifur> Sukoshi: I can't say whether thats heathen or not since I don't know lisp ;).
03:14:58 <fax> lisp is cool, def. worth trying at some point
03:15:18 <suifur> fax: its on my to-learn list, right after Scala/Smalltalk, Erlang and then Lisp
03:15:44 <Sukoshi> What say you, troupe -- a Smalltalk VM or a bytecode compiler?
03:16:01 <suifur> Sukoshi: The first thing I thought was a bite code compiler
03:16:11 <suifur> Sukoshi: Why would you implement a VM on top of a VM is my question
03:16:23 <suifur> why not write a VM to run on anything if you were to go that route?
03:17:07 <Sukoshi> suifur: Well, because Java has lots of cross platform libraries.
03:17:24 <Sukoshi> And because C is hardly portable :P (but if you do want to do it at a low-level, D probably would be.)
03:17:33 <suifur> Sukoshi: ok. So why not just create a bite-code compiler?
03:17:47 <Sukoshi> suifur: I want that, but my only concern is flexibility.
03:17:59 <suifur> Sukoshi: why would it cut flexibility/?
03:18:11 <Sukoshi> suifur: Because in a Smalltalk system, you should be able to customize just about *anything*.
03:18:27 <suifur> (I'm not trying to be annoying or dumb, I just honestly don't know these questions lol)
03:18:54 <suifur> Sukoshi: ah, hmmm. I see your point.
03:19:16 <suifur> Sukoshi: though done properly, I think the bytecode compiler could work well
03:20:16 <Sukoshi> suifur: Hmm. Then why don't you and RodgerTheGreat and fax toss around the point while I do my daily Japanese work? ;)
03:20:36 <suifur> daily japanese work eh?
03:20:42 <suifur> RodgerTheGreat: you still about?
03:20:58 <fax> Sukoshi: how do you keep it up -_-
03:21:00 <GregorR-L> The only reason C seems unportable is Windows.
03:21:33 <bsmntbombdood> The only reason asm seems unportable is other proccessors.
03:22:38 <suifur> fax: what do you think?
03:22:48 <fax> suifur: about what in particular?
03:23:06 <suifur> fax: vm on top of vm versus bytecode compiler?
03:23:20 -!- zbrown has changed nick to rufius.
03:23:23 -!- suifur has changed nick to zbrown.
03:23:28 <fax> ive only really skimmed the jvm notes before
03:23:51 <zbrown> fax: I'm assuming you know Java?
03:23:54 <fax> and I dont know smalltalk really well so I cant really tell if a bytecode compiler would have some flexability problems..
03:24:12 <Sukoshi> fax: Because I really love the language ;)
03:24:25 <fax> Sukoshi: what ?
03:24:40 <zbrown> hmmm, I wish #scala was more active. We could really learn a lot from them since they implemented scala to run in both .NET's CLR and JAv's JVM
03:24:46 <Sukoshi> http://users.ipa.net/~dwighth/smalltalk/bluebook/bluebook_imp_toc.html <-- For the discussion you two are doing.
03:29:35 <zbrown> fax: I feel like the vm within the vm could be an easier problem to solve than a bytecode compiler for smalltalk to java
03:50:03 <fax> you left :p
04:30:51 <GregorR-L> http://www.codu.org/dsss_tutorials/tut_environment.avi < Tutorial on setting up GDC+DSSS+Tango for newbies - opinions?
04:33:47 -!- immibis has joined.
04:44:20 <GregorR-L> I mean to post that in #d.tango <_<
04:44:28 <Sukoshi> D Something Something Something (else)
04:44:41 <GregorR-L> A community-driven D standard library.
04:44:55 <GregorR-L> bsmntbombdood: How'd you guess the expansion?
04:45:26 <Sukoshi> I was thinking D Socialist Society of Scripters.
04:45:57 <Sukoshi> GregorR-L: Does D have any cross platform GUI library?
04:46:30 <Sukoshi> GregorR: Then D has matured since I last saw it. Hmm.
04:47:12 <GregorR-L> There's a program (Tioport) to port (much) Java code to D, so SWT is ported automatically (pretty amazing).
04:49:46 <GregorR-L> It was unautomated and Windows-only, isn't supported anymore.
04:49:57 <GregorR-L> http://www.dsource.org/projects/tioport/ < has SWT
04:54:47 <Sukoshi> Hmm. This looks like a job for The Troupe Discussion.
04:55:11 <Sukoshi> RodgerTheGreat, zbrown, fax, ASSEMBLE!!! <-- What do you think of D, since it seems a lot more mature than last time, for a VM.
04:55:29 <fax> I hate D -_-
04:55:35 <Sukoshi> Oh yes, I missed that DSSS was originally written by Gregor Richards part, GregorR-L.
04:59:07 <fax> I dont know what to say except I am totally irrational... but please dont let that have any effect on your plans
04:59:07 <Sukoshi> Chirp chirp is a good reason, hmmm... *considers*.
04:59:53 <Sukoshi> I mean, if you say you hate D because you hate C, it's understandable, but....
05:00:16 <Sukoshi> Why couldn't it rape your father as well?
05:00:18 <bsmntbombdood> my name is GregorR-L, you killed my father, prepare to die
05:01:27 <bsmntbombdood> don't have to be queer to enjoy a warm, damp, tight cavity
05:01:37 <Sukoshi> ..............................
05:02:04 <Sukoshi> Talking about D led to this *shudder*.
05:02:11 <fax> Sukoshi: see :p
05:02:20 <Sukoshi> Well, any elaborations on your reasons, fax, other than this rape business?
05:02:25 <fax> D its just some bad vibe :P
05:02:42 <Sukoshi> Ah-hmm. Reason noted by fax.
05:03:00 <fax> the most purpose I can think is something like "fix C++s problems"
05:03:12 <Sukoshi> My main concern was that, fat managers like Java a lot more than D.
05:03:34 <bsmntbombdood> what is it with you and this stupid "practicality"
05:03:41 <GregorR-L> fax: Yeah, that's why Java exists. Only they fixed C++'s problems by removing them and all associated features.
05:04:39 <Sukoshi> I code in Esolangs or Scheme when I want to have fun, I code in other languages when I want to get things done.
05:04:56 <fax> Scheme is perfectly fine for getting stuff done!
05:05:48 * oerjan wonders if *chirp chirp* is some reference he doesn't get.
05:06:02 <Sukoshi> oerjan: Well, it sure hasn't been garbage collected yet.
05:06:06 <GregorR-L> oerjan: Sukoshi said it at a weird place :P
05:06:54 <oerjan> Sukoshi wasn't the first.
05:06:59 <fax> Sukoshi: lambda and code transforming macros, everything the body needs!
05:07:16 <fax> oerjan: crickets make the sound at the middle of the night when -nothing- is happening :P
05:07:19 <bsmntbombdood> on saturday june 11, 2005, at 06:15:14, GregorR said "You can put < and > in those, just not -->"
05:15:24 <GregorR-L> And that line is fascinating because ...?
05:21:04 <Sukoshi> Think of ``-->'' as a sexual organ.
05:23:39 <GregorR-L> I'm glad my penis doesn't look like that :P
05:24:27 <Sukoshi> I'm glad you're not adding graphic detail to that :P
05:24:45 <GregorR-L> Well, I don't want to flood the channel.
06:00:52 -!- GreaseMonkey has quit (anthony.freenode.net irc.freenode.net).
06:00:52 -!- GregorR-L has quit (anthony.freenode.net irc.freenode.net).
06:04:22 -!- GreaseMonkey has joined.
06:04:22 -!- GregorR-L has joined.
06:06:29 <pikhq> fax: You're quite right: everything the body needs is provided by Tcl.
06:06:49 <fax> wait Tcl has macros which dont suck?
06:06:53 * fax investigates
06:06:54 <pikhq> (well, except that lambda's not a *primitive*, but a fairly short, simple proc)
06:09:30 <pikhq> Anything more complex than doing macros via interp isn't primitive; merely trivial. ;)
06:12:50 <oerjan> and does it have correct scoping?
06:13:13 <pikhq> Depends upon the Tcl version. . .
06:13:54 <pikhq> The CVS version has it as a wrapper around the "apply" command (which takes a list and executes it as an anonymous function).
06:14:47 <pikhq> The stable version involves returning a temporary proc name; this lets the [lambda] feature work with the miriad Tcl functions that assume a proc is pass by reference.
06:14:49 <bsmntbombdood> you can do a doubly linked list and only use one word for the two pointers
06:14:59 <fax> what how??
06:15:06 <pikhq> bsmntbombdood: Yeah, but xor linking isn't worth it.
06:15:23 <fax> sho w meeeeee
06:15:27 <fax> I dont beleive it
06:15:44 <pikhq> http://wiki.tcl.tk/519 <-- Lambda implementations in the stable version of Tcl.
06:15:46 <fax> bsmntbombdood: now you cant access either
06:15:53 <GregorR-L> fax: The pointer is the xor of the previous and next. Since you're always going through it one way or another, you simply xor against the one you last saw.
06:16:07 <fax> but then you need to have two items
06:16:22 <fax> you cant store the head, you need to head and head of tail
06:16:38 <GregorR-L> Yeah, those are stored outside the nodes.
06:18:19 <fax> usually I store only the head...
06:18:30 <fax> oh well thats a neat trick
06:19:11 <bsmntbombdood> fax: no point in a doubly linked list without storing the tail
06:19:11 <GregorR-L> 1) GC. 2) Don't sacrifice readability and understandability for one word.
06:19:31 <bsmntbombdood> GregorR-L: obviously you can only do it in ungced languages...
06:19:32 <pikhq> http://wiki.tcl.tk/10743 <-- I think this is my favorite 8.4 Tcl implementation of anonymous, first-class functions. . .
06:20:14 <GregorR-L> Anybody want to help me make a game with my JS 3D engine? :)
06:25:06 <pikhq> GregorR-L: No, I want to oooh and aaah at something that turns functions into being first-class.
06:26:13 <bsmntbombdood> i think that's worthy of a few ooohs, but not if i don't know tcl
06:26:52 <pikhq> First step to make functions first-class: rewrite part of the interpreter. . . From within Tcl. :p
06:28:00 <pikhq> 39 lines of code for the whole thing.
06:30:09 <pikhq> But giving C lambda using C?
06:30:33 <pikhq> Tcl is given lambda. . . From pure Tcl.
06:30:35 <fax> you cant capture free vars
06:30:36 <GregorR-L> C already has first-class functions.
06:30:47 <pikhq> GregorR-L: But not anonymous ones.
06:31:30 <bsmntbombdood> actually, no, because cpp macros can't edit the toplevel
06:31:30 <pikhq> 39 lines of code for going from no anonymous functions, no first-class functions to having anonymous first-class functions.
06:33:10 <GregorR-L> Any language with anonymous functions has closures, they just may be a bit ugly.
06:33:24 * pikhq just tested; yeah, the 39 loc gives proper scoping.
06:33:55 <immibis> closures are local variables which are accessed after leaving the scope, right?
06:36:30 <oerjan> not quite, they are functions that access such variables
06:37:35 <oerjan> one more try, they are the function, bundled together with the variables
06:42:18 <oerjan> no, it's cata- or hylo- or something -morphic :)
06:50:14 <oerjan> catamorphic or hylomorphic
06:51:16 <oerjan> bsmntbombdood: you wouldn't know it was haskell if you weren't one too :D
06:52:10 <oerjan> (although strictly speaking it is more category theory, which some people occasionally import into haskell)
06:52:11 <bsmntbombdood> just because i know what haskell language sounds like doesn't mean i'm a haskeller
06:53:02 <fax> I wish I learned haskell a few years ago
06:53:33 <oerjan> bsmntbombdood: hey, i did happen do know math before i knew haskell
07:39:22 <Sukoshi> http://web.engr.oregonstate.edu/~budd/SmallWorld/ReadMe.html <-- Yay.
07:39:30 <Sukoshi> It's only an applet though, so we'll have to change that.
07:40:36 <fax> bsmntbombdood: I thought you said abstract machine
07:41:24 <fax> Sukoshi: I read a bit of those books
07:41:34 <fax> I think smalltalk looks very clear
07:59:59 -!- clog has quit (ended).
08:00:00 -!- clog has joined.
08:02:53 -!- Sukoshi has quit ("Leaving").
08:06:27 -!- ihope_ has quit (anthony.freenode.net irc.freenode.net).
08:06:27 -!- pikhq has quit (anthony.freenode.net irc.freenode.net).
08:26:08 -!- GreaseMonkey_ has joined.
08:26:50 -!- GreaseMonkey has quit (Nick collision from services.).
08:27:08 -!- GreaseMonkey_ has changed nick to GreaseMonkey.
09:01:59 -!- immibis has quit ("Rebooting").
09:21:51 -!- GregorR-L has quit ("Leaving").
10:07:31 -!- GreaseMonkey_ has joined.
10:07:39 -!- GreaseMonkey has quit (Nick collision from services.).
10:08:46 -!- GreaseMonkey_ has changed nick to GreaseMonkey.
10:32:45 -!- oerjan has quit ("lunch").
10:41:38 -!- RedDak has joined.
10:44:51 -!- GreaseMonkey has quit ("^ I'm with stupid").
10:51:10 -!- fax has changed nick to afx.
10:57:57 -!- afx has changed nick to fax.
11:52:13 -!- rufius has quit (anthony.freenode.net irc.freenode.net).
11:52:13 -!- RedDak has quit (anthony.freenode.net irc.freenode.net).
11:52:13 -!- fax has quit (anthony.freenode.net irc.freenode.net).
11:52:13 -!- helios24 has quit (anthony.freenode.net irc.freenode.net).
11:52:14 -!- tokigun has quit (anthony.freenode.net irc.freenode.net).
11:52:14 -!- Izzy7 has quit (anthony.freenode.net irc.freenode.net).
11:52:14 -!- zbrown has quit (anthony.freenode.net irc.freenode.net).
11:52:14 -!- RodgerTheGreat has quit (anthony.freenode.net irc.freenode.net).
11:52:14 -!- meatmanek has quit (anthony.freenode.net irc.freenode.net).
11:52:15 -!- lament has quit (anthony.freenode.net irc.freenode.net).
11:52:15 -!- oklopol has quit (anthony.freenode.net irc.freenode.net).
11:52:15 -!- cmeme has quit (anthony.freenode.net irc.freenode.net).
11:52:15 -!- fizzie has quit (anthony.freenode.net irc.freenode.net).
11:52:15 -!- mtve has quit (anthony.freenode.net irc.freenode.net).
11:52:15 -!- sp3tt has quit (anthony.freenode.net irc.freenode.net).
11:53:04 -!- RedDak has joined.
11:53:04 -!- fax has joined.
11:53:04 -!- zbrown has joined.
11:53:04 -!- rufius has joined.
11:53:04 -!- RodgerTheGreat has joined.
11:53:04 -!- meatmanek has joined.
11:53:04 -!- helios24 has joined.
11:53:04 -!- lament has joined.
11:53:04 -!- oklopol has joined.
11:53:04 -!- cmeme has joined.
11:53:04 -!- tokigun has joined.
11:53:04 -!- mtve has joined.
11:53:04 -!- sp3tt has joined.
11:53:04 -!- fizzie has joined.
11:53:04 -!- Izzy7 has joined.
12:02:53 -!- RedDak has quit (Remote closed the connection).
12:28:59 -!- edwardk has joined.
12:29:17 -!- edwardk has left (?).
12:33:21 -!- RedDak has joined.
13:05:30 -!- ehird has joined.
13:24:31 -!- rufius has changed nick to suifur.
13:25:09 -!- suifur has quit ("leaving").
13:26:17 -!- rufius has joined.
13:51:16 <ehird> what brainfuck needs is continuations.
13:51:27 <ehird> not gotos, not functions, but nice, simple continuations
13:52:31 <ehird> you'd only need & (create new continuation, place it at the current cell, place 0 at next cell) and % (get continuation from cell, get argument from next cell, jump to continuation with argument replacing the original 0 from &)
13:52:40 -!- zbrown has changed nick to suifur.
13:52:42 <ehird> nice and simple and a pain to use
13:52:44 <ehird> sounds like brainfuck to me
13:52:47 -!- rufius has changed nick to zbrown.
14:47:22 -!- ihope_ has joined.
14:47:35 -!- ihope_ has changed nick to ihope.
15:02:29 <zbrown> I think I like smalltalk :)
15:19:55 -!- RedDak has quit ("I'm quitting... Bye all").
15:46:39 -!- purple has joined.
15:46:46 -!- purple has left (?).
16:13:44 -!- jix has joined.
16:17:45 -!- SilentScience has joined.
16:21:04 -!- RedDak has joined.
16:25:09 <ihope> Not much esolang-related.
16:25:29 <ihope> Outside of esolangs, first day of driver's ed.
16:25:36 <ihope> (Or drivers' ed, if you want to go that route.)
16:26:56 <ihope> I think I'll take a look at some very basic message-passing later today.
16:28:01 <RodgerTheGreat> right now, I'm just kinda doodling and deciding wether this is going to be an "art week" or a "coding week".
16:28:22 <RodgerTheGreat> I'm kinda between projects, as the Smalltalk thing is only just starting to pick up momentum
16:28:30 <ihope> I take it by "art" you mean "art other than coding".
16:29:17 <RodgerTheGreat> I consider coding an artform, but I generally mean drawing or ink work when I use the term "art"
16:34:25 <ihope> '[In] Smalltalk . . . there is no difference between values which are objects and values which are primitive types. . . . This fact is summarised in the commonly heard phrase "In Smalltalk everything is an object" (which would more accurately be expressed as "all values are objects", as variables aren't).' http://en.wikipedia.org/wiki/Smalltalk
16:34:32 <ihope> Variables aren't objects! That must be remedied!
16:35:20 <RodgerTheGreat> invent MinisculeSpeak to rectify this oversight- you can do it, ihope!
16:35:49 <RodgerTheGreat> I think Sukoshi has been insanely successful in making everyone obsessed with Smalltalk.
16:37:37 -!- fax has quit (Remote closed the connection).
16:38:17 * ihope ponders all the crazy features a language should have built in
16:38:42 <ihope> Monads, delimited continuations (fancy!), message passing, variables as values...
16:39:17 <RodgerTheGreat> I misread "Monads" as "Moods" which could make for a hilarious language
16:39:22 <ihope> Oh, and static dependent typing.
16:39:37 <ihope> "ERROR: Compiler is in a bad mood. Add caffeine and try again."
16:40:14 <RodgerTheGreat> and if you wound up with a female compiler, you'd be lucky to get anything compiled at all a couple days a month
16:40:33 <ihope> "Wow, how'd you get it to run so fast?" "Morale."
16:40:58 <RodgerTheGreat> if you kept screwing up, your compiler might get frustrated at you and start scrambling your code out of spite
16:41:20 <RodgerTheGreat> if you became friends with your compiler, it would do more work to optimize your code.
16:41:29 <ihope> What do you call the feeling that everyone's an idiot?
16:42:40 <ihope> "Gah! Everyone around me is an idiot!"
16:43:13 <ihope> "ERROR: Programmer is an idiot. Source file deleted."
16:43:56 <RodgerTheGreat> "ERROR: I'll nullpointer YOUR FACE if you write something that idiotic again, I swear to god."
16:46:24 <ihope> Or, if the compiler is happy, "ERROR: Programmer is an idiot. Source file fixed. Changes credited to me."
16:46:37 -!- SilentScience has changed nick to CakeProphet.
16:46:47 <ihope> Or, if the compiler is VERY happy, "ERROR: Programmer is an idiot. Source file fixed. Changes credited to programmer."
16:47:13 <ihope> Er, ScientSilence.
16:47:44 <ihope> CHEESECAKE FIELD... er, FIEND
16:47:54 <ihope> RodgerTheGreat: something like that.
16:50:59 * RodgerTheGreat is listening to Kb - Beyond the gates from Nectarine Demoscene Radio
16:52:38 <ihope> Monads, delimited continuations, message passing, variables as values. Really, generic zippers should be included too.
16:53:23 <CakeProphet> I just remembered how bland the conversation gets here.
16:53:43 <ihope> Method to... simulate a pointer, I guess.
16:54:24 <ihope> Hmm. Read something that sounds like the cat's pajamas (whatever those are) and you realize it's just a pointer :-P
16:55:19 <ihope> Though perhaps since a variable is pretty much a pointer, generic zippers could replace variables.
16:55:24 <ihope> WOW, CAPITAL LETTERS
16:55:41 <ihope> WE NEED TO GET GREGORR IN HERE
16:56:16 <RodgerTheGreat> actually, yeah. Even when I pretend to use capslock I reflexively shift. <:[
16:56:57 <ihope> NOW, DOES ANybody actually know anything about generic zippers?
16:57:04 <CakeProphet> when will you ever need to... USE CAPITAL LETTERS AT ALL TIMES BY DEFAULT
16:57:24 <ihope> When you need to use a lot of capital letters.
16:57:30 <ihope> ...Perhaps #haskell would have a better answer.
16:57:58 <CakeProphet> ....proglang channels scare me. anything I say spurs a pedantic debate.
16:59:55 <CakeProphet> LOL NO WAI DOOD, LISTS ARE MORE LIKE A BOUNDLESS TAPE OF REFERENCES, NOT A CONTAINER FOR VALUES.
17:00:12 <CakeProphet> except without the surfer/chatspeak slang.
17:01:51 <CakeProphet> ....and everyone wants everyone else to follow their Rules for Syntax Style in Which The One True Way to Format Things is Used
17:02:05 <RodgerTheGreat> like "Geez, what are you- mentally handicapped? Any even introductory programmer should understand the difference between a list and a container. Begone, fool" ?
17:03:15 <CakeProphet> YOU SHOULD PROBABLY USE TWO LINE BREAKS INSTEAD OF ONE, AND CAMEL-CASE YOUR METHODS COCKBREATH.
17:04:51 <RodgerTheGreat> me: "So, I'm having trouble with this applet-" #Java: "Why would you use an applet? They suck, and nobody uses them for anything. Use Java webstart."
17:05:57 <CakeProphet> ...yep. and you'll never get them to help unless you follow that first step. IT'S LIKE #PYTHON.
17:06:15 <CakeProphet> ....and if you bitch... then they'll say that they've been trying to help you, and you're just not listening.
17:06:46 <lament> and they're usually right.
17:06:59 <RodgerTheGreat> this is why I'm glad that #Esoteric and ##Nonlogic contain large numbers of people who are not gigantic assholes
17:11:07 <CakeProphet> but I'm usually right too. so it doesn't matter.
17:12:16 <lament> yes, but you're the one asking for help :)
17:12:25 -!- sebbu has joined.
17:12:53 <CakeProphet> it's people who are certain they're right that are usually huge dicks.
17:14:44 <lament> maybe people who are huge dicks tend to be right? :)
17:15:17 <CakeProphet> ...doesn't matter who's right. everyone's right. when helping someone... being a huge dick doesn't work.
17:15:38 <CakeProphet> they need help with a java applet.... not <insert /way/ better alternative>
17:16:22 <lament> CakeProphet: well, you need to consider whether they need help with a java applet, or only think they do.
17:16:45 <lament> often it's the latter.
17:16:59 <lament> very often people make architectural decisions like that without thinking too much.
17:17:18 <CakeProphet> ........what? it doesn't matter... they still need help with a java applet.
17:18:52 <lament> CakeProphet: when somebody wants to cut a piece of cheese with a hammer, do they "need help with a hammer", or do they need to be pointed out they're using the wrong tool?
17:20:00 <CakeProphet> ...depends. I'm curious how you'd go about cutting cheese with a hammer...
17:20:52 <GregorR> I'd say he needs help with a hammer of a cutting-cheese-with-a-hammer expert.
17:21:18 <lament> CakeProphet: sure, and afterwards, try cutting your hair with a blowtorch
17:21:49 <GregorR> Weeeell, to be fair, cutting your own hair is a bad idea in general. Let your mechanic cut your hair with a blowtorch.
17:22:10 <zbrown> lament: I figure its better for people to screw it up and figure out that thats the wrong way to do it than to be led in the right direction. People learn more from failure than from success.
17:22:15 <lament> GregorR: that's an interesting question, should a mechanic or a barber do it?
17:22:55 <lament> zbrown: that's not true. Consider all the Perl programmers. :)
17:23:35 <CakeProphet> ....so in conclusion.... I win and am right about everything. your opinions are all moot.
17:23:36 <GregorR> Well, to be fair, they had success ... just in a really failurific way.
17:23:41 <zbrown> lament: True. But perl is a heathen's language!
17:37:38 <ihope> No, dentists should do all hair-cutting.
17:37:56 <ihope> After all, teeth might be made of protein, which is what hair is made of!
17:41:36 <ehird> ihope, and scientists investigating sub-atomic particles should do /everything/
17:42:05 <ihope> Nah, set theorists should do everything.
17:42:29 <ihope> Or first-order logicians.
17:43:12 <lament> consider a set of first-order logicians.
17:43:40 <ihope> I refuse, as I am not a first-order logician.
17:44:01 <lament> consider a set of people considering sets.
17:44:30 <ihope> I refuse, as I am not a person considering sets.
17:44:40 * ihope throws conlangs at CakeProphet
17:44:42 <ehird> consider a set of (people considering a set of (people considering a set of first-order logicians))
17:44:59 <ehird> consider s-expressions
17:45:14 <ihope> I refuse, as I am not a (person considering a set of (people considering a set of first-order logicians))
17:45:25 <ihope> I refuse, as I am not an element of s-expressions.
17:45:33 <lament> consider the set of people refusing to consider sets.
17:46:35 <lament> http://esoteric.voxelperfect.net/wiki/HelloWorld
17:46:47 <ihope> I gladly fulfill your request, thereby making me not a person who refuses to consider sets. I refuse for that reason.
17:46:58 <ihope> Oops, I fulfilled it in the process of refusing to do so...
17:47:22 <CakeProphet> ....we're going to have to stop this... before my brain explodes.
17:48:01 <lament> Consider the set of people whose brains are made to explode by set theory.
17:48:56 * lament waits for the explosions
17:50:19 <ihope> I refuse, as I am not a person whose brain is made to explode by set theory.
17:51:24 <lament> you don't need to belong to X to consider X.
17:52:33 <ihope> Well then, prove it by considering the set of smart people.
18:41:18 -!- GregorR has quit (Read error: 104 (Connection reset by peer)).
19:05:19 -!- RedDak has quit (Remote closed the connection).
19:30:56 -!- EgoBot has joined.
19:32:03 -!- GregorR has joined.
20:12:36 <ehird> bsmntbombdood, indeed
20:13:09 <ehird> lament, by writing a BF interp
20:13:12 <lament> continuations need to be stored somewhere
20:13:15 <lament> where would you store them?
20:13:44 <bsmntbombdood> a reference into a continuation array kept by the interpreter
20:13:47 <ehird> continuations in the code: [0] = continuation number, [1] = the argument or 0
20:13:54 <lament> bsmntbombdood: i suppose that's one way of doing it.
20:13:56 <ehird> continuations for calls: [0] = cont. num, [1] = the argument to pass
20:14:28 <lament> i don't understand that
20:14:40 <ehird> & is like "callcc", and sets [0] = cont number, [1] = the argument or 0 (0 when it hasn't been called yet), % is like calling the continuation [0] with the argument [1]
20:14:52 <lament> by [0] you mean the first memory cell?
20:15:04 -!- RedDak has joined.
20:15:11 <ehird> [0] = the current memory cell at & or %, [1] = the current cell + 1
20:16:30 <bsmntbombdood> i think it would be better if & read the cont number instead of writing it
20:16:54 <bsmntbombdood> overwriting the continuation that previously had that number
20:17:03 <lament> it's closer to what Scheme does
20:17:06 <ehird> i'm not sure i understand
20:17:23 <lament> ehird: have [0] be like the "variable name" for the continuation.
20:17:26 <bsmntbombdood> +& sets continuation 1 to the current continuation
20:17:34 <ehird> sounds a bit high level for BF :)
20:18:10 <ehird> i guess what i'm talking about is more like goto but with arguments
20:18:36 <lament> with goto, you specify the label, not have it specified for you
20:18:47 <ehird> you have to specify the label with % too
20:19:00 <ehird> you have to navigate to the cell with the continuation number in it, or manually add it
20:19:36 <bsmntbombdood> and what happens if you set more than 256 continuations?
20:19:52 <lament> who said brainfuck cells were limited to 256 symbols?
20:20:13 <lament> what do you mean 'most', we're creating a new language
20:21:01 <ehird> &>>++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.<<% <-- infinite hello world!
20:21:01 -!- GregorR-L has joined.
20:21:19 <bsmntbombdood> user set continuations are better, because then you can allways, say, have continuation 0 be a "return continuation", and then you have subroutines
20:21:25 <ehird> &>>code% is, of course, more fussy than +[>code<]
20:21:46 <ehird> bsmntbombdood, framework for subroutines is the origination of this idea
20:22:05 <ehird> except, i would use a stack with the two continuation cells being one member, and use it as a call stack
20:22:20 <bsmntbombdood> i don't see how you can do subroutines without letting the user set the continuation number
20:22:33 <lament> I don't see why & needs an argument.
20:22:39 <ehird> lament, it doesn't
20:22:47 <bsmntbombdood> because the subroutine can't find the return continuation
20:22:57 <ehird> "the argument" refers to the argument passed at a symmetrical % call
20:23:25 <ehird> (basis: easy passing of where the procedure arguments start in the general stack)
20:25:07 <bsmntbombdood> to call a subroutine you just do [-]&> if_zero { (load subroutine number) > (load subroutine arg) < % } else { > (return value is the current cell now) }
20:25:57 <ehird> as far as i know the original &% definitions make it even easier
20:26:41 <ehird> i'm not sure, still working out the best way to define them
20:26:46 <ehird> maybe eliminate the arguments altogether?
20:26:56 <ehird> though, that makes stuff a lot harder
20:27:01 <lament> that would make continuations rather worthless
20:28:56 <ehird> i think "& Create a continuation, and set [0] to its id. Set [1] to 0 if we didn't come from a %, the argument from % otherwise." and "% Jump to the continuation whose id is in [0], using [1] as the argument." are the simplest and easiest definitions
20:29:54 <ehird> function definitions would appear to be &>[cell pointer is at argument]<, leaving the function id on the current cell
20:30:07 <ehird> err - of course, nulling out the argument at the end
20:30:32 <ehird> and function calls just getting the current cell as the function id then >arg<%
20:31:04 <bsmntbombdood> to define a subroutine: (load subroutine number)&> if_not_zero {(argument is in the current cell, code goes here) (place return value in current cell) >[-]<[->>+<<]>% }
20:31:26 <ehird> seems a lot more verbose to me =)
20:31:44 <ehird> of course, that incorporates return values
20:31:56 <ehird> that's up to the user really.
20:32:08 <bsmntbombdood> it needs return values, because the continuation is on a different tape
20:32:25 <ehird> if % left a value then it'd be brainfuck+functions not brainfuck+continuations
20:32:27 <bsmntbombdood> it's much better to have the user assign continuation numbers
20:37:34 <bsmntbombdood> "& overwrite continuation number [0] with the current continauation. Set [1] to 0 if we didn't come from a %, the argument from % otherwise." and "% Jump to the continuation whose id is in [0], using [1] as the argument."
20:37:53 <ehird> "continuation number [0]"?
20:38:00 <ehird> i think we have terminology clashes here
20:38:23 <ehird> "continuation whose id is in [0]"
20:38:31 <ehird> OK sounds reasonable
20:39:11 <bsmntbombdood> yours is like not letting the user choose the variable name for the function passed to call/cc
20:39:25 <ehird> yeah i like your version
20:40:20 <ehird> just to make this language more distinct from brainfuck i suggest we have a 0-infinity data size and 0-infinity tape size. =P
20:40:44 <ehird> and also because that's helpful if you're compiling some language into brainfuck. which is the whole point of this variation. since continuations make procedures easier
20:41:21 <ehird> but hell to deal with for compiler writers. =)
20:42:27 <GregorR-L> You could just use my c2bf's ld :P
20:43:18 -!- mtve has quit (Read error: 110 (Connection timed out)).
20:43:44 <ehird> why shouldn't & be
20:43:54 <ehird> "& overwrite continuation number [0] with the current continauation. Set [0] to 0 if we didn't come from a %, the argument from % otherwise."
20:44:01 <ehird> using [1] is unheard of in BF
20:44:09 <ehird> but , sets the precedent of overwriting the current cell
20:45:41 <ehird> after all, since the continuation no. is computed by the user they can easily copy it someplace
20:47:04 <ehird> So & is "Replace the continuation whose id is in the current cell with the current continuation, and then set the current cell to 0 if this is just after the & call, or the argument passed to % if we come from there"
20:47:15 <bsmntbombdood> this is much better than other attempts i've seen to give brainfuck subroutines
20:47:51 <ehird> suggestion: a NULL value for cells, for EOF on , and no argument on &
20:47:55 -!- edwardk has joined.
20:47:59 <ehird> since, you might want to pass 0 as an argument, e.g.
20:48:11 <ehird> and applied to , for consistency
20:48:34 <ehird> an extra value cells can have?
20:48:50 <ehird> i assume you know what NULL in itself is =)
20:49:23 <ehird> then NULL is a black hole cell
20:49:33 <ehird> but without any other minus numbers
20:49:48 <ehird> NULL being "the value before 0"
20:50:07 <ehird> and [ switches on NULL, not 0 (maybe? maybe switch on both?)
20:51:03 <lament> i very much don't like null
20:51:12 <lament> just using 0 for "no argument" is not so bad, though.
20:51:26 <ehird> lament, there are many valid cases when you'd want to pass 0 as an argument
20:51:40 <ehird> but i'd suspect none when you'd want to pass the black hole known as null
20:51:46 <lament> ehird: yes. Just write your program in such a way that passing 0 as an argument can be treated the same as not coming from anywhere.
20:51:59 <ehird> bsmntbombdood, longjmp is not the epitome of good design
20:52:07 <lament> &[processing unusual arguments] processing 0 argument or nothing
20:52:23 <ehird> lament, processing 0 argument would be run on function creation
20:52:48 <lament> right, so design things in such a way that 0 argument means nothing should be done.
20:53:24 <ehird> i can see approximately one way to do that sanely: add one to every argument and subtract it in the function
20:53:56 <ehird> it's saner than other ways
21:00:10 <ehird> especially if writing a compiler
21:02:42 <bsmntbombdood> if the cell size is unbounded than you can return value+1 from a function
21:03:05 <ehird> nothing to do with returning - it's to do with calling
21:03:24 <ehird> but just adding one to the args at call-time and subtracting one at the start of the function sounds reasonable to me
21:05:52 <oklopol> <RodgerTheGreat> after all, not every moment of IRC can be bash.org <<< most of bash is crap.
21:06:18 <RodgerTheGreat> then I guess every moment of IRC *is* bash.org, in a way
21:07:06 <oklopol> <CakeProphet> ......what purpose does capslock serve? <<< i've never really understood why have both u- and lcase
21:07:13 <oklopol> ucase is as pretty as it gets.
21:07:21 <ehird> oklopol, linguists disagree
21:07:48 <ehird> bsmntbombdood, then unbound cells =)
21:08:27 <bsmntbombdood> remember the good old days before lowercase was invented?
21:09:28 <ehird> (I THINK LISP WAS WROTE (LIKE TIHS))
21:09:33 <ehird> i don't think lisp ever used commas
21:10:13 <GregorR-L> I don't find upper- and lower-case to be particularly valuable.
21:10:17 <ehird> that must have been a very early version
21:10:22 <edwardk> I love lisp, I love forth, but I can't survive without a type system these days ;)
21:11:31 <edwardk> i can go slumming in ocaml, coq of f# when its needful ;)
21:13:13 <ehird> i think he means /static/ type system
21:13:50 <lament> type systems tend to be static.
21:14:00 <lament> it's rare that a type suddenly changes.
21:14:12 <lament> i suppose in Ruby and Smalltalk that could happen.
21:14:25 <lament> but not, for example, Scheme
21:14:41 <lament> integers don't suddenly become strings or anything like that :)
21:14:54 <edwardk> i like manifest not latent types. there specific enough? =)
21:15:29 <edwardk> scheme is 'typed' in the latent (what appears to be untyped) sense, haskell is typed in the manifest there is no tag here but the compiler knew what the type was sense.
21:16:01 <lament> edwardk: i think you're trying to say that you like languages with statically typed variables.
21:16:33 <edwardk> lament: i like lazy languages with strong type systems and snazzy features like dependent types.
21:17:06 <edwardk> yeah, i get coq and cayenne, maybe epigram ;)
21:17:18 <edwardk> and haskell if you want to call GADTs a form of dependent type
21:17:25 <ehird> bsmntbombdood, so current extended BF: "& Replace the continuation whose id is in the current cell with the current continuation, and set the current cell to 0 if we've just ran & or the argument passed to % if we came from that." "% Take the continuation in the current cell, and call it with the argument in the next cell." and unbounded cells
21:17:38 <ehird> that allows for 0 arguments, too
21:17:47 <lament> i don't like the concept of types.
21:18:10 <lament> the OO model seems to be more intuitive.
21:18:29 <edwardk> in my toy language my type checking is really more a form of control flow analysis and constraint satisfaction than traditional types. i love types, they just aren't strong enough =)
21:18:59 <edwardk> i love the 'if it compiles its correct' feeling.
21:19:01 <ehird> bsmntbombdood, sound good?
21:19:27 <lament> edwardk: define correct :)
21:19:58 <edwardk> lament: correct in the the compiler checked your pre and post conditions and tried to determine if it would terminate for you, then tucked you into bed and read you a story kind of sense. ;)
21:20:20 <lament> edwardk: compiled python is quite correct, although of course something like "1" + 2 would of course raise an exception.
21:20:59 <ehird> bsmntbombdood, so &[-code; some sort of return value setting[-]] is the way to define a function and func>arg+<% is the way to call one
21:21:02 <lament> that's one of course too many.
21:21:32 <lament> edwardk: the beauty of python is that with a single type (object) you can't possibly have type errors :)
21:21:41 <edwardk> i believe that if the compiler on its highest anal retentive setting doesn't emit a warning you should be comfortable that no runtime errors will occur, and i'll even lump exceptions and infinite loops in the class of 'errors'. i'm willing to relax the requirement of termination though ;)
21:22:20 <lament> edwardk: but that's crazy and counterproductive.
21:22:31 <lament> edwardk: exceptions are not errors, they're just a control flow mechanism.
21:22:42 <edwardk> lament: well, its what i've been working towards. exceptions i'm ok with if they are caught
21:22:52 <ehird> exceptions are traditionally Things That Should Never Happen
21:23:09 <ehird> exceptions are now This Happened, And It's Very Possible, But I Don't Like It. Clean It Up, Please.
21:23:15 <lament> edwardk: that's also a bad philosophy, since you can always catch everything by surrounding your entire program with a catch clause.
21:23:20 <edwardk> i'm ok with exceptions as a control flow mechanism, in my setting they are just a form of delimited continuation, nothing to write home about.
21:23:49 <oklopol> GregorR: i like listening to your tutorials even though i didn't understand what the latter one was about
21:23:55 <lament> edwardk: which actually happens in java :)
21:24:12 <ehird> bsmntbombdood, I probably will =P
21:24:17 <edwardk> ok, shall i write out a dissertation on the correct use of exceptions being that you should catch them all as close to the exception as it is possible to understand the intent of the application user? =)
21:24:39 <ehird> bsmntbombdood, Hm - I wonder what else could make BF more friendly to compiler-makers
21:24:44 <ehird> Well - not more friendly rather than not a complete pain
21:24:51 <lament> edwardk: the point is, the distinction is not a technical one.
21:25:05 <lament> edwardk: i.e. compiled python is "correct" in the technical sense
21:25:34 <bsmntbombdood> "correct" only as in "no syntax errors", which isn't very useful
21:25:57 <edwardk> compiled pythoin is correct with respect to its semantics. i just don't like those semantics
21:26:11 <oklopol> promise me you won't talk for long, it's a pita reading 2 hours of logs :)
21:26:37 <ehird> bsmntbombdood, Expanding tape size, for one. But that isn't very innovative
21:26:41 <SimonRC> Here is an example of an embarassing bug in Python:
21:27:10 <ehird> bsmntbombdood, indeed
21:27:31 <SimonRC> From a library, I got an error message where the text was "null". Oops, someone had gotten the text and cause arguments the wrong way round to the exception construction.
21:28:45 <SimonRC> that just wouldn't happen if there were some types
21:29:06 <bsmntbombdood> i didn't realize if you have continuations you automatically get procedures too
21:29:07 <lament> types make very little sense in an object-oriented language
21:29:18 <lament> i suppose they do make sense (as interfaces)
21:29:24 <ehird> bsmntbombdood, What about EOF behaviour? I suggest leaving the cell as it is - it's the only way that can't be mistaken for \0 or some other character being entered by the user
21:29:33 <SimonRC> It depends on what you mean by OO...
21:29:40 <lament> edwardk: read anything alan kay has to say on the subject.
21:29:44 <ehird> bsmntbombdood, well - continuations are a special case of closures, and functions are special cases of closures
21:29:48 <edwardk> without them its very hard to ensure that every message you send can be handled on arrival
21:29:50 <SimonRC> There are at least 9 things that contribute to "being OO"
21:29:56 <edwardk> i have, and i still don't agree with him ;)
21:30:11 <SimonRC> and different languages have different subsets
21:30:24 <SimonRC> Bloodyimplementation inheritance is just one of them
21:30:55 <SimonRC> http://paulgraham.com/reesoo.html
21:30:57 <edwardk> smalltalk is nice for developing in the small, and i do like the live-update properties that you get from allowing freeform permutation of objects on the fly while it runs, which you can't do easily in a more strongly typed system, which is also why erlang is the stability king of functional languages
21:31:27 <edwardk> but the win there comes at the expense of usability of other areas of the language.
21:31:42 <SimonRC> Updating a running system conflicts nastily with referential transparency.
21:31:49 <lament> edwardk: well, that's always the case with everything :)
21:32:03 <ehird> bsmntbombdood, the only other slightly helpful thing i can think of is push and pop functions, pop removing the last element of the tape (last = was actually changed sometime) and placing it in the current cell, push adding to the end of the tape
21:32:07 <ehird> but that's a bit high level for BF
21:32:13 <edwardk> lament: sure. i just have to pick a point in the design space and camp out in it and see if anyone shows up to the party ;)
21:32:30 <edwardk> in my case its 'very strongly typed' but still semi-decidable in practice.
21:33:05 <lament> edwardk: is haskell strongly typed enough?
21:33:12 <edwardk> lament: unfortunately, no.
21:33:25 <edwardk> lament: which is what led to my current compiler project in the first place ;)
21:33:43 <ehird> bsmntbombdood, end is defined as the last element in the tape which was touched in some way - +'d or -'d
21:33:51 <ehird> but - its a bit ill-defined, yeah
21:34:13 <lament> edwardk: i suppose if you're against infinite loops, you can never be satisifed :)
21:34:21 <edwardk> ij want polymorphic records and variants, subset types, limited termination checking ala NCI, and flow based type refinement, and optimistic evaluation.
21:34:38 <SimonRC> AFAICT, Haskell is OO in senses 1, 2, 4, 5, 6, 7. But its form of 7 blows
21:34:48 <SimonRC> AFAICT, Haskell is OO in senses 1, 2, 4, 5, 6, 7. But its form of 7 blows almost everything else out of the water.
21:34:52 <edwardk> lament: i'm not against them, i just want to be able to say in the type that something is total in an unpointed domain and incur a proof burden
21:35:16 <edwardk> for the cases where showing that something is well-founded recursive or productive corecursive matters.
21:35:43 <SimonRC> edwardk: you've seen Epigram, right?
21:36:00 * SimonRC knows one of the guys working on that: ecb.
21:36:04 <edwardk> it doesn't really win anything for me over developing in coq though.
21:36:18 <lament> but coq has such a funny name.
21:36:25 <ehird> bsmntbombdood, it can't
21:36:34 <ehird> unless the halting problem has recently been solved =)
21:37:01 <edwardk> bsmntbombdood: i get away with it by tracking Pointedness in the types. basically by polluting them in the presence of certain forms of recursion and them slowly relaxing that as i compile via NCI flow analysis
21:37:05 <SimonRC> occasionally Haskell will prove non-termination for you
21:37:26 <SimonRC> edwardk: i understood about half of that
21:37:42 <lament> edwardk: lifespan? This variable will live for 10 more iterations :)
21:37:51 <SimonRC> If your recursion has no base case, Haskell might be able to inferr and impossibly-general type for you
21:38:47 <edwardk> basically what i'm doing right now is this, if a function recurses into itself or passes around a function in a manner than admits general recursion i'll tag the type as pointed, its permitted in my semantics to fail to 'unpoint' something, but its never ok for me to say that something will terminate if it doesn't.
21:39:30 -!- RedDak has quit (Read error: 113 (No route to host)).
21:39:31 <ehird> i hate how haskell forbids (\x -> x x) (\x -> x x)
21:39:32 <edwardk> if a type is unpointed then its always safe for me to evaluate it in a strict manner, this is actually more liberal than strictness analysis, because strictness says i need the answer, but in this case i say that i may not need the answer, but if you speculate and evaluate it
21:39:37 -!- jix has quit ("CommandQ").
21:39:39 <ehird> i mean - you can't forbid that priceless expression =)
21:39:40 <edwardk> then you will still terminate if you would terminate before
21:39:53 <SimonRC> edwardk: nice terminology collision, BTW
21:40:59 <SimonRC> "point-free" can mean that no parameters are bound to names.
21:41:02 <edwardk> lament: lifespan comes in the form of regions
21:41:09 <ehird> SimonRC, *pointless =)
21:41:22 <ehird> bsmntbombdood, i think that's about it as far as language definition goes.
21:41:36 <ehird> i can't think of anything more in the spirit of BF that helps compiler-writers or similar folk
21:41:39 <edwardk> simonrc: yeah it comes from a different place than unpointed and pointed domains. a pointed CPO is how you view functions in semantics
21:42:10 <edwardk> you basically view all functions as continuous functions in a pointed CPO. totally unrelated to the pointfree/pointless debate =)
21:42:12 <lament> edwardk: i think Brainfuck is the language for you.
21:42:23 <lament> edwardk: Pieces of code without [] are guaranteed to halt
21:42:48 <edwardk> it has tail call optimization
21:43:05 <ehird> it has other iteration methods, but they're based on recursion
21:43:54 <edwardk> lament: heh i'll pass on writing my next compiler in bf ;)
21:44:15 <lament> edwardk: i think the problem is that any useful code will admit existence of infinite loops.
21:44:25 <ehird> edwardk, but continuations. =(
21:44:52 <edwardk> lament: i admit them. i just allow you to request for them to not be present and to be able to type check the safety of a function w.r.t to termination
21:45:34 <ehird> you can't determine that.
21:45:37 <lament> edwardk: right, i'm just saying the cases in which you would be able to use that are limited and not practically interesting
21:45:50 <ehird> no, correct in any turing-complete system
21:45:56 <edwardk> lament: actually you'd be surprised how many you can
21:46:10 <bsmntbombdood> what does a language need so that you can implement continuations in it?
21:46:12 <edwardk> ehird: ok. you weren't here when i talked about the premise behind what i've been working on
21:46:35 <ehird> bsmntbombdood, well - goto works
21:46:52 <ehird> if it has eval() and functions, you could even stretch it into that
21:47:10 <ehird> eval("function cont" + cont++ + "() {" + compile(inner_cont_code) + "}") or something
21:47:12 <edwardk> i've been playing with the edge of undecidability. my type system 'falls back' to a fairly standard type system, but it makes a 'best effort' to prove properties beyond that, so i can appeal to semi-decidability safely and just run the algorithm for a while.
21:47:13 <ehird> bsmntbombdood, hm?
21:47:20 <ehird> bsmntbombdood, well - you'd need non-local gotos
21:47:36 <ehird> something like the structs wrapping jmp_bufs in C use
21:47:39 <edwardk> sorted : Ord a => [a] -> Bool
21:47:41 <ehird> that's basically continuations in C
21:47:45 <ehird> just using non-local gotos
21:48:27 <edwardk> then use it in the type as a post condition for sort, sort : Ord a => [a] -> {xs : [a] | sorted xs} which incurs a proof obligation in the compiler. if it can prove it, great it moves on and you see nothing
21:48:30 <lament> halting int factorial(positive int n) {return n * n - 1};
21:48:39 <edwardk> if it can prove a counter example you get THAT and it stops.
21:48:55 <edwardk> if it can't do either it'll offer to let you compile it with a runtime check, but you will at least know it couldn't prove it
21:49:31 <edwardk> the same thing happens with an explicit termination annotation. i'll check it, making a best effort, and if it has to give up it shrugs its shoulders emits a warning or an error and moves on.
21:50:08 <edwardk> its true that you can't prove these things in general, thats fairly passe. the question is for what class of practical programs can these things be proven automatically and efficiently.
21:50:19 <bsmntbombdood> " Sum-of-product-of-function pattern - objects are (in effect) restricted to be functions that take as first argument a distinguished method key argument that is drawn from a finite set of simple names."
21:50:24 <ehird> lament, that is not factorial
21:50:35 <ehird> bsmntbombdood, yes it can - setjmp/longjmp is a non-local goto
21:50:36 <lament> edwardk: only for those where it's obvious by looking at the source, it seems :)
21:51:48 <edwardk> so for right now, if you build a factorial function in the toy language the NCI will note the lack of well-founding of negative numbers in most implementations and complain about a negative argument, noting that the function isn't total with a warning or emitting an error if it can show you ever call it with a negative number.
21:52:05 <edwardk> it'll also note the termination of positive arguments and it can do that in a bounded number of passes over the code.
21:52:36 <edwardk> i don't see the point in not doing it if i can, and the errors it catches are sometimes non-trivial.
21:53:12 <edwardk> moreover with a large class of these annotations explicitly made on the standard libraries a lot of misuse cases are caught early on
21:53:23 <ehird> it can't show if you ever call it with a negative number
21:53:26 <edwardk> furthermore they open up opportunities for the compiler
21:53:56 <edwardk> ehird: again, if i can, i do, if i can't prove that every argument issued to the function is positive, i warn, and can insert a runtime check.
21:54:22 <ehird> bsmntbombdood, i can't think of anything else to add to the language - can you?
21:54:27 <edwardk> ehird: everyone jumps to the halting problem as the answer. its true. but its not the end of the story. a lot of practical programs can be written in coq and its not even turing complete.
21:54:42 <ehird> blah at not turing complete.
21:55:06 <ehird> bsmntbombdood, infinite tape, unbounded cells, continuations- i think that's about it
21:55:13 <lament> "The word coq means "cock" in French, and stems from a tradition of naming french research development tools"
21:56:12 <edwardk> ehird: what i get out of it is a language in which i can fully express a lot of the invariants in my libraries, where i can quickly throw up counter examples at the user because the 'quickcheck' style facilities can directly use the local invariants, and where counter-example guided unrolling can catch a lot more.
21:56:29 <edwardk> ehird: have you seen ESC/Haskell? or the other ESC projects?
21:56:37 <edwardk> ESC/Haskell is probably the most convincing
21:57:22 <edwardk> basically all i do is use the ESC/Haskell approach, wrap it in a nicer syntax and add limited termination checking
21:59:15 <edwardk> the combination isn't present elsewhere all in one package
21:59:28 <edwardk> lament: yes, we all know that coq is fairly unfortunately named =)
22:00:21 * edwardk climbs down off his soapbox ;)
22:03:52 <zbrown> Any smalltalkers in here right now? If I call a return(^) before the last line of code, does it necessarily end code exection? As I understand it, the compiled/interpreted form of the return(^) comes at the end either way
22:05:24 <zbrown> http://nonlogic.org/dump/text/1184015056.html <--- An example. I'm confused as to how they're using the return as a conditional for code that comes after the return
22:07:02 <ehird> bsmntbombdood, i guess i'll just go ahead and implement it
22:25:25 -!- mtve has joined.
22:28:42 <SimonRC> I think you are parsing it wrong...
22:29:44 <SimonRC> ^ ((salary isNil) ifTrue: [salary := 0] ifFalse: [salary])
22:31:40 <SimonRC> roughly, In Java: "public Integer getSalary() { if (salary == null) { salary = 0; return salary; } else { return salary; }"
22:32:18 <ehird> what's the alternative?
22:32:39 <SimonRC> I can't see an alternative.
22:34:26 -!- edwardk has left (?).
22:52:07 * ehird ponders how BF could be made more compiler-friendly
22:54:55 <SimonRC> allow arbitrary flowgraphs rather than the current loop construct?
22:55:31 <GregorR-L> It takes a bit of work to make proper continuation/goto/etc, but it's all there and possible.
22:56:14 <GregorR-L> I'm betting ehird hasn't even looked at C2BF? :P
22:56:31 <ehird> GregorR-L, i've taken brief glances at it
22:56:39 <SimonRC> GregorR-L: how is that, BTW?
22:56:57 <SimonRC> forked out the $183 needed for the formal C spec? :-P
22:56:58 <GregorR-L> SimonRC: Same as it has been since I stopped working on it. All the fundamentals are there, but I'm too lazy to implement all the generations.
22:57:11 <GregorR-L> Heww no - I can C without a spec :P
22:57:30 <GregorR-L> Anyway, everything necessary for functions, gotos, continuations, etc was all done a long time ago.
23:00:25 <ehird> C without spec = !C :(
23:00:54 <GregorR-L> 100% spec compliance == useless overhead
23:01:11 <GregorR-L> Especially since the "memory model" of BF doesn't exactly lend itself to C.
23:01:40 <ehird> ridiculous is 100% spec compliance
23:02:02 <ehird> i'm curious though - how exactly do you implement a stack in BF efficiently?
23:02:19 <GregorR-L> I don't - I implement it inefficiently.
23:03:36 <GregorR-L> I'm trying to remember the name of the theorem I worked under ... it's the one stated something like "If you have a hotel with infinite rooms, and each is filled, but you need to put new people in, how do you get the rooms? For every renter, move them from room #X to room #2*X"
23:03:46 <GregorR-L> So I have a stack, heap and carry spaces all side-by-side.
23:04:04 -!- Sukoshi has joined.
23:04:47 <GregorR-L> I have a stack, and a cell next to the stack that is 1 up 'til the end of the stack (to make getting to the end easy).
23:06:06 <Sukoshi> Did you see my link yesterday, RodgerTheGreat ?
23:06:36 <Sukoshi> http://web.engr.oregonstate.edu/~budd/SmallWorld/ReadMe.html <-- Koko de kurikku shitekudasai.
23:07:24 <Sukoshi> But that's exactly what we need :)
23:07:30 <Sukoshi> The source is there. We can base it off that.
23:07:48 <Sukoshi> Of course, this is Little Smalltalk, not ST-80, so there will have to be changes, but we can use this model.
23:07:56 <Sukoshi> Oh no. ST-80 is a lot more to implement :P
23:08:05 <RodgerTheGreat> Recall the Nonlogic motto: Reinventing the wheel for fun!
23:08:13 <Sukoshi> Yeah. MVC is absent GregorR-L.
23:08:23 <Sukoshi> RodgerTheGreat: But this is a practical project :P
23:09:06 <Sukoshi> Also another question: My JVM is not finding the LinkedList removeFirst() method.
23:09:31 <RodgerTheGreat> well, from what I understand, the difference between Little Smalltalk and ST-80 is pretty much just the API (built in Smalltalk on top of the interpreter base)
23:09:31 * Sukoshi grumbles how she's used to her own linked list implementation in C where she uses structs and pointers, grumble grumble.
23:09:47 <Sukoshi> RodgerTheGreat: There are a lot, IIRC.
23:10:04 <RodgerTheGreat> Sukoshi: wouldn't a Vector or even an ArrayList be better?
23:10:22 <Sukoshi> RodgerTheGreat: Not in this case.
23:10:33 <Sukoshi> I'm doing a List of Bencodes (my own class).
23:11:50 <Sukoshi> But it's not finding removeFirst() :(
23:12:02 <Sukoshi> St00pd newfangled package thingamabobbers.
23:13:39 <Sukoshi> Well, remove(0) works, but I wonder if removeFirst() is more optimized.
23:13:47 <RodgerTheGreat> hm. Are you correctly applying generics, as per Java-5-ness?
23:14:37 <Sukoshi> I don't want to use Java 5 because last time I remember, GCJ/Open-Java-VMs didn't have Java 5 features yet.
23:15:01 <RodgerTheGreat> Y'know, like "LinkedList<Bar> foo = new LinkedList<Bar>();
23:15:03 <SimonRC> I never thought that parameterised types could be broken so badly much until I saw Java Generics.
23:15:10 <ehird> gcj/open-java-vms are not worth the trouble
23:15:26 <ehird> ((java is not worth the trouble. but.)
23:15:57 <Sukoshi> Yeah... that syntax is kinda ........
23:16:56 <SimonRC> At least Java/C++ type parameterisation syntax is better than ML's
23:17:39 <SimonRC> ML type syntax sucks <large object> through a straw
23:17:48 <RodgerTheGreat> I mainly dislike Java5 generics because they seem kinda artificially tacked onto the language design
23:18:16 <lament> artificially tacking stuff onto design is a large part of software engineering.
23:18:45 <lament> consider the mess that is WWW.
23:19:05 <Sukoshi> What are ``uncheked or unsafe operations'' ?
23:19:20 <Sukoshi> I'm not catching exceptions?
23:19:26 <RodgerTheGreat> Sukoshi: they mean you either aren't using generics properly or you're doing some shady casting
23:19:40 <SimonRC> Java Generics are all in the name of Bar-Quad-Scum-Batter-Billy-Tea.
23:20:34 <SimonRC> Bar-Quad-Scum-Batter-Billy-Tea being the god of outrageous hacks done to keep old programs working.
23:20:50 <SimonRC> in this case, the new programs can still run on old JVMs
23:20:54 <RodgerTheGreat> Sukoshi: if you add the <> parameterizing to your linkedlist like I mentioned above, it'll work like a charm, I'll bet
23:22:15 <Sukoshi> Oh, another thing -- is it easier to say, catch a List OutOfBounds exception, or is it easier to do an integer check against the bounds?
23:22:16 * SimonRC recommends pronouncing "Bar-Quad-Scum-Batter-Billy-Tea" out loud to get the joke.
23:22:34 <SimonRC> Sukoshi: how often will it get out of bounds?
23:22:45 -!- sebbu2 has joined.
23:23:35 <SimonRC> Sukoshi: just let the exception propagate out then, I suppose.
23:23:53 <Sukoshi> Yeah, I would think the integer check is faster, because the stack doesen't have to unwind.
23:24:19 <RodgerTheGreat> but in all seriousness, I believe you'll have to catch the exception if it's thrown, regardless of external checking. Can the program be reasonably expected to continue running if it *does* get an invalid index?
23:24:37 <Sukoshi> Hey, the compiler isn't complaining, and I'm not either :)
23:24:52 <Sukoshi> Just my experience with C tells me that this can be accessed incorrectly.
23:25:08 <RodgerTheGreat> it depends how much you trust yourself to play by the rules of your own code in other classes
23:26:06 <Sukoshi> I would hope to god nobody inserts a Bencode at -1 index.
23:26:13 <Sukoshi> But I just don't know how stupid people are.
23:27:01 <Sukoshi> I realized something important over the last few days -- it's essential to, at some point, program for a little bit in a lower-level not as sophisticated language.
23:27:15 <Sukoshi> Because for a while, you start forgetting just how crappy the lower level ones are.
23:28:52 <RodgerTheGreat> this is why I'm forcing myself to write all my cryptography programs in C++. It's for practice, but it's also so I can even better appreciate Java in all it's glory
23:29:05 <bsmntbombdood> recursive function of symbolic expressions and their computation by machine
23:36:24 <lament> Sukoshi: what's wrong with forgetting how crappy they are?
23:37:00 <lament> some things are best forgotten
23:37:30 <lament> medicine was pretty crappy 100 years ago, would you undergo an operation using 100-year-old techniques to experience for yourself how crappy it was?
23:37:48 -!- ehird has quit (Read error: 104 (Connection reset by peer)).
23:37:54 <GregorR-L> lament: That's hardly a valid analogy.
23:38:48 <lament> (although there's a flaw in it)
23:39:26 <GregorR-L> Here's two: 1) Using C won't kill you. 2) Many modern medical techniques aren't based on the older techniques, so the older techniques don't actually give you any insights into current ones.
23:39:59 <lament> i don't think 2) is at all valid
23:40:03 <RodgerTheGreat> it'd be more like doctors learning 100 year old techniques to see what they were like (potentially learning lifesaving tricks if they find themselves completely without modern tools)
23:40:11 <lament> 2) is wrong both about medicine and about computing.
23:40:30 <SimonRC> C++'s typesystem has a bit of oomph, at least
23:40:40 <SimonRC> you can expect the types to do some of the work for you
23:40:59 <SimonRC> and C++ is great for being really specific about how you want to allocate memory
23:41:02 <GregorR-L> I hardly think that leeches and bloodletting inspired vaccination.
23:41:20 -!- sebbu has quit (Connection timed out).
23:41:30 <SimonRC> Leeches inspired the use of anti-clotting drugs in surgery
23:44:43 -!- EgoBot has quit (anthony.freenode.net irc.freenode.net).
23:44:43 -!- zbrown has quit (anthony.freenode.net irc.freenode.net).
23:44:43 -!- RodgerTheGreat has quit (anthony.freenode.net irc.freenode.net).
23:44:43 -!- suifur has quit (anthony.freenode.net irc.freenode.net).
23:44:43 -!- lament has quit (anthony.freenode.net irc.freenode.net).
23:44:43 -!- cmeme has quit (anthony.freenode.net irc.freenode.net).
23:44:43 -!- meatmanek has quit (anthony.freenode.net irc.freenode.net).
23:44:43 -!- oklopol has quit (anthony.freenode.net irc.freenode.net).
23:44:43 -!- fizzie has quit (anthony.freenode.net irc.freenode.net).
23:49:05 -!- GregorR-L has quit (anthony.freenode.net irc.freenode.net).
23:49:05 -!- ihope has quit (anthony.freenode.net irc.freenode.net).
23:49:07 -!- sebbu2 has quit (anthony.freenode.net irc.freenode.net).
23:49:07 -!- Sukoshi has quit (anthony.freenode.net irc.freenode.net).
23:49:07 -!- CakeProphet has quit (anthony.freenode.net irc.freenode.net).
23:49:07 -!- Izzy7 has quit (anthony.freenode.net irc.freenode.net).
23:49:07 -!- tokigun has quit (anthony.freenode.net irc.freenode.net).
23:49:07 -!- helios24 has quit (anthony.freenode.net irc.freenode.net).
23:49:08 -!- sp3tt has quit (anthony.freenode.net irc.freenode.net).
23:49:08 -!- mtve has quit (anthony.freenode.net irc.freenode.net).
23:49:09 -!- GregorR has quit (anthony.freenode.net irc.freenode.net).
23:56:52 -!- cmeme has joined.
23:56:52 -!- oklopol has joined.
23:56:52 -!- lament has joined.
23:56:52 -!- meatmanek has joined.
23:56:52 -!- RodgerTheGreat has joined.
23:56:52 -!- suifur has joined.
23:56:52 -!- zbrown has joined.
23:56:52 -!- EgoBot has joined.
23:56:52 -!- fizzie has joined.
23:56:52 -!- sebbu2 has joined.
23:56:52 -!- Sukoshi has joined.
23:56:52 -!- mtve has joined.
23:56:52 -!- GregorR-L has joined.
23:56:52 -!- GregorR has joined.
23:56:52 -!- CakeProphet has joined.
23:56:52 -!- ihope has joined.
23:56:53 -!- helios24 has joined.
23:56:53 -!- tokigun has joined.
23:56:53 -!- sp3tt has joined.
23:56:53 -!- Izzy7 has joined.
23:58:43 -!- tokigun_ has joined.
23:59:43 <Sukoshi> RodgerTheGreat: So, have you been playing with Smalltalk?