purr changed the topic of #elliottcable to: a
gkatsev_ has joined #elliottcable
gkatsev has quit [Ping timeout: 246 seconds]
glitch^ has joined #elliottcable
glitch^ has quit [Ping timeout: 246 seconds]
<eligrey> pikajude: what
<pikajude> sup
glitch^ has joined #elliottcable
glitch^ has quit [Ping timeout: 255 seconds]
_whitelogger has quit [Ping timeout: 240 seconds]
_whitelogger has joined #elliottcable
_whitelogger has joined #elliottcable
glitch^ has joined #elliottcable
glitch^ has quit [Ping timeout: 260 seconds]
_whitelogger has joined #elliottcable
meowrobot has quit [Quit: let us connect our intestines and mutually digest]
_whitelogger_ has joined #elliottcable
_whitelogger has joined #elliottcable
_whitelogger has joined #elliottcable
_whitelogger has joined #elliottcable
glitch^ has joined #elliottcable
glitch^ has quit [Ping timeout: 240 seconds]
glitch^ has joined #elliottcable
glitch^ has quit [Remote host closed the connection]
meowrobot has joined #elliottcable
ec has quit [Ping timeout: 240 seconds]
purr has quit [Ping timeout: 256 seconds]
Rurik has joined #elliottcable
Rurik has quit [Changing host]
Rurik has joined #elliottcable
purr has joined #elliottcable
ec has joined #elliottcable
purr has quit [Ping timeout: 246 seconds]
ec has quit [Ping timeout: 240 seconds]
purr has joined #elliottcable
ec has joined #elliottcable
<ec^> Rurik! meowrobot! alynn!
<ec^> good morning world!
<Rurik> ec^, hi
<ec^> :D
<ec^> you're awake!
<ec^> what time zone are you? ugh you gotta tell me what time zone I need to be awake in so I can drag you into my work. :3
<Rurik> ec^, GMT +5.5
<ec^> Rurik: Well, let me know when you're going to have some time available. I can try to work out a time to focus on you. (=
<ec^> Rurik: also, hit me up with your e-mail address. I'm using a private-hosted task-list tool, unfortunately.
glitch^ has joined #elliottcable
<Rurik> ec^, seem PM
<Rurik> *see
<Rurik> ec^, I am free right now
<ec^> it's Akshat Jain, right? if I recall correctly? (putting your e-mail in my contacts, lol)
<purr> lol
<Rurik> ec^, yep
<ec^> -what
<purr> <whitequark> what the hell exactly
<ec^> -what
<purr> <alexgordon> though github DOES sound like a porn site
<ec^> Rurik: sorry, with people
<Rurik> ec^, no problems
<ec^> Rurik: hmmm. so, 1. do you know the CoffeeScript basics, and 2. have I walked you through the basics of Paws before?
<ec^> and 3. how long are you here for right now :P
<Rurik> ec^, no, no, and I'm here for the next 3 hours
<ec^> hm. Have you written Ruby?
<ec^> and, you're very familiar with JavaScript at least, right?
<Rurik> I'm familiar with Javascript
<ljharb> ec^: you're writing paws in coffeescript? O.o
<ec^> ljharb: <breathes>
<ljharb> hey man, it's cool, you can do whatever you want, but, you, you're crazy, man
<ec^> 1. JavaScript because it's a language *designed* to be web-stuff related (big on asynch, big on distributed tasks, big on what JavaScript community *ludicrously* calls ‘isometric code’),
<ljharb> it was designed from the beginning to be serverside also
<ljharb> and it's "isomorphic" :-p
<ec^> 1a. JavaScript because writing a browser plugin for your language work is a *great* way to revolt everybody everywhere, trying to get browsers to implement it right off the bat is a great way to sign off *all* of your agency in the design to Committies, Committies, and More Committies.
<ec^> 2. CoffeeScript because I'm working on an exploratory implementation of an experimental language, and I decided early on that I was going to draw a hard line at ‘clarity and simplicity of code are more important than *anything* else.’
<ljharb> i question "simplicity" and "coffeescript", but those are good priorities
<ec^> like, it's not really, in some ways, an implementation for real people to ever usefully run code on. (It is, but that's like, almost an extraneous goal.) it's something for somebody to *read the code of* when they go ‘Ugh, elliott's explanations make no sense, HOW DOES PAWS WORKKKK’
<ec^> ljharb: why?
<ljharb> coffeescript is a very flawed language from a language design perspective
<ec^> There are a couple very valid arguments against CS. It's a very bad choice for almost anything. *Especially* nowadays, compared to when I chose it.
<ljharb> right
<ec^> But almost none of those reasons are any of the ones usually parroted.
<ljharb> variable shadowing is my big one
<ec^> ‘isomorphic’: equally ridiculous.
<ljharb> (yeah, "universal" is a better word imo, and is gaining popularity)
<ec^> Yeah, it's annoying that they made that choice; but it's trivial to work around, *and* is generally a nudge in a Good Direction
<ec^> ugh no universal is the worst
<ljharb> lol, what word would you use
<purr> lol
<ec^> client/server or server-DOM is just so much more clear and conveys the *real* thing going on
<ec^> Like, ‘universal’ implies you're Just Writing Clean Code, and Following Standards, not writing code that depends on sketchy platform-features
<ljharb> that's what it means to me
<ec^> yeah, that's precisely what I'm pissed off by.
<ljharb> what sketchy platform-features?
<ec^> There's so much more to *writing ‘isomorphic’ apps* than just writing clear, platform-independant code.
<ec^> ugh sorry that's a side-discussion (although very relevant to Paws)
<ec^> I can't spend a lot of time having this discussion right now ;_;
<ljharb> k, no worries
<ec^> basically: CoffeeScript was a mistake, but not in any way I could have known at the time.
<ljharb> understood
<ec^> The only reason it was a mistake is that ES6 (or more specifically, babel / other transpilers) kinda took over and *succeeded*, against all expectations; and Jeremy (and the rest of the world) stopped caring about, improving, or maintaining CoffeeScript.
<ljharb> i don't know why anybody expected it not to succeed
<ec^> so now CoffeeScript, *while achieving its' goals*, is a technical debt that I have no option but to abandon soon, and is going to suck up a bunch of my time and effort to shift away from
<ec^> lol.
<purr> lol
<ljharb> and yeah, depending on jeremy to not be a pile wrt software is def a mistake
<ec^> ES6 *screams* R6RS, up and down.
<ljharb> r6rs?
<ec^> or, idk, maybe Python 3? I don't know Python very well.
<ec^> lisp?
<ljharb> not familiar with lisp
<ec^> a New And Improved In Every Way!!!!!1! standard was worked on for years by a lot of very smart people.
<ljharb> and python 3's big mistake was forking the language, JS won't do that
<ec^> and it turned out super-committee-ified, and terrible, and worthless, basically,
<ljharb> ie, python 2 code didn't work in python 3
<ec^> and about half of the big implementors rebelled and said ‘yeah, we're not doing this.’
<ec^> and about half the users said ‘yeah, we're not using this.’
<ec^> so for a while the community was split, and now everybody's given up and R5RS is the only *real* scheme.
<ljharb> xkcd standards
<ec^> see R6RS didn't really … fork the language. The biggest deal was precisely the same stuff JavaScript is experiencing pains with right now: the module system, and *support* for the module-system
<ljharb> anyways sorry to take you on tangents, was just curious about cs/paws :-)
<ec^> hold on a friend is pissed as fuck at me
<ljharb> imo it's pretty early in the morning to be that angry
<ec^> basically because they were sitting here waiting for my attention, and the conversation was going to be important, and I got wrapped into responding to somebody on IRC instead and that kind of shattered my have-an-important-conversation-in-real-life focus.
<ec^> they just left. |=
<ec^> brb.
<ec^> gonna make a lot of poop.~
Hrorek has joined #elliottcable
<ec^> Hrorek: Rurik?
Rurik has quit [Ping timeout: 256 seconds]
<ec^> Hrorek: which one of you is youuuuu agrdfjhu5y4t3ar
<Hrorek> ec^, yep
<Hrorek> my internet is down
<Hrorek> on 3G now
<ec^> Hrorek: lollll
<purr> lollll
<ec^> you have a lot of nicks. ;)
<ec^> what do they mean?
* ec^ -learn rurik=Рюрик
<ec^> -learn rurik=Рюрик
<purr> ec^: Learned `rurik`.
<ec^> Hrorek: so, I'm kinda torn here:
<ec^> If the end-goal is getting you up to speed on ‘what I do every day’, to prove that language-development is really procedurally-simple besides the Hard Thinking parts,
<ec^> then I need to get you up-to-speed on the codebase.
<ec^> unfortunately, the simple tasks that are *approachable*, are also drudge-work. And I don't want to assign you a bunch of boring drudgery on *my* project. But the non-drudge-work tasks … will require you to be a lot more up-to-speed on things.
<ec^> It's like, a catch-22.
oldskirt has joined #elliottcable
<ec^> ~oldskirt@unaffiliated/frodenius
<oldskirt> yo
<ec^> lol hi oldskirt
<purr> lol
<ec^> frodenius
<ec^> what a strange word, what is it?
<oldskirt> it's a made up name :P
<oldskirt> my first nick from when I was 13 or so
<Hrorek> ec^, don't worry about it
<ec^> oldskirt: oh, lol :P
<purr> lol
<ec^> Hrorek: meaning?
<Hrorek> ec^, just throw whatever needs to be done at me
<Hrorek> I'll handle it
gkatsev_ is now known as gkatsev
oldskirt has quit [Ping timeout: 240 seconds]
oldskirt has joined #elliottcable
<ec^> Hrorek: ... lol
<purr> lol
<ec^> Hrorek: still around?
oldskirt has quit [Ping timeout: 260 seconds]
Hrorek has quit [Ping timeout: 240 seconds]
<ec^> bah
<ec^> ljharb: sorry I disappeared, a lot came up. >:
<ec^> Social Living™ lol.
<purr> lol
<ljharb> np
oldskirt has joined #elliottcable
<ec^> what was I saying
<ec^> CoffeeScript 'cuz ‘I want code accessible to non-JavaScripters, and I want it to run in web-browsers, even if agonizingly slowly’, and when those requirements were evaluated, CS was the best option. ¯\_(ツ)_/¯
<ec^> I hate it in lots of ways, but strangely never apparently in the way that others I interact with seem to hate it. O_O
<ec^> sometimes I wonder if any of the peopler complaining about it have actually ever even used it.
<ljharb> how is CS accessible to anyone besides rubyists (and maybe some python devs)
Hrorek has joined #elliottcable
<ec^> er, because Ruby and CoffeeScript are the Way Code Should Be? the entire Java/C heritage is *insanely* incomprehensible and inaccessible to beginner programmers, and it makes me very fucking sick.
<ec^> but that's a conversation for another day. Just read it as ‘'cuz elliott's-opinions-on-learning-to-program / opinions-on-PLT’ reasons.
<ljharb> lol
<purr> lol
<ljharb> k
<ljharb> just pointing out that it's not at all accessible to non-JavaScripters, it's only accessible to rubyists
<ljharb> which if that's your goal, then you're good
<Aria> Heh. I have yet to successfully explain coffeescript.
<Aria> Without first explaining javascript, then how it's different
<jfhbrook> wait you actually like cofeescript?
<jfhbrook> I worked with it for a good 6 months at a prior job, it's *okay* but it's no es6 and transpilation kinda sucks
<jfhbrook> like just in general
<jfhbrook> I'll never be convinced that babel is easy-peasey and watchify makes everything okay
<ljharb> transpilation does suck in general
<ljharb> babel's pretty decent tho.
oldskirt has quit [Ping timeout: 240 seconds]
oldskirt has joined #elliottcable
<jfhbrook> I mean I've heard rave reviews of babel so I'm sure that *for* a transpiler it's pretty good
<ljharb> right, i agree with you in a general principle
<ljharb> i write ES3 syntax with ES6 APIs, in all my modules.
<ljharb> but at work we write ES6 and use babel, and it's pretty nide
<ljharb> *nice
<jfhbrook> we're all es5 all the time because 0.10
<jfhbrook> still haven't figured out the problem with running 4 in prod
<jfhbrook> I ran our service on my laptop and sieged it for a day and a half, no repro
<jfhbrook> guess I'm gonna try in staging next?
<ljharb> yeah airbnb's having small roadbumps upgrading to 4 also
<ljharb> we're still on 0.10 and very sad about it
<jfhbrook> this isn't really a small roadbump
<jfhbrook> we're entirely ready except our perf goes to shit
<jfhbrook> for no good god damned reason
<jfhbrook> part of me wants to turn on the profiler in prod
<jfhbrook> does babel strictly transpile to es5 or can you tell it to use native implementations?
<ec^> 2:16 PM <jfhbrook> I worked with it for a good 6 months at a prior job, it's *okay* but it's no es6 and transpilation kinda sucks
<ec^> jfhbrook: this conversation is basically ‘How things were four years ago.’
<ec^> *now* it's inarguably a terrible choice.
<ec^> but the points I'm making are from when ES6-transpilation wasn't really an option, like it is now.
<jfhbrook> I see
<jfhbrook> yeah, I was using coffeescript like 2 and a half years ago? I think still before babel was really a thing
<ec^> yepz
<ec^> now I just have all this technical debt, and am in this shitty spot where CoffeeScript isn't yet *unusably* out-of-date; but it's really damn close,
<ec^> and yet ES6 is not *usably* prepared, or enough of an improvement in practice to invest all the effort to switch yet
<jfhbrook> coffee2es6 would be a cool thing
<ec^> although jesus christ the amount of time I've spent arguing this in various venues is almost precisely the same amount it would probably require to upgrade … >,<
<ec^> lol that's a lie. but it feels like it.
<purr> lol
<ec^> no, a continuously updated coffeescript would be a cool thing.
<jfhbrook> that would *also* be handy
<ec^> CoffeeScript *plus* ES6 would be a cool thing.
<jfhbrook> nobody wants to adopt cs?
<ec^> So much of CoffeeScript could *stop* being weird. Take all the good parts of CoffeeScript, build it on top of the ES2017 spec, implement it on top of Babel's architecture instead of rolling-your-own ...
<ec^> Semantic indentation and an attention to aesthetics in an otherwise-fully-ES2017-compatible translanguage would be, fucking beautiful.
<ec^> I'm *seriously* considering writing SweetExpressions for JavaScript. |=
<jfhbrook> sweetexpressions?
<jfhbrook> |= being an example?
<jfhbrook> remind me, is x |= y equivalent to x = x || y ?
<ec^> JS is having some of the same problems the lisps have: it's becoming a truly beautiful language on the *inside*, and (possibly partially *because* of that), people will continuously hear nothing whatsoever against its' syntax, and will argue the syntax doesn't matter *against all of the fucking evidence to the contrary*, and *all the newcomers who are
<ec^> confused and hate it*
<ec^> no lol
<ec^> there's an old lisp thing
<ec^> it's ... basically a lisp transpiler, a bit like coffeescript for lisp? nah, that's a terrible example
<ec^> it's a *completely transparent* translation of the lisp sexprs into a partially-semantic-identation, or-alternatively-bracketed, syntax.
<jfhbrook> I see
<ljharb> jfhbrook: you don't want to use native ES6, it's always going to be slower than ES5.
<jfhbrook> I mean that's *a* reason not to use native es6
<ljharb> i guess debugging would be a reason to use it, but there's source maps
<ec^> but the thing is that any transformation it does can be done in text / in the code, without changing the meaning. Like, you *can* type the -> in CS, but you can also continue to type function(){}, and their meaning is identical? or something kinda like that?
<jfhbrook> and I'm skeptical of the idea that a shim would always be faster---after all, if that were the case, why wouldn't the runtime just use es5 to implement it under the covers?
<ec^> hard to explain to a non-lisper, but, nonetheless, the point is it would be beauuuuuuutiful to have it done to JS.
<ljharb> jfhbrook: i'm not talking about a shim. babel transpiles syntax, not API.
<ljharb> ec^: i'm sure there's a babel transform plugin for the thin arrow
<ec^> basically ignore all the terrible and pointless objections that all the JavaScript Nerds have when you complain about JS's syntax, and just write our own syntax. ¯\_(ツ)_/¯
<jfhbrook> so, uhh, reader macros ec^ ?
<ljharb> jfhbrook: also yes, shims are very often faster. native Object.assign only recently got faster than my shim, and only in one browser
<ec^> ljharb: missed my point. Was just presenting a simple example of the kind of *syntactic* transform that sweet-expressions do, as opposed to the kind of semantic transform that CoffeeScript messily mixes in with the useful syntactic ones.
<ljharb> ah k
<ec^> jfhbrook: Oh! no, but, have you seen sweet.js?
<ec^> so big fan much omg
<ec^> that's part of the reason I haven't pulled the trigger and re-written my code in modern JS
<jfhbrook> I *did*
<jfhbrook> at least I *think* I did
<ec^> am DESPERATELY hoping for that whole thing where apparently TC39 is considering some sort of macro system for JS *natively*?
<jfhbrook> it was the little js macros language yeah?
<ec^> omg if that happens then I will just, I will die, I will die, I will die, I wil diiiiiieee with happiness
<ljharb> i haven't heard anything about it yet in the committee.
<ljharb> i think we'd have to have value types first.
<jfhbrook> lolno tc39 is too busy figuring out how to make classes even more unweildy
<purr> lolno
<ec^> ljharb: oh. I swear people at jsconf were talking about it
<ec^> and The Reason Sweet.js Died is nominally because “well JavaScript's going to do it itself now so we don't need to work on this anymore”
<ljharb> jfhbrook: what do you think will make them more unwieldy?
<ec^> which is simultaneously sad and really exciting
<jfhbrook> I mean I'm kinda sorta being a smartassed troll without much backup but
<ljharb> ec^: it's also because the zeitgeist is moving to "only use standard things"
<jfhbrook> callable constructors?
<jfhbrook> and private members?
<ljharb> sure
<jfhbrook> those don't sound that pressing to me
<ljharb> callable constructors means you don't have to use `new`, which is how JS has always worked
<ec^> jfhbrook: -^
<ljharb> it's not about "pressing", many proposals are worked on at once
<jfhbrook> I understand the rationale ljharb, that doesn't mean I think it's right
<ec^> “Unlike most past efforts to make Lisp more readable, our approach is generic (the notation does not depend on an underlying semantic) and homoiconic (the underlying data structure is clear from the syntax).”
<ljharb> it's important to browsers to be able to self-host JS
<ljharb> so, for example, `Date`.
<ec^> See, that's what we need: that translates, to non-lispers, to <Generic> and <Still Completely Lisp-y>
<ljharb> and browser makers do consider that requirement very pressing
<ec^> we need a syntactic transform that makes JS *less awkward*, while maintaining generic-ness and still-completely-JS-y-ness
<jfhbrook> yeah that's cute ec^ like I see why you would want that
<ec^> 3:01 PM <+ljharb> it's important to browsers to be able to self-host JS
<ec^> wait, what did I miss
<ec^> which thingie is necessary for self-hosting that you were discussing?
<ljharb> callable constructors
<jfhbrook> the argument is that you can't really write Date with es6 classes because callable ctors
<ljharb> browsers want to get rid of all their crappy C code and replace it with JS.
<ec^> -learn t-expressions=Fixing lisp. <http://readable.sourceforge.net/>
<purr> ec^: Learned `t-expressions`.
<ljharb> you can't write most of the builtins with ES6 classes
<ec^> -learn alias sweet-expressions=t-expressions
<purr> ec^: Learned `sweet-expressions` => `t-expressions`.
<ljharb> since all of them have [[Call]] behavior
<jfhbrook> I use Date as an example
<ljharb> right, Date's the one most often used to support callable constructors
<ec^> ljharb: I haven't used classes yet
<jfhbrook> but I'm also okay with using es5 for these
<ec^> or for that matter, *any* JS feature beyond, like, ES4. /=
<ljharb> true
<ec^> so what's this about callability?
<ljharb> ec^: ES4 never existed
<ljharb> ec^: `class Foo() {} Foo()` is a syntax error in ES6,
<jfhbrook> you don't have to write it with es6 classes in order for it to be written in es
<ec^> ¯\_(ツ)_/¯ Old JavaScript™
<ec^> oh damn o_o
<ec^> seriously?
<jfhbrook> yeah
<ljharb> yes, you must use `new` with a `class`
<ec^> damn.
<ljharb> ec^: "callable constructors" would be `class Foo() { call constructor() {} } Foo()` or something
<ec^> that's horrible. I've avoided typing the new keyword for years; I'd hate to have to start now. ;)
<ljharb> :-p same
<jfhbrook> presumably it would always be call constructor() { return new Foo(); } or similar
<ec^> jfhbrook: take a look at this, you might like it:
<ljharb> right
<jfhbrook> I don't mind having to call with new
<jfhbrook> that doesn't bother me in the least
<ec^> basically, at the lowest level of abstraction, it turns {a + b + c} into (+ a b c)
<jfhbrook> and I don't get why other people get so upset about it
<ljharb> i abhor `new`
<ec^> then it layers more useful things on top of that slowly, but they are all completely 100% transparent to lisp's data-type / sexprs
<jfhbrook> beyond "these aren't real classes" but then you must REALLY hate the class keyword
<ec^> which is crucial if you want to convert lispers
<ljharb> yes, i really hate the class keyword also
<ec^> 3:06 PM <+ljharb> i abhor `new`
<jfhbrook> worse is better
<ec^> 3:06 PM <+ljharb> yes, i really hate the class keyword also
<ljharb> but i do like the construct. just not the word
<ec^> -qft
<ec^> purr come on
<ljharb> if it'd been the `blueprint` keyword i'd adore it
<ec^> uggggh i love scheme
<ec^> I forget
<ec^> ljharb: blueprint? 'splain some more
<ec^> I know *very* little about ES6, you may need to do some background here o_o
<ljharb> ec^: i just don't like the word "class" because JS doesn't have classes
<ec^> f{n - 1} ⇒ (f {n - 1}) ⇒ (f (- n 1)), and g{- x} ⇒ (g (- x)).
<ljharb> and having that overlap with other langs (read: java) makes teaching JS much harder also.
<ljharb> and googling stuff
<ec^> ljharb: so very true. But I'm saying, I thought ES6 *added* classes. Is that not the case?
<ljharb> no
<ljharb> it added a syntactic construct for prototypical inheritance
<ljharb> using a keyword they badly named "class"
<ljharb> but that confusion is also part of why i dislike the keyword name
<ljharb> JS doesn't have classical inheritance, and never will.
Hrorekr has joined #elliottcable
<ec^> “See [Rationale] for why these rules are the way they are, and [Retort] if you were told that Lisp's s-expression notation can't be improved on.”
<ec^> Man, I am really in love with whoever wrote this ancient obscure dead project
<ec^> *I* want to write a pages-long retort on why everybody-who-thinks-JS's-syntax-is-just-fine is super, duper, very, Wrong on the Internet!!!1!
Hrorek has quit [Ping timeout: 250 seconds]
<ec^> -learn t-expressions=Fixing the lisps. <http://sourceforge.net/p/readable/wiki/Solution#quick-examples>
<purr> ec^: Learned `t-expressions`.
<ec^> -learn t-exprs = t-expressions
<purr> ec^: Learned `t-exprs`.
Hrorekr has quit [Ping timeout: 255 seconds]
Hrorekr has joined #elliottcable
<ec^> wait wtf
<ec^> I just nearly fell out of my chair. saw my own name on one of the pages of that wiki.
<ec^> “Mac OS X "Homebrew" includes our readable package, just use "brew install readable". As of 2014-06-14 it only supported Scheme, not Common Lisp. Our thanks to Elliott Cable for packaging it!”
<ec^> no it doesn't! My pull-request was never accepted! wtf? o_o
<ec^> -learn s-expressions=“Some believe that traditional Lisp s-expression notation descended from the gods, and thus cannot be improved on. We think that's nonsense.” <http://sourceforge.net/p/readable/wiki/Retort/>
<purr> ec^: Learned `s-expressions`.
<ec^> “In other words, this is such a serious problem that a large number of people have tried to fix it. Again, this is evidence that traditional Lisp syntax has serious flaws.” — one of the best arguments related to software you can possibly make.
<ec^> There's a few ways to rebut ‘Lots of people think this is terrible, so maybe you should consider that maybe it actually *is* terrible?’ ... but very few ways to rebut ‘Lots of people thought this was *so terrible*, that they considered to investigate the issue in depth, and even began devoting their valuable effort, time, and resources to *creating a
<ec^> solution.*’
<jfhbrook> that's interesting
<jfhbrook> -s-expressions
<purr> jfhbrook: “Some believe that traditional Lisp s-expression notation descended from the gods, and thus cannot be improved on. We think that's nonsense.” <http://sourceforge.net/p/readable/wiki/Retort/>
<ec^> jfhbrook: right!
<ec^> it fascinates me
<ec^> their approach isn't perfect; I have a lot of reservations, on several levels
<jfhbrook> sure, but it's an attempt and apparently a reasonable one
<ec^> but they're some of the only people in PLT that I *really believe* had their heads screwed on straight. So much that goes on seems so very opaque to me ... foreign, strange motivations; things approaching *active hostility* towards users; a complete disregard for the diversity of the userbases of programming-languages and the diversity of needs and opinions
<ec^> therein; strange attachments to theory over demonstrable ... ugh I'm done sorry
<ec^> guys this is so cute
<ec^> in
<ec^> suffer
<ec^> a
<ec^> bly
<ec^> cute
<jfhbrook> nice
<jfhbrook> kids amirite
<ec^> e2.0 amirite
krainboltgreene has joined #elliottcable
<krainboltgreene> Hello!
<ec^> welcome to my place!
<ec^> krainboltgreene: also, good call on the irccloud :P
<krainboltgreene> I'm lazy like that about some tools.
<ec^> so, sounds like you had some thoughts. car2shar?
<krainboltgreene> I've been diving into react/redux lately, due to work. I've noticed specifically that redux libraries tend to have *tentacles*.
<krainboltgreene> They want to creep into your middleware, action creators, reducers...
<krainboltgreene> It's a very weird situation. Everything is so "small" its like they think they can avoid abstraction.
<krainboltgreene> That said I am super happy about things like virtualdom and cycle.js
<ec^> I know nothing about any of these things, because I do not react and I *barely* front-end; but simultaneously, I know your pain. I think it's endemic to the JavaScript community rn, basically.
eligrey has joined #elliottcable
eligrey has quit [Quit: Leaving]
glitch^ has quit [Remote host closed the connection]
<krainboltgreene> Honestly endemic of ruby, js, and probably soon elixir.
<krainboltgreene> Elm seems to be the only one actively combatting this. Their package manager even goes so far as to suggest the right SEMVER step.
oldskirt has quit [Ping timeout: 265 seconds]
eligrey has joined #elliottcable
eligrey has quit [Client Quit]
eligrey has joined #elliottcable
oldskirt has joined #elliottcable
<ec^> krainboltgreene: Elm? I don't think I'm familiar.
<ec^> And I haven't heard the word ‘elixir’ since my Ruby days. Is that a real thing people really use? o_O
oldskirt_ has joined #elliottcable
oldskirt has quit [Ping timeout: 255 seconds]
jaal has quit [Quit: Connection closed for inactivity]
oldskirt_ has quit [Ping timeout: 246 seconds]
<krainboltgreene> ec^: Oh hell yeah, Elixir is getting biiiiig. I mean there's an elixirscript even.
oldskirt has joined #elliottcable
<krainboltgreene> Elm is a transpile-to-javascript frontend language and it has the best error messages: https://twitter.com/rachelcolby11/status/676843156957061121
<ljharb> ok yeah that's super fancy
<krainboltgreene> Right? It's amazing.
oldskirt has quit [Read error: Connection reset by peer]
<krainboltgreene> And I mean their whole outlook is akin to this.
<ljharb> is that something that JS could have? or is there an aspect to elm that's required for it
<krainboltgreene> Like, for instance, you can't push to their package manager unless you have documentation for each public function.
<krainboltgreene> ljharb: Well they get it for free with their pure functional type system.
<krainboltgreene> But I sincerely believe you could do this by being a bit explicit and looking at the AST tree.
<krainboltgreene> I've been suggesting to the node people that we should have "exits points" detailed in package.json, and those are files that explicitly are for public importing.
<krainboltgreene> Then the system would read the AST output for those files and that's how you'd get the Major version change suggestions.
<krainboltgreene> But getting new fields into package.json is congress level hard.
<ljharb> you can add any field to package.json
<ljharb> getting npm to respect it is the struggle
<ljharb> but, if you made a tool that reliably prevented accidental breaking changes in a non-major release, i'd bet they'd use it
oldskirt has joined #elliottcable