ec changed the topic of #elliottcable to: #
<alexgordon> wtf is #hoodie
<cuttle> i honestly think paws can actually be something special re async
<cuttle> and concurrency
<ELLIOTTCABLE> I like to think so.
<ELLIOTTCABLE> alexgordon: hoodie is a noBackend implementation, apparently
<ELLIOTTCABLE> http://nobackend.org
<alexgordon> hm wonder if mathematica can do a frequency analysis of an mp3 file
<alexgordon> spectral analysis, that's the word I wanted
<joelteon> man
<joelteon> how do you "find all valid paths"
<joelteon> because they can fork at any time
<joelteon> and you have to collect all the results
<joelteon> or do you use like a rose tree
<joelteon> dude
<joelteon> that's the fucking solution
<joelteon> a rose tree
cloudhead has quit [Ping timeout: 248 seconds]
<alexgordon> joelteon: are you on substances?
<joelteon> no, why
<alexgordon> joelteon: just seemed that way
<joelteon> huh
<joelteon> that's weird
<joelteon> alexgordon: do you know how to convert a rose tree into a list of every possible path?
<joelteon> from the top to each end node
<alexgordon> joelteon: wtf is a rose tree
<prophile> a tree with an arbitrary number of children for each node
<alexgordon> so, a tree?
<prophile> yup
<alexgordon> lol
<purr> lol
<alexgordon> joelteon: wouldn't that use a lot of memory? why not just walk it?
<prophile> paths Nil = []; paths (Node x children) = do { child <- children; path <- paths child; return (x:path); }
<joelteon> ok, that too
<joelteon> ok, a tree
<joelteon> haskell people call it a rose tree a lot, i dunno why
<joelteon> ok, the problem is you can't solve it with only one function
<joelteon> because you'll just get a flat nondelineated list
<joelteon> oh, no, you can
<prophile> alexgordon: i think laziness means this is walking it
<joelteon> man, I'm really stupid
<joelteon> what's wrong with me today
<joelteon> maybe that blow to my head did something
<joelteon> i forgot how to spell delineate
<joelteon> man i cannot concentrate at all
<Nuck> Okay, I just lost a few points on this C++ quiz
<Nuck> So I need somebody who knows at least some C++: do the arithmetic operators not have varying precedence to make multiplication happen before division?
<Nuck> My professor is saying it doesn't o_o
<Nuck> (which seems odd, I've never seen a language where math didn't group like in math)
<Nuck> Am I going crazy or should I punch this professor in the face?
<prophile> I think he's right?
<prophile> lemme check
<prophile> yeah, that's how it works in python at least
<Nuck> I think I figured it out. He was mixing up operator precedence with order of execution, it seems. I guess I should email him.
<prophile> uh, what do you mean by order of execution?
<prophile> http://alastair.hovercatsw.com/C99.pdf says the same thing
<prophile> same situation in lua
<Nuck> Well, the question was asking whether an expression with no parens would be evaluated from left to right, and I said no, since multiplication had to be evaluated first
<Nuck> And according to all my sources, C++ does in fact follow PEMDAS
<prophile> yes, that's associativity not precedence
<prophile> PEMDAS/BEDMAS is bollocks
<Nuck> Is it?
<prophile> addition and subtraction have the same level of predecence
<Nuck> I don't even know, this is just annoying that this professor is never there at class to explain this shit ._.
<prophile> so do multiplication and division
<Nuck> I'm debating whether to approach our dean and ask to be dropped without a fail, simply because the professor is a complete waste of space
<prophile> as you point out too, it only specifies the predecence, not which way they associate
<prophile> what's the structure as far as that goes?
<prophile> if there's someone lower down you can go to, might be wiser
<prophile> that being said, places of education shit themselves over this kind of thing, so you probably wouldn't have any trouble being dropped without a fail
<Nuck> Our only structure is parttime < fultime < dean
<Nuck> He's fulltime
<Nuck> And I think only hte dept dean can do stuff like drop w/o fail this late
<prophile> k
<prophile> that's a bit different to the british structure then
<Nuck> This'd be easier if blackboard at least *worked*
<prophile> hah
<cuttle> Nuck: c++ *definitely* has math grouping. Io and Smalltalk and APL/J/K are examples of languages which do not group
<prophile> blackboard
<Nuck> But nooooooo quizzes are in the fine print on quizes
<prophile> there's your problem
<Nuck> lol yeah
<purr> lol
<Nuck> They're piloting canvas right now apparently
<Nuck> All the pilot professors are in love
<prophile> at least it isn't fucking moodle
<Nuck> haha my middle school did that
<alexgordon> Nuck: multiplication before division? wat
<Nuck> My high school did eChalk
<cuttle> one of my classes is moodle
<cuttle> and two are canvas
<Nuck> At least yo uhave any that are canvas
<joelteon> OMG
<prophile> yes, joelteon, that's called a penis
<prophile> now please put it away
<prophile> it's not for using in public
<alexgordon> Nuck: multiplication/division, and addition/subtraction always have equal precedence (I even remember my maths teacher explaining this in year 7)
<Nuck> alexgordon: Yeah
<joelteon> dude
<joelteon> in 2003
<joelteon> the saints made one of the best plays in history to score a touchdown on the last play of the game
<joelteon> to get into the playoffs
<Nuck> I figured that one out I think, it's just a professor who sucks at things
<joelteon> then their kicker missed the extra point
<joelteon> holy shit
<joelteon> i cannot imagine doing that
<Nuck> http://balthasar.plejeck.com/up/2013-10-07-19:19:32-6616.png Where do you think assignments are in this sidebar?
<Nuck> The answer? NOWHERE.
<Nuck> How about quizzes? Underquizzes right? NOPE. Under a tiny link at the bottom of the Start Here page
<Nuck> THANKS BLACKBOARD
<alexgordon> Nuck: I don't get it, you seem to be saying that multiplication happens before division
<cuttle> yeah you'd think at least one online class thing didn't completely suck
<Nuck> alexgordon: Nah, I'm saying that mult/division happen before addition/subtraction, thus saying that "any mathematical expression with no parens is eval'd left->right" is false
<Nuck> At least that's my logic there
<alexgordon> oh ok
<Nuck> I think h was expecting us to just regurgitate what the book says ._.
<Nuck> (which is bad because I haven't actually opened the book)
* Nuck sighs
<Nuck> Somebody please get me out of here
<joelteon> so today I learned that a "rose tree" is called "a tree"
<joelteon> i feel pretty smart
<alexgordon> joelteon: lol I've never heard of "rose tree" before
<purr> lol
<joelteon> haskellers use it a lot
<joelteon> well that's not entirely true
<alexgordon> seems that way
<joelteon> at least one haskeller has used it at least once
<alexgordon> that's a considerably weaker assertion
alexgordon has quit [Quit: Computer has gone to sleep.]
<ELLIOTTCABLE> Nuck: oh my god, memories
<Nuck> ELLIOTTCABLE: what
<ELLIOTTCABLE> Blackboard
<Nuck> Of me being a dumbass or of college?
<Nuck> Oh
<Nuck> Yeah blackboard is hatred
<Nuck> Pure loathing
<Nuck> Death
<joelteon> ok, i rewrote my finder
<prophile> rose tree isn't an uncommon term
<cuttle> 9:03 PM <•joelteon> at least one haskeller has used it at least once
<cuttle> 9:04 PM <•alexgordon> that's a considerably weaker assertion
<cuttle> joelteon: well i mean it's useful in contrast to say binary tree or w/e
<prophile> it's a tree with arbitrary numbers of children and data at every node
<prophile> also the cofree comonad on lists
<joelteon> man i wish weechat's output was easy to copy and paste
<whitequark> Nuck: by the way
<whitequark> multiplication and division have same precedence
<whitequark> and in C-langs, regardless of precedence, order of execution is only defined across sequence points
<whitequark> so even for a + b * c, you may never know what the order is.
<whitequark> it usually happens ltr or rtl; gcc and clang are ltr. however, more advanced compilers, such as icc or armcc, may shuffle things more heavily
<joelteon> impossibru
<prophile> whitequark: both gcc and clang will shuffle them liberally
<whitequark> prophile: hrm. last time I asked, I got an explicit reply that clang did not take advantage of sequence points
<whitequark> of course, I'm talking about side-effecting operations, not just arithmetics
Sorella has quit [Quit: Ex-Chat]
fwg has joined #elliottcable
<prophile> whitequark: precisely
<prophile> integer + and * are not side-effecting operations
malia has joined #elliottcable
<malia> ..
<prophile> ...
<malia> hello prophile
<prophile> hello
fwg has quit [Ping timeout: 248 seconds]
<whitequark> prophile: well, it's not interesting at all with non-side-effecting ones
<whitequark> since you can't observe it anyway
<whitequark> er. what I mean is that even in a language without a notion of sequence points, the compiler is free to reorder arithmetics.
<prophile> actually you can with snans
<prophile> but i know what you mean
<whitequark> oh let's not talk about floating point
<prophile> or division by zero I think?
<whitequark> you can't even do arithmetically equivalent transformations on them
<whitequark> division by zero is UB
<whitequark> therefore, it never happens
<prophile> true
<prophile> signed int overflow too, which catches a lot of people out
<whitequark> and shifting 1 into sign bit
<whitequark> and shifting more bits than the width
<whitequark> and null pointer dereference
<whitequark> I can rant about this for hours
<prophile> i'd forgotten about 1 into the sign bit
<prophile> yes to the others
<prophile> unaligned access too i think
<whitequark> it's less of an issue now
<prophile> what is?
<whitequark> unaligned access, since cpus handle it transparently, and compilers never assumed codepaths are unreachable based on unaligned access
<prophile> "cpus"
<whitequark> well, I'm not aware of any ones which did
<whitequark> prophile: what?
<prophile> oh you lucky, sheltered man
<whitequark> arm since v7 translates it into several bus cycles, just as x86 does
<prophile> the embedded devices world is not so lucky
<whitequark> and the rest of the gang is hardly relevant in the big picture
<whitequark> hah
<prophile> my own personal nemesis, the msp430, has bitten me on that one
<whitequark> if you truly get into embedded territory, then C breaks down hard
<whitequark> try 16-bit chars
<whitequark> which is, I believe, a plain out violation of the standard
<prophile> that's perfectly valid unless you've made the assumption that sizeof returns a value in octets
<whitequark> I don't really think C is a good low-level language
<whitequark> it both requires a set of wrong things, and omits from the standard another set of wrong things
<whitequark> all based on petty wishes of committee members
<prophile> C is the worst language for this sort of thing apart from every other language
<whitequark> exactly
<prophile> it's the democracy of the programming family
<whitequark> prophile: "C is the democracy of the programming family" wat.
<purr> beep.
<prophile> "it has been said that democracy is the worst form of government except all those other forms that have been tried from time to time."
<prophile> winston churchill
<prophile> i assumed it was another famous quote which he didn't actually say
<prophile> but there it is in hansard
<whitequark> I know that, yeah
<whitequark> except you can actually do better than C
<whitequark> easily
<whitequark> just not easily make others adopt it.
<prophile> FORTRAAAAN
<whitequark> prophile: wat.
<purr> beep.
<whitequark> now the actual one
<prophile> man, FORTRAN is a great language
<prophile> moving away from it to C was a mistake
<whitequark> ALGOL is a great language, sorta
<whitequark> FORTRAN is... um... er...
<prophile> FORTRAN 77 even makes it current
<prophile> and FORTRAN 90 is downright wonderful
<prophile> i'd take it over C any day
<whitequark> besides, it's the same committee shit. I think the latest fortran (was that fortran 2012?..) even has object-orientedness and closures and crap
<whitequark> prophile: yeah, what about compilers?
<prophile> (I'm not actually serious)
<whitequark> there's gf77 and... and what?
<prophile> clearly the future of embedded :)
* whitequark facepalms
<prophile> I'M SORRY
<prophile> when 6am rolls around i forget how to do anything but troll :(
<whitequark> it's not really about you
<whitequark> btw
<prophile> COBOL.Net is a thing
<prophile> a friend of mine works on an IDE for it in his day job
<whitequark> hngg
<whitequark> does it offer MUMPS interoperability?
<prophile> no idea what MUMPS is
<prophile> oh, just looked up his company on wikipedia
<prophile> they do borland as well
<whitequark> MUMPS is a completely ridiculous language which is endemic to healthcare
<whitequark> like COBOL is to banking
<whitequark> aka, having mumps is better than using MUMPS :p
<prophile> ouch
<joelteon> yeah, i've read that a bunch of times
<niggler> lol
<purr> lol
malia has left #elliottcable [#elliottcable]
malia has joined #elliottcable
malia has quit [Client Quit]
eligrey has quit [Quit: Leaving]
<whitequark> so I just watched Baccano!!
<whitequark> what the hell
<whitequark> why does none of it make any fucking sense
<whitequark> more importantly, why is it so that I seem to only ever be attracted to series which make completely zero sense.
<whitequark> I mean, they all manage to not make sense in various amusing and/or interesting ways, but
<whitequark> oh
<whitequark> that may be it.
<whitequark> it's still ridiculous though
<whitequark> I should find and watch more of it.
malia has joined #elliottcable
malia has quit [Client Quit]
prophile_ has joined #elliottcable
sammcd_ has joined #elliottcable
PLejeck has joined #elliottcable
Nuck has quit [*.net *.split]
jvulc has quit [*.net *.split]
sammcd has quit [*.net *.split]
prophile has quit [*.net *.split]
dskuza has quit [*.net *.split]
fwg has joined #elliottcable
<ELLIOTTCABLE> cuttle: no paws.rs on GitHub? I was gonna take a look.
fwg has quit [Ping timeout: 256 seconds]
fwg has joined #elliottcable
jvulc has joined #elliottcable
PLejeck has quit [Changing host]
PLejeck has joined #elliottcable
dskuza has joined #elliottcable
PLejeck is now known as Nuck
<ELLIOTTCABLE> jvulc! hi.
wudofyr has quit [Remote host closed the connection]
wudofyr has joined #elliottcable
Sgeo has quit [Read error: Connection reset by peer]
Kapone has joined #elliottcable
Sorella has joined #elliottcable
<ELLIOTTCABLE> … who's Kapone?
<Kapone> friend of Cloudhead
<Kapone> pragcypher
Kapone has quit [Quit: Leaving]
<jvulc> Hihi
<ELLIOTTCABLE> jvulc: (=
yorick has joined #elliottcable
alexgordon has joined #elliottcable
<ELLIOTTCABLE> alexgordon!
<alexgordon> ELLIOTTCABLE!
<alexgordon> ELLIOTTCABLE: moving to stripe
<alexgordon> rewriting the whole website basically!
<alexgordon> now, first I need an SSL cert
<ELLIOTTCABLE> cool
<alexgordon> feel like rewriting the whole thing
<alexgordon> currently its a big mess of PHP
<alexgordon> I should use Flask
<ELLIOTTCABLE> oh gods
<ELLIOTTCABLE> and what's flask
<alexgordon> ELLIOTTCABLE: like sinatra for python
cloudhead has joined #elliottcable
<ELLIOTTCABLE> cloudhead!
sharkbot has quit [Remote host closed the connection]
sharkbot has joined #elliottcable
cloudhead has quit [Ping timeout: 256 seconds]
sammcd_ is now known as sammcd
<joelteon> you know what makes me feel dumb, is when there's an executable called foo and a file called foo.hs and i'm trying to cat foo.hs and i forget there's an executable
<joelteon> so i type in "foo" and tab complete and it completes to "foo" and I hit enter anyway
<cuttle> ELLIOTTCABLE: ah ok i will put it up
<joelteon> and then i have to wait 2 and a half minutes and when it finally ends, my window title is like 150 characters long
<cuttle> joelteon: hahah yeah i've done that
<cuttle> joelteon: not as bad, i wanted to test my lexer, so i was running it on main.hs, but tabcompleted to main, and it printed out a buncha gobbledygook
<joelteon> yeah
<cuttle> ELLIOTTCABLE: rust is far from perfect at this point, so there's the occasional ugly workaround
<joelteon> i wish cat would refuse to cat files that appear to be binary
alexgordon has quit [Quit: Computer has gone to sleep.]
<joelteon> man, rust's performance is really not very remarkable
<ELLIOTTCABLE> hi, all
<joelteon> hi ec
<ELLIOTTCABLE> hi joelteon
<ELLIOTTCABLE> this code is the most terrible code
<ELLIOTTCABLE> the most terrible of all the terribles
<joelteon> how bad
<joelteon> i'm compiling GCC now
<joelteon> this should be done pretty soon
<cuttle> ELLIOTTCABLE: what coe?
<cuttle> code*
<ELLIOTTCABLE> Thinking of ordering a Tessel or three.
<ELLIOTTCABLE> Node.js “embedded” development-fun? Sounds neat.
<ELLIOTTCABLE> Worried about their custom interpreter, though. Sounds painfully slow.
<ELLIOTTCABLE> cuttle: what do you think about writing a VHDL FPGA ‘program’ for a Paws interpreter?
<ELLIOTTCABLE> that is, an actual ‘Paws machine.’
<cuttle> that would be fuckin sweet
<cuttle> like, paws is more nonlocal than tempus, so it doesn't map to compiling down to fpgas as well, but due to ownership, it's way more local than basically everything else
<cuttle> and also you mean a machine, not a thing that compiles it to machines
<cuttle> so yeah perfect fit
<ELLIOTTCABLE> huh?
<cuttle> idk just rambling
<ELLIOTTCABLE> not a compiler, no
<cuttle> yeah i know
<ELLIOTTCABLE> I mean an interpreter, basically, if I understand myself right?
<cuttle> yeah
<ELLIOTTCABLE> idfk fpgas.
<cuttle> yeah i getcha
<ELLIOTTCABLE> brb twitter-bio. “idfkfpgas.”
<cuttle> tessel sounds fuckin dumb if you're running javascript on embedded hardware
<cuttle> fuck javascript
<cuttle> i mean
<ELLIOTTCABLE> it's actually pretty neat.
<ELLIOTTCABLE> I'm a huge Node fan.
<cuttle> the concept of tessel looks way cool
<ELLIOTTCABLE> like, not *just* because it works well for things I want to do, I also like it, conceptually.
<cuttle> with like the modules and shit
<cuttle> but like
<ELLIOTTCABLE> npm for ‘embedded development?’ yes please.
<ELLIOTTCABLE> I mean, sure, it's shit.
<cuttle> is js *really* the best we can do
<ELLIOTTCABLE> but it's *accessible* shit.
<cuttle> sure
<cuttle> impossible to: debug, optimize
<ELLIOTTCABLE> well, you've whitequark's factory.
<cuttle> :p
<ELLIOTTCABLE> or whatever it's called; unfortunately, I can't remember.
<cuttle> oh um
<cuttle> foundry
<cuttle> yeah well i mean foundry is really fuckin cool
<cuttle> but also build on ruby syntax :p
<cuttle> but yeah
<ELLIOTTCABLE> but idfk anything about that. looks like Tessel gives me an existing set of libraries; a language I already understand, that's great for networked/connected-stuff; and, most importantly, *a connection* to use all that on.
<cuttle> yeah sure
<cuttle> so yeah it is cool
<cuttle> but just from a technical standpoint
<cuttle> from a people standpoint it is cool
<cuttle> from a technical standpoint it is very much worse is better i guess
<cuttle> makes me sad at how much we could have something that is easy for people, and also takes way more advantage of performance opportunities
<cuttle> like, that's the goal of both paws and tempus
<cuttle> make massive parallelism the natural-to-humans thing to do
<cuttle> rather than fuckin dumb sequential bottleneck
<joelteon> guys it takes awhile to build gcc
<joelteon> i don't know if you knew
<cuttle> joelteon: haha
* ELLIOTTCABLE nods
<ELLIOTTCABLE> so.
<ELLIOTTCABLE> would love to get alex in here. happy to do some Paws chat.
<ELLIOTTCABLE> WORST CODE WORST CODE WORST CODE
<cuttle> ELLIOTTCABLE: whatcodewhatcode
<ELLIOTTCABLE> err
<ELLIOTTCABLE> ↓ that
<purr\GH> [woof] ELLIOTTCABLE pushed 7 new commits to Master+: https://github.com/ELLIOTTCABLE/woof/compare/8afd5aa8c0ee...733a92d4cfe8
<purr\GH> woof/Master+ 1f1c1f3 elliottcable: + filled out the `Lens` documentation
<purr\GH> woof/Master+ b9e7bb8 elliottcable: + starting on Lens#call
<purr\GH> woof/Master+ acbc683 elliottcable: + one-line -> one_line
<ELLIOTTCABLE> trying to pump out a shitty, but powerful, terminal-printing library
<ELLIOTTCABLE> for some things I Want™ for Paws.
<cuttle> ah
<cuttle> the pretty printing code
<cuttle> ELLIOTTCABLE: i would have written a little paws.c except that c's memory management paralyzes me when i want to write a parser
<ELLIOTTCABLE> nah, do rs, that's neat
<ELLIOTTCABLE> good chance to learn it with something we all know well
<ELLIOTTCABLE> Paws being so simple right now, and all
<cuttle> yeah i'm definitely sticking with this
<cuttle> but just for the future
<cuttle> i want to know better c memory techniques :p
<ELLIOTTCABLE> Paws.c is something we can collaborate on, then
<cuttle> like, reading input string buffer shit
<ELLIOTTCABLE> because Paws.c is *supposed* to be a light-weight, universally-embeddable Paws interpreter with an *excellent* API
<cuttle> what are best practices there?
<cuttle> yeah
<cuttle> i want to optimize the fuck out of it too
<ELLIOTTCABLE> and ‘excellent-API’ plus ‘interpreter’ plus ‘lightweight’ equals excellent change to learn good C practices at a simple level
<cuttle> was planning on making a stream-based reentrant lexer and parser
<ELLIOTTCABLE> nah, code-weight is more important than optimization to me in that implementation
<cuttle> which would dovetail nicely with your plans for executing things
<cuttle> well i mean we can have both
<ELLIOTTCABLE> optimizations which cost much in cognitive-overhead for unskilled programmers reading the code are a non-starter in my intended implementation
<ELLIOTTCABLE> perhaps could do a binary-API compatible JIT compiler?
<cuttle> well yeah we're not going to do like twisty bullshit
<cuttle> just like really efficient architecture
<ELLIOTTCABLE> drop the interpreter in, replace it with the more-complex JIT compiler when the API-consumer's project would benefit from that
* ELLIOTTCABLE nods
<ELLIOTTCABLE> need to talk about the IPP a bit
<cuttle> yeah
<cuttle> i think that the whole runnign it multiple times is a mistake
<ELLIOTTCABLE> I mean, nothing important right now; as previously ascertained, it shouldn't affect the VM/language design *anyway*
<cuttle> like i think we should just have like directives
<cuttle> like
<cuttle> #ipp [ paws code ]
<cuttle> that gets run
<cuttle> yknowwhaimean
<ELLIOTTCABLE> nonono the entire point is to have one language that modifies itself
<ELLIOTTCABLE> but *other* ways of modifying itself, than unbounded infinite multiple-runs, I'm definitely open to /=
<cuttle> ok
<cuttle> well i mean
<ELLIOTTCABLE> or, to put it another way:
<cuttle> in j
<ELLIOTTCABLE> I may never make an IPP.
<cuttle> functions are lexed but not parsed until execution
<ELLIOTTCABLE> There's always M4, or even the CPP.
<ELLIOTTCABLE> could just run the CPP or M4 *on Paws code*, for simple translations.
<cuttle> because parsing is context-senstive; you have to know whether a given identifier is a function, because all functions can be infix
<cuttle> fuck no cpp
<cuttle> we can have a simple beautiful two-tier macro system
<cuttle> and the macros can even affect each other
<cuttle> and be full paws
<cuttle> what if the macros are more declarative rules
<cuttle> like
<cuttle> full paws in the expansions
<yorick> just compile and run it as C and then interpret the output as paws
<cuttle> hahaha
<cuttle> perfect
<joelteon> what if macros can modify the entire syntax tree
<cuttle> joelteon: that's the idea :p
<joelteon> oh
<ELLIOTTCABLE> I'm not going to *write* a macro system, no matter what.
<cuttle> you were going to write the ipp
<cuttle> which is quite literally a macro system
<ELLIOTTCABLE> If there's going to be anything other than full, language-level inhabiting mutation of the code, then I'm just going to choose some external binary / external system, and declare it as “the official preprocessor of Paw!11!1!s”
<cuttle> ok well here's the problem
<cuttle> what you want
<cuttle> does not get the user anything more useful or fun
<joelteon> paw
<ELLIOTTCABLE> I've never seen anything called a ‘macro system’ that didn't differentiate between code-modifying-code and executing-code.
<cuttle> makes jit or anything efficient infinitely harder
<ELLIOTTCABLE> I'd disagree re: useful/fun;
<cuttle> ELLIOTTCABLE: what do you mean by that?
<ELLIOTTCABLE> it allows for a richer library.
<ELLIOTTCABLE> because libraries for X purpose, can modify the syntax;
<cuttle> you should be able to have full paws code in the macros
<ELLIOTTCABLE> and the code modifying the syntax, can use libraries for X purpose.
<cuttle> there's just an execution-phase-separation between the two
<ELLIOTTCABLE> i.e. it works both ways.
<cuttle> how about macros can use other paws execution units
<cuttle> but not the current one
<ELLIOTTCABLE> whatcha mean two-tier macro system?
<cuttle> like
<ELLIOTTCABLE> (just now reading up above)
<cuttle> because paws is all about very granular execution units
<cuttle> tiny ones
* ELLIOTTCABLE nods
<ELLIOTTCABLE> thought about this, in the past.
<cuttle> like, here's the problem
<ELLIOTTCABLE> couple observations:
<cuttle> you should not have macros in the compiled-to-bytecode execution units
<ELLIOTTCABLE> first off, although I'm not *truly* dead-set on it, I *really* like the idea of changing the syntax, half-way down a single file.
<cuttle> all macro info should be *gone* already
<cuttle> when it's bytecode and being passed around on the network
<cuttle> macros should only be relevant when parsing and compiling a new execution unit
<ELLIOTTCABLE> that is, not having to open up a second file, if you're throwing out a quick one-file script/library (I want Paws to be like Node, where “modules” or “libraries” tend to be so fucking simple and granular, that they're like 100 lines or less in a single file, and then published.)
<ELLIOTTCABLE> … and want that script/library to have some custom syntax.
<cuttle> right
<ELLIOTTCABLE> second,
<cuttle> i agree with that
<ELLIOTTCABLE> that means that you can't *dynamically* decide on which syntaxes/extensions to use, in your code: the, er, whatever you want to call it, compiler or whatever, needs to know *before-hand* which external libraries you're going to use (because it needs to know which ones to get new rules/macros/whatever from)
<ELLIOTTCABLE> so, at that point, “including libraries” becomes a matter of passing flags to the compiler …
<ELLIOTTCABLE> … not `foo = require('bar')`.
<ELLIOTTCABLE> another of my much-loved idioms from Ruby days, and now npm/node, is:
<ELLIOTTCABLE> (on line 300 of a one-page, one-day, one-off hackodule)
<ELLIOTTCABLE> return require('markdown').parse(text)
<ELLIOTTCABLE> not even bothering to scroll to the top of the file to add a new little dependency, and add all of the features that dependency might provide, to your current efforts.
<ELLIOTTCABLE> (of course, I want to expand that to not even needing to *download a library*, or even *look up a library name* for that matter. more on that at another point, when we get around to discussing my plans for library-support.)
<cuttle> ELLIOTTCABLE: ok, ideas:
<ELLIOTTCABLE> now, when you get to Paws, and the desires for dynamic syntax; what if that happens deep in some sort of conditional-guarded block? some code that may not execute, or even won't *usually* execute? what if the syntax-changes relevant to, idk, markdown parsing (let's say it provides an inline “markdown-string” format, with included syntax for literals),
<ELLIOTTCABLE> happens after that inclusion, but only *if* it was included?
<ELLIOTTCABLE> yeah. very contrived example. I know.
<ELLIOTTCABLE> just bringing up issues, here.
<cuttle> you should *not* be able to use runtime-dependent conditions to determine which macros to include
<cuttle> that should be deterministic at parse/compile-time
<cuttle> and
<cuttle> so basically you should be able to use arbitrary paws code to decide which syntax extensions to include, and to write those extensions themselves, but they should all be like pure-paws, no i/o, yknow
<cuttle> which we can verify in our dynamic way with like the whole insanity/causality-graph system
<cuttle> but anyway
<cuttle> so here's an example:
<cuttle> suppose you have a cool library for manipulating lists
<cuttle> and you want to manipulate syntax, using that library
<cuttle> so you import the library
<cuttle> and use it in macros elsewhere
<cuttle> that's totally fine
<cuttle> i'm thinking
<cuttle> what if you want to write macros, using it, in the same library
<cuttle> that's when the whole multiple-runs thing comes into play
<cuttle> and probably we should allow that, and do the whole multiple-runs-find-a-fixed-point thing
<cuttle> I am onboard with that
<cuttle> but we do need a phase separation
<cuttle> like
<cuttle> #[ macro code ]
<cuttle> not married to that syntax but just as an example
<cuttle> wow i am still fucking hopped up on that single extra espresso shot in my coffee this morning
<ELLIOTTCABLE> -clouds
<purr> ELLIOTTCABLE: is stuck up in the clouds; hilight 'em if you want 'em.
<cuttle> ELLIOTTCABLE: i finally have a happy image of the macro system in my head
<cuttle> paws is fucking beautiful
<ELLIOTTCABLE> hold on hold on reading
<ELLIOTTCABLE> I got up to take a shit, took off my pants, and have been leaning on the bed with my laptop, standing next to the bathroom, ever since.
<ELLIOTTCABLE> this happens *way* more often than I'd like to admit.
<ELLIOTTCABLE> (getting distracted from a planned poo, 'cause code. or 'cause IRC.)
<ELLIOTTCABLE> I talk about these things, because it is my firm and unshakable belief that one cannot help another design programming languages, unless they fully grok the other's poo.
<cuttle> ._.
<cuttle> .-.
<ELLIOTTCABLE> okay.
<ELLIOTTCABLE> so if I understand you correctly, you want IPP-style execution to be *optional*?
<ELLIOTTCABLE> i.e. have a second mode, of some sort, where your code is never given access to syntax APIs?
<ELLIOTTCABLE> that sounds reasonable.
<ELLIOTTCABLE> but why the mode-seperation *in syntax*? (i.e. #[])
<ELLIOTTCABLE> also:
<ELLIOTTCABLE> your hit-and-run mention of insanities for discovering syntax modification is genius.
<ELLIOTTCABLE> I'm curious how to go about it, exactly, I see issues, but I *never* thought of that.
<ELLIOTTCABLE> like, instead of [ syntax-run, syntax-run, syntax-run, syntax-run, IO-run ],
<ELLIOTTCABLE> you'd have [ IO-run <ABORT>, syntax-run, syntax-run, syntax-run, IO-run ]
<ELLIOTTCABLE> hm
<ELLIOTTCABLE> obvious issues
<ELLIOTTCABLE> but I wonder if there's an interesting way around them.
<cuttle> well it's like
<cuttle> paws is all about doing things at runtime
<cuttle> but still having 100% safety about them
<cuttle> so you can for instance run in a mode where all I/O operations are neutered
<cuttle> basically, you don't know exactly what operations will happen until they are queued up
<cuttle> but you can have a middleman who says "nop you cannot do that action" standing in front of the queue
<ELLIOTTCABLE> I don't have an *exact* plan for that, yet.
<cuttle> AND I JUST REALIZED YOU CAN FUCKING WRITE THAT IN PAWS
<cuttle> FUCK YES I FUCKING LOVE PAWS
<ELLIOTTCABLE> or rather, my plan 'tis a silly plan.
<cuttle> extraneous use of 'tis when is would suffice
<cuttle> ;p
<ELLIOTTCABLE> a silly plan of simply never doing them, and thus never returning from them.
<ELLIOTTCABLE> I'm sure there's a smarter way.
<ELLIOTTCABLE> need more concrete insanities specification, first.
<cuttle> well you should immediately return not-doing them
<cuttle> because never returning is indistinguishable from doing
<ELLIOTTCABLE> yah, that's the point :D
<cuttle> why is that a good thing
<cuttle> oh because it stops the graph from flowing upwards?
<ELLIOTTCABLE> the rest of the code following/depending-on (we need to talk more about your dependencies ideas. I know you've had them queued up for ages)
<cuttle> not-returning is contagious?
<ELLIOTTCABLE> will just not-happen, *because* it can't.
<cuttle> yeah uhuh
<ELLIOTTCABLE> so, let's wrap up chat about IPP.
<cuttle> that is good
<cuttle> i was just thinking of
<ELLIOTTCABLE> we need to go back to using Wave.
<cuttle> some sort of contagion
<cuttle> and i mean paws is all about contagion on the graph
<cuttle> so we could have a reified not-returning that also spreads
<ELLIOTTCABLE> too many interconnected, independant streams of thought; that really need to be more persistent than IRC can make them, but more flowing and dynamic than mailing-lists can
<cuttle> rather than just not-returning
<cuttle> but i like the idea
<ELLIOTTCABLE> problems I have with Wave:
<cuttle> yeah wave sucks for desinging languages
<ELLIOTTCABLE> topics are a tree, not a graph.
<cuttle> evrything does
<ELLIOTTCABLE> it's GREAT that you can diverge and split at any point
<cuttle> anyway though i love paws
<cuttle> and it's gonna be fuckin great
<ELLIOTTCABLE> it's GREAT that responses naturally gravitate towards small and flowing when synchronously discussing, and long-and-in-depth when asynch
<cuttle> > have a furious irc conversation
<ELLIOTTCABLE> but it's NOT-GREAT that you can have two, completely separate, trees in the *same thread*, about the *same thing*, and they aren't connected.
<cuttle> > look up to rest of linguistics class being silent
<cuttle> (because irc is segregated from Real Life)
<ELLIOTTCABLE> I want something where we start talking about statement-dependencies, and it can be synched up with all previous discussions about statement-dependencies
<cuttle> right
<ELLIOTTCABLE> a *graph* of discussion-trends
<ELLIOTTCABLE> that, like wave, is “ordered-chronological-list-like” at its leaves
<cuttle> well maybe we can make that in mu *after* we make paws
<cuttle> ;)
<ELLIOTTCABLE> yep.
<ELLIOTTCABLE> deal.
* ELLIOTTCABLE laughs
<ELLIOTTCABLE> okay. well, this *isn't* wave, and important stuff has scrolled off the top, which would normally, since this *isn't* wave, would mean it never gets talked about, soooo ...
<ELLIOTTCABLE> … why the syntax for seperation of concerns?
<ELLIOTTCABLE> as I understand, from a quick read, we seem to mostly agree. but I still don't see a reason to *explicitly* separate code that is non-runnable without syntax-APIs, and code that is non-runnable without I/O APIs,
<ELLIOTTCABLE> not to mention at all universal code that is applicable-to / reference-able-within *both*
<cuttle> well it's like
<cuttle> *after* compilation, all that code will be gone
<cuttle> *before* compilation, it's all you want to be executed unless it depends on the rest of the unit
<cuttle> hmmm
<cuttle> and also it's given access that the rest of the code is't
<cuttle> hmmm well maybe that can be handled by the dynamic thing
<joelteon> huh, impresive
<joelteon> impressive
<joelteon> so I started with String and [], with this solver
<cuttle> in compilation, you track all the graphs that use syntax modification and kill them
<joelteon> and now I'm using ByteString and Array, and it's down to 0.25 seconds
<cuttle> so there is some static graphey stuff you can do too
<cuttle> fuck yeah paws
<ELLIOTTCABLE> hmmmm
<cuttle> joelteon: nice
<cuttle> ELLIOTTCABLE: so yeah maybe no separation
<ELLIOTTCABLE> how do you track them?
<cuttle> but also i'm concerned about clarity of code
<ELLIOTTCABLE> oh, me too
<joelteon> and it's searching /usr/share/dict/words which is like
<cuttle> hiding it halfway down the page makes it possibly pathological
<ELLIOTTCABLE> but remember, a *huge huge huge* tenet of Paws is,
<joelteon> 236,000 words
<cuttle> sure sure sure
<ELLIOTTCABLE> “Give them all of the guns and all of the rope.”
<joelteon> and it finds every match in 250ms
<cuttle> let things be dangerous sure
<cuttle> :p
<joelteon> i wonder how fast c++ can do it
<ELLIOTTCABLE> I want to enforce sanity with community, and documentation, and tooling, and MINASWANETHDWP; not with linguistic restrictions.
<ELLIOTTCABLE> so, of *course* it's fucking insane to majorly change the syntax halfway down the file. But there's a conceivable reason to; and given the *other* goals (one-file libraries, two-way interaction between functionality-libraries and syntax-modification), it's easy and sane to allow for it, even if it sounds insane to use it.
<ELLIOTTCABLE> so, allow for it. and then tell people, you'd damn well better know what you're doing, and you don't, so don't.
<joelteon> oh cool
<cuttle> ELLIOTTCABLE: sure
<cuttle> yeah i'm thinking with graphey stuff it's totally fine
<cuttle> your IPP idea is now sound in my mind
<cuttle> idk i just want to like
<cuttle> have all the syntaxey stuff run first
<cuttle> well that's all optimization
<cuttle> you can have a slightly better compiler that ignores all non-syntax-modifying code until you have run the syntax-modifying code first, or until it's depending on it
<cuttle> and I mean if we have string-to-symbol functions that's impossible in the pathological case
<cuttle> ugh
<cuttle> i guess it's fine
<cuttle> to run code in neutered mode, including macros
<ELLIOTTCABLE> hmmmmm
<cuttle> and then compile-and-run code in macro-neutered mode, actually applying the macros you set up
<ELLIOTTCABLE> which pathological case?
<cuttle> ELLIOTTCABLE: like, locals[random_number().to_string().to_symbol()
<ELLIOTTCABLE> this is all making some sort of dependencies-tracking sound like a better and better idea.
<ELLIOTTCABLE> realistically:
<cuttle> ELLIOTTCABLE: like, locals[random_number().to_string().to_symbol()] = 1234
<cuttle> yknow
<ELLIOTTCABLE> I'm not excited for Paws, except as a small-scale “I'm excited to make this and play with it and interact with cool software developers in the process.”, way
<ELLIOTTCABLE> what I'm goddamn excited for, is what follows Paws.
<ELLIOTTCABLE> the Ruby and Haskell and JavaScripts of Paws, instead of Lisp/C
<ELLIOTTCABLE> I want to see things that take from Paws as Ruby takes from Smalltalk: take the awesome shit, but make it more accessible.
<ELLIOTTCABLE> there's no string-to-symbol, by the way
<ELLIOTTCABLE> can only “create” symbols that correspond to a single Unicode unit, at runtime; and then, only once (when exploding the first symbol that comprises that unit)
<ELLIOTTCABLE> unless I mistake your meaning.
<ELLIOTTCABLE> but, what I was saying.
<ELLIOTTCABLE> I don't think I see an elegant way to fit statement-dependencies, or diagonal execution, or whatever you want to call it, into the design I like for Paws, everything we have so far.
<ELLIOTTCABLE> needs to start from the bottom, and needs to throw away a lot of other marginally interesting, but not crucial, stuff.
<ELLIOTTCABLE> but the Next Language, something that *does* build on this, with static-analysis capabilities, with some sort of type-inference, with a *bit* less (but not much less) dynamism …
<cuttle> dependency tracking can be done at runtime using ghosts
<cuttle> and that's fine
<ELLIOTTCABLE> … while keeping all of the asynch CPS sexiness, and insanities, but insanities-on-meth (static-analysis leveraging insanities!),
<ELLIOTTCABLE> yeah.
<cuttle> but yeah it does eliminate some static analysis re macros
<cuttle> which is why i think we should have a separation thing for macros
<cuttle> i think we just need to accept that there isn't a good way to make 2-way dependencies for macros
<cuttle> you can have macros that depend on pure paws code
<cuttle> and you can have paws code that depends on macros
eligrey has joined #elliottcable
<ELLIOTTCABLE> look, it's sephr
<ELLIOTTCABLE> brb.
cloudhead has joined #elliottcable
<ELLIOTTCABLE> whee
<cuttle> I FUCKING LOVE EVERYTHING
<cuttle> ELLIOTTCABLE: about to make my first contribution to the rust stdlib
* ELLIOTTCABLE grins
<ELLIOTTCABLE> oh really? what is it?
<cuttle> also bbiab
<cuttle> ELLIOTTCABLE: well, a function isn't as polymoprhic as it can bre
<cuttle> be*
<cuttle> polymorphic* :p
<cuttle> on the Option type, which is like Haskell's Maybe
<cuttle> i'll explain from my next class
<cuttle> bye
<ELLIOTTCABLE> aww k
<joelteon> critical hit
<cuttle> back
<cuttle> in CS
<cuttle> :p
<cuttle> oh jesus cloning rust takes a while
<cuttle> :p
<cuttle> not *that* long really
<joelteon> :u
<cuttle> actually pretty fast
<joelteon> cloning llvm takes a long time
<cuttle> :p
<cuttle> yeah it does
<joelteon> laziness is neato
<cuttle> ELLIOTTCABLE: made a pull request!
<cuttle> :D
<joelteon> you matter
<cuttle> literally my first pull request of all time
<cuttle> besides maybe like making a game with friends or some shit that doesn't count
<joelteon> word
<cuttle> ELLIOTTCABLE: often about to take a shower and end up leaning over chair typing in chat or code, but never ever pants-off to shit, because i abide by a strict rule that the pants only come off after the bathroom door is locked
fwg has quit [Ping timeout: 245 seconds]
<joelteon> ok, so i'm writing C++ for the first time ever
<joelteon> this is really weird
<joelteon> REALLY weird
<cuttle> joelteon: haha finally popped yr cherry eh?
<cuttle> what're you writing?
<joelteon> i'm writing my solver in c++ now
<joelteon> because haskell is 22 times faster than rust
<joelteon> i want to see how fast cpp is
<joelteon> probs pretty fast
<joelteon> haskell is just so intuitive and c++ feels really weird
<cuttle> joelteon: agreed
<joelteon> REALLY weird
<cuttle> haha yeah
<joelteon> oh well
<joelteon> and no type inference
<cuttle> learning haskell to the point where it's what your brain thinks in
<cuttle> is *great*
<cuttle> well i mean there is
<cuttle> in the new c++
<joelteon> well it's because function definition is so easy
<cuttle> auto x = 3;
<joelteon> it doesn't even feel like function definition
<joelteon> it feels like writing a spec
<ELLIOTTCABLE> your first pull-request evaaarrr?
<ELLIOTTCABLE> impressive :D
<ELLIOTTCABLE> wish I understood haskell ddis
<cuttle> ELLIOTTCABLE: srsly let me teach u haskl
<cuttle> ddis?
<joelteon> and it kinda feels like C anyway
<joelteon> while(!myfile.eof()) { getline(myfile, line); lines.push_back(line); }
<joelteon> like wtf
<joelteon> why is there an "out" param in getline
<joelteon> who designed this
<cuttle> joelteon: well, if it returned a value, getline would have to allocate memory
<joelteon> yeah
<joelteon> ok
<joelteon> :(
<cuttle> joelteon: this way, you can manage your own memory, which is paramount
<joelteon> computers are stupid
<cuttle> yeah :(
<cuttle> well, use cin
<cuttle> it's much funner even though iostreams are kinda bullshit
<joelteon> i'm reading a file stream
<ELLIOTTCABLE> watching http://vimeo.com/68470326
<cuttle> all the same
<cuttle> don't use getline
<joelteon> not stdin
<cuttle> use a stream
<cuttle> they work on fiels
<cuttle> files
<joelteon> how do you make a stream
<cuttle> ifstream file;
<joelteon> i'm USING an ifstream
<cuttle> ifstream.open("file.txt");
<joelteon> am i retarded
<cuttle> wait file.open :p
<cuttle> file >> variable
<joelteon> i don't see how to read a line
<joelteon> oh lord
<cuttle> wait i guess just use getline
<cuttle> but use std::strings
<joelteon> >> doesn't do strings
<purr> joelteon: SyntaxError: Unexpected token ILLEGAL
<cuttle> but i guess you probably are
<joelteon> and I'm using std::string
<cuttle> oh god
<cuttle> fuck c++
<cuttle> anyway
<ELLIOTTCABLE> this video.
<ELLIOTTCABLE> right in the feels.
<ELLIOTTCABLE> THIS. all of THIS.
<cuttle> what?
<joelteon> how do you make a thing printable
<joelteon> in Haskell I'd make it an instance of Show
<cuttle> joelteon: just give it a to_string method and call it yourself
<cuttle> joelteon: or you can overload operator<< on ostream for your specific type
<cuttle> eithe rway
<ELLIOTTCABLE> hi
<purr> ELLIOTTCABLE: hi!
<cuttle> hi
<purr> cuttle: hi!
<cuttle> quite honestly, rust's reference system is really becoming frustrating
<ELLIOTTCABLE> so, where were we
<cuttle> paws?
prophile_ is now known as prophile
<ELLIOTTCABLE> yes.
<ELLIOTTCABLE> prophile: hi!
<ELLIOTTCABLE> vil!
<ELLIOTTCABLE> vil: hi.
* ELLIOTTCABLE cuttle: yes.
<ELLIOTTCABLE> let's. do this.
<vil> hi!
<ELLIOTTCABLE> since I'm here, and my mind is well-and-thoroughly on Paws-related stuff,
<ELLIOTTCABLE> any big issues to bring up? something we can chat about at a high-level right now?
<ELLIOTTCABLE> I feel like there's a bunch of things I've told y'all to hold off on bringing up, or arguing for. wish I'd kept a list.
<vil> I really don't have anything
<vil> I've been so in-and-out the whole time that I can barely remember the state of things
<ELLIOTTCABLE> that's unfortunate
<ELLIOTTCABLE> was asking cuttle, mostly, since we're on the topic
<ELLIOTTCABLE> vil: you should re-learn things. work with alexgordon and I on the spec? I'd love some more eyes.
<vil> I really don't have time to do anything meaningful
<vil> I want to
<vil> but school and Conduit
<vil> mostly school
<ELLIOTTCABLE> aw
<ELLIOTTCABLE> Conduit?
<vil> my app
<vil> I want it released by Christmas so that I have a source of income
<vil> it's been a month since I even had time to work on it
<vil> did some whiteboard work last night finally
<vil> it's actually functional, I just have to put it in a prettier box
<vil> and clean up the plugin structure a bit
<cuttle> jesus this code is getting really fucking ugly
<ELLIOTTCABLE> cuttle: which code?
<cuttle> paws.rs parser
* ELLIOTTCABLE laugh
<ELLIOTTCABLE> ick.
<cuttle> going half-measure on parser combinators is not fun in rust like it is in js
<cuttle> i need to either go full-measure or not at all
<cuttle> ELLIOTTCABLE: how far are you in brba again?
<ELLIOTTCABLE> what?
<ELLIOTTCABLE> brba?
<ELLIOTTCABLE> oh. idfk. behind.
<ELLIOTTCABLE> starting over and watching from the start, probably.
<cuttle> ah ok
<ELLIOTTCABLE> ugh.
<ELLIOTTCABLE> I'm so bad at computer.
<ELLIOTTCABLE> done with this shit, re: woof.
<cuttle> know that feel
<joelteon> cuttle: right, but can you make something printable automatically
<joelteon> guess not
<joelteon> jesus i'm spoiled
<ELLIOTTCABLE> what
<ELLIOTTCABLE> when did this happen
<ELLIOTTCABLE> *why* did this happen
<cuttle> joelteon: well, overloading operator<< is about the best you can do
<cuttle> it does it for a lot of different places
<cuttle> any streams, which is c++'s way of handling strings
<cuttle> there's stringstream for concatenation and iostream for i/o
<joelteon> also, there's no option type
<joelteon> in the stdlib
<joelteon> that really grinds my gears
<joelteon> just gonna admit it
<cuttle> yeah, you have null pointers instead
<cuttle> ;)
<joelteon> yeah
<joelteon> i sure do
<cuttle> also there's boost::optional but do you really want to use boost
<joelteon> no?
<joelteon> probably not
<cuttle> probably not :p
<joelteon> is there a vector append operation
<cuttle> push_back
<joelteon> yeah, but for another vectorrrrr
<cuttle> oh
<cuttle> use insert and iterators
<joelteon> oh ofc
<joelteon> easy
<cuttle> lol c++ sucks
<purr> lol
<joelteon> is there a map function for vector
<joelteon> can I add methods to vector
<cuttle> you use a for loop and iterators
<cuttle> you cannot add methods
<joelteon> jesus
<joelteon> this language sucks
<cuttle> actually
<cuttle> in c++0x
<cuttle> there are lambdas and map
<cuttle> and also type inference
<cuttle> c++11*
<cuttle> are you using that?
<cuttle> it's just a compiler flag
<joelteon> yeah, i am
<cuttle> ok then yeah you have map and lambdas and stuff
<joelteon> where's map
<joelteon> how to documentations
<joelteon> if I google map it returns std::map
<cuttle> oh that's a data structure haha
<joelteon> yeah
<joelteon> i know
<joelteon> that's why i'm asking
<cuttle> oh I guess there isn't a map function
<cuttle> there are ways to do it pretty concisely though
<cuttle> like transform()
<cuttle> I guess
<cuttle> everything has its downsides though
<cuttle> like everything in c++ :p
<joelteon> "candidate template ignored: failed template argument deduction"
<joelteon> take a gander at that
<cuttle> is this the right way to write it? function<T(vector<V>)>
<joelteon> no idea
<joelteon> it's not complaining
<cuttle> shouldn't it be
<cuttle> function<T, vector<V>>
<cuttle> try that
<joelteon> "too many template arguments for class template 'function'"
<cuttle> oh never mind you had it right
<cuttle> ugh
<joelteon> oh noooo
<joelteon> i had it backwards
<cuttle> but yeah
<cuttle> you did
<cuttle> it should be V(vector<T>)
<cuttle> wait no
<joelteon> shouldn't it be vector<V>(T)
<cuttle> vector<T>(v)
<joelteon> but the return type is vector<V>
<cuttle> uggghg no yeah you're right
<cuttle> vector<V>(T)
<joelteon> why is the argument deduction failing
<joelteon> i'll ask ##c++
<joelteon> this is gonna be a lot of fun
<joelteon> well they're not happy
<joelteon> wow
<joelteon> either C++ type inference is really hard, or clang and gcc are really dumb
<joelteon> this is a complicated language
<ELLIOTTCABLE> ughghghghhhhh
<ELLIOTTCABLE> going through µpaws.js, figuring out what isn't copied, yet.
<ELLIOTTCABLE> hi, cuttle, hi, cuttle, hi, cuttle
<cuttle> hi ELLIOTTCABLE
<ELLIOTTCABLE> hi cuttle
<ELLIOTTCABLE> help me paws.js
<cuttle> aight
<ELLIOTTCABLE> going through, figuring out what I haven't done on the copy-types+ g-branch
<ELLIOTTCABLE> then I've gotta squash-down, merge into master.
<ELLIOTTCABLE> so, that's nearly done, I think.
<ELLIOTTCABLE> depending on if there's anything massive I missed.
<ELLIOTTCABLE> what I need, soon:
<ELLIOTTCABLE> - flesh out test-coverage for the code I've been copying from µPaws.
<ELLIOTTCABLE> I've been thoroughly testing all the *important* stuff, but coverage is far from complete. Simple but complete tests for all the untested little aspects would be excellent.
<ELLIOTTCABLE> - moving in on the reactor
<ELLIOTTCABLE> all I've copied is the *types*, I've stayed away from anything doing executing, because I vaguely want to rearchitect what µPaws does, slightly.
<ELLIOTTCABLE> cuttle: is my code remotely approachable for you? it's reallllly simple coffeescript. Or I've tried to keep it thus.
<cuttle> ELLIOTTCABLE: where?
<ELLIOTTCABLE> er,
* ELLIOTTCABLE ell.io/tt$Paws.js
<ELLIOTTCABLE> oh, no advance() yet
<ELLIOTTCABLE> but I'm wanting that to be a part of the reactor
<ELLIOTTCABLE> 83% coverage, not bad, I suppose
<cuttle> aight
<ELLIOTTCABLE> mmmm
<devyn> 12:53 #elliottcable: <+joelteon> devyn: my first use of sudo -e today
<devyn> because these things must be announced, right?
<ELLIOTTCABLE> hi, devyn
<devyn> hola
<joelteon> yeah, they must be
<devyn> ELLIOTTCABLE: how are you
<ELLIOTTCABLE> I am good. Ish. You?
<ELLIOTTCABLE> I'm working on paws.js.
<ELLIOTTCABLE> micah's successfully gotten me excited for Paws again, which is cool.
<devyn> that's good :)
<joelteon> I get to use gdb today
<ELLIOTTCABLE> devyn: Paws with me. Paws with me. Paws with me. I want friends, I want excitement, I want to *finish* something.-feels.
<devyn> man I'm so behind on Paws it probably wouldn't be worth it
<devyn> I also have a three hour class in about an hour
<purr\Paws> [Paws.js] ELLIOTTCABLE pushed 8 new commits to copy-types+: https://github.com/ELLIOTTCABLE/Paws.js/compare/4da663d099e4...7bdddb974e4d
<purr\Paws> Paws.js/copy-types+ 3bb6fab elliottcable: + Label#clone tests
<purr\Paws> Paws.js/copy-types+ a2bb150 elliottcable: (- meta fix) Excluding additional.coffee from test-coverage
<purr\Paws> Paws.js/copy-types+ 5d9cea6 elliottcable: + Thing#compare test
<ELLIOTTCABLE> devyn: then not right this minute. but let me catch you up? :D
<cuttle> devyn: i could explain paws to you very simply
<cuttle> it's been pretty distilled into what makes it special
* ELLIOTTCABLE nods
<ELLIOTTCABLE> cuttle says it well. there's not a lot left to Paws, anymore.
<ELLIOTTCABLE> or rather, not a lot left that's not been either A) deferred into some section of the language “that we'll deal with later” (insanities/error-handling, distribution, syntax/IPP), B) cut out entirely, or C) distilled down into something extremely simple
PragCypher has quit [Quit: Leaving]
<purr\Paws> [Paws.js] ELLIOTTCABLE force-pushed copy-types from 9fbcbcd to a76b14a: https://github.com/ELLIOTTCABLE/Paws.js/commits/copy-types
<cuttle> ELLIOTTCABLE: and i mean the deferred stuff is all pretty simple too
<cuttle> distribution is by far the most vague
<ELLIOTTCABLE> cool. types are now fully merged into master.
<ELLIOTTCABLE> now I'm gonn start on a little refactor that takes into account a lot of what alexgordon and I have done, as well as a couple things from you.
<ELLIOTTCABLE> (basically, re-naming things to not be confusing, as much as possible. Thing -> PawsObject, Execution -> Continuation, Label -> Symbol …)
<cuttle> do not call execution continuation
<cuttle> that is a misuse of continuation
<ELLIOTTCABLE> naaaaaaaah, distribution is by far the least *vague*
<ELLIOTTCABLE> it's just the most *difficult*
<cuttle> well yeah i mean it's the one we've least worked on :p
<ELLIOTTCABLE> distribution isn't something where I can be all “I'm Elliott! Preformance doesn't matter! Hahahah MAGIC!”
<cuttle> call execution function or method or block or whatever
<cuttle> but not continuation
<ELLIOTTCABLE> or “This is Paws! I can just make it *cool*, and it won't *matter* if it's good! Hahahaha MAGIC!”
<cuttle> because, whenever you *have* continuations, they're not a *thing*. they're a *role* a function plays
<ELLIOTTCABLE> I'll have to actually learn hardcore networking optimization stuff, and figure out how to optimize the data-types for over-the-wire transfer.
<cuttle> so calling a data type Continuation is very much not in line with established terminology
<ELLIOTTCABLE> the only *interesting*, and undefined stuff, is *still* mostly of the stuff-Elliott-doesn't-know, but-needs-to-learn variety
<ELLIOTTCABLE> hm, k
<ELLIOTTCABLE> block doesn't work very well /=
<ELLIOTTCABLE> will figure out later.
<ELLIOTTCABLE> distribution is pretty easy to cover, verbally. implementing it, integrating it into the design, less-so:
<ELLIOTTCABLE> implementations provide ‘extensions.’
<ELLIOTTCABLE> for instance, uhhhh, `string clone` might be an extension.
<ELLIOTTCABLE> if other implementations connected to the network ‘running’ a Paws program *don't* have that extension, then they connect to that instance that *does* have it. that instance becomes a static point in the graph.
<cuttle> well i mean we should be careful about merging scopds
<cuttle> scopes
<cuttle> because a big benefit of both ownership and distribution is that it separates what can affect what
<ELLIOTTCABLE> now, some sort of computery-sciency-magicy-overy-elliott'sy-heady magic, we grade various executions as they are cloned over and over (this only matters for tight-loop stuff), finding out what interfaces they continually require access too,
<ELLIOTTCABLE> and then we try to ‘move’ those executions to a home on an implementation/instance “closer” to the implementation/instance that has the APIs they need.
<ELLIOTTCABLE> that's the only *interesting* aspect of distribution in my head.
* cuttle nods
<cuttle> that's more operational
<ELLIOTTCABLE> other than that, it's just a matter of sending inter-Unit requests over-the-wire in the most efficient way possible.
<cuttle> we should define what paws code itself sees as a result of distribution
<ELLIOTTCABLE> boring, already-solved stuff that probably just needs me to learn a lot.
<ELLIOTTCABLE> oh, nothing, by definition.
<ELLIOTTCABLE> I've always intended that distribution be indistinguishable from a program running in a single, massively parallel, implementation that has *all* of the APIs that *any* of the implementations provide.
<ELLIOTTCABLE> meaning, as soon as a browser running Paws joins the federation, *all* code running on that federation of implementations has a DOM-extension of APIs available to it, transparently.
<ELLIOTTCABLE> whether the code is actually *running* in the browser, or on an HTTP server, or in a database interface, must be invisible to the code. otherwise what's the point of distributing the code across those implementations?
<cuttle> well it's a very leaky abstraction
<cuttle> you need to be able to see *some* of it
<cuttle> i mean it should all be in behind the scenes hooks
<cuttle> so you can write beautiful code and then write separate hook code to improve it
<cuttle> but like it shouldn't be hermetically sealed away
<ELLIOTTCABLE> hm
<ELLIOTTCABLE> the only reason I could ever think of to allow *any* way of differentiating,
<ELLIOTTCABLE> was security-stuff.
<ELLIOTTCABLE> i.e. ensuring that secured data never leaves a particular secure environment in an insecure fashion
<ELLIOTTCABLE> “keep the unencrypted form of password X stored in the secure-implementation; *always* make requests to the function that provides an encrypted version of it travel over the wire”
<cuttle> well also
<cuttle> broken connections
<devyn> ELLIOTTCABLE: well that's good
<ELLIOTTCABLE> that's obv an issue
<ELLIOTTCABLE> but I want to solve that at the networking layer, not the linguistic layer.
<ELLIOTTCABLE> i.e. a combination of redundancy-of-data, caching, and reconciling with insanitie
<ELLIOTTCABLE> insanities*
<ELLIOTTCABLE> if connection is lost, in the huge majority of cases, I don't want the code to know/care.
<cuttle> like i mean if the plug is pulled from the wall
<ELLIOTTCABLE> hm?
<cuttle> there is no way to solve it and you want to obviously minimize data loss etc.
<ELLIOTTCABLE> er, confus™
<ELLIOTTCABLE> elaborate
<cuttle> like
<cuttle> you want the code to be able to know if the connection is irrepairably lost
<cuttle> liek
<cuttle> erlang's philosophy
<cuttle> is all about knowing when something fails, and making that as much of a non-event as possible.
<cuttle> by restarting shit
<cuttle> so like you should be able to know about failures
<cuttle> it's the same reason you want hashes instead of functions
<cuttle> you don't want hermetically sealed abstractions if they can fail
<ELLIOTTCABLE> hm
jedivulcan has quit [Ping timeout: 240 seconds]
<ELLIOTTCABLE> well, that's another thing that's easy enough to change at a later date.
<ELLIOTTCABLE> one of those things that doesn't affect the language-design, the way Paws is set up. Just whether or not we open up particular APIs. Unless I'm missing something.
jvulc|znc has joined #elliottcable
<cuttle> yeah pretty much
<joelteon> ok, i think i'm an idiot
<joelteon> the C++ version of my pathfinding algorithm takes 0.81s
<joelteon> that was a waste of several hours
<cuttle> joelteon: well i mean c++ is not automatically faster than haskell
<joelteon> right
<cuttle> joelteon: like, c++ just has the potential to be automatically faster
<joelteon> but it's 3x slower
<cuttle> and not in the case of parallelization either
<cuttle> it's much harder to parallelize
<cuttle> and you have to work to get to fast
<cuttle> sometimes letting ghc do it for you is way easier
<joelteon> yeah i'm trying to figure out how i could improve the performance
<cuttle> well are you using flatmap
<cuttle> because stop that
<joelteon> haskell does it pretty well
<cuttle> well c++ doesn't
<cuttle> there's a reason everyone in ##c++'s first reaction to that was disapproval :p
<joelteon> because c++ is bad for type inference
<joelteon> :V
<cuttle> well also because you're doing lots of slow things
<joelteon> oh
<cuttle> like copying to a vector and then copying from that vector to another vector
<cuttle> do things in-place in c++ as much as you can
<joelteon> oh
<ELLIOTTCABLE> hi
<purr> ELLIOTTCABLE: hi!
<cuttle> hi
<purr> cuttle: hi!
<cuttle> joelteon: what's the freaking vec length function in rust
<joelteon> cuttle: len() maybe
fwg has joined #elliottcable
fwg has quit [Changing host]
fwg has joined #elliottcable
<joelteon> cuttle: did that work
<devyn> 16:56:03 -!- joelteon [~joel@unaffiliated/otters] has left #oftn ["bye"]
<devyn> y
<devyn> -.-
<joelteon> because
cloudhead has quit [Ping timeout: 248 seconds]
<joelteon> the last 25 lines in my scrollback
<joelteon> are the channel information, from me parting and joining
<joelteon> and i never close weechat excep when i'm rebooting
fwg has quit [Ping timeout: 240 seconds]
<joelteon> that's why
<devyn> yeah it's not active at the moment because everyone's busy with school
<devyn> the entire channel is well under 30; what do you expect
<joelteon> well, it's just like this place, but with more sephr and less ec
<joelteon> that's not like
<joelteon> very alluring
<devyn> I don't pay attention to it much either but I'm still in it just in case there actually is something interesting
<joelteon> but if you insist
<devyn> and not just sephr jerking over the technological singularity
<joelteon> is it ever not sephr jerking
<devyn> at the moment, not really
<devyn> and he's jerking to an empty audience too
<devyn> lol
<purr> lol
<joelteon> yeah
<devyn> I need to push my commits more often
<joelteon> yeah
<devyn> wanted to work on something and realized that I hadn't pushed about 6 commits and therefore didn't have them on my laptop