<gq>
vigs: just kidding, joelteon doesn't matter ^_^
<gq>
-otters @ joelteon
<purr>
joelteon: write-only stream
<devyn>
vigs: what is your reason for "vehemently" hating it, other than the bandwagon? I can understand disliking it, but I don't understand *hating* it
<vigs>
TIL there's a bandwagon
<gq>
i like coffeescript because of the name
<devyn>
it was a pretty contentious thing in the Node.js community for a while, and I'm not even involved in that at all and I heard about it
<gq>
which i know is shallow but programmers are bad at naming langs
<vigs>
apart from how absolutely unnecessary it was to implement, I've found myself coded into a corner trying to implement something that's stupidly simple, only to find that you can't do it in coffeescript
<gq>
see my rant in elliottcablechan about that
<gq>
vigs: understandable
<vigs>
the most recent example was trying to create an array of anonymous objects
<devyn>
vigs: you mean like [{x: 2}, {y: 3}]?
<vigs>
mhm
<devyn>
because coffeescript doesn't change that at all...
<devyn>
coffee> [{x: 2}, {y: 3}]
<devyn>
[ { x: 2 }, { y: 3 } ]
<vigs>
I remember running into some issues with that a while back, I'll dig up the chatbot module on monday
<vigs>
(it's on my work machine)
<devyn>
mmkay
<vigs>
some people may like this (but oh god why would anyone sane like it), but oh fuck funciton calls
<vigs>
function param1 param 2 param3
<vigs>
why
<vigs>
why why why
<gq>
oh, that's the problem
<vigs>
just do function(param1, param2, param3) the visual separation of function name and parameters is way better than that monstrosity
<gq>
i'm not sane.
<gq>
never been.
* gq
nods
<devyn>
vigs: lol I use Ruby and I prefer no-parens there in many cases, which is why CoffeeScript even has that
<purr>
lol
<vigs>
devyn: see, that's exactly how I realized I need to understand why coffeescript was necessary. It brings in the crazies who like lispy syntaxes :P
<vigs>
any syntax too similar to JS would've been met with a "UGH WHY WOULD YOU CHANGE THAT BUT NOT THIS"
<devyn>
Ruby... isn't a lispy syntax
<vigs>
and by appalling people like me, it entices rubyheads and lispers
<devyn>
it's like the exact opposite
<devyn>
massively complex grammar
<devyn>
but it looks pretty
<vigs>
right, but I've heard people lump them together in these contexts
russfrank has joined #elliottcable
inimino has joined #elliottcable
<vigs>
but I can't really talk about those, as I've stayed away from ruby
<devyn>
I don't think it really makes sense to lump them together when we're talking about a syntax
<vigs>
okay, that's fair
<vigs>
I want to play with ruby, though
<devyn>
for some other things, yes
<vigs>
maybe my biases will evaporate if I tried it
<devyn>
they both have an emphasis on metaprogramming, which isn't a hugely common thing in most languages
<vigs>
but yeah, as much as I dislike coffeescript, it brings an entirely different crowd into the JS(ish) scene
<vigs>
still doesn't mean I have to like it ;P
<devyn>
but for example, you can do shit like: html { body { div(class: "world") { p "Hello!" } } } and have that generate valid HTML
<devyn>
which might not make a huge amount of sense for HTML, but it's a general pattern that can be used for a lot of things
<devyn>
effectively allowing declarative styles of things in Ruby
<vigs>
huh
<devyn>
the craziest part of that is the actual implementation; Ruby allows you to evaluate blocks (lambdas, really) in a different context (like JS bind()/apply())
<devyn>
and it also allows you to respond to when a method is missing by defining method_missing(name, *args, &block)
cloudhead_ has joined #elliottcable
cloudhead_ has quit [Changing host]
silentbicycle has joined #elliottcable
silentbicycle has quit [Changing host]
<devyn>
and methods are sent by default to self
<devyn>
so you can basically not even define those tag names
<devyn>
and just generate tags when you receive a method_missing() call
manveru has joined #elliottcable
manveru has quit [Changing host]
<vigs>
wait are you still talking about ruby?
<devyn>
yep!
<vigs>
oh yeah I've heard great things about ruby
<vigs>
and that's super interesting
<devyn>
yeah, Ruby is a super fun programming environment honestly
<vigs>
(I've also heard stuff from the haters, but it's less convincing, despite my falling in that camp more than the latter)
<vigs>
but again, I *should* reserve judgement until trying it. Coffeescript, on the other hand…
<devyn>
it has a lot of syntax goodies too. it's the only language I know of that has a "redo" keyword, which basically allows you to re-run the current iteration of a loop without moving on to the next element
<devyn>
which... you shouldn't use too much, because spaghetti, but it can be useful when obvious
<vigs>
…that…that sounds not very useful
<vigs>
that sounds the same as decrementing the loop counter in a for loop
<devyn>
it is, except a lot of the time you don't really want to have a separate counter variable, and counter variables are very rarely used in Ruby
<devyn>
they're ugly
<devyn>
[:a, :b, :c].each { |x| redo if x == :b }
<devyn>
will loop infinitely once it reaches b
<devyn>
heh
<vigs>
…ah
<devyn>
you can also `retry` when handling an error. for example, let's say you catch an error, and you know you can change something and try to run that exact same piece of code again
<devyn>
you just use the `retry` keyword
<vigs>
that's neat
<devyn>
and it's just super super dynamic. you can generate classes, modules, methods, whatever dynamically
<devyn>
normally you would class A; def b; 3; end; end
<devyn>
but you can also: Class.new { define_method(:b) { 3 } }
<devyn>
er,
<vigs>
but honestly, I can't look over the completely unncessary syntax :|
<devyn>
A = Class.new { define_method(:b) { 3 } }
<joelteon>
lol wtf
<purr>
lol
<devyn>
haha that's the whole point! lots of unnecessary syntax
<joelteon>
"you can't create anonymous objects in coffeescript"
<devyn>
it's actually *a good thing*
<joelteon>
reminds me of this conversation i had with a dude earlier today
<devyn>
it makes code look so pretty
<joelteon>
where he was like "in languages that don't have regex i use split()"
<joelteon>
i was like "say again"
<devyn>
because you can choose which syntax you want to use to make the code clearer in a given circumstance
<vigs>
joelteon: arrays of anonymous objects; I remember running into a wall with that a while ago when working on my department's hubot
<devyn>
it may make more sense to "action if not condition" or "action unless condition" depending on what condition and action are
<devyn>
even though they're logically equivalent
<devyn>
they read differently
<joelteon>
arrays of anonymous objects......
<joelteon>
yeah that is definitely something you didn't understand rather than something coffeescript can't do
<vigs>
joelteon: nah, I did a bunch of research to try to fix that one problem; the workaround was long and ugly
<joelteon>
ok
<joelteon>
either way, hating coffeescript for a problem that doesn't exist doesn't make much sense
<vigs>
it may have been something related to that, but it was a little while back so I'd have to find that branch to be sure
<vigs>
coffeescript was "solving" a problem that didn't exist to begin with, imp
<vigs>
* imo
<devyn>
I just realized I'm pretty sure you can do prototypal inheritance in Ruby hahaha
<joelteon>
i'm glad coffeescript exists because i don't have to write "function"
<vigs>
…
<devyn>
joelteon: ES6 arrow syntax.
<joelteon>
also, varargs....
<joelteon>
oh yeah, es6
<joelteon>
good thing that's widely supported
<devyn>
joelteon: there are compilers that compile ES6 down all the way to ES3, if you want
<vigs>
the arrow syntax for functions is actually pretty cool, I don't hate that
<joelteon>
calm down there bud
<joelteon>
i don't know anything about javascript
<vigs>
but typing "funciton" was never really an issue…
<joelteon>
you just misspelled it
<joelteon>
i think that proves my point
<vigs>
(typing with one hand)
<vigs>
also f-u-tab usually does it for me $$shrug
<devyn>
isn't it even harder to make typos when typing with one hand?
<vigs>
ffs
<vigs>
¯\_(ツ)_/¯
<vigs>
hang on
<vigs>
kay two hands now. and nop, I was just whacking the keyboard, rather than looking at it
<devyn>
heh
* devyn
flops like a fish on his keyboard
<devyn>
k,mji nhu,k.iaertfaerfsafde
<vigs>
(got netflix up, what do you want from me?)
<joelteon>
nhtidtficgfigtfitgftgfit
<devyn>
<3 AcDisplay
<purr>
Let it be known that devyn hearts AcDisplay.
<devyn>
just wish it'd be a little faster to pick up on the sensors
<devyn>
the delay is a little too much
<vigs>
but like I said, coffeescript tries to solve a lot of problems that don't actually exist with syntax that is pretty…well, non-C-like.
yrashk has quit [Ping timeout: 240 seconds]
<joelteon>
"I wish this language's syntax was more like C." said nobody ever
yrashk has joined #elliottcable
<joelteon>
that's like saying it reminds you less of ebola
<devyn>
honestly I think the best approach is to do something like Haskell does, where there's a layouty, significant whitespace syntax that looks like math, and a curly-brace-and-semicolon syntax that looks like C
<devyn>
and you can use either
<vigs>
people hate on ObjC for having wonky function call syntax. ` [object functionname:param1 morefunctionname: param2]; ` But coffeescript's function call syntax is just…egregiously bad, imo. Absolutely no visual separation between function name and parameters.
<vigs>
Can someone tell me and/or point me to a resource that explains the space-delimited function call syntax? Like, why that's a "good" decision on the language designer's part?
<vigs>
(not being condescending, I really wanna know what the reasoning is.)
<vigs>
brb
cloudhead_ has quit [Ping timeout: 272 seconds]
yrashk has quit [Ping timeout: 272 seconds]
incomprehensibly has quit [Ping timeout: 260 seconds]
amatecha has quit [Ping timeout: 260 seconds]
ELLIOTTCABLE has quit [Ping timeout: 240 seconds]
silentbicycle has quit [Ping timeout: 268 seconds]
manveru has quit [Ping timeout: 272 seconds]
<devyn>
vigs: I think it's more of a declarative style. See nginx, or X11, or even Apache config I think
<devyn>
vigs: it also means, in CoffeeScript's case, that you can: delay 2000, -> do_something(42)
<devyn>
which looks a lot nicer than delay(2000, -> do_something(42)) IMO especially in the case where that function spans multiple lines
<devyn>
(because then you'd have to have the closing paren somewhere)
<devyn>
it also appeals more to natlangy/Englishy constructs
<devyn>
it can also be used to sort of extend the syntax in a way. lots of Rails apps use a helper called "h" which is just escape_html
<devyn>
<%= h @some.user_input %>
<devyn>
vs.
<devyn>
<%= h(@some.user_input) %>
<devyn>
in Ruby's case it also means you can leave off the parens when you have no arguments
<devyn>
which unfortunately CS can't do
<devyn>
but, it's very useful in Ruby because everything is a method and there are no "properties" or anything like that
<devyn>
if this were Ruby, one could just: q(template.content).children.first.clone
<devyn>
even "property assignment" is normally a method, so while you would normally
<devyn>
x.prop = "value"
<devyn>
the alternative is:
<devyn>
x.prop=("value")
<devyn>
yes, that's right, a method called prop=
<devyn>
that's how it works in Ruby
<devyn>
and a lot of the reasons for design in CoffeeScript is just because "Ruby does it"
<devyn>
CoffeeScript's compiler was originally written in Ruby, even
<joelteon>
also there's a lot more function application in haskell than c
<devyn>
vigs: well yeah, when talking about Haskell and ML (also OCaml, of course), it would be stupid to have function application use parens
<devyn>
vigs: `f 1 2 3` is not `f(1, 2, 3)`, but actually `f(1)(2)(3)` in JS equivalent. that is, it keeps returning functions until it's received the last argument
<devyn>
which is called "currying"
<devyn>
functions in Haskell are single-input, single-output
<vigs>
back
* vigs
reads scrollback
<vigs>
okay yeah that haskell example totally makes sense
gq has quit [Ping timeout: 252 seconds]
<joelteon>
in haskell function application is all over the gaffe
eligrey has quit [Quit: Leaving]
<joelteon>
so nix is cool, right
<joelteon>
have i convinced any of you to use it yet
<devyn>
I still haven't gotten around to it
<devyn>
also: debian is the devil, but damn if it doesn't have pretty much everything you could ever possibly need pre-built