ELLIOTTCABLE changed the topic of #elliottcable to: more cult
<vigs> ELLIOTTCABLE: you're a fucking wizard
<ELLIOTTCABLE> vigs: love u 2
<ELLIOTTCABLE> joelteon: obviously
<ELLIOTTCABLE> joelteon: 'cuz Kim Jong-un invented it in his infinite wisdom
<ELLIOTTCABLE> -ELLIOTTCABLE
<purr> ELLIOTTCABLE: literally a worse villain than Edward the Sparkly Vampire. boo hiss
<ELLIOTTCABLE> -learn ELLIOTTCABLE = literally a fucking wizard. boo hiss
<purr> ELLIOTTCABLE: Learned `ELLIOTTCABLE`.
<ELLIOTTCABLE> -ec
<purr> ELLIOTTCABLE: literally a fucking wizard. boo hiss
<ELLIOTTCABLE> -elliott
<purr> ELLIOTTCABLE: literally a fucking wizard. boo hiss
<ELLIOTTCABLE> woah they're linked k
<vigs> ELLIOTTCABLE: re: that Secret link you posted: fuck purple skull, saying "that's racist"
<ELLIOTTCABLE> reading a lot of it now
<vigs> I'm also attracted to pasty-ass white girls, and I'm BROWN. Hell, I'm not even attracted to most brown girls, ffs
<vigs> by brown I mean Indian, but
<ELLIOTTCABLE> LOL AT SECRET
<purr> LOL
<ELLIOTTCABLE> just read this message:
<ELLIOTTCABLE> “Being completely dismissed tends to upset people, brown pile of shit”
<ELLIOTTCABLE> right after reading yours
<ELLIOTTCABLE> and was like, WOAH that's racist
<vigs> LOL
<vigs> but no, *green pile of shit nails it
<vigs> people are too fucking sensitive sometimes :.
<vigs> * :/
<vigs> Like this one time, I was at a dinner party thing at a parents' friend's place and was chatting with some guy roughly my age, and jokingly said "brownie" instead of "indian person" and he got SUPER offended
<ELLIOTTCABLE> hi all
<vigs> like, chill the fuck out, we're both brown and that shit was funny
<ELLIOTTCABLE> disagree.
<vigs> (there was context that made "brownie" funny there) but yeah I sometimes say "brownie" in place of "Indian" ¯\_(ツ)_/¯
<ELLIOTTCABLE> The right to be-offended is a basic fuckin' right. The Internet desensitizes us to that fact, I mean, I've definitely done my share of tone-policing or the like, but … I'm definitely of the growing opinion that anybody, anywhere, has a measure of right to go “that. that's the line, and you just crossed it.” to just about anyone else.
<ELLIOTTCABLE> Doesn't mean anybody'll *listen*, or that their ability to do so somehow impinges on your free speech, but …
<ELLIOTTCABLE> I really think our world is (positively.) developing into one where the majority of people are going to tell you to right-fuck-off if you're seen to ignore somebody else's hurt. Especially if you're the one who caused it.
<vigs> Yeah, but while I don't remember exactly what I said, but it was a groan-worthy joke that wasn't offensive/said with vitriol towards anybody. Literally no reason to get pissy about it.
<vigs> And yeah, telling people to fuck off is an awesome attitude.
<ELLIOTTCABLE> nono that's missing the point
<ELLIOTTCABLE> It's *hugely* dangerous to believe that “it wasn't mean” equates to “it wasn't offensive.”
<vigs> right
<vigs> even so, I think it was stupid that he got all annoyed at that.
<ELLIOTTCABLE> FUCK ME FUCK ME FUCK ME
<ELLIOTTCABLE> it's apparently Chicago Craft Beer Week
<ELLIOTTCABLE> and I didn't even know that was a thing, and now I feel like I fail at life because I have no plans or didn't hear about this or whatever
<vigs> lol
<purr> lol
<vigs> anyway I gotta take off
<vigs> gotta check out a house I could sublet this summer
<ELLIOTTCABLE> vigs: lame
<ELLIOTTCABLE> vigs: you're 14, right? how you subletting a house?
<vigs> ELLIOTTCABLE: …a room in a house, and I'm 20
<vigs> My lease here ends in mid-June, and my new place's lease starts in mid september, and I'll be in town during summer because full-time job.
<ELLIOTTCABLE> where do you live again
<vigs> San Luis Obispo; it's on the central coast of California. I'm from the Bay Area, though.
<vigs> So when I'm home, I sometimes hang out with SF Twitter nerds, they're cool people
<vigs> okiedoke, gotta take off forreal now
* ELLIOTTCABLE fucking fucking fucking fuck.
<gkatsev> what kind of fuck was it again?
<ELLIOTTCABLE> a fucking fuck.
rckts has joined #elliottcable
<ELLIOTTCABLE> look its colby rocketwig
<rckts> lookit that
<rckts> but no more @rockets :(
<ELLIOTTCABLE> why not?
<rckts> got really annoyed one day and on a whim got someone to switch me over to @cdl, they grabbed @rockets
<ELLIOTTCABLE> brb pizza
<ELLIOTTCABLE> mmmmm
<rckts> nice nice nice
<ELLIOTTCABLE> rckts: so, I've heard good things about Ember. It fills a hole in my own knowledge (heavy-framework at the top of the stack)
<ELLIOTTCABLE> from everything I've heard, it beats out Angular for that position, sooooo
<rckts> yeah - apparently it feels a lot less hacked together than Angular too which is nice
<ELLIOTTCABLE> oh, and,
<ELLIOTTCABLE> -langugaes @ rckts
<ELLIOTTCABLE> hm
<ELLIOTTCABLE> -language @ rckts
<ELLIOTTCABLE> …
<ELLIOTTCABLE> -find language
<purr> ELLIOTTCABLE: Found: jux, languages, languages.ours, paws sex, and reduction
<rckts> you misspelt languages the first time around
<ELLIOTTCABLE> -languages @ rckts
<purr> rckts: ‘What languages should you learn?’ The answer: more of them! Try `-object-oriented`, `-functional`, and `-low-level` for some suggestions. (If you really want to stretch your mind, try `-paradigms` <3)
<rckts> -paradigms
<purr> rckts: So you want to be an unusually well-rounded programmer! Try learning one of each of these: a LISP <http://schemers.org> | a logic language <http://swi-prolog.org> | something concatenative <http://factorcode.org> | a hardware-description language <http://wikipedi.as/VHDL>
<rckts> -functional
<purr> rckts: STOP CATEGORIZING THEM ಠ_ಠ
<rckts> LOL
<purr> LOL
<ELLIOTTCABLE> purr is great.
<ELLIOTTCABLE> textual pff thats dumb
<ELLIOTTCABLE> anyway
<ELLIOTTCABLE> rckts: is PHP the only language you know well right now?
<rckts> ELLIOTTCABLE: actually, Obj-C is probably the language I'd say I know most, with JS under that
<rckts> and yeah yeah, i had irssi set up but i lost my conf and cba to recreate it
<ELLIOTTCABLE> interesting. Ruby'd be a good choice to learn, because it pairs well with ObjC.
<ELLIOTTCABLE> That'll allow you to share a lot of conventions / knowledge with your ObjC codebases
<rckts> ah, alright - that makes sense, I'll probably see about focusing on that for a bit and try my hand at making some stuff
* ELLIOTTCABLE nods
<ELLIOTTCABLE> Honestly, Ruby'll be a sideshow for you. It's simple enough for you to pick up.
<ELLIOTTCABLE> Stay away from Rails etc, it's just a language you should know for myriad purposes.
<ELLIOTTCABLE> greaaaaat for quick scripts, greaaaaat for prototyping, great community, pretty code, etcetcetc
<rckts> Ugh, yeah, no matter how hard I try I just can't seem to like Rails, so no worries about that - from what I remember when I tried to pick up Ruby a few years ago, it came pretty easily to me
<ELLIOTTCABLE> but yeah. I'm a big JavaScript nut nowadays; Node's great; and frontend-heavy apps are the future at the moment.
<ELLIOTTCABLE> fuck rails.
<rckts> hahahaha
<ELLIOTTCABLE> beyond that … spend some time learning languages that won't directly apply to your web work.
<ELLIOTTCABLE> Haskell for sure (but don't ask me about that, I'm insanely incapable at Haskell).
<rckts> I've yet to try my hand at any front-end heavy apps.. or I suppose any web apps at all, really
<rckts> Oh god Haskell nope
<ELLIOTTCABLE> Scheme, ditto, although that's another sideshow: you can read the entire specification in an evening.
<ELLIOTTCABLE> nonono, seriously!
<ELLIOTTCABLE> stretch your brain! All the other things mentioned are Rut languages; they're basically the same thing, with minor variations.
<ELLIOTTCABLE> Scheme and Haskell are a good starting-point to stretch your horizons, and really make yourself a better software developer *period*.
<ELLIOTTCABLE> A) learn a LISP, B) learn Haskell, C) follow some designers, and D) follow some feminists.
<ELLIOTTCABLE> Boom, you'll be a 85% better programmer.
<rckts> yeah, this is all really good - thanks a lot yo. i'll probably dive into Ruby sometime soon and then after I get pretty competent with it I'll take a look at Haskell or Scheme
<rckts> and I basically do C and D already so
alexgordon has quit [Quit: Textual IRC Client: www.textualapp.com]
<ELLIOTTCABLE> rckts: D's dead. (Facebook notwithstanding.)
<ELLIOTTCABLE> rckts: if you want a not-iOS-focused low-level language as an alternative to ObjC, learn Rust, IMO.
<ELLIOTTCABLE> Go's an acceptable alternative, although I personally find it disgusting.
<ELLIOTTCABLE> OH BY THE WAY
<ELLIOTTCABLE> -didja @ rckts
<purr> rckts: didja write a paws yet? didja? didja!?
<ELLIOTTCABLE> if you want a project to learn Ruby well, write me a Paws. ;)
<ELLIOTTCABLE> there's a spec now and everything!
<rckts> where's the spec at?
<ELLIOTTCABLE> -spec @ rckts
<purr> rckts: Paws' Version 10 specification <http://ell.io/spec>
<rckts> dope - I'll take a look at it, ahaha
<ELLIOTTCABLE> realistically, I'd totally be your foreverbffslave if you did that, but the advice itself *isn't* bad. Writing a mostly-complete Scheme implementation is an *excellent* way to teach yourself a fuckton about a new programming language *and* about languages themselves.
<ELLIOTTCABLE> I can't more highly recommend that you allot a weekend to read the spec, and try your hand at implementing the basics in JavaScript or Ruby. There's tooooons of tutorials and random related information out there.
<rckts> any recommended reading for programming paradigms or other higher level non-language specifics?
<ELLIOTTCABLE> you'll end up learning Scheme, Ruby, *and* how programming languages basically work, in a few days' exploration.
<ELLIOTTCABLE> hmmmmmmmm
<ELLIOTTCABLE> not-language-specific is hard.
<rckts> I haven't had any formal training or anything like that so I'd like to get a bit more general CS knowledge
<ELLIOTTCABLE> the only people who seem to be non-languageist, are high-level academics who write shit that even *I* can't understand /=
<ELLIOTTCABLE> if you try to advance your knowledge of any individual language far enough, you'll quickly get into general CS stuff
<ELLIOTTCABLE> for instance: how's your grokking of the Objective-C object-model and runtime
<ELLIOTTCABLE> get even mildly deep into that shit, and you'll hit meat real quick.
<ELLIOTTCABLE> but beyond that, the best way is to learn one of the languages that these topics are often discussed *with*.
<rckts> object-model, not bad, but still pretty basic, and runtime - uhhhhhHHHH yeah no unfortunately not very much
<ELLIOTTCABLE> (in my experience? yet again, Scheme and Haskell. Lua, to some extent, 'cuz it's so simple; especially when discussing programming-langauge implementation stuff.)
<rckts> Yeah, I get you, makes sense
<ELLIOTTCABLE> oh. relevant:
<ELLIOTTCABLE> learn ISO C *well*.
<ELLIOTTCABLE> You should be able to do some dirty, filthy things to/with/in that language before you try to go much of anywhere else as a programmer.
<ELLIOTTCABLE> not so much because C itself is great, or matters in the modern world (well, *I* like it, but nobody else does), or …
<rckts> aaahaha - good advice
<ELLIOTTCABLE> but instead, because understanding C *means* that you **understand the machine**.
<ELLIOTTCABLE> and knowing how your machine works is crucial to working in almost any pragmatic language.
<rckts> right, for sure
<ELLIOTTCABLE> Figuring out what's going on with your leaky-ass memory situation is not really that different a task, whether you're working in highly memory-managed Ruby, or in ARC ObjC. The actual *changes* you'll eventually make, sure; but they all require a basically equal understanding of the hardware you're coaxing.
<rckts> yeah, I remember hearing someone say if you know your machine level well enough down to the architecture, you should theoretically be able to debug a lot more issues you encounter while programming
<ELLIOTTCABLE> theoretically? nah, it's extremely definite, concrete fact.
<rckts> oh i think it was "theoretically be able to debug every issue you encounter"
* ELLIOTTCABLE nods
<ELLIOTTCABLE> so.
<ELLIOTTCABLE> Pending your availability of free-time, I assign you the following learning-plan:
<rckts> idk pretty sure he was just being safe by saying theoretically, because it was on a podcast and he didn't want to end up starting an argument, haha
<ELLIOTTCABLE> Spend a weekend on reading about Objective-C's internals. (Suggest mikeash's archives, NSHipster, maybe furbo's writing too), and build something *exclusively* in ISO C.
<ELLIOTTCABLE> something difficult, or mind-bending, too. Something that's not necessarily familiar territory for you. (Scheme implementation! Or Paws! Or perhaps a simple database. I'm sure you can come up with something.)
<ELLIOTTCABLE> if that drags on into a second weekend (idk your schedule, but, you get my point), then that's okay. let it, that's important foundation.
<ELLIOTTCABLE> Then, a second weekend, thoroughly learning Scheme or Common Lisp. IMO, you don't really need to write anything complex in it to grok the parts you need to, at this point; it's more learning to “speak the language,” especially if you want to start reading more meaty CS stuff.
<ELLIOTTCABLE> Finally, dive into Ruby and JavaScript. You'll have a different perspective on things at this point *anyway* (which is good), so not much point in laying out specifically what parts of those you'll want to explore, yet.
<ELLIOTTCABLE> That's when you start getting stuff you can easily apply to pet projects; and everybody knows that's where the self-driven learning happens.
<ELLIOTTCABLE> pick up Ember or try Sinatra or idfk, you get the idea. make a thing™.
<rckts> Make A Thing™
<rckts> yeah no I get you
<ELLIOTTCABLE> and then, step four, stop listening to me and go get a real CS dude, 'cuz I know fuckall
<ELLIOTTCABLE> I just make programmin' languages. And bad ones, at that.
<ELLIOTTCABLE> so, follow, in no particular order:
<ELLIOTTCABLE> @glowcoil @whitequark @alextgordon @devynci @cloudhead @gkatsev @inimino
<ELLIOTTCABLE> and probably katlogic although idk his twitter.
<ELLIOTTCABLE> oh and idle in here, 'cuz all of those people are in here.
<ELLIOTTCABLE> ;)
<ELLIOTTCABLE> sans whitequark, he hates me.
<rckts> boom, followed them all - and yeah, I'll start keeping my IRC client open
<rckts> this is all really good advice, thanks dude - saved your tips/plan above in a gist for myself, i think i'll probably get started this weekend if i can get this client work out of the way
* ELLIOTTCABLE grins
<ELLIOTTCABLE> and finally,
<ELLIOTTCABLE> write a Paws.
<ELLIOTTCABLE> here's my pitch:
<ELLIOTTCABLE> A) Paws is cool.
<gkatsev> what's the question?
<ELLIOTTCABLE> B) You'll be contributing to a clearly-soon-to-be-famous-project.
<ELLIOTTCABLE> C) Implementing a *simple* language (most of Scheme, Lua, Paws) is a *great* way to learn a lot about programming.
<gkatsev> LOL @ B
<purr> LOL
<ELLIOTTCABLE> D) You don't have the inventors of Scheme or Lua at your beck-and-call to answer questions and help you learn.
<ELLIOTTCABLE> ;)
<vigs> -didja @ rckts
<purr> rckts: didja write a paws yet? didja? didja!?
<gkatsev> implementing languages is a great way to learn PL
<ELLIOTTCABLE> -didja didja @ rckts
<purr> rckts: didja didja didjaaaaaaaaaaaaaaa … writeapawsyet?
<rckts> omfg
<ELLIOTTCABLE> -find didj @ rckts
<purr> rckts: Found: didja?, how about now?, and didja didja?
<rckts> wow
<gkatsev> -how about now?
<purr> gkatsev: well? didja didja?
<gkatsev> are you cdl on the twitters?
<rckts> well that pitch is good enough for me - that'll probably be my Ruby project after weekend 3
<rckts> yup - twitter.com/cdl
<vigs> ricketssssssss
<rckts> i'd take cdl as a nick on here but it's taken :(
<ELLIOTTCABLE> /nick coldby
ELLIOTTCABLE is now known as bloodwig
<gkatsev> is it actually being used?
bloodwig is now known as elliottcable
rckts is now known as cdl
<elliottcable> rckts: you can usually get nicks wiped, if you want to
<cdl> WAIT
elliottcable is now known as ELLIOTTCABLE
<cdl> yeah it's already registered to someone :(
cdl is now known as rckts
<ELLIOTTCABLE> it's taken
<ELLIOTTCABLE> and he's active
<ELLIOTTCABLE> saddest day
<rckts> v sad
Rusky has joined #elliottcable
<gkatsev> yeah, that was the question
rckts is now known as cdl_
<cdl_> this one's free tho
<gkatsev> if they aren't active, then you can ask staff to get it for you
<cdl_> ah - good to know
<ELLIOTTCABLE> meh you can do better than an underscore
ELLIOTTCABLE is now known as cdl_on_twitter
<cdl_on_twitter> this, for instance
<cdl_> that's a good one
<gkatsev> lol
<purr> lol
cdl_ is now known as colbyl
<colbyl> i have this one
<gkatsev> I mostly do js nowdays. Though, kind of working through Real World Haskell at a book club at work.
<gkatsev> c_d_l
<gkatsev> you should change the l to an r and be cdr
cdl_on_twitter is now known as ELLIOTTCABLE
<colbyl> ok brb going to go eat
<ELLIOTTCABLE> kk
<ELLIOTTCABLE> gkatsev: that's a cool book-club
<ELLIOTTCABLE> I wish I had anybody to improve myself with
<ELLIOTTCABLE> I giveu p chicago sux >:
<ELLIOTTCABLE> woah I am clearly drunker than I thought I was
<gkatsev> ELLIOTTCABLE: you should move to boston, clearly. :P
<ELLIOTTCABLE> … how is boston better, exactly?
<vigs> but boston isn't california
<ELLIOTTCABLE> my issue is that everybody I know is apparently in saffron.
<ELLIOTTCABLE> sanfan*
<ELLIOTTCABLE> fucking cali, I hate it so much, but, ugh
<gkatsev> sanfan? no one calls it that...
<gkatsev> well, except you, I guess
<gkatsev> lol
<purr> lol
<gkatsev> boston isn't cali
<gkatsev> plus it has more interesting stuff :P
<vigs> ELLIOTTCABLE: why do you hate it? I mean, there's the fucking stupid SF tech culture that I'm coming to dislike more and more, but it's not JUST that
<ELLIOTTCABLE> I don't get why people say nobody calls it that
<ELLIOTTCABLE> because people absolutely call it that.
<ELLIOTTCABLE> people call it that often enough that I hear “nobody calls it that” literally once a month.
<ELLIOTTCABLE> *By motherfucking definition* people call it that.
<ELLIOTTCABLE> ಠ_ಠ
<gkatsev> I've literally never heard SF being called that
<ELLIOTTCABLE> vigs: opposite. I've always hated Cali, coming from Alaska; but I'm failing to find the community and tech culture anywhere else I want
<ELLIOTTCABLE> gkatsev: seriously? I've seen some san franciscan flip off the handle at some foreigner literally over and over overoairhwaiutoat
<gkatsev> boston has a good community and tech culture
<vigs> ELLIOTTCABLE: lol do Alaskans hate CA or something? :P
<purr> lol
<ELLIOTTCABLE> that said, I'm a special case. I call all locations by abbreviated nicknames in everyday conversation.
<ELLIOTTCABLE> I get so much shit for calling Logan Square “LoSqua”, or river-north “RiNor”
<vigs> ELLIOTTCABLE: But yeah, I'm disappointed by some/most of the stupid tech stuff I hear about. I don't ever wanna live in SF city proper, though. I'd rather be out in the East Bay.
<ELLIOTTCABLE> why? and where's that?
<vigs> which probably doesn't mean much to you, now that I think about it
<ELLIOTTCABLE> I'm assuming that I'll get a much smaller place for my current rent in downtown SF when I move.
<vigs> that is correct
<vigs> but CA is expensive in general
<ELLIOTTCABLE> yeah I got told the other day that “the valley” *does not include SF*
<ELLIOTTCABLE> I thought The Valley was a term for all that mess of places where Tech Happens
<vigs> which valley?
<ELLIOTTCABLE> like San Francisco and Cupertino
<ELLIOTTCABLE> idfk “the valley”, that everybody talks about
<vigs> Tri Valley? Silicon Valley? "The Valley" that's near LA?
<ELLIOTTCABLE> uh
<ELLIOTTCABLE> no clue
<vigs> exactly
<ELLIOTTCABLE> probably Silicon Valley?
<vigs> probably haha
<ELLIOTTCABLE> SEE EVEN MORE REASONS TO HATE CALI ;_;
<ELLIOTTCABLE> you people are bad at names
<ELLIOTTCABLE> do you think we call one of the mountains “the mountain” in Alaska?
<vigs> the East Bay is gorgeous, albeit suburban. But loads of stuff to do/really nice, upscale cities
<ELLIOTTCABLE> “Let's go to the place with the snow, for the weekend!”
<vigs> at least in the Tri Valley (Dublin/Pleasanton/Livermore/San Ramon)
<ELLIOTTCABLE> “Oh, no, I'm going to the village. You know, the only one, that we call the village, instead of calling it by its name.”
<vigs> lol
<purr> lol
<ELLIOTTCABLE> and people make fun of me for abbreviating names. YOU PEOPLE DON'T EVEN **HAVE** NAMES. ಠ_ಠ
<vigs> …yes we do?
<ELLIOTTCABLE> East Bay meaning, what, like, where @nexxylove lives?
<vigs> it's very region specific
<vigs> literally east of the bay, within reason
<vigs> where's @nexxylove live?
<ELLIOTTCABLE> Alameda / Oakland / etc, right?
<ELLIOTTCABLE> and no idea, I think it was Alameda, I don't really remember
<ELLIOTTCABLE> yeah, meh
<vigs> if you look at a BART map, the city I'm from is the east most stop
<ELLIOTTCABLE> Chicago's my first city, but I've definitely learned the lesson here: none of my Neighbourhood™ friends will come downtown to hang out with me.
<ELLIOTTCABLE> people literally never leave their little locale.
<vigs> :(
<ELLIOTTCABLE> so “close to San Francisco” very likely doesn't count as in San Francisco. /=
<vigs> exactly
<vigs> EXACTLY why I'd rather live close to SF
<vigs> but not IN the city
<vigs> I also wanna live in Seattle for some point tbh
<ELLIOTTCABLE> where the hell is ‘close enough,’ though?
<vigs> the PNW looks really pretty and the people seem really cool
<vigs> ELLIOTTCABLE: anywhere reachable by BART, I'd wager
<ELLIOTTCABLE> Again: maybe just a Chicago thing, but even people in the neighbourhoods that are less than fifteen minutes' L-ride from the loop, are averse to coming downtown.
<ELLIOTTCABLE> yeah, not how it works, here.
<ELLIOTTCABLE> maybe SF is different.
<ELLIOTTCABLE> if I move, it's going to involve crashing with a friend for a few months.
<ELLIOTTCABLE> leaving my shit here and renting a futon, kinda thing.
<ELLIOTTCABLE> so I can get a feel for the neighbourhoods, and know where to look for property.
<vigs> I know some assholes (read: super dickwads) would consider stuff east of Oakland (which is basically right on the bay) as not part of the Bay Area
<ELLIOTTCABLE> oh nah I *love* Seattle, Portland, and YVR.
<ELLIOTTCABLE> Fucking love.
<vigs> I wanna visit :<
<ELLIOTTCABLE> but … Chicago's burnt me out on living in <any city that isn't SF>.
<vigs> lol
<purr> lol
<ELLIOTTCABLE> I've learned the hard way that even a tech-friendly-ish city isn't going to be any better for me than back-ass-woods Montana.
<vigs> not wrong
<ELLIOTTCABLE> So after this, it's either A) SF, the beating fucking heart of tech,
<ELLIOTTCABLE> or B) giving up entirely on ever having anything more tech-social than what I have now, and going somewhere I'll be existentially happy.
<vigs> I take it you've lived in back-ass-woods Montana, too? :P
<ELLIOTTCABLE> (Montana. Colorado. Back to Alaska. Iceland. Scotland. Russia.)
<ELLIOTTCABLE> no, I want to.
<vigs> damn
<vigs> oh
<ELLIOTTCABLE> Montana is my number-1 “where I'm going to end up.”
<vigs> also faaaaalse: there's way more to SF (and the Bay Area) than just TECH ALL THE THIGNS
<ELLIOTTCABLE> You know, once I've made a name for myself, or not, as the case may be. Once I get married, and am ready to have kids, etc.
<vigs> that mentality is stupid imo :<
<ELLIOTTCABLE> lol, like what?
<ELLIOTTCABLE> being afraid of guns?
<ELLIOTTCABLE> owning cats?
<ELLIOTTCABLE> driving praises?
<ELLIOTTCABLE> priuses*?
<ELLIOTTCABLE> ಠ_ಠ
<ELLIOTTCABLE> I fucking hate California.
<vigs> I really don't like some of the techpeople's attitudes :/
<vigs> i'd elaborate but I'm also doing stuff rn so
<ELLIOTTCABLE> I was raised very Republican; I'm still relatively conservative. Big, open areas; lots of snow, lots of mountains, lots of dogs, lots of guns, and very, very, very few people.
<ELLIOTTCABLE> California's, frankly, only on the books because I don't understand Haskell. |=
<ELLIOTTCABLE> I can't imagine *advancing* in my field, if I move where I want to be.
<ELLIOTTCABLE> Sucks to be in a field where that's the case, but … it's my calling. /=
<vigs> see, I don't even want to be a developer forever :/
<ELLIOTTCABLE> okies, done ranting. Forgive me. Mildly drunk. :P
<vigs> I do wanna go into the management part of a business, but…coding is just so damn fun
<vigs> lol no worries
<purr> lol
<ELLIOTTCABLE> management, god forbid
<ELLIOTTCABLE> I want the experience to guarantee my monetary future, to give myself the chance to comfortably consider having kids,
<ELLIOTTCABLE> but mostly, I want to make really fucking great things and give them away.
<ELLIOTTCABLE> Open source is all I care about. /=
<vigs> that's an awesome attitude
<ELLIOTTCABLE> management sounds like the WORST THING EVER
<vigs> basically, but I had a really good experience in high school doing a thing
<vigs> so…I'm considering it
<vigs> okay phew, I have a minute
<vigs> Rusky: the best SCOTUS case is Bethel v. Fraser (1986)
<vigs> look it up
<vigs> read the speech
<vigs> (it's amazing)
<Rusky> haha
<vigs> ELLIOTTCABLE: So in high school, I led my school's robotics club for two of the three years I was on it. It was a rad experience. We were the only high school to consistently compete against universities for over a decade in RoboSub, an AUV competition. Fucking robotic submarines that did shit by themselves.
<colbyl> ok, back
<ELLIOTTCABLE> vigs: speaking of, I have a drone in my bathroom that I've yet to try out
<ELLIOTTCABLE> it's just WAITING to be node.js'd
<vigs> It was awesome. I took over the team after only one year in the club, and I really enjoyed that position of leadership. I learned a LOT, both about tech, and about managing people. I raised $11,000 for the team my first year. For fuck's sake, I even had to let go of an officer (it was HARD because we were friends, but went smoothly). Anyway, that experience really kinda made me consider management. But only for a company I really
<vigs> like.
<ELLIOTTCABLE> yes, I just used node.js as a verb.
<gkatsev> what's waiting to be nodejsed?
<vigs> sftech is already spoiling you
<ELLIOTTCABLE> blame the IPA.
<vigs> gimme
<gkatsev> noded, rather
<ELLIOTTCABLE> gkatsev: quadcopter
<ELLIOTTCABLE> vigs: hm?
<gkatsev> you, drone in your bathroom
<ELLIOTTCABLE> nodejsed!
<gkatsev> why is it your bathroom?
<ELLIOTTCABLE> because it's the only place I Have room
<vigs> my friend said he'd get me a bottle of champagne tonight so we could have mimosas but he didn't :<
<gkatsev> that seems like a peculiar place to have a drone in
<vigs> something came up so…next weeked
<ELLIOTTCABLE> I have beer >:
<vigs> * weekend
<ELLIOTTCABLE> gkatsev: my house is full of things in peculiar places.
<vigs> ELLIOTTCABLE: you say that like it's a bad thing
<ELLIOTTCABLE> ugh long story
<ELLIOTTCABLE> bored lonely weird
<ELLIOTTCABLE> my bff is off doing awesome shit like, for the WHOLE OF THE NEXT COMING WEEK
<ELLIOTTCABLE> and I, for once, have absolutely no plans
<ELLIOTTCABLE> that was bad-enough-feels
<vigs> aw
<ELLIOTTCABLE> but I just discovered that it's Chicago Craft Beer Week.
<gkatsev> nodecopter it up then
<gkatsev> bam, plans
<ELLIOTTCABLE> and A) nobody told me / I didn't know, which is sad enough, cuz I'm quickly becoming a craft-beer nerd-noob,
<ELLIOTTCABLE> but more importantly, after texting / faceboking, and then hell, *publicly tweeting*,
<ELLIOTTCABLE> I have nobody to go do anything with tonight.
<ELLIOTTCABLE> So I'm at home, alone, microwaving left-over pizza, and drinking beer alone,
<ELLIOTTCABLE> while epic awesome craft-beer events are going on all over town.
<ELLIOTTCABLE> gkatsev: already too drunk to risk anything with high-RPM blades.
<ELLIOTTCABLE> gkatsev: :P
<ELLIOTTCABLE> gkatsev: oH MY GOD NODEROCKETS
<ELLIOTTCABLE> WHAT THE FUCK IS A NODEROCKET HOW DO YOU PROGRAM A ROCKET I HAVE NO IDEA BUT I AM EXCITED
<gkatsev> clearly you need to drink some more to get to the ballmer peak
<gkatsev> ELLIOTTCABLE: Yes!
<gkatsev> ELLIOTTCABLE: when are you getting down to florida?
<ELLIOTTCABLE> balmer peak only applies when the most dangerous thing you're working with is a getter method
<ELLIOTTCABLE> balmer peak does not apply to anything involving soldering irons, high-speed rotors, or national security
<ELLIOTTCABLE> colbyl: hi!
<colbyl> hey!
<ELLIOTTCABLE> hi!
<colbyl> [loop intensifies]
<ELLIOTTCABLE> something something programming joke something
<ELLIOTTCABLE> DIIIIEEEEDDDDDD
<colbyl> can't wait for Fox news to pick this up and say that Twitter's been hacked by ELBACTTOILLE@
mcc has joined #elliottcable
<ELLIOTTCABLE> colbyl: LOL
<purr> LOL
<ELLIOTTCABLE> oh my god my second or possibly third favourite person's in my channel
* ELLIOTTCABLE glomps mcc
<mcc> hiiiiii
<ELLIOTTCABLE> you get my first glomp in a solid decade or so.
<mcc> and wow that was a really nice thing to say about purr there!
<mcc> omg, i am honored
<ELLIOTTCABLE> yah
<mcc> elliot i just realized i hadn't talked to you in awhile and i wasn't sure if you'd seen all the nonsense about EMily
<ELLIOTTCABLE> should be
<ELLIOTTCABLE> it's probably just 'cuz I'm drunk
<ELLIOTTCABLE> what? Emily, as in, @nexxylove? or a different one?
<mcc> I am making a language!
<ELLIOTTCABLE> DA)IWHET P(ULAKY HPW(OT AIWL
<ELLIOTTCABLE> FUCK YES
<ELLIOTTCABLE> but you can't do that
<ELLIOTTCABLE> you're not an #ELLIOTTCABLE regular
<mcc> and it has some interesting features relative to the idea of being a hosting platform for other languages
<ELLIOTTCABLE> only #ELLIOTTCABLE regulars are allowed to make new programing languages
<ELLIOTTCABLE> rule.
<ELLIOTTCABLE> it is one.
<ELLIOTTCABLE> okay reading the post
<mcc> i'm a semiregular. close enough
<ELLIOTTCABLE> yah yah we talked about this in the Apple store
<ELLIOTTCABLE> did I ever tell you,
<mcc> haha
<mcc> yes
<mcc> i liked your ideas
<ELLIOTTCABLE> that YOU LITTLE FUCK, it's ALL YOUR FAULT,
<ELLIOTTCABLE> apwrl a9ut ahrow
<mcc> i go in a slightly different direction
<mcc> wait waht's my fault?
<ELLIOTTCABLE> I was too distracted by that conversation
<mcc> i think i like it when things are my fault
<ELLIOTTCABLE> and I literally bought the wrong sizes in LITERALLY EVERYTHING I BOUGHT
<mcc> oh nooooo
<ELLIOTTCABLE> all the things I was supposed to buy for my bff, I bought in a Men's Large, which is way too big for her,
<mcc> that's… that's not the kind of glitching i like to do!
<ELLIOTTCABLE> and all the things I was supposed to buy for me, I bought in either XL, or Men's Medium
<ELLIOTTCABLE> neither of which fit **me**
<ELLIOTTCABLE> ailjwrha;uektoeait
<ELLIOTTCABLE> literally every Apple Company Store product I own, has been relegated to an in-the-house-only sleeping/lounging ite
<ELLIOTTCABLE> SO MANY DISAPPOINT
<ELLIOTTCABLE> anyway reading blog
<ELLIOTTCABLE> everything in the first half:
<ELLIOTTCABLE> you're describing small languages. and small languages are tony-the-tiger Grrreat™.
<ELLIOTTCABLE> Scheme, Lua, Pawsifidosaysomyself,
<ELLIOTTCABLE> so definitely lots of feel-you-there.
<ELLIOTTCABLE> holy gods this is long
<ELLIOTTCABLE> mcc: okay, I'll let you make the call: I'm mildly drunk. Should I wait and read this later, or will it be more fun if you get my drunk commentary? :P
cuttlebone has joined #elliottcable
cuttlebone is now known as glowcoil
<ELLIOTTCABLE> cuttlebone: mcc's doing a language
<glowcoil> hi mcc
<mcc> Elliottcable: i think drunk commentary sounds GREAT.
<mcc> hi glowcoil
<glowcoil> i've seen the littlest bit of the language on twitter
<ELLIOTTCABLE> glowcoil: so far looks like data-as-code with currying-procedures as the core type
<ELLIOTTCABLE> gkatsev: http://msm.runhello.com/p/934
<mcc> elliottcable: did you ever see Io? People told me about it when I started describing Emily, and it does a lot of smart things similar to the things i want to do
<ELLIOTTCABLE> Io's great (=
<ELLIOTTCABLE> I don't know Io's internals well, though. When I learned Io, I wasn't a PLT nut, so I didn't know to start tearing things apart.
<ELLIOTTCABLE> “That would just assign 4 to the variable “y”, it would not create a function.”
<mcc> yeah and, here's the trick, the language internals know whether a particular piece of data-as-code is secretly just data
<ELLIOTTCABLE> so, lexically-scoped?
<mcc> so "serializable" could be a type which could be applied to a function
<ELLIOTTCABLE> important caveat:
<mcc> not sure what you mean by "lexically scoped". it explains scopes a little further
<ELLIOTTCABLE> you should be aware ahead of time that you will be LAUGHED AT and HAVE ROOT-BEER POURED UPON YOU INCESSANTLY and you WON'T EVEN GET TO DRINK ANY OF IT, if you don't actually implement.
<ELLIOTTCABLE> number one rule of #ELLIOTTCABLE.
<ELLIOTTCABLE> well, rules.filter(function(rule){ rule.indexOf('penis') === -1 })
<glowcoil> "serializable" types/typeclasses is probably my favorite thing
<ELLIOTTCABLE> “a type which could be applied to a function”
<ELLIOTTCABLE> 'splain
<mcc> I'm already implementing!! :D
<mcc> I actually implemented function application last night.
<glowcoil> (note: nobody's implemented here, don't believe him)
<mcc> But the parser has a problem
<glowcoil> oh neat!
<mcc> but i think once i get the parser working i might have working application
<ELLIOTTCABLE> glowcoil: :P
<glowcoil> i've written so many parsers they make me nauseous
<mcc> elliottcable: as explained later in the blog post, types in Emily are predicate functions.
<mcc> so "int 4" returns true if 4 is an int.
<ELLIOTTCABLE> glowcoil: don't go breaking my inspiration-giving white lies!
<glowcoil> mcc: cool!
<ELLIOTTCABLE> glowcoil: she *really believes* that rootbeery-death will come. respect dat, yo.
<ELLIOTTCABLE> parsing is boring pff
<ELLIOTTCABLE> screw syntax, make neat languages
ELLIOTTCABLE changed the topic of #elliottcable to: screw syntax, make neat languages
<ELLIOTTCABLE> reading
<mcc> which lead me to the statement of "you could apply this type to this function", i.e., you could pass an emily block to the "serializable" builtin, and it returns true if it fits the criteria for serializability (i.e.: no code, only data, in the underlying representation)
<ELLIOTTCABLE> (selectors are interned strings? really?)
<mcc> elliottcable: in objective c? Yeah
<mcc> try @selector( functionName: ) sometime
<mcc> it returns an integer, or it did in earlier versions of objc anyway
<ELLIOTTCABLE> 've used it, but never looked at the contents thereof
<ELLIOTTCABLE> treated 'em as opaque and didn't think about it until right now
<joelteon> magic
<ELLIOTTCABLE> magic™
<joelteon> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~magic~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<ELLIOTTCABLE> you forgot the tm
<ELLIOTTCABLE> don't make me litigate you
<ELLIOTTCABLE> -litigate joelteon
<ELLIOTTCABLE> <in an alternate universe, joelteon was just permabanned>
<joelteon> way too many tildes on the right
<ELLIOTTCABLE> mcc: cool!
<ELLIOTTCABLE> mcc: so serializable is a “type” in your definition of types
<ELLIOTTCABLE> :: block > bool
<joelteon> no code, only data
<joelteon> so......a constant?
<mcc> joelteon: so like imagine two javascript objects
<mcc> joelteon: { a = { b: 3, c: 4} } and {a = { b:3, c: function(x) { return 4 } } }
<ELLIOTTCABLE> mcc: so, in terms of implementation, because I've never implemented a pattern-matching language,
<ELLIOTTCABLE> each possible match is its own code, basically, yes?
<glowcoil> ELLIOTTCABLE: : oh yeah objc felt more low level than it was till i learned that about selectors
<mcc> joelteon: we can say the first object is "data only", the second object contains code
<ELLIOTTCABLE> and a “block” is a set of matches/code-bits?
<mcc> joelteon: and the basic idea of Emily is that objects are functions
<ELLIOTTCABLE> glowcoil: I understand them; I'm mildly familiar with the runtime. I just never realized they were interned, somehow.
<glowcoil> ELLIOTTCABLE: oh
<ELLIOTTCABLE> or, I guess I did.
<ELLIOTTCABLE> I just … didn't have the conscious thought that “selector == Symbol”
<mcc> elliottcable: Yeah. Although internally, for simplicity, the "code-bits" for some matches are just constant values which are compared against.
<mcc> the internal representaiton is uh… oh wait i'll just link the code 1 sec
<ELLIOTTCABLE> mcc: certainly, that seems to be the point
<ELLIOTTCABLE> got it
<ELLIOTTCABLE> really like it so far.
<ELLIOTTCABLE> sounds like my kind of functional language.
<mcc> it just… i want to code in this. i like the idea of coding in this.
<mcc> i feel like i actually stripped out a bunch of garbage.
<ELLIOTTCABLE> less of the formality, and a whole lotta awesome(-sounding, at least … grain of salt.) pragmaticity.
<mcc> thanks :D
<mcc> there are some non-pragmatic elements which concern me.
<mcc> or well
<mcc> ok so here's my biggest worry
<mcc> Wren pointed this out
<mcc> let's say you say:
<mcc> int == string
<ELLIOTTCABLE> so [] is your object-literal syntax, yiss?
<mcc> this is parsed by the language into "int.eq string"
<ELLIOTTCABLE> or rather, match-literal, I suppose
<mcc> "int.eq" returns false, because it tests the atom .eq to see if it's an int, which it isn't
<mcc> we then apply string to false
<mcc> wait, what?
<mcc> ok so when the typesystem's in place, that's an easily-catchable compile-time type error
<mcc> but like
<mcc> what if you actually DID want to compare int to string, somehow?
<ELLIOTTCABLE> hold on.
<mcc> what if you wanted to store int in a block as a member?
<mcc> also yeah [] is the object-literal syntax
<ELLIOTTCABLE> are you telling me that *compile-time*, `int` and `string` are treated specially, as some sort of “type” thing?
<ELLIOTTCABLE> that seems extremely not-in-sorts. Everything else is very elegant, small-pieces put together consistently to make an elegant whole,
<mcc> no, they're just predicates that return true or false depending on whether their argument is an int, or a string
<ELLIOTTCABLE> but I liked the way you described types, semantically. Those shouldn't need some sort of compiler magic to make them Work™.
<mcc> However, my assertion is the compiler should be able to tell that int eq returns false, and that if you pass null to false that is an error.
<ELLIOTTCABLE> sounds like you need to break away from C or Haskell type-syntax assumptions and come up with a new syntax for that, which doesn't break your semantics / make everything an ugly mess.
<ELLIOTTCABLE> reading
<mcc> errr i mean, if you pass any argument to "false' that is an error
<mcc> actually i'm thinking about having false and null be the same thing
<ELLIOTTCABLE> “int eq returns false” hrr/
<mcc> int(.eq) is testing to see whether .eq is an integer
<mcc> anyway, there's no special syntax for types, there's just application
<mcc> : is special, but it will be a macro
<vigs> okay time to play vidya games
<vigs> bye
<glowcoil> vigsya games
<vigs> heyo
<mcc> (a : b) will be shuffled into something like ( if (b a) { return a; } else { fail; } )
<ELLIOTTCABLE> okay yep nope too drunk for this
<ELLIOTTCABLE> let me back up and re-read
<mcc> hahahah
<ELLIOTTCABLE> `int.eq string`
<glowcoil> mcc: ohhh i get it
<glowcoil> mcc: i don't get the int.eq string though
<ELLIOTTCABLE> why isn't that, basically, assuming that “blocks” are JavaScript-ish structures, but with predicates instead of interned strings as keys,
<ELLIOTTCABLE> `int[eq](string)`
<ELLIOTTCABLE> or, to re-phrase,
<ELLIOTTCABLE> why can't the type-predicates such as `int` and `string`, have an .eq member defined?
<mcc> https://bitbucket.org/runhello/emily/src/10ed8f556a10df500e5b5ce483f7018762c10e6b/ast.h?at=default <<-- look for "EmBlock" / "EmPair", but this interpreter is AWFUL, so this doesn't say much about what the someday-interpreter will look like
<mcc> elliotcable: ok so, the problem is, int takes *any argument you pass it*, and tells you whether it is an int
<mcc> let's say you say obj .eq
<mcc> .eq is an atom
<ELLIOTTCABLE> ahhah
<ELLIOTTCABLE> *why* does it?
<ELLIOTTCABLE> why can't types provide a .eq?
<ELLIOTTCABLE> can't they be matchers, like any other block?
<ELLIOTTCABLE> :x
<mcc> well, because i want you to be able to pass in general functions
<mcc> and, this is not a problem limited to types
<mcc> let's say i define a function
<mcc> postive ^x = x > 0
<ELLIOTTCABLE> I understand.
<mcc> i now want to use postive as a type.
<mcc> it doesn't have eq defined.
<mcc> now, one thing i COULD do!
<mcc> i could change how i define a type.
<ELLIOTTCABLE> it boils down to: you need to both be able to *find the member* `.eq`, and *preform the dictated action* `.eq`
<mcc> yes. ideally i should be able to do both.
<ELLIOTTCABLE> an obvious ‘problem’ (or at least, cognitive dissonance coming from other languages) when you conflate lookups and application.
<mcc> yeah.
<mcc> however, in order to do both, i have to make some concept, somewhere, less elegant.
<ELLIOTTCABLE> okay, so, some solution suggestions, just off the top of my head. probably already considered all of these, buuuuut …
<mcc> so let's say i define a type such that passing in .eq, specifically, must do some magic.
<mcc> now the type is a liar. "int .blah" returns false, because .blah is an atom not a number, but "int .eq" returns a non-nil vlaue.
<ELLIOTTCABLE> A) always the easiest answer: syntactic. Provide an explicit-application syntax. Basically, you could define things like .eq, important basic stuff, on things like `int`
<mcc> another option is i could have some kind of a like… "underlying-object" call
<ELLIOTTCABLE> and if you *really* want to apply `int` to .eq, but int has .eq defined, then `int****.eq` *forces* it to use the non-pattern-matched, default reception behavior
<mcc> like (underly int).eq
<ELLIOTTCABLE> (sorry for the terminology, don't know your preferred terms)
<glowcoil> mcc: do you know about smalltalk style church booleans
<mcc> no, that sounds right. that's another thing i considered. maybe the atoms such as ..eq are magic somehow
<mcc> glowcoil: they're basically the v and i combinators right?
<mcc> one other possibility!
<mcc> i could have it be assumed that the types take arguments in the form [ ]
<mcc> so int[ .eq ] is false, but int( .eq ) is the equality tester for int.
<ELLIOTTCABLE> nnononononono
<mcc> another option is i could say: don't compare functions. why are you comparing functions. that isn't even sensible
<ELLIOTTCABLE> no magic.
<glowcoil> mcc: i think that's definitely a way to do it, though i've also seen them as \ab->a and \ab->b
<ELLIOTTCABLE> Magic's Bad™
<mcc> it isn't magic! :D keep reading
<ELLIOTTCABLE> your whole design is beautiful unmagic, I love it so far
<mcc> [ ] is how you pass arguments to functions.
<mcc> atan2[ 3, 4 ]
<ELLIOTTCABLE> mmmmmmmmm
<ELLIOTTCABLE> holon, reading
<ELLIOTTCABLE> areiothea9utowr0io
<mcc> and it isn't magic. i'm passing a block with the members 3,4 to the unary function atan2
<ELLIOTTCABLE> haven't even gotten past the first couple paragraphs of your writ up.
<mcc> hahaha ok
<ELLIOTTCABLE> think I need to read more before we keep talking.
<ELLIOTTCABLE> 'cuz I'm very confused, you just introduced new syntax to me.
<ELLIOTTCABLE> “ so int[ .eq ] is false, but int( .eq ) is the equality tester for int.”
<ELLIOTTCABLE> lost me.
<mcc> spoiler: scopes, functions, objects, and argument lists are the same entity in this language :D
<ELLIOTTCABLE> yah, expected as much
<ELLIOTTCABLE> and/or hoped for
<mcc> the definition of a type could be: a predicate function which takes as argument a block containing a single element, and determines whether that element is a member of the type
<glowcoil> mcc: so are there no thunks (talking about ^ arg binding)
<ELLIOTTCABLE> argument-lists as homogenous type is good, like that, very much a fan
<mcc> glowcoil: a thunk is a nullary function right
<ELLIOTTCABLE> Paws is, of course, unary-argument as well
<glowcoil> mcc: right
<ELLIOTTCABLE> hi you motherfucker glowcoil you're back
<ELLIOTTCABLE> stay back this time
<mcc> glowcoil: that's in there, but i'm confused about how it works. I think there is a special object _ which is "void"
<ELLIOTTCABLE> -rootbeer @ glowcoil
<mcc> and some kind of a syntax like "do thunk"
<mcc> to invoke the thunks
<mcc> the way that the "first pass" interpreter will work
<mcc> is that a thunk is an object which ignores its argument
<mcc> (object/block/function, same thing)
<mcc> and the "do thunk" syntax is actually a macro which invokes thunk with nil as argument
<ELLIOTTCABLE> what's with thunks. foreign concept to me. what're we talking about?
<mcc> elliottcable: a thunk is just a function with no arguments
<mcc> haskell people seem to like the term "suspension"
<mcc> for thunks
<mcc> but nobody else seems to say that
<mcc> i think i call them nullaries
<ELLIOTTCABLE> yeah, nullary function makes way more sense to me
<ELLIOTTCABLE> so, why's it an issue and/or what do you need them for? missed the genesis.
<mcc> elliottcable: you need them because how else is if gonna work?
<mcc> no way i'm writing a friggin if construct into the language
<mcc> or well i guess i am but
<ELLIOTTCABLE> err
<ELLIOTTCABLE> I mis-spoke:
<mcc> if (a > b) { print a }
<mcc> that gets macro'd into
<ELLIOTTCABLE> why do you need nullaries beyond taking `nil`, and then not using it.
<mcc> if ^(a > b) ^{ print a }
<mcc> elliottcable: oh! well, i don't think i do. however, passing in nil is not a very obvious user behavior.
<mcc> elliottcable: so i wanna disguise it somehow.
<glowcoil> sorry intermittently dying
<ELLIOTTCABLE> seems eminently syntactic
<glowcoil> and coming back alive
<ELLIOTTCABLE> “I want my users to not have to type nil”
<glowcoil> running a high temperature :p
<ELLIOTTCABLE> very much not a big language-design issue :P
<ELLIOTTCABLE> ignore me reading your post.
<mcc> haha
<mcc> there are a couple reasons i might want _ and nil to be two different types.
<mcc> however, false and nil.
<ELLIOTTCABLE> speaking of syntax:
<mcc> i cannot come up with any good reason for those to be separate.
<ELLIOTTCABLE> wait, what's _?
<mcc> _ would be void
<glowcoil> mcc: well, are you aware of the whole debate about like removing universal nullability
<ELLIOTTCABLE> This is the best thing.
<mcc> something special that can't even be stored in a variable
<mcc> glowcoil: no, i am not?
<glowcoil> whoo irccloud twitter embedding
<ELLIOTTCABLE> glowcoil: RIGHT
<ELLIOTTCABLE> who was hacking Steam?
<ELLIOTTCABLE> katlogic?
<mcc> elliottcable: i dont' get it!
<glowcoil> mcc: so like, java allows like every type (well, not primitives) to contain null, because they're effectively pointers
<mcc> glowcoil: ohhh. whereas c++, it varies?
<mcc> i mean C# not C++
<glowcoil> mcc: but in haskell, you have explicitly nullable types like Maybe
<mcc> C# it varies, and C++ just… is shit.
<mcc> on that front.
<glowcoil> well C# and C++ have the same thing as Java, they just have more by-value types
<glowcoil> so less nullability
<ELLIOTTCABLE> “do you really want to talk programming languages on a first date?”
<ELLIOTTCABLE> “that just seems like it's destined to failure.”
<glowcoil> but in Haskell, the only way to have something nullable is if it literally loops forever, or if you specify it in the type
<mcc> glowcoil: yeah, i know what you mean in haskell
<glowcoil> mcc: ok
<mcc> glowcoil: also i think recent c# has a specific type adjective
<glowcoil> oh interesting
<mcc> like, in addition to const, there's nonnullable or something
<glowcoil> oh cool
<glowcoil> getting prouder and prouder of c# all the time :')
<mcc> and they had to add all this additional wacky syntax around nullables
<mcc> heh
<glowcoil> though yeah it's a bit of a pile haha
<mcc> anyway, uh, i don't know.
<mcc> have you ever seen the graph of how universal nullability is implemented in Java?
<mcc> See if you can guess how they did it :(
<ELLIOTTCABLE> glowcoil: wat
<ELLIOTTCABLE> glowcoil: okay, granted, I'm judging it without knowing much about it, so that's all on me,
<ELLIOTTCABLE> but it certainly seems like just-another-C++.
<ELLIOTTCABLE> Dump ALLLLL of the features in there™!
<glowcoil> ELLIOTTCABLE: ok it's like c++ in the amount of features
<glowcoil> ELLIOTTCABLE: but i would argue that it just works a lot better
<glowcoil> ELLIOTTCABLE: there's not a lot of danger from not knowing about them? i'd say?
<glowcoil> also the features tend to add *more* safety in various ways
<glowcoil> mcc: the graph?
sharkbot has quit [Remote host closed the connection]
sharkbot has joined #elliottcable
<mcc> glowcoil: the way universal nullability works in Java is that null is of a special type which technically inherits from every object type D: D: D:
<ELLIOTTCABLE> wat
<ELLIOTTCABLE> mcc: wat.
<purr> beep.
<mcc> so if you think about the inheritance tree in java
<glowcoil> mcc: eewwwww?!
<mcc> you just have a tree, and then
<ELLIOTTCABLE> that might actually be the first actually-programming-related wat in purr.
<ELLIOTTCABLE> -what
<purr> <Nexxy> I have a personal rule ... don't feel bad for people that name themselves after final fantasy characters.
<mcc> EVERY SINGLE BRANCH ON THE TREE IS TIED TO A STAR
<ELLIOTTCABLE> awww yuffster <'3
<glowcoil> mcc: so *usually* you can't have multiple inheritance...
<mcc> haha yeah but null's the exception :(
<ELLIOTTCABLE> -what
<purr> <prophile> to be honest i think it's all downhill after kidney cracker
<ELLIOTTCABLE> -what
<purr> <Nuck> gqbrielle: What's ladyprison, hobbits?
<mcc> anyway c# like C++ is another language that just takes EVERY FEATURE FROM EVERYWHERE, except (1) it's good because they made a better choice of which features to take, and (2) it's bad because they took WAY MORE features
<ELLIOTTCABLE> okay no. sorry. back to reading.
<mcc> their standard library is a mess because every single class was designed assuming a totally different set of language features present.
<ELLIOTTCABLE> mcc: {} is function-literal syntax, yiss?
<ELLIOTTCABLE> summarize the syntaxes for creating a new block, for me.
<ELLIOTTCABLE> all of the sugars.
<ELLIOTTCABLE> I see that there's an object-literal-ish one, a dot-one for assigning a new match *to* an existing block, something to do with _ …
<mcc> ok
<mcc> so, remember, the language uses macros. there's a "core" language and then there's the language extended by macros. the macros just rewrite lines then execute them.
<mcc> in the core language, as far as i've planned, the only syntaxes are
<mcc> . ( the dot symbol, prefixes a word )
<mcc> ^ ( the caret, prefixes a word )
<mcc> ( ) , { } , [ ] , ;
<ELLIOTTCABLE> no mention of macros yet, by the way, haven't gotten that far
<mcc> it's vague.
<ELLIOTTCABLE> kk
<mcc> the () {} [] are "group" operators.
<ELLIOTTCABLE> vague is fine, have you *seen* my spec?
<mcc> i have to say group cuz i cna't say block.
<mcc> ( ) and { }, all they do is, they "return" the last statement in the block.
<glowcoil> mcc: is = syntax
<glowcoil> or macros
<mcc> the difference between ( ) and { } is that ( ) uses the scope of the enclosing group, and { } creates a new scope which inherits from the enclosing group.
<mcc> [ ] creates a new block , sets the new block as its own scope, and rather than returning the last value, it returns the new block.
<mcc> so this is why [ a = 2; b = 4 ] works.
<mcc> anyway, that other thing-- yeah, that's the important thing. = is a just a macro. it is not syntax.
<ELLIOTTCABLE> oh. oh god.
<mcc> however, it's a *very complicated* macro that does a bunch of things. it might not be implemented in the language itself.
<ELLIOTTCABLE> girl I was talking to, mis-interpreted “PLT” as
<mcc> anyway, to answer your question.
<ELLIOTTCABLE> somehow referring to http://www.learningtree.com
<mcc> the ideology is the [ ] is supposed to be the only way to create a block.
<mcc> and that = can also create a block, because it's a macro, and ultimately, it's using [ ]
<ELLIOTTCABLE> gotcha
<ELLIOTTCABLE> hrm
<mcc> however, there's kind of a trick... because somewhere, there's gonna be a lambda syntax!
<ELLIOTTCABLE> how can I gain access (store in variable / return) the scope itself, as an object?
<mcc> which I think is gonna look something like ^( a + b )
<ELLIOTTCABLE> or did I mis-interpret, and you don't have objective scope?
<mcc> elliotcable: it's a variable named scope
<mcc> and what the = macro does is
<mcc> if you say a = b
<mcc> this actually means: scope .a .set ( scope .b )
<mcc> remember, in this language, ( ) is NOT APPLICATION. ( ) is just for grouping.
<ELLIOTTCABLE> yep yep
<ELLIOTTCABLE> very familiar with that, Paws' syntax is nearly identical, but with very different semantics
<ELLIOTTCABLE> juxtaposition is application, parenthesis is grouped indirection
<ELLIOTTCABLE> so, that's the syntax I think in all day already :P
<ELLIOTTCABLE> so.
<ELLIOTTCABLE> explain .set
<ELLIOTTCABLE> (and gods, `locals a b (locals c)` is causing so much nostalgia)
<ELLIOTTCABLE> (hey glowcoil remember that time that mcc thought all the same syntax-things that I thought would be good, would be good?)
<glowcoil> :p
<mcc> .set is just .set
<mcc> you have a block
<mcc> a = [ ]
<mcc> you want to add a pattern to a such that if you pass the atom b to a, it will return 3
<mcc> you say: a.set .b 3
<mcc> or!
<mcc> you could just say a = [ b = 3 ]
<ELLIOTTCABLE> mmmm
<ELLIOTTCABLE> I'm missing a fundamental, here.
<mcc> and that actually means a = [ scope .set .b 3 ]
<ELLIOTTCABLE> so, all blocks clearly must have some pre-existing set of matches associated with them.
<mcc> ...which itself actually just means scope .set .a [ scope .set .b .3 ]
<mcc> probably? probably .eq
<ELLIOTTCABLE> (I presume there's some sort of inheritance mechanism at work here? eh, answer that later.)
<mcc> there are prototypes
<ELLIOTTCABLE> good choice of inheritance mechanism; I, of course, approve,
<ELLIOTTCABLE> so, if I'm wrapping my head around this correctly …
<mcc> oh, but it's weirder than that :D
<mcc> but i'll tell you the trick later
<ELLIOTTCABLE> that's scope('set')('a')(function{...})
<ELLIOTTCABLE> yes?
<ELLIOTTCABLE> yah sure
<ELLIOTTCABLE> focus for now, because I am drunk, dumb, and easily sidetracked like a rabbit but not as fluffy
<ELLIOTTCABLE> GOD I would love to be that fluffy
<ELLIOTTCABLE> I'm an incipient furry, I just know it
<ELLIOTTCABLE> SwooshyCueb: TEACH ME TO EMBRACE MY INNER FURRY
<ELLIOTTCABLE> and given that blocks are curried, that's basically, scope('set')('a', {...})
<ELLIOTTCABLE> and given that blocks function as tables when data-y, that's basically scope['set']('a', { ... })
<ELLIOTTCABLE> have I de-constructed this sanely?
<mcc> embracing an incipient furry is easy you just need cute kitsune girls
<mcc> well
<mcc> or boys, depending on sexuality, but you seem pretty straight
<mcc> elliot: yeah, i think... i think that's correct.
<mcc> if i'm interpreting this as javascript, that looks correct to me.
<mcc> ok so having a drunk person read this is actually real useful.
<mcc> cuz someday i catually have to TEACH PEOPLE HOW THIS WORKS.
<mcc> so if it doesn't make sense to a drunk person.
<mcc> it sure won't make sense to a beginning cs student.
* ELLIOTTCABLE laughs out loud
<ELLIOTTCABLE> me? pretty straight?
<mcc> at any rate, literally: scope is a function. if you pass it the atom ".set", it returns a curried function which takes two arguents A and B, and modifies "scope" such that B is added for pattern A
<mcc> Elliotcable: Are you? I don't know. I got that impression.
<ELLIOTTCABLE> teaching it is the best thing EVER
<ELLIOTTCABLE> I drag random motherfuckers in here and teach them Paws constantly
<ELLIOTTCABLE> or did when actively adjusting the semantics and nailing down the precise rules
<ELLIOTTCABLE> mcc: my heartiest wish for you is that you acquire yourself an alexgordon, someday. ('=
fmap has joined #elliottcable
<ELLIOTTCABLE> what's an fmap ಠ_ಠ
<mcc> ok. what's an alexgordon.
<mcc> idk what's an fmap with you
<ELLIOTTCABLE> no, there's a dude who joined. not important.
<ELLIOTTCABLE> The two most useful resources I've ever had, in trying to design a programming language,
<fmap> whats an elliottcable?
<mcc> fmap, how straight is elliottcable? i need to know if it's ok to send him pics of cute kitsune boys
<ELLIOTTCABLE> were A) somebody who knows *way* more than I do (variously @glowcoil, @inimino, @whitequark …), and B) somebody who has *no fucking idea* what I'm talking about, most of the time (@alextgordon)
<ELLIOTTCABLE> it's very okay :3
<ELLIOTTCABLE> well, kitsune, probably nsm
<glowcoil> mcc: can u send me cute kitsune boys too
<glowcoil> haha
<ELLIOTTCABLE> -34 Kurama
<purr> ELLIOTTCABLE: Here. <http://bit.ly/1nTgRm3> [NSFW]
<purr> ELLIOTTCABLE: ... if you had any sense, you wouldn't have asked.
<ELLIOTTCABLE> -34 Renamon @ glowcoil
<purr> glowcoil: Here. <http://bit.ly/1nTgUhJ> [NSFW]
<purr> ELLIOTTCABLE: (You're a dick.)
<ELLIOTTCABLE> anyway,
<ELLIOTTCABLE> mcc: Sorry, was being imprecise. To couch things in non-specific-to-my-little-backwater-channel terms,
<ELLIOTTCABLE> mcc: Find somebody who has a *really* hard time understanding what you're doing, and **keep them around**
<ELLIOTTCABLE> it's literally an invaluable resource, in my experience.
<ELLIOTTCABLE> Having alexgordon say “no, what, that makes no sense” *over and over* has probably led to me refining my work more, even, than glowcoil. And glowcoil's been pretty damn instrumental in the past.
<ELLIOTTCABLE> here's one for you:
<mcc> elliottcable: haha ok that's actually some good advice
<ELLIOTTCABLE> what's the `3` in `a = [ b = 3 ]`?
<ELLIOTTCABLE> you doing an integer type, or Church numerics, or …?
<ELLIOTTCABLE> being a terrible person like myself and using your interned strings as integers …?
<mcc> purr: oh, i like the second one! :D
<mcc> elliottcable: ok so the general answer is "i have an integer type"
<ELLIOTTCABLE> mcc: … we should talk more about porn. *after* programming languages.
<ELLIOTTCABLE> okay. that's all I needed to know, don't need to go into specifics now
<ELLIOTTCABLE> unless it's somehow particularly innovative or interesting
<ELLIOTTCABLE> reading more.
<mcc> elliottcable: the more specific answer is, "3" is an object, which takes .plus as an argument.
<mcc> … the REALLY specific answer is, "3" is some kind of a magical thing that gets coerced into a specific numeric type the first time you use it, cuz i THINK i want int and float to be two separate tyeps.
<ELLIOTTCABLE> oooo so not a native integer type, they *are* logical numerics
<fmap> it's not obviously an object
<ELLIOTTCABLE> fmap: WHAT
<ELLIOTTCABLE> fmap: ARE
<ELLIOTTCABLE> fmap: YOUUUUU
<mcc> it's an object cuz everything's an object
<mcc> the promise is that the language contains literally nothing but unary functions
<mcc> so you can call anything with anything
<mcc> just some things will be type errors
<mcc> like
<mcc> "null 3"
<ELLIOTTCABLE> I get freaked out when there's somebody in my channel and I don't know who they are and I start to hyperventilate and I can't and UGH
<mcc> that is a type error
<ELLIOTTCABLE> like akshatj who the fuck is akshatj
<ELLIOTTCABLE> hmmm
<ELLIOTTCABLE> kkkkk
<ELLIOTTCABLE> more:
<ELLIOTTCABLE> does “type error” equate with “no match?”
<ELLIOTTCABLE> i.e. pattern-matching-parameterization-sense no match?
<mcc> teeechnically
<mcc> the current plan is i have some kind of tracing thing
<mcc> and there is a magic function "fail"
<mcc> which terminates the program, or terminates up to something like an exception handler, i don't know yet
<mcc> and if the compiler can determine that you inevitably call the fail function, it will make that a compile-time warning error
<ELLIOTTCABLE> okay definitely bears more discussion later
<mcc> it will be more helpful once you've read up to :
<ELLIOTTCABLE> what's the execution-model, here?
<mcc> what do you mean
<ELLIOTTCABLE> all executed serially? clearly, blocks are code, so they're executed when called …
<ELLIOTTCABLE> I guess it's stack-based, then?
<ELLIOTTCABLE> “The one difference between { } and ( ) is that { } places its values into a new scope. What is a scope? A scope is a block. When you say …”
<mcc> stack based, yeah?
<mcc> except, like, uh
<ELLIOTTCABLE> and earlier that [...] ditto, except with the scope being a new thing
<mcc> scopes do something interesting
<ELLIOTTCABLE> so, stupid question I'm sure, but …
<mcc> enclosing scopes prototype-inherit from outer scopes
<ELLIOTTCABLE> since all of those are immediately-executed grouping operators, how do I define a chunk of code, store it, and then execute it later?
<mcc> There's a lambda syntax, which i haven't decided on
<mcc> ^( a + 3 )
<mcc> does not execute a + 3, but rather defines a closure that returns a + 3 when executed
<mcc> ^{ a + 3 } is the same thing except the function contains its own scope
<ELLIOTTCABLE> hm, okay, so I *wasn't* confused? Everything so far is not actually functional?
<ELLIOTTCABLE> er, y'know what I mean
<mcc> it isn't functional in the sense of "functionally pure" in the sense of haskell.
<mcc> evaluation is not lazy. it is immediate.
<mcc> in order to defer evaluation of a statement, you must create a closure.
<ELLIOTTCABLE> not what I meant, errr,
<mcc> the general rule of thumb is that anytime a ^ appears, you made a closure
<ELLIOTTCABLE> yeah. that's what I meant.
<ELLIOTTCABLE> OKAY READING ON
<ELLIOTTCABLE> err
<mcc> so a ^b = 3 # closure
<ELLIOTTCABLE> m'kay
<ELLIOTTCABLE> wait
<mcc> a .b = ^( 3 ) # closure
<ELLIOTTCABLE> I thought `a.b = c` was syntactic sugar for `a b ^arg = c`
<mcc> a .b ^= 3 # Closure, and sugar for the previous line, but maybe i hate this syntax
<mcc> nope.
<ELLIOTTCABLE> okay *definitely* got lost then
<ELLIOTTCABLE> completely misunderstood everything.
<mcc> a .b = c is sugar for "modify a such that if you pass it .b as an argument, return c"
<mcc> oh! also, i described ^= wrong earlier.
<mcc> ^= is confusing. i'm not sure i like it. i'm loath to describe it cuz i'm not sure i like it.
<mcc> god, i'm gonna have to find a clear way to explain all this D:
<mcc> i bet it'll be easier when i can just toss in code samples
<mcc> i hope i didn't just make a programming language that only makes sense if you already know programming languages
<mcc> Test
<fmap> S Test
<mcc> fmap it appears we are alone
<mcc> fmap: so how are you doing
* erynofwales pokes her head out
Aranjedeath has joined #elliottcable
* mcc blinks
<mcc> erynofwales: oh! hi!
eligrey_ has joined #elliottcable
* erynofwales waves
<erynofwales> hi hi :)
<mcc> i didn't know you knew elliott
<gkatsev> EC knows a whole bunch of people
<gkatsev> he collects them.
<erynofwales> haha
<fmap> i'm doing well! so what programming language are you making?
<erynofwales> how many people are in this channel?
<gkatsev> only 39
<gkatsev> 2 are bots
<mcc> fmap: i'm making this thing?? http://emilylang.org/
Rusky has quit [Read error: Connection reset by peer]
<mcc> i dunno if i'll actually get to name it emily, maybe there will be contention for the name and i'll fall back on emmy
<mcc> but i think emily is cuter.
<fmap> interesting
eligrey has quit [Ping timeout: 258 seconds]
<erynofwales> why not emily?
<mcc> fmap: short version: objects are a special case of functions.
<ec-textual> hello?
<mcc> hi ec-textual
ec-textual has joined #elliottcable
<ec-textual> PLEASE GOD BE WORKING
<mcc> god's away on business
<ec-textual> -logs
<purr> ec-textual: `curl -Lr -`bc <<<'2 ^ 16'` http://ell.io/logs | tail +2 | less -RS`
<mcc> erynofwales: there's a type checking DSL for ML called emily, although it appears to be defunct, and there's a dubious-looking XML parsing product which has a scripting language. they may have trademarked "the emily scripting language"
<erynofwales> oh, lame :(
<ec-textual> oh, you know erynofwales?
<mcc> we talk on "twitter"
<mcc> ec-textual: i assume you're elliot
<mcc> also: so everything in this channel is being logged?
<ec-textual> oh, definitely
<ec-textual> several places
<ec-textual> -weblogs @ mcc
<mcc> good to know, i'll avoid badmouthing former employers.
<ec-textual> -logs @ mcc
<purr> mcc: `curl -Lr -`bc <<<'2 ^ 16'` http://ell.io/logs | tail +2 | less -RS`
<ec-textual> good plan.
<ec-textual> but I *guarantee* you you won't be able to say anything worse than has already been said.
<erynofwales> is there a [nolog] or similar?
<mcc> apparently however i'm not concerned about voicing a like of furry porn.
<mcc> oh well
<ec-textual> idk for the webloggers or bots; but the curl'able logs are from my own logs directory
<mcc> i was playing spelunky but then spelunky crashed :(
<ec-textual> okay. mcc: chat more on one of the upcoming days? idk my schedule, **trying** to make plans this weekend for fucking beer-week
<ec-textual> but … failing that, I'm happy to learn more
<ec-textual> also, you'll get taught Paws, whether you like it or not
<ec-textual> #pawsrape
<ec-textual> #notfurrysexualactivity, #theprogramminglanguage
<ec-textual> … what's Aranjedeath … how do people keep appearing when I look away
<Aranjedeath> notabot
<mcc> ec-textual: i'll try to get this back on my xchat-text rotation. i'm trying to irc more
<mcc> i'll come by and if you have any more thoughts you can let me know :)
<mcc> also i would feel more comfortable if you do not make jokes about rape.
<ec-textual> mcc definitely +1 for irccloud, disappointing service interruption I'm currently experiencing notwithstanding
<ec-textual> happy to accomodate you on that, but perhaps it's worth sharing a heads-up that far worse things'll pass your consciousness if you hang out in here /=
<ec-textual> about the only things I actually ban for are politics, religion, and PHP.
<ec-textual> if you want to talk somewhere else / in-private about emily, lemme know
<ec-textual> night! :D
* Aranjedeath laughs
<mcc> ttyl!
Rusky has joined #elliottcable
mcc has quit [Quit: This computer has gone to sleep]
fmap has quit [Quit: Page closed]
mcc has joined #elliottcable
eligrey_ has quit [Quit: Leaving]
<glowcoil> uggghghhhh
<glowcoil> i'm genuinely going to die
ec-textual has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
<glowcoil> ok suddenly i feel a lot better
mcc has quit [Quit: This computer has gone to sleep]
mcc has joined #elliottcable
mcc has quit [Client Quit]
mcc has joined #elliottcable
mcc has quit [Quit: This computer has gone to sleep]
<devyn> ELLIOTTCABLE: as you know, I don't really tweet, though; I'm more of an input guy than an output guy, so to speak, haha
<devyn> I prefer talking with people personally to just broadcasting thoughts
<devyn> but I absolutely will read what random stranger on the internet who thinks his opinion is important has to say
vigs has quit [Ping timeout: 258 seconds]
vigs has joined #elliottcable
Rusky has quit [Quit: Leaving.]
Rusky has joined #elliottcable
Rusky has quit [Client Quit]
Rusky has joined #elliottcable
Rusky has quit [Quit: Leaving.]
Rusky has joined #elliottcable
Rusky has quit [Quit: Leaving.]
Rusky has joined #elliottcable
Rusky has quit [Quit: Leaving.]
Rusky has joined #elliottcable
Rusky has quit [Ping timeout: 240 seconds]
yorick has joined #elliottcable
alexgordon has joined #elliottcable
glowcoil has quit [Quit: Connection closed for inactivity]
Rusky has joined #elliottcable
<oldskirt> holy wall of backlog
<oldskirt> ah, new members of the cult
<manveru> we a cult now?
<oldskirt> CULT OF PLT, we run around in capes, didn't you know?
<manveru> irccloud is nice, but it has no way to search/download logs
<manveru> oldskirt: i'm gonna have to dig out my cape then
ec-textual has joined #elliottcable
ec-textual has quit [Quit: My MacBook Pro has gone to sleep. ZZZzzz…]
eligrey has joined #elliottcable
prophile has joined #elliottcable
<ELLIOTTCABLE> FINALLY booted up my AR Drone
<ELLIOTTCABLE> so, so fuckin' awesome.
<ELLIOTTCABLE> who is oldskirt o_O
<oldskirt> I was fwg
<oldskirt> now I'm an old skirt
<ELLIOTTCABLE> wateven
glowcoil has joined #elliottcable
<gkatsev> ELLIOTTCABLE: nodecopters are awesome, right?
<ELLIOTTCABLE> okay nope lied not awesome
<ELLIOTTCABLE> >:
<ELLIOTTCABLE> repl works, but absolutely no code that I write does anything whatsoever
<alexgordon> here's a question
<alexgordon> why aren't there functional shader languages?
<alexgordon> shading seems like an area which is limited in scope enough that you could build a "sufficiently smart compiler"
<gkatsev> ELLIOTTCABLE: :(
<gkatsev> ELLIOTTCABLE: are you connected to the drone's wifi?
<ELLIOTTCABLE> gkatsev: yep, I can control it through a REPL in another terminal, but the program written as code won't work.
<ELLIOTTCABLE> takeoff() does nothing.
<gkatsev> ELLIOTTCABLE: weird
<katlogic> To rephrase: Why game designers don't use it?
<alexgordon> katlogic: I'll guess: it doesn't have a website :P
* alexgordon googles "Obsidian language" finds nothing
<katlogic> Why reinvent the language?
<alexgordon> which language?
<katlogic> Haskell is quite fit for this purpose. There is also SaC
<katlogic> (single assignment C)
<alexgordon> I'm confused
<prophile> hey ELLIOTTCABLE
<prophile> you were a standing desk guy for a while right
<katlogic> alexgordon: Back to your question - because programming in this style is hard, and the necessary functional red tape is just too much.
<ELLIOTTCABLE> still am
<alexgordon> katlogic: lol bullshit
<purr> lol
<prophile> how is it?
<katlogic> alexgordon: HPC and game design is generally systems programming, not particularly highly abstracted.
<alexgordon> katlogic: yeah well that's the state of things now
<alexgordon> but it doesn't have to be that way
<katlogic> For example, one has to be careful about not introducing branch pipeline stalls
<katlogic> This is very hard to manage if there is shitton of abstraction
<alexgordon> depends on your abstraction
<katlogic> Much simpler if you just write it near-to-metal in opencl
<prophile> performance concerns are why structured programming never took off for instance
<prophile> or relational databases
<alexgordon> prophile: LOL
<katlogic> prophile: Unfortunately sarcasm works only if you are not making your statement out of context, otherwise its just lame strawman.
<alexgordon> meow
<ELLIOTTCABLE> prophile: it's spectacular.
<alexgordon> katlogic: anyway it seems hard to draw any conclusions when nobody has tried yet
<prophile> katlogic: I'm only here to make occasional remarks and take part in the occasional "I'm more British than you" contests with alexgordon
<katlogic> alexgordon: Again, there are functional systems for opencl.
<ELLIOTTCABLE> but one thing nobody stressed to me enough,
<alexgordon> prophile: I'M SO BRITISH I PUT MARMITE ON MY CRUMPETS
<ELLIOTTCABLE> is that it *takes a lot of time* to become acclimated.
<ELLIOTTCABLE> the most I could stand for at first, was maybe two or three hours. then I hurt too bad.
<alexgordon> katlogic: but none of them have websites? :P
<katlogic> :))
<prophile> I DO THE SAME BUT I HAVE A MUCH MORE DISMISSIVE EXPRESSION ON MY FACE WHEN I DO IT
<ELLIOTTCABLE> I was really chagrinned, because I thought I'd *wasted* all that money on a nice standing setup, a nice standing-mat, etc etc etc
<ELLIOTTCABLE> but nope, a year later, I can do six hours or so at a stretch if I'm focusing, before switching to sitting.
<ELLIOTTCABLE> but, nonetheless, absolutely make sure you have an alternative. We weren't designed to *stand* for hours at a time any more than we are designed to *sit* for hours at a time; it's just as unhealthy, in different ways.
<alexgordon> prophile: I GET NERVOUS WHEN I SEE AN ENGLISH FLAG IN A NON-SPORTING CONTEXT
<ELLIOTTCABLE> another really important thing is moving.
<ELLIOTTCABLE> -standing desk @ prophile
<purr> prophile: don't you mean ‘dancing desk?’
<katlogic> prophile is here to serve the queen.
<prophile> katlogic: *Her Majesty the Queen
<prophile> ELLIOTTCABLE: I'm considering making the jump myself
<ELLIOTTCABLE> it sounds like a joke, but it's absolutely not. It took me a while to learn to, but now I naturally *dance around* while I code / chat / whatever.
<prophile> alexgordon: I THINK THE SAME ABOUT THE SCOTTISH FLAG
<katlogic> Imperialistic hag of the british beehive!
<prophile> katlogic: you're not from southampton are you?
<ELLIOTTCABLE> stand on one leg and kick the other back and forth gently … bounce back and forth from one leg to another … spin around in place, if the music's got me feeling that … bob my hips
<ELLIOTTCABLE> constantly change how I stand.
<prophile> because last time I entered a republican/royalist debate in here, it turned out the guy I was debating with was someone I actually knew
<alexgordon> prophile: which one are you?
<prophile> I'm a royalist when in the presence of foreigners
<prophile> otherwise largely republican but I don't think it's really one of the country's main concerns
<ELLIOTTCABLE> so.
<ELLIOTTCABLE> expect to develop it, it's a skill;
<ELLIOTTCABLE> and remember that you'll be moving, not standing. (=
<katlogic> Damn IRC, in real life my russian accent would immediately give me away.
<ELLIOTTCABLE> prophile: absolutely do it. absolutely.
<alexgordon> prophile: *american accent* It must be soo totally awesome that you're related to the queen of england
<prophile> she's your queen too!
<prophile> *lynching*
<prophile> ELLIOTTCABLE: k
<prophile> ELLIOTTCABLE: should I get a tall chair too? or just use a different surface when I need to sit?
<alexgordon> yeah we didn't lose that war, we're just biding our time
<katlogic> prophile: To external observers like me, your country appears like odd mix of thatcherism and stalinist mother russia, with emmigrants icing the cake.
<prophile> but to an internal observer like me, I *know* that's how it is
<katlogic> Or immigrants?
<prophile> expats are worse than immigrants
<katlogic> Indeed, though my observations are largely from expats
<alexgordon> what's the difference?
<katlogic> British blokes in Prague are the worst kind of tourist indeed.
<alexgordon> katlogic: well yeah, most of them are stag weekends and sex tourists :P
<katlogic> Cant really blame em for that tho
<alexgordon> ha
<katlogic> First, czechs are pretty slutty overall, second the state of acceptable in dating pool in UK seemed to be dire.
<katlogic> (been only to London, but I kinda assume its like that in the rest of UK as well)
<alexgordon> katlogic: the best chicks in london are eastern european, so yah... might as well stay home
<alexgordon> the rest of the UK is worse
prophile has quit [Quit: The Game]
prophile has joined #elliottcable
prophile has quit [Client Quit]
alexgord_ has joined #elliottcable
<vigs> anyone know of any CLI magickery on OS X that'll let me turn on internet sharing?
alexgordon has quit [Ping timeout: 240 seconds]
<katlogic> man pfctl ?
<katlogic> (there are pointy-clicky menus for that as well in macosx)
<vigs> yeah, I'm tired of using the pointy-clicky menus.
<vigs> hmm…not sure if pfctl is what I want. I was prowling through networksetup earlier
<katlogic> I think pf.conf is ultimately what macosx uses though
glowcoil has quit [Quit: Connection closed for inactivity]
alexgord_ is now known as alexgordon
<alexgordon> vigs: internet sharing? man it's been a while ;P
<alexgordon> vigs: such bad memories
<alexgordon> trying to get a dialup connection to share between two computers over ethernet
<vigs> alexgordon: looool yeah, I need to turn it on every time I wanna connect my 3DS to the wireless at my current place :/
<vigs> It'll change once I move out but it's just a pain in the ass to have to open Sharing and click the tiiiiny checkbox
<vigs> (yes, I'm THAT lazy)
yorick has quit [Remote host closed the connection]