<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>
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
<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
<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?
<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: 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>
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>
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>
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>
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>
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>
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
<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
<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