ec changed the topic of #elliottcable to: #
<alexgordon> being taught the same as everybody else can only reduce variance
<prophile> I'd think of it as being introduced to the same things rather than being shepherded into the same programming styles
<alexgordon> heh
<prophile> if I teach a bunch of kids what FRP is, or the liskov substitution principle, or what 'with' does in python
<prophile> I'm not doing that to the detriment of whatever else they've learned
<yorick> the liskov substitution principle is rather useless
<yorick> does it really need a name?
<prophile> giving a name to something just makes it easy to refer to
<yorick> does it ever need to be referred to?
<alexgordon> nope
<yorick> just makes it sound more important and maybe overrepresents it in actual code
<prophile> you're against naming things in case people think they're important?
<alexgordon> teaching the liskov substitution principle is like telling your children "don't kill people". Either they *already* understand it, or there's no hope for them
<prophile> they probably already understand it at some level, but formalising it can clarify what they already know
<yorick> alexgordon: I think it's more like "to be less thirsty, you can drink water instead of soda" and calling it the Waterimov Substitution Principle
<alexgordon> to the extend that it's applicable to the real world, it contains no useful insights
<yorick> of course poisonous water is a violation of it
<yorick> and seawater :P
<alexgordon> prophile: actually I think LSP underlies a bigger problem: overuse of inheritance in academia
<alexgordon> the only people who use more inheritance than java programmers, are java programmers in academia
<yorick> oh god the UML diagrams are all coming back
<alexgordon> xD
<alexgordon> at least in the real world you quickly learn Not To Do That Shit
<yorick> all of the InternalFrameInternalFrameTitlePaneInternalFrameTitlePaneMaximizeButtonWindowNotFocusedState
<alexgordon> universities seem to teach a bastardized version of programming where if a feature exists, It Must Be Used
<alexgordon> not only do they teach it, they mandate it
<alexgordon> gotta teach the whole language
<yorick> I can see the inheritance diagram up to InternalFrameInternalFrameTitlePaneInternalFrameTitlePaneMaximizeButtonWindowNotFocusedState until all the InternalFrames are gone :P
<yorick> why not teach people about org.springframework.aop.framework.AbstractSingletonProxyFactoryBean
<alexgordon> initWithBitmapDataPlanes:pixelsWide:pixelsHigh:bitsPerSample:samplesPerPixel:hasAlpha:isPlanar:colorSpaceName:bytesPerRow:bitsPerPixel: ?
<yorick> " Convenient proxy factory bean superclass for proxy factory beans that create only singletons. "
<alexgordon> I think this is not unique to programming though
<yorick> of course not, it happens with the government too :P
yorick has quit [Remote host closed the connection]
<ec> hi
<purr> ec: hi!
<alexgordon> hi ec
<ec> hi
<purr> ec: hi!
<ec> no
<alexgordon> lol
<purr> lol
sharkbot has quit [Ping timeout: 240 seconds]
sharkbot has joined #elliottcable
alexgordon has quit [Quit: Computer has gone to sleep.]
<purr> <devyn> it is a fact ----------- I think
niggler has quit [Quit: Computer has gone to sleep.]
<joelteon> is it ok to ban people just for being annoying
<devyn> joelteon: lol in what
<purr> lol
<joelteon> deviantart
* devyn shrugs
<purr> ¯\(º_o)/¯
<devyn> I don't dA
<joelteon> it's ruhtarded
* devyn goes back to working on whatever he was working on before
<devyn> but now with alcohol and caffeine in his system!
<devyn> ^_^
<joelteon> >alcohol
<purr> <prophile> will you desist
<joelteon> what should i do now
eligrey has quit [Quit: Leaving]
* ec sighs
<ec> friend?
<ec> saddest.
<purr> <alexgordon> also I didn't know "Chains" was an attire
<purr> <alexgordon> wait is joelteon gq?
<whitequark> friend?
* whitequark thinks of a syntax for closures
<whitequark> (x) { print(x) }
<whitequark> or even (x) x * x, if it's a single expression
<whitequark> [|1, 2, 3|].map((x) x * x)
<whitequark> oh also, a clean solution to self-swizzling
<whitequark> if you don't mention self as the first argument, it is taken from environment
<whitequark> ie: def foo; () self; end; FOO.foo # => FOO
<whitequark> as an upvalue
<whitequark> but if you do
<whitequark> def foo; (self) self; end; FOO.foo(1) # => 1
<whitequark> then it just gets bound to whatever's passed as the first argument
<whitequark> useful like this:
<whitequark> define_method(:foo, (self, bar) @x + bar)
<whitequark> whaddayathink?
<whitequark> @x implicitly dispatches on self, as usual, of course
<whitequark> oh and methods are just closures where the first argument is self
<whitequark> and def name(args...) is sugar for define_method(:name, (self, args...) { ... })
alexgordon has joined #elliottcable
<purr> <Nuck> PAWS WILL TELEPORT YOUR BABY TO DEAD.
yorick has joined #elliottcable
yorick has quit [Remote host closed the connection]
yorick has joined #elliottcable
<purr> <alexgordon> PHP is like a good burrito
<alexgordon> gives you the shits?
<prophile> sieves you the gits?
Sorella has joined #elliottcable
Sorella has quit [Ping timeout: 256 seconds]
eligrey has joined #elliottcable
<purr> <alexgordon> now if I could download popcorn from usenet...
yorick has quit [Remote host closed the connection]
<devyn> lol
<purr> lol
<joelteon> lol
<purr> lol
<joelteon> no i am not gq
<alexgordon> surely someone must be on irc right now
<alexgordon> ec
<alexgordon> ec
<alexgordon> e
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> ec
<alexgordon> well if he's not here, this was pointless
<alexgordon> and if he is here, he'll be very angry
<joelteon> fuck em
<ec> lol
<purr> lol
<ec> hi, ish
<prophile> callCC is only naively implementable in a language with a sensible type system if propositional logic is equivalent to intuitionistic logic
<ec> prophile: smaller words, bro. smaller words.
<prophile> cump
<devyn> propositional logic, intuitionistic logic… wat
<devyn> whoa
<devyn> actually a thing
<devyn> alexgordon
<devyn> alexgordon
<devyn> alexgordon
<devyn> alexgordon
<devyn> alexgordon
<devyn> alexgordon
<devyn> alexgordon
<devyn> alexgordon
<devyn> alexgordon
<devyn> alexgordon
<devyn> alexgordon
yorick has joined #elliottcable
<whitequark> prophile: wat
<whitequark> I understand your terms, but the sentence as a whole still doesn't make sense
<purr> <Nuck> when the fuck was I a seahorse
<prophile> whitequark: the curry-howard isomorphism
<prophile> pierce's law as an axiom is enough to turn intuitionistic logic into propositional logic
<whitequark> mmmmm
<prophile> which is ((p -> q) -> p) -> p
<prophile> under the curry-howard isomorphism that corresponds to the call/cc type signature
<prophile> and if there's an implementation for call/cc, then ((p -> q) -> p) -> p is a theorem of intuitionistic logic
<prophile> which would make it equivalent to propositional logic
<whitequark> what the fuck
<whitequark> I believe you
<whitequark> but my brain hurts
<whitequark> wait.
<prophile> here, you can borrow my heat sink
<whitequark> ((p->q)->p)->p
<whitequark> call/cc returns twice
<whitequark> either you're using some other kind of type signatures than me
<prophile> q is basically ignored
<prophile> callCC takes ((p -> q) -> p) as an argument
<whitequark> yes, I understand the part where intutionistic logic turns to propositional logic
<prophile> (p -> q) is the continuation passed in
<whitequark> but how the fuck is this related to call/cc
<prophile> and you call it to call the current continuation
<whitequark> still don't get it
<whitequark> hrm
<prophile> look up the continuation monad if you like
<prophile> it gimps the types by putting monads on them
<prophile> but it does make it possible to actually implement
<prophile> that is, you put callCC in the kleisli category and make it ((a -> Continuation b) -> Continuation a) -> Continuation a
<whitequark> brb drugs
<whitequark> no
<whitequark> really
<whitequark> fuck that
<whitequark> I'm too fucking dumb
<whitequark> and it is not like this knowledge is particularly rewarding or what
<ec> hi
<purr> ec: hi!
<whitequark> hi
<purr> whitequark: hi!
<ec> I don't want to be dumb
<ec> prophile: you need to help me find an appropriate CS program for me, some time.
<ec> I'm completely willing to put in 4 years to learn to understand that shit. I truly believe it'll make me a better programmer, and I crave that. /=
<prophile> whitequark: well, it's actually relevant to my current project
<prophile> ec: I'm sure you could find a much better use for 4 years
<prophile> I could teach you all the relevant theory you need to know in maybe 6 weeks
<whitequark> ec: it looks way cooler than it is.
<ec> … but you do you have 6 weeks to dedicate to teaching me?
<ec> whitequark: not about the cool.
<ec> whitequark: I'm more interested in the *mental framework*.
<ec> Look at Paws. Or at least what you know of it. I'm a talented programmer, but I work *entirely* off of intuition.
<whitequark> ec: the corresponding mental framework does not make you a better programmer
<whitequark> in fact, both in mathematics and programming, intuition is extremely important. more than formal proofs.
<ec> I can make great things like that … sure, I may not necessarily believe that I'll *truly gain anything*, i.e. make objectively better products, with that knowledge
<ec> but I'm a fucking developer!
<whitequark> ec: it has incredibly little relevance to developing software.
<whitequark> and that relevance is mostly coincidental.
<ec> given the option between using proprietary, black-box tooling (intuition.) to produce greatness, and open-source, dissectible, introspectible tooling (logic.), I'm going to put in the effort to learn the latter tool.
<ec> even if I'm already proficient in the former.
<whitequark> how do you think people create new mathematical proofs?
<whitequark> logic allows you to validate them.
<whitequark> and again
<whitequark> it's like, well, monads
<ec> don't forget, there's also the communication aspect.
<whitequark> category theory has absolutely zero relevance to programming in haskell.
<whitequark> it won't make you a better programmer; it won't let you understand the language any better, in fact.
<ec> I'm exhausted of spending my life having people smarter than me try ti tell me that my <something> is <some other thing>, and not having the words to argue with them *without* dragging them into a six-hour-long exposition wherein I describe <something> in detail until they *finally* understand why I think it's different
<whitequark> right
<whitequark> I didn't say you don't need *any* CS
<whitequark> just not the insane mind-bending pure mathematics parts
<whitequark> in fact
<ec> prophile: opinion?
<whitequark> you need surprisingly small logical framework even in order to make a practical formalization of a programming language
<whitequark> e.g. look at Typed Scheme
<whitequark> it draws about one A4 page of notation and semantics from math, which you can understand in a day
<ec> Typed scheme? unfamiliar
<prophile> my experience has been that learning the formalities, like learning many other things, hasn't itself flipped a magical "you are now a good programmer" switch
<whitequark> ^ that, a million times
<prophile> what it does do is gives you new ways of thinking about things
<ec> yes, that's exactly what I want.
<prophile> and experience to draw on, if you like
<ec> thinking about programming is currently boring.
<ec> or, to put it another way, I'm *too good* at thinking about programming the way I currently think about programming.
<ec> I know I'm going to improve very little, or no further at all, even, in my current vector. I want to change it up, find new ways of approaching the same things.
<ec> Not *necessarily* better, just different; and *if* better, more “better through variety” than anything else.
* prophile thinks
<ec> It's like natural selection. Homogeneity is death; as much so in the mind as elsewhere.
<whitequark> ec: from what I understand from our discussions
<whitequark> start from regular CS.
<whitequark> you'll see immediate and huge benefit.
* ec nods
<ec> as soon as I can find a program that doesn't try and teach anything important using *fucking Java*, I'm hoping to do so.
<whitequark> SICP?
<ec> although I *do* intend to take mathematics courses in parallel. It's just something that interests me, that logical and precise and proven way of thinking.
<whitequark> EOPL3?
<ec> SICP's been on my mind quite a while. Thanks to inimino, mostly.
<prophile> sounds like you might be interested in the oxford CS course then
<ec> But I'd like to do it *with* somebody, *with* people.
<whitequark> as in?
<ec> And most importantly, *with* a skilled teacher/professor. I need somebody smarter than me to talk to, and to answer questions.
<whitequark> mmm
<ec> A lot of learning is figuring things out for yourself, yes … but there's a difference between an hours' hard thought on a topic,
<whitequark> you can ask me for about anything in SICP :)
<ec> and banging your head against it for *fucking days*, getting discouraged, and giving up.
<whitequark> and prophile for, likely, just anything you can think of
<prophile> haha
<ec> Still not the same as a school setting.
<ec> hmmmmmmmm.
<ec> Maybe i'll start some sort of mutual-learning group in Chicago.
<ec> There's *got* to be at least a few programmers there interested in improving themselves.
<ec> are SICP-clubs a thing? or a more abstracted, non-SICP-specific version of the same?
<whitequark> dunno
<whitequark> not interested in meatspace.
<whitequark> well, learning groups in meatspace.
<ec> lol
<purr> lol
<ec> really?
* ec pats whitequark
<ec> Life's worth more than programming, imo.
<whitequark> ec: so? didn't say otherwise
<whitequark> lemme repeat that the way I meant it
<whitequark> not interested in programming learning groups (or, learning groups for about anything I can figure out on my own) in meatspace.
* ec nods
<ec> I tend to understand things better when I *explain* them,
<whitequark> it's just... so slow
<ec> and to boot, I sometimes get mentally stuck and need a random input to reset me
<ec> between the two, a group of people whom I can mutually explain things to, and have things explained to me by, is really productive
<alexgordon> huh so this is what the darth pro looks like, to scale: http://chocolatapp.com/snaps/darthproinreallife.png
<whitequark> ten minutes with a good mentor is usually worth a thousand hours with peers.
<whitequark> however, it doesn't really have to be a learning group
<whitequark> find a guy on the internet with related interests, pester him until he replies :p
<ec> lol.
<purr> lol
<whitequark> it helps if you have something sensible to say, too. but works even without it rather well.
<ec> well, at the moment, there's other shit too. I need socialization excuses in my life right now. This messy move, and problems with the girl, and blahblahblah are making me *really* lonely.
<ec> Need excuses to meet people in Chicago when I'm there. And can't imagine doing better than the kind of person who'd want to read the SICP with me.
<whitequark> reading about highly technical stuff with geeks sounds just about right kind of socialization for me
<whitequark> </sarcasm>
<prophile> ec: have you ever read GEB?
<ec> whitequark: I know you're kinda new here; but I'm really burnt out on the other kinds.
<prophile> renaissance man that you are, I suspect it'd be exactly up your street
<ec> Had a reallllllly crazy year last year.
<ec> Lots of sex, alcohol, parties, drugs (not by me, but still)
<whitequark> prophile: Godel, Escher, Bach?
<ec> a lot of traveling, hundreds of people in my life on a daily basis.
<prophile> whitequark: aye
<ec> prophile: is that the shit with the “strange loops?”
<whitequark> yep
<prophile> damn right
<ec> got the solid impression that it was all bullshit.
<whitequark> ec: it isn't
* ec eyebrows
<prophile> it's a hell of a book
<whitequark> well, if the parts I know about represent the book as a whole
<ec> hm, I've got it on my shelf
<whitequark> then it's fucking awesome
<prophile> highly recommend it
<whitequark> ^
<ec> hmmm
<ec> 'k
<prophile> it also makes - in many ways - a very good introduction to the formal stuff you were talking about earlier
<ec> what was the other thing you mentioned, than SICP?
<whitequark> EOPL3?
<prophile> Alistair's "How To Formal" syllabus
<ec> that
<ec> prophile: in order?
<alexgordon> ec: don't listen to them
<prophile> roughly, I haven't ordered it yet
<ec> what're the prerequisites
<whitequark> prophile: did you just pick things at random?
<alexgordon> ec: they're trying to turn you to the light side
<whitequark> though, comonads
<prophile> it's a combination of the things i've found useful
<whitequark> I like their application
<whitequark> I wonder if there is a sane alternative
<whitequark> and by sane I mean composable
<whitequark> or, not like that
<whitequark> I wonder if it is even possible to create a composable alternative and retain the useful semantics
<whitequark> prophile: seen an interesting application of monads/comonads in embedded dev
<whitequark> basically... monads were used to represent (some kinds of) operation over normal, bounded data structures
<whitequark> and comonads were used to represent operations over external data
<prophile> interesting
<whitequark> together, you could ensure that the program will not abruptly halt
<whitequark> as in, monads guaranteed that you won't shit itself in the internals
<whitequark> and comonads provided a way to channel input inside, and also guaranteed that you won't shit yourself while handling it
<alexgordon> ec: TALK TO ME ABOUT STUFF
<whitequark> it's a poor explanation I know :/
<whitequark> didn't really get it, just understood that it may be very damn useful.
<whitequark> monads are a much lesser PITA than, for example, ATS
<whitequark> prophile: you have PEG twice in that list
<whitequark> and seriously, fuck PEG
<whitequark> lemme show what you should use instead
<whitequark> um, LtU is dead
<prophile> do I?
<prophile> my mistake
<prophile> LtU?
<alexgordon> lambda the ultimate I assume
<alexgordon> though it seems very much alive
<whitequark> right
<whitequark> "user error: Table './ltu/cache' is marked as crashed and should be repaired"
<whitequark> but I found the article
<prophile> interesting
<whitequark> unlimited lookahead AND linear complexity
<ec> hi
<purr> ec: hi!
<ec> alexgordon: wat
* prophile puts it in the papers to read box
<alexgordon> ec: STUFF. TALK TO ME
<whitequark> prophile: pls explain it to me when you read it
<whitequark> because I kinda failed it
<whitequark> but I didn't really try very hard, though.
<ec> are -clouds
<whitequark> should pick up on parsing... I really suck on the topic
<prophile> well, start at the basics
<prophile> you're familiar with the workings of regexes, I take it?
<prophile> NFAs and such?
<whitequark> yeah
<ec> alexgordon: what *is* this. *You* bugging *me* to talk about Paws?
<ec> alexgordon: was there recently a disruptive event in your life?
<ec> alexgordon: death of a family member? bad breakup? realized you were actually straight?
<prophile> familiar with LL(1) and recursive-descent munging?
<whitequark> yeah
<alexgordon> ec: HAHA
<whitequark> up to this point, I pretty much understand it
<whitequark> well, it's not exactly hard.
<prophile> those are all you actually need to know in practice
<whitequark> LR(1)/LALR(1) kinda evades me
<whitequark> that is, I have some vague understanding of how it works
<whitequark> and I can fuck with the grammar until it works like I want it to
<alexgordon> ec: yes. paws me up.
<prophile> LR(1)/LALR(1) are a nice little academic thing, but I really, really don't like them
<prophile> they don't compose well
<whitequark> prophile: it's really practical though.
* alexgordon imagines "pawsing up" as some kind of grease application
<whitequark> I hate them, but use them.
<prophile> and they ended up with indecipherable error messages
<ec> alexgordon: -> #Paws.Nucleus
<whitequark> yeah yeah
<whitequark> PEGs are shit, though.
<prophile> most sensible programs can be rotated into basically LL(1) with the few exceptions easily handlable via custom code in a recursive descent parser
<prophile> they really aren't
<whitequark> well, in part implementations are to blame
<alexgordon> -spec
<purr> alexgordon: Paws' half-arsed Version 10 specification <http://ell.io/ihQzs>
<whitequark> NO LEXER? YES THIS IS A GREAT IDEA
<whitequark> LET'S ALLOCATE A NODE PER CHARACTER YEAH
<prophile> you don't actually have to allocate a node per character, you know
<whitequark> right.
<whitequark> but for example every. single. ruby peg parser does that
<whitequark> they all suck
<prophile> obviously the ruby community is the one famous for its care about efficiency
<whitequark> then, we have this exponential behavior
<prophile> let me find you a paper
<whitequark> which can kinda be alleviated into linear space by memoization
<prophile> that you may find intriguing
<whitequark> but this feels like a horrible hack for it
<prophile> it's a completely different approach to using a PEG
<whitequark> besides!
<whitequark> you can't even blindly memoize the results of PEG; generally that will lead to a *less* efficient parser
<prophile> ^ read, absorb
<prophile> correct
<whitequark> so
<alexgordon> PEGs are stupid because if you want an easy parser: use a parser generator. If you want a good parser, write it yourself
<whitequark> it really is a hack
<alexgordon> there IS no middle ground
purr has quit [Remote host closed the connection]
purr has joined #elliottcable
<whitequark> prophile: the criticism of regexes at the start is not well founded enough
<whitequark> that is
<whitequark> the implementations are really shit, but the problem is that they don't do NFA-DFA transformation
<whitequark> if you do perform them, you can tackle the pathological backtracking quite easily.
<prophile> the problem is that they can't, because practical regex libraries aren't actually regular expressions
<whitequark> right
<alexgordon> not sure what the context is, but the answer is ragel
<prophile> and the backtracky goodness is useful in practice
<whitequark> prophile: oh, sure it is
<whitequark> but if you implement them *properly*, it does not exhibit pathological behavior
<whitequark> lemme show you
<prophile> read the implementation part anyway, that's the juicy bit
<prophile> "Remember that NFAs are endowed with the ability to guess perfectly when faced with a choice of next state: to run the NFA using an ordinary computer, we must find a way to simulate this guessing."
<prophile> well that's clearly not true
<prophile> you just keep track of the set of active states
<whitequark> read along
<prophile> ah, lovely
<alexgordon> lol
<purr> lol
<whitequark> prophile: "The SNOBOL-like modus operandi"
<whitequark> god why
<whitequark> oooooh
<whitequark> section 4
<whitequark> neatness
<whitequark> prophile: ok. I'm still wary of PEGs.
<whitequark> they are probably fine for source code parsers
<whitequark> but for a built-in finite automata / parser facilities, I'd really choose something better.
<alexgordon> still don't see why a PEG would be faster to write than a ragel/lemon parser
<alexgordon> alternatively, still don't see why a PEG would have better error handling than a hand written recursive descent
<prophile> a PEG is a formalism, not an implementation
<alexgordon> any implementation of it
<prophile> I tend to write grammars and PEGs then write a recursive-descent parser from that
<prophile> s/and/as/
<alexgordon> I guess? but you can do that with lemon and it'll take less time
<prophile> lemon is just another LALR parser
<prophile> it may be nicer than bison but imo that just means it's a turd polished to a mirror shine
<alexgordon> yeah, just another LALR parser
<whitequark> every single L*R* parser generator I've seen sucks compared to menhir
<alexgordon> works great though
<alexgordon> for prototypes
<whitequark> still shit though
<alexgordon> if you want a production compiler, recursive descent is still the only way
<alexgordon> though tell that to ruby or php
<whitequark> php
<whitequark> there are also LL(k) generators.
<prophile> alexgordon: well, gcc up until one of the 4.* series was still mostly autogenerated
<whitequark> wow
<prophile> hence its famously terrible error messages
<alexgordon> point is, there are three things people evaluate parser libraries/generators on: 1) prototyping suitability (how long it takes to write a parser), 2) parser speed (how fast the parser goes), 3) error recovery in the parsers
yorick has quit [Remote host closed the connection]
<alexgordon> lemon has 1 owned, recursive descent has 3 owned, and it's pretty even on number 2 (lemon gets you most of the way there, with minimal effort, but recursive descent can be optimized by hand to squeeze everything out of it)
<whitequark> you can do RDP fast with pattern matching
<whitequark> ie not C++
<whitequark> well, generally fuck clangs
yrashk has joined #elliottcable
<ec> what's wrong with clang? D:
<alexgordon> ec: GCC 4, man. can't get better than that
* ec eyebrow
<alexgordon> except maybe gcc 3
<ec> really?
<ec> but, but, but, pretty errors!
<joelteon> gcc 13.2 is pretty good
<prophile> clang's got code of mine in there
<prophile> which clearly makes it superior to gcc in every way
<prophile> and when you hit that one edge case with integer overflow and get one fewer instruction
<prophile> you'll have me to thank
purr has quit [Remote host closed the connection]
purr has joined #elliottcable
purr has quit [Remote host closed the connection]
purr has joined #elliottcable
<purr\GH> [purr] ELLIOTTCABLE pushed 2 new commits to master: https://github.com/ELLIOTTCABLE/purr/compare/f1940fa01bed...e073ffcf1fc9
<purr\GH> purr/master 64045ab elliottcable: (- new) Adding -listening as an alias to ♪
<purr\GH> purr/master e073ffc elliottcable: (- fix) -song should work outside isDick contexts
<ec> prophile: lol'd
<purr> lol
<prophile> I'm going to risk exposing myself as unclassy
<prophile> -listening Lights
<purr> prophile is listening to “All of the Lights”, by Kanye West
<prophile> whoa, not THAT unclassy
<prophile> bloody hell
<prophile> i meant the journey song
<alexgordon> prophile: xD