<devyn>
make test 0.04s user 0.09s system 95% cpu 0.132 total
<devyn>
lol parallel test running
<purr>
lol
<devyn>
and most of that is overhead from make
<devyn>
build/libpaws-tests 0.00s user 0.02s system 163% cpu 0.014 total
<devyn>
lol
eligrey has quit [Quit: Leaving]
<devyn>
ELLIOTTCABLE: can I have permission to just do a multi-op (stage and charge separately) reactor now? :p I don't think there's anything terribly complicated about it
<devyn>
you know what, never mind, I don't need to do that now
<devyn>
it can be done later
prophile has joined #elliottcable
oldskirt has joined #elliottcable
<ELLIOTTCABLE>
Yeah not anything complex, I just need to spec it.
<ELLIOTTCABLE>
Basically rewrite the semantics of infrastructure charge and infrastructure discharge
alexgordon has joined #elliottcable
Guest76736 has joined #elliottcable
yorick has joined #elliottcable
Sgeo has quit [Read error: Connection reset by peer]
prophile has quit [Quit: The Game]
Guest76736 has quit [Ping timeout: 264 seconds]
<glowcoil>
ELLIOTTCABLE, devyn: still like halfway through the syntax discussion, so I don't know where you guys ended up, but I'm really thinking that it's impossible to express the arbitrary graphs we want without having to break out into naming things
<glowcoil>
and that's not bad, we should embrace it, and *also* have SQL/haskell-style combinators that express common shapes
<glowcoil>
so that you don't have to do the manual naming all the time
<alexgordon>
glowcoil: why is naming bad?
sharkbot has quit [Remote host closed the connection]
sharkbot has joined #elliottcable
<glowcoil>
ELLIOTTCABLE, devyn: basically, we have a *great* syntax for trees that everyone knows and loves, and then for DAG-ey/rejoiney things and for cycles, we should use naming
<glowcoil>
alexgordon: right, it's not bad
<alexgordon>
glowcoil: the swift guy said that the reason he didn't do "everything is an expression" is that he wants to encourage people to name their shit
<glowcoil>
alexgordon: interesting, didn't know that
<glowcoil>
yeah i like people naming things, but i also like the *ability* to fully express all shapes with expressions
<glowcoil>
but yeah, I wasted a long time when trying to design a dataflow language yeeeaars back trying to design a fully general graphey syntax for expressions, like f g h where that like pipes f through g and into h, and it's just dumb
<glowcoil>
because we have this great syntax for specifying trees with 1. joined together subtrees and 2. backedges with names
<glowcoil>
which gets you 1. dags and 2. potentially cyclic
<glowcoil>
ELLIOTTCABLE, devyn: so for some kind of points-free graph language, I feel like it should be done all in userspace as a set of combinators, like your <-- and +-- thing
<glowcoil>
like, [statement] -> [staement] -> [statement] or something means sequentially perform these actions, ordered on completion
<glowcoil>
and then you have a good system, related to the error and option system, for when a thing is *done* returning things
<glowcoil>
joelteon: you can split a number into a sequence of decimal digits by repeated division and moduloing
Guest76736 has joined #elliottcable
prophile has joined #elliottcable
Guest76736 has quit [Ping timeout: 240 seconds]
prophile has quit [Quit: The Game]
prophile has joined #elliottcable
Guest76736 has joined #elliottcable
<ELLIOTTCABLE>
glowcoil: what the *fuck* is a "combinator"
<ELLIOTTCABLE>
side-question
<ELLIOTTCABLE>
just see the term everywhere, and it seems so meaningless.
<ELLIOTTCABLE>
re: manual naming,
<ELLIOTTCABLE>
well, IMO, that's very similar to my concerns about Paws syntax.
inimino has quit [Ping timeout: 264 seconds]
<ELLIOTTCABLE>
have a simple syntax that is A) an easy abstraction-target, and B) handles the most general / useful cases,
<ELLIOTTCABLE>
and just don't *worry* about representing all possible programs in a single syntax.
<ELLIOTTCABLE>
that just seems like such a stupid non-goal.
<ELLIOTTCABLE>
sure; *a* SSA-style, super-verbose, but still textual (non-binary) syntax isn't a terrible idea. Hell, I'm a horrible enough person that I might want to just do that in XML or JSON.
<ELLIOTTCABLE>
but I don't want naming (because naming either requires scope, or requires global unique SSA-style names, which is very user non-compatible) in my primary example- / abstraction-target- syntax.
<ELLIOTTCABLE>
Guest76736: your nickname is damaged :P
<ELLIOTTCABLE>
glowcoil: I feel like you know so many things that I don't that we can no longer communicate well :P
<ELLIOTTCABLE>
I couldn't understand half of what you were saying, above.
<katlogic>
My pointy haired boss would be so proud of glowcoil
<katlogic>
"Unopinionated multi-backedge graph synnergy, err, i mean, UML model compilers emitting Java"
yorick has quit [Remote host closed the connection]
<alexgordon>
ELLIOTTCABLE: a combinator is posh word for a function
<cloudhead>
lol
<purr>
lol
<cloudhead>
usually it's meant as a function that takes other functions and returns a combination of those functions
<cloudhead>
but can be more generic than that
<ELLIOTTCABLE>
I'm sure it'll sound like the least intelligent thing ever (DURR I WROTE JAVA I KNOW WAT A FUNCTION IS THX),
<ELLIOTTCABLE>
but ... I grew up with first-class functions. A function taking functions and manipulating them doesn't remotely seem strange for me, nor do I understand why it needs it's own word.
<ELLIOTTCABLE>
I mean, a *modifier*, sure. “Higher-level function.”
<ELLIOTTCABLE>
but … just seems to breed confusion. /=
<cloudhead>
it's a special kind of function
<ELLIOTTCABLE>
how so?
<katlogic>
ELLIOTTCABLE: Lambda
<katlogic>
Isn't the function which takes list of data and turns it into something which can be invoked later considered special?
<ELLIOTTCABLE>
katlogic: er, what?
<ELLIOTTCABLE>
afaik, “lambda” is another stupidly-fancy term for anonymous, first-class, function.
<ELLIOTTCABLE>
again with the ಠ_ಠ on my part for mixing up the terms in a single environment.
Guest76736 is now known as TheMathNinja
<joelteon>
if you do it properly, all the functions are anonymous
<joelteon>
they're just values
<joelteon>
so you can bind some of them to names if you really want to
<ELLIOTTCABLE>
well, depends on "do it properly."
<ELLIOTTCABLE>
that will differ from language to language.
<ELLIOTTCABLE>
but, nonetheless: yes. that's the point of anonymous functions, yes.
prophile has quit [Quit: The Game]
prophile has joined #elliottcable
eligrey has joined #elliottcable
<katlogic>
ELLIOTTCABLE: Sure, thats just fancy name for "function which takes data and turns it into code".
<katlogic>
The only cool thing about it is that all other combinators can be derived from it. Ie if you have S and K, you don't need lambda anymore, yet remain functionally computable.
<katlogic>
(again, fancy math words for what in engineering basically boils down to reduction from universal list transposition rule, to more cumbersome forth-like stack machine)
prophile has quit [Quit: The Game]
<katlogic>
and one can go all the way to the other side of the opposite spectrum, ie something absurdly impractical yet still turing-complete, ie rule 110
oldskirt has quit [Ping timeout: 264 seconds]
<cloudhead>
ELLIOTTCABLE: one way to look at it is: a combinator is a function that doesn't perform a reduction
<cloudhead>
so applying it results in a larger/deeper expression that previously
<cloudhead>
there's no exact definition though, it's just something that combines things in some way
yorick_ has joined #elliottcable
yorick_ is now known as yorick
<alexgordon>
cloudhead: ELLIOTTCABLE: like I said, posh word for "function"
<alexgordon>
combinator is what you say when you want your ideas to be seen as important
<cloudhead>
heh except they don't mean the same thing
<cloudhead>
s/important/specific
<alexgordon>
it's like "use" and "utilize"
<cloudhead>
nein
<alexgordon>
We will utilize the toaster to make toast
<cloudhead>
lol
<purr>
lol
<cloudhead>
combinator carries meaning beyond "function"
<alexgordon>
I dunno, I mean technically the identity function is a combinator
<cloudhead>
yea but that's not what people mean when they say combinator
<cloudhead>
that's the mathematical definition
<cloudhead>
I don't think many people use it that way
* alexgordon
shrugs
<purr>
¯\(º_o)/¯
<alexgordon>
just say function :P
<cloudhead>
lol
<purr>
lol
<cloudhead>
no
<cloudhead>
;p
<cloudhead>
I'll say function when there's no more specific term
<alexgordon>
wear a lab coat
<cloudhead>
it's like refusing to use the word "method", because all methods are functions
<alexgordon>
ah but method actually means something
<cloudhead>
so does combinator
<alexgordon>
a method is a function with a parameter of a given type
<alexgordon>
combinator is too wishy washy
<cloudhead>
as opposed to a function with a parameter of a taken type?
<alexgordon>
:P
<cloudhead>
;p
<cloudhead>
yea it's a little more wishy washy
<alexgordon>
strip() is a method of String and ur mom
<cloudhead>
lol
<cloudhead>
take Parser combinators
<cloudhead>
if I just said
<cloudhead>
Parser functions
<cloudhead>
that wouldn't mean much, of course a parser has to be a function
<cloudhead>
but it's more specific than that, they are functions that can be combined together to form other parsers
<alexgordon>
I guess but it seems to me like people say "humans aren't monkeys!" -- if we're not monkeys then what _are_ monkeys?
<cloudhead>
lol
<purr>
lol
<alexgordon>
combinator has been extended with too many definitions to have any one overarching definition
<joelteon>
apes actually
<cloudhead>
yea, it's not very well defined, I'll give you that
<cloudhead>
but it (usually) gets the message accross
<cloudhead>
I see it a lot in haskell docu
<cloudhead>
and it actually helps
<cloudhead>
when I see "X combinators", I know these are functions that can turn 2 Xs into a single X
<cloudhead>
"X functions" just tells me that the functions operate on X, but I don't know in what way
<cloudhead>
but it's context-dependent I guess
<ELLIOTTCABLE>
-clouds
<purr>
ELLIOTTCABLE: is stuck up in the clouds; hilight 'em if you want 'em.
<ELLIOTTCABLE>
cloudhead: ugh, I used to like you
<ELLIOTTCABLE>
3:29 PM <cloudhead> I'll say function when there's no more specific term
<ELLIOTTCABLE>
"I will use the most specific term I know in every circumstance" is almost the simplest possible definition of pedantic. Or, as alexgordon puts it (more evocatively), 'posh.'
<cloudhead>
it's called communication
<ELLIOTTCABLE>
Always, always, always start with the *friendlier* (which boils down to "more general", because the more general the application of the word, the more more people will know the term, and the less likely it is to be new-and-therefore-scary) word for the concepts you intend to convey,
<cloudhead>
pedantry is a different thing
<ELLIOTTCABLE>
no.
<ELLIOTTCABLE>
communication is the opposite.
<ELLIOTTCABLE>
pedantry is the use of communication tools, to the detriment of actually communicating.
<cloudhead>
yea, which is the opposite of using the right term
<ELLIOTTCABLE>
only "upgrade" to the more-specific, less-general, and therefore more-scary term **when necessary**.
<ELLIOTTCABLE>
As in, when the difference between the two terms is directly relevant *in the current context*.
<cloudhead>
exactly
<cloudhead>
I don't see the problem then
<ELLIOTTCABLE>
Then, when the context changes enough that the difference is no longer relevant, downgrade again.
<ELLIOTTCABLE>
Yes. So exactly. Stop saying "combinator." Ever. Because you're *not* talking at a mathematics symposium on a new proof of the snorgdorgability of the typed lambda calculus.
<ELLIOTTCABLE>
(as a general example, but the same rule applies to everything.)
<ELLIOTTCABLE>
</high-horse>
<ELLIOTTCABLE>
glowcoil: you awake?
<cloudhead>
the only reason to use the more general term "function" is if someone doesn't know what a combinator is
<ELLIOTTCABLE>
<glowcoil> ELLIOTTCABLE, devyn: basically, we have a *great* syntax for trees that everyone knows and loves, and then for DAG-ey/rejoiney things and for cycles, we should use naming
<cloudhead>
if the person I'm talking to knows, I'd rather be specific about what I'm saying
<ELLIOTTCABLE>
cloudhead: yes. which must be your assumption in nearly all circumstances.
<cloudhead>
why?
<ELLIOTTCABLE>
glowcoil: you never said *which* is this "great syntax for trees that everybody knows and loves." 'cuz I sure as hell don't know of any textual syntaxes for trees. :P
<cloudhead>
how can you have a conversation if that's your assumption?
<ELLIOTTCABLE>
… by being friendly, avoiding pedantry, using simple words unless it's absolutely necessary to do otherwise.
<ELLIOTTCABLE>
I struggle with this constantly; it's a huge philosophical drive in my life, and it pains me to watch people (as in, the 'smart' sort of people I deal with often, for whom this could possibly be a problem) walk around just … not caring.
<ELLIOTTCABLE>
not gonna continue arguing it.
<cloudhead>
it's the opposite of not caring though
<ELLIOTTCABLE>
>:
<cloudhead>
not caring is using any word that kinda fits the bill
<cloudhead>
and in the process, creating lots of confusion
<cloudhead>
because you're talking about a very complicated subject without caring to be specific
<ELLIOTTCABLE>
disagree completely. We're not talking about a fucking specification here, we're talking about a chat in a hallway at a conference, we're talking about a public IRC channel, we're talking about open mailing lists and GitHub issues.
<cloudhead>
a hallway chat, sure
<ELLIOTTCABLE>
Places where newcomers are rarely welcomed, rarely made to feel competent, rarely able to even achieve the *linguistic* barrier-to-entry, even when the actual conceptual barrier is smaller.
<cloudhead>
but any kind of documentation or explanation should try not to be sloppy with the definitions
<ELLIOTTCABLE>
gods, so much absolutely disagree
<ELLIOTTCABLE>
buckets and buckets and buckets and philosophies and world views and *lifes* full of disagree.
<cloudhead>
:)
prophile has joined #elliottcable
<ELLIOTTCABLE>
documentation should *absolutely* use the more accessible, general terms.
<cloudhead>
if there's no possible ambiguity, sure
<ELLIOTTCABLE>
all documentation should *absolutely* lean far towards the ‘inexact’ side of the precision / accessibility trade-off.
<cloudhead>
:/
<ELLIOTTCABLE>
documentation doesn't exist to specify. *well-written code*, and when there are multiple codebases, *specifications*, exist to specify.
<ELLIOTTCABLE>
documentation exists to *explain* and *lead* and *introduce*.
<cloudhead>
more general is fine, as long as it's still 100% correct
<ELLIOTTCABLE>
so, so, so, so, so much of what we say to people is “how do I do this?” “RTFM.” when the ‘FM’ in question is an obtuse pile of goddamn crap.
<ELLIOTTCABLE>
ugh. this conversation gives me all of the stresses.
<ELLIOTTCABLE>
programmers are all fucking horrible people. all of them all of them all of them all of them all of them all of them all of them
<ELLIOTTCABLE>
.
<cloudhead>
lol
<purr>
lol
<ELLIOTTCABLE>
I get glowcoil-hates-computers feels whenever I talk about this stuff, except it's about programmers instead of computers.
<cloudhead>
I think your opinion would change if you worked in a team
<cloudhead>
not about programmers, but about this topic
<cloudhead>
the understanding of things is partially derived from the words we use to describe those things
<cloudhead>
by using a slightly wrong word, you perpetuate a slightly wrong understanding
<cloudhead>
unless the person is already very familiar with the subject
<cloudhead>
sometimes it's not even about how "correct" the word is, but about the point you want to convey - this might lead you to chose a more specific term, to make sure your point comes accross
<cloudhead>
but communication is nothing but conventions, it cannot work without an agreement on the definition of words
<cloudhead>
so when you break the agreement, you break communication
prophile has quit [Quit: The Game]
prophile has joined #elliottcable
prophile has quit [Quit: The Game]
<joelteon>
this is the coolest thing i've ever written
<joelteon>
primes = 2 : filter (\ x -> not $ any (\ prime -> x `mod` prime == 0) (takeWhile (<= floor (sqrt (fromIntegral x))) primes)) [3 ..]
oldskirt has joined #elliottcable
nicksergeant has joined #elliottcable
yorick has quit [Read error: Connection reset by peer]