<micahjohnston>
there's actually a flash animation
<devyn>
“Who Could You Trust (feat. Devyn)” lol
<purr>
lol
alexgordon has quit [Quit: Computer has gone to sleep.]
<eccloud>
hi
<purr>
eccloud: hi!
<eccloud>
micahjohnston: We talked about this; it's possible to use ownership to know about completion.
<micahjohnston>
oh, well that seems a bit ad hoc
<micahjohnston>
idk
<micahjohnston>
a bit
<eccloud>
when something completes, it disgorges *all* ownership; if you want to, for some reason, wait until *completion* (which breaks encapsulation, but whatevz, I'm all for metaprogramming and Evil™), you can take ownership on an arbitrary mutex, charge the callee with that ownership, then disgorge it yourself.
<elliottcable>
basically, every little change you make, as long as it passes `cake test`, commit it.
brr has joined #elliottcable
<elliottcable>
type a stupid, unpunctualized, uncapitalized commit-message, with a “+” before it:
<elliottcable>
“+ added isPair()”
<judofyr>
past tense?
<elliottcable>
doesn't matter
<elliottcable>
granular-commits are entirely free-form, that's the point
<judofyr>
k
sephr has joined #elliottcable
<elliottcable>
as long as there's a plus at the start of the line, I couldn't give less of a shit.
<elliottcable>
there's a *lot* of restrictions on how you safe-stage-commit to my projects; so granular commits are a way to escape those restrictions when you're focusing on code.
<elliottcable>
the only thing I ask is you commit much, commit often; keep a complete track-record of your work. It's all recorded for eternity. (=
<judofyr>
fair enough
<elliottcable>
So.
<elliottcable>
I'll show you later how to merge the granular branches (like copy-parser+) down to the safe-stage branches (like copy-parser), so they can be merged together into Master.
<elliottcable>
Here's Micha's rather ingenious parser:
<purr\Paws>
Paws.js/parser+ f86f10f Magnus Holm: + parse executions
<devyn>
so in addition to SSE* you can get FMA and shit
<devyn>
if the processor supports it
<Nuck>
CoffeeScript should add interfaces
<Nuck>
It'd bw so much better
<judofyr>
elliottcable: you want to keep the genesis stuff for keeping track of locations?
<devyn>
Nuck: typeclass master race
<alexgordon>
elliottcable: the REALLY great thing about coffeescript is that it forces YOU to write in a style that I can read
<judofyr>
elliottcable: "genesis" doesn't make much sense to be though
<devyn>
alexgordon: that's the point.
<Nuck>
devyn: >implying I'm serious
<elliottcable>
judofyr ⑊ Yes, definitely. It's very useful for debugging-output; I can take the original string and mark it up based on the current position and shit
<devyn>
Nuck: lol
<purr>
lol
<elliottcable>
It's the “genesis” of the AST.
<elliottcable>
You can call it `source` or whatever you like (=
<alexgordon>
wait, you can do that with newlines in coffeescript?
<elliottcable>
alexgordon ⑊ what?
<alexgordon>
linebreak after &&
<elliottcable>
It's *very* fragile. You've gotta re-write it several times, changing indentation.
<devyn>
lol
<judofyr>
isn't all of CoffeeScript like that?
<devyn>
guise just write Go and use gofmt
<Nuck>
... wow
<devyn>
what could go wrong
<elliottcable>
judofyr ⑊ → #Paws.Nucleus
<Nuck>
I didn't even realize how bad CoffeeScript is until now. How the fuck do you even manage that outside of Python?
<elliottcable>
What's wrong with Python?
<Nuck>
Whitespace for blocks.
<Nuck>
Other than that, what I've seen of Python (3, at least) is fine
<Nuck>
2 had the gripe of manually passing a reference to self around
<elliottcable>
I *like* whitespace-based indentation. Doing that, although massively differently, for Fullness
brr has joined #elliottcable
<Nuck>
I think whitespace-based block syntax is a good idea in theory, but it just ends poorly in practice because it reduces freedom (like I use tabs to indent and spaces to align, which Python doesn't seem to appreciate) and causes all kinds of awkward errors
<alexgordon>
Nuck: coffeescript is great
<alexgordon>
HOW DARE YOU SPEAK ILL
<alexgordon>
OF THE GREATEST LANGUAGE EVER MADe
<elliottcable>
Nuck ⑊ same page.
<alexgordon>
elliottcable: Nuck uses tabs
<Nuck>
alexgordon: You also program in Objective C and C++, you're used to languages being awkward and exploding randomly.
<elliottcable>
Nuck ⑊ which is why I'm doing it Right™ in Fullness.
<elliottcable>
WHAT
<elliottcable>
HARD TABS
<elliottcable>
-kick Nuck HARD TABS ಠ_ಠ
* alexgordon
knows how to push elliottcable's butttons
<Nuck>
Yes, hard tabs. For indenting, not for aligning.
<elliottcable>
oh
Nuck was kicked from #elliottcable by elliottcable [HARD TABS ಠ_ಠ]
Nuck has joined #elliottcable
<elliottcable>
hard-tabs 'r for-fags
<elliottcable>
look it rhymes
<elliottcable>
threesp tabs! <3
<Nuck>
What's wrong with hard tabs? I've seen nothing wrong with them, besides alignment
<Nuck>
I use threewide tabs too
<elliottcable>
Hard tabs are a bit like ...
<alexgordon>
that's like saying, "I only use whores to give to the poor, not to derive pleasure from it"
<Nuck>
But if I want, I can switch to 2, 4, 8, 16
<elliottcable>
... designing your web-page with the assumption that the end-user is going to customize the background-color.
<elliottcable>
And thus, making your page insanely ugly for the 85% of users that *don't* customize it, so it's blank white, which your design is ugly on.
<Nuck>
No, it's like designing your web page with the assumption that the end-user is going to change the font size or the font face
<elliottcable>
99.999% of people have hard-tabs set to the default, 8 spaces
<Nuck>
Which is actually important to do
<elliottcable>
and there is NOTHING IN THE WORLD more ugly than code indented with a full fucking EIGHT SPACES before each block.
<Nuck>
elliottcable: Nope. Most people (outside of vim) have it set to 4.
<elliottcable>
Especially Node-like code with lots of sub-levels.
<elliottcable>
Not at all.
<Nuck>
And that's a user thing. Just set the fucking variable.
<elliottcable>
I'll go compile a list of the defaults in each editor some day.
<Nuck>
Most GUI editors default to 4
<elliottcable>
Yes. That only affects *you*.
<elliottcable>
Which is a complete failure of design on your part, as the code-designer.
<Nuck>
It's the viewer's fault to not set the width
<Nuck>
I view this the same way I view CSS units. I use em because it allows the user to scale the font size to match their personal preferences.
<Nuck>
indentation is very much a personal thing, you should never force it on anybody
<Nuck>
Some people can't read code as quickly if it isn't indented the amount they're used to
<elliottcable>
Yes, and when the general default that applies to 90% of people reading it is commonly four-or-less-spaces, I'll be happy to use hard-tabs.
<Nuck>
Who cares what the default is? Most editors default to hard tabs anyways, so if you're working with them they're gonna have to configure anyways
brr has quit [Ping timeout: 240 seconds]
<elliottcable>
I care what the default is, when it's unchanged.
<elliottcable>
Damn, I need to take a survey of this now.
<Nuck>
So why not just configure the width like a sane human being and treat the indentation as an element of the display instead of the content
<elliottcable>
*Because most people don't*.
<elliottcable>
This is your argument:
<Nuck>
Most people *do* though
<elliottcable>
Me: “stop leaving the background of your website un-specified, and then designing your website as if it's set to magenta.
brr has joined #elliottcable
<elliottcable>
You: “Just set your browser to have a background of fucking magenta, and then design for that!
<Nuck>
I've never met anybody who didn't use a GUI Editor (Notepad++ and Sublime both default to 4-wide tabs) who didn't configure their editor
<Nuck>
Ever
<Nuck>
Just, like, flat-out
* alexgordon
grins with glee
<elliottcable>
Me: “ ... most browsers are *not customized*, so your website is going to look fucking stupid in most of them. You're being a bad steward of your design.
<Nuck>
alexgordon: What's the default hard tab width in Chocolat?
<Nuck>
elliottcable: The *only* editors that use 8-wide tabs are Vim, emacs, and nano.
<alexgordon>
Nuck: I did a statistical analysis of a sample of code for each language to detect the most common tab width in each community
<Nuck>
alexgordon: That's... creepy and obsessive
<alexgordon>
lol
<purr>
lol
<alexgordon>
if code were a girl, you would be right
<alexgordon>
Nuck: also, and this convinced me to stop using hard tabs... hard tabs are very uncommon
<alexgordon>
so I consider that, by using soft tabs we are closer to a consensus
<Nuck>
the browser defaults to 8-wide too, but we (the hard tab users) are really pushing GitHub to set that in CSS
<purr\Paws>
Paws.js/parser+ 33e82a4 Magnus Holm: + add source range
<Nuck>
alexgordon: I believe in web development hard tabs are actually more common
<Nuck>
And anyways, who cares about consistency outside single codebases - you follow the rules of the code you are in
<Nuck>
If they use tabs, you use tabs
<Nuck>
If they use 15 spaces, you use spaces
<elliottcable>
I'm definitely with you on that one.
<elliottcable>
But consistency *does* matter outside of the code-base.
<Nuck>
If they use 12 semicolons, you use 12 semicolons
<Nuck>
... Okay, maybe not that one. Fuck them, I will rewrite the entire fucking thing
<elliottcable>
But if you *choose* 12 semicolons for a new project, you're making it harder to contribute, and making life more difficult for everybody who develops software *everywhere*, if your code is open-source.
<Nuck>
Yes, but in this case, hard tabs are the saner option; they're designed specifically for this purpose. Just because Linus Torvalds said we use 8-wide tabs, does not mean 8-wide tabs are common. They aren't.
<Nuck>
Windows and Mac editors tend to use 4-wide from what I've seen
<Nuck>
*nix is the *only* place where 8-wide is default
<Nuck>
And you know what? Users of *nix editors tend to configure their editors well
<Nuck>
I've never, in my life, met somebody who used vim with the defaults.
<elliottcable>
pretty sure my vim is still set to 8-sp hard-tabs.
<Nuck>
(why would you? The thing is hideous)
<gkatsev>
tabstop should stay at 8 in vim...
<Nuck>
Well that's your own fault. How hideous it is is your problem. Just cause you can't wrangle your editor into 4-wide ain't my fault.
brr has quit [Ping timeout: 240 seconds]
<Nuck>
If you like 8-wide, you can have 8-wide, I'll just consider you an idiot.
<elliottcable>
I can't say it again.
<elliottcable>
All of this is irrelevant.
<Nuck>
The *only* negative of using hard tabs is that some retards set some things to default to 8-wide tabs. But that's like catering to IE6, why the fuck should I do it?
<elliottcable>
*All* that matters is how your code appears to others.
<Nuck>
Exactly why I use hard tabs!
<elliottcable>
Giving others customizable, that's great. I'm all for the *idea* of hard-tabs.
<elliottcable>
But giving *some* other users (the very small number who care) customizability,
<Nuck>
elliottcable: If you have a problem with hard tabs' defaults, don't take it up with hard tabs, take it up with the editors.
<elliottcable>
is *not* as important as the design for the *rest* of them.
brr has joined #elliottcable
<elliottcable>
Jesus. Thank god you're not a designer.
<Nuck>
... I am
<Nuck>
Why should I cater to people who can't be assed to set a single variable?
<elliottcable>
You're the type who would insist on using a non-standard CSS property, say “fuck you” to all the users whose browsers' don't support it the way you want it to be, and then say “take it up with the browser developers” to anyone who disagrees with you.
<elliottcable>
moving on to code.
<Nuck>
elliottcable: No way. I said this before, this is just like using ems instead of px
<Nuck>
Just because it might display differently on different browsers is not a negative. It's a positive.
<Nuck>
Lea Verou had a wonderful article on why she uses hard tabs now, from the perspective of a designer (and probably one of the biggest experts on CSS).
brr has quit [Ping timeout: 240 seconds]
brr has joined #elliottcable
<micahjohnston>
stop giving a shit about tabs and spaces
<micahjohnston>
walk outside, it's lovely weather
<alexgordon>
back
<alexgordon>
haha micahjohnston
<alexgordon>
<3
<alexgordon>
we don't live in utah though
<micahjohnston>
come here
<micahjohnston>
it's lovely weather
<micahjohnston>
at the moment anyway
<micahjohnston>
anyway tabs and spaces fucking suck
<micahjohnston>
we should stop using text but while we still are just use the same thing within a project
<micahjohnston>
Nuck: when I use vim it's with the defaults because any moment spent configuring a text editor makes me want to shoot myself
<micahjohnston>
alexgordon: high five?
<elliottcable>
micahjohnston ⑊ You still school? 'cause we're Pawsing, judofyr and I.
<elliottcable>
“Any number that can be created by fetishtically multiplying 2s by each other, and substracting the occasional 1, will be instantly recognizable to a hacker.”
<elliottcable>
There's another in the same book on the same topic, about how ‘hackers’ gravitate towards powers of two for absolutely no reasonable reason (he attributes it to them thinking they're cool, but whatever)
<elliottcable>
But. Seriously. There's nothing saying it has to be 2, 4, or 8.
<purr\Paws>
Paws.js/parser+ 1d51817 Magnus Holm: + reindent
<elliottcable>
2 is too small to me, 4 looks slightly too big. Tried 2 for a while, but too hard to differentiate blocks visually; settled on three, it's made me extremely happy.
<elliottcable>
anyway
* elliottcable
goes back to code
<gkatsev>
elliottcable: nothing other than that that's the general consensus for just about most projects
<judofyr>
yeah, I think 2 is too little for Coffee/Python
<elliottcable>
and 4's too much for Node, 'cause insane sub-block'in
<elliottcable>
middle-ground!
<elliottcable>
anyway, seriously doesn't matter. moving on to writing code!
<elliottcable>
protip, get rid of lots of parens, it'll help
<elliottcable>
but more importantly, yeah, expect() is *fucking ugly* with CoffeeScript
<elliottcable>
should looks great
<elliottcable>
but I needed it to work back to IE6.
<elliottcable>
I'll probably write my own someday, or refactor should to work with IE6. *shrug*
<whitequark>
I'm theoretically interested in writing a Paws implementation backed by LLVM.
<elliottcable>
Willox ⑊ To answer your question a little more seriously ... there's a solid half-dozen incomplete implementations by various people. There's only one implementation that runs code, but it's *literally* the most incomprehensible code you've ever seen in your life.
<elliottcable>
whitequark ⑊ Talk to prophile_; he wanted to do a compiler as his thesis at one point.
<whitequark>
will do
<Nuck>
derpgordon: The URL of that is infinitely more awesome than the actual thing
<elliottcable>
whitequark ⑊ and talk to me about it too, but let's move to #Paws.Nucleus to get away from the noise
<derpgordon>
Willox: it exists in elliottcable's mind, and in micahjohnston's mind, and noöne else's
<Willox>
ic
<elliottcable>
Willox ⑊ Meh. Ignore derpgordon, he's just jealous that he can't understand it. ;)
<elliottcable>
Willox ⑊ I'll teach you when I have a little more time ... but I'm in the middle, this week, of copying the implementation into CoffeeScript to make it a little more accessible.
<Nuck>
elliottcable: He'd understand it if you added square brackets to every method call
derpgordon is now known as gordonbrown
<Nuck>
>more accessible
<Willox>
I can't even find anything written in 'Paws'
<elliottcable>
I HAVE NO IDEA HOW TO DOOOO THIIIIIS
<Nuck>
The RIZZAAAAAAAA
<micahjohnston>
Willox: let's assess your knowledge
<micahjohnston>
Willox: do you know first-class continuations?
<micahjohnston>
like, call-cc?
<whitequark>
do you know why are they inferior to delimited continuations?
* whitequark
giggles
* elliottcable
pats whitequark
<micahjohnston>
lol
<purr>
lol
<Willox>
Stop bullying me D:
<elliottcable>
Ignore him, he's high on cold medicine.
<whitequark>
elliottcable: high on cold
<micahjohnston>
Willox: not bullying
<whitequark>
medicine is for pussies
* elliottcable
quietly leads whitequark to bed and tucks him in kindly
<micahjohnston>
Willox: want to know where you're coming from
<Willox>
micahjohnston, I know nothing about PLT, if that's involved
<micahjohnston>
aight
<micahjohnston>
what languages do you know well?
<Willox>
P.much, Lua
<Willox>
I'm only 16, I like Lua but I know some other stuff
<micahjohnston>
aight
<micahjohnston>
so
<micahjohnston>
(I'm 17)
<micahjohnston>
(Lua is pretty sweet)
<Willox>
Lua's hot
<micahjohnston>
Paws is kinda dynamically flavored like Lua
<micahjohnston>
everything is a table or whatnot
<elliottcable>
<3 Lua
<purr>
Let it be known that elliottcable hearts Lua.
<micahjohnston>
yknow
<micahjohnston>
but even more so
<Willox>
Everything is a table?
<Willox>
do you mean all types are table based?
<elliottcable>
The earliest Paws flavours were definitely heavily influenced by JavaScript's and Lua's object systems.
<Willox>
Or are there numbers and stuff that aren't?
<Nuck>
Jesus christ holy fuck my lag is terrifying me
<elliottcable>
that, plus a heavy influence of Node's asynchronicity (I started the Paws project a couple months after Node hit the ground; I was really into asynch-as-a-lifestyle then.)
<Nuck>
Your messages are rolling in 30 lines at a time
<Willox>
I'm not sure how a language can be focused on being asyncronous
<elliottcable>
Willox ⑊ you'll understand soon enough. TRUST IN THE MICAH.
<micahjohnston>
Willox: so do you know like continuation-based asynch IO? like Node?
<micahjohnston>
where you don't use return values and instead pass continuations?
<elliottcable>
The entire point of doing this was to design the first *asynchronous language*. So it's not surprising that you can't imagine how a *language* could be asynch itself, because it was basically unprecedented.
<micahjohnston>
instead of saying input = get_line(); print(input)
<Willox>
So it's completely async?
<micahjohnston>
you say get_line(function(line) { print(line); })
<micahjohnston>
note: this is not paws; this is a concept
<Willox>
that's crazy
<Willox>
Is there no 'return' in paws?
<micahjohnston>
so basically the point of this is:
<whitequark>
micahjohnston: wait what, you're 17
<micahjohnston>
whitequark: right
<whitequark>
and I thought at one point that you were more mature than me
<whitequark>
...
<micahjohnston>
Willox: well, we'll get to that
<micahjohnston>
Willox: it makes things look nice, no callback spaghetti
<gkatsev>
whitequark: not mutually exclusive :P
<Willox>
ok
<elliottcable>
whitequark ⑊ Micah's pretty fucking mature in a lot of ways.
<micahjohnston>
Willox: ok so you get the whole callbacks-for-io thing?
<Willox>
Yeah
<elliottcable>
whitequark ⑊ The only people I respect more than micah, at least intellectually, are inimino (michael john-clement), and cloudehad (alexis sellier.)
<Willox>
micahjohnston, I've done some work in node.js
<micahjohnston>
Willox: ok neat
<Willox>
and async based Lua
<micahjohnston>
cool
<micahjohnston>
so
<elliottcable>
wasn't there a Nodesque eio-thing that integrated the luavm?
<micahjohnston>
the silly thing about those libraries like node.js is:
<micahjohnston>
continuation-passing style is a really simple thing to mechanically transform your programs into
<gkatsev>
elliottcable: you mean node in lua or lua in node?
<elliottcable>
with diagonal execution, and the same (or very similar) asynch model
<micahjohnston>
elliottcable: yeah
<elliottcable>
go build it. ;)
<elliottcable>
finish tempus later! take my cool ideas and run with themmmmmm. That way we can share notes. :D
<elliottcable>
er, compare notes*
<micahjohnston>
Willox: yeah, think about it like this. code is already run from the inside out, first evaluating the functions on the inside, and then passing those as aguments to the functions on the outside. in paws, it just takes the outsides and packages em up into callbacks to pass around
<micahjohnston>
make any sense?
<Willox>
Yes
<Willox>
I don't understand why you want it to work that way, though?
* whitequark
giggles
<elliottcable>
saves you all the typing of callbacks.
<elliottcable>
and indentation of callbacks.
<micahjohnston>
well, I don't either, unless there's diagonal execution
<elliottcable>
go look at iced-coffee-script
<elliottcable>
it's a lot like using syntax and promises to ‘pretend’ to be paws.
<elliottcable>
every time each() returns (asynchronously), the rest of the function will run again. No different than a callback in that way.
<Willox>
I get it now
<elliottcable>
normally, you'd call something_else *before* that; if you wanted it to run *after* the call to each, but only run once, then you'd package the interior up in an “uncallback” wrapper
<Willox>
I can't possibly imagine how you got it to work like that
<elliottcable>
so, something_else(); print(my_list.each());
<elliottcable>
usually you want to call asynchronous calls in-sequence; and usually, if you return multiple values, you want to operate the same way on *each* of those values (i.e. the body of a forEach() function
<Willox>
I actually think I understand how this is all meant to work :v
<Willox>
I imagine I'm not going to be a fan of how it looks when it's Paws though
<elliottcable>
cool! now he can explain to you how it's all concurrent as well
<elliottcable>
it can *look* like anything you want, by the way
<elliottcable>
Paws has no syntax; it's a VM. The syntax is completely and totally dynamic, you build it within the language.
<elliottcable>
Long story.
<Willox>
that sounds
<Willox>
interesting
<elliottcable>
But you can easily write, say, a Lua wrapper for Paws, so that your Paws code looks damn-near-exactly like Lua
<alexgordon>
it's like lisp but with more neckbeards
* micahjohnston
is very tired of the hyperbole about that :p
<Willox>
I'd be quite happy with that
<Willox>
(the Lua part
<Willox>
)
<elliottcable>
it shouldn't be hyperbole!
<elliottcable>
if it is, then I fucked up royally >:
<Willox>
So, how's it all concurrent? :V
<elliottcable>
but I intend to ship a faux-JavaScript wrapper, just to show off the ability to do pretty much anything you damn-well please with the syntax
<elliottcable>
well, he mentioned that the data-type is a lot like tables in your Lua;
<Willox>
I love tables in lua
<elliottcable>
we basically add data to that huge structure of tables that comprises the data-space of the whole program, that describes how locking should flow through that space
<elliottcable>
so that you can say “if somebody locks on <this table>, then this sub-table should also be locked up, because it's a *part* of the overall data-structure that table represents.”
<elliottcable>
for instance, if you have a structure representing a person, then the sub-table holding the first and last names, can be locked against whenever the person table is locked against.
<elliottcable>
if that made any sense.
<elliottcable>
sorry, they're not *actually* tables, they're just similar. not going to bother getting into the differences now.
<micahjohnston>
so then there's a queue for all the calls in the whole program, and if any part of the data-graph is locked-up, then something that requires access to it is delayed until it's free again
<elliottcable>
anyway: since we can “cascade” locking data through the object system, it turns out to be pretty simple to encode information about *any* data your code might need, into the code
<elliottcable>
and between the two of those, and the fact that the code is broken-down into these tiiiiinnnyyyy bits for the asynchronicity as he already described,
<elliottcable>
we can block any of those tiny bits whenever necessary for the locking. Which leads to nearly bulletproof concurrency with very little effort on the user's part†
<micahjohnston>
wow spotify
<elliottcable>
† the caveat being, obviously, that everybody has to be careful to represent the relationships within their structured data carefully.
<micahjohnston>
interrupts the maad city to swimming pools transition with a kenney chesney ad
<elliottcable>
every “thing” in Paws is an ordered-list.
<elliottcable>
including numbers or strings or what-have-you.
<elliottcable>
it's an ordered-list of relationships to other ordered-lists, other things.
<elliottcable>
dictionary/table like structures are built of very short ordered-lists, acting as pairs; from within the language, they're indistinguishable from “tables”/dictionaries
<elliottcable>
not *inherently*, but there's a lot of assumptions that *treat* them as key-value.
<Willox>
How does foo['b'] result with 456?
<elliottcable>
So working with them *as if* they were key-value is very quick and easy; and in some situations, it's actually harder to *avoid* treating them that way.
<micahjohnston>
yeah i don't get why this is useful elliottcable
<elliottcable>
basically looks through the list in reverse-order, finding the first “pair-like” entry that has a “key-like” value matching 'c'
<elliottcable>
reverse-order because we also treat the faux-dictionaries as versioning.
<Willox>
pair-like being an entry of length 2
<Willox>
and key-like being the first element in that entry?
<elliottcable>
since it iterates in reverse-order, it looks like c has changed.
<elliottcable>
of course, you can explicitly grab the pair representing c, and *change*, if you don't want to versioned-update.
<micahjohnston>
elliottcable: well if these are linked-lists it's easier to prepend and easier to search in forwards-order
<elliottcable>
pair-like basically meaning “a length of two *or* three” with a first-value that is something like a label/string
<elliottcable>
micahjohnston ⑊ it's actually stored as a reverse-linked-list :3
<elliottcable>
in Paws.c it was, anyway
<Willox>
Couldn't that end with some kind of memeory issue?
<micahjohnston>
all right lol ;p
<purr>
lol
<elliottcable>
certainly.
<elliottcable>
Memory management is completely undefined at the moment.
<elliottcable>
But that's an interesting question in and of itself, because the langauge is intended to be distributed.
<elliottcable>
anyway: all of this is entirely “ish.”
<elliottcable>
By which I mean, the lowest-level implementation doesn't *depend* on it, by design.
<elliottcable>
you could store “pairs” as a native type, instead of a very short list-thing.
<elliottcable>
you could implement “assignment” to overwrite, not append.
<Willox>
I'm liking the function calling and how it's async
<elliottcable>
you could store metadata *about* an assignment, on the assignment-pair *with* the key and value.
<Willox>
I'm really not sure about lists
* elliottcable
laughs
<elliottcable>
you'll get along well with micahjohnston, then
<purr>
hah
<elliottcable>
he's been telling me to get rid of this object-system for ages
<Willox>
I'm not sure even if I understood it if it is a good idea
<elliottcable>
On a related note:
<elliottcable>
There was a short period of time where the plan was to dump the entire object system and just steal Lua's, because we couldn't agree on one we all liked.
<elliottcable>
(mentioned since you like Lua.)
<Willox>
Probably the best idea
<Willox>
;)
<elliottcable>
I just typed `arguments.callee.caller.caller.caller.caller` in all seriousness.
<gkatsev>
whhyyyyy
<elliottcable>
it gets worse.
<gkatsev>
does it?
<gkatsev>
can it?
<elliottcable>
I'm basically using the call-stack as a data-storage structure.
<gkatsev>
>.<
<elliottcable>
transferring data OOB into this function with it.
<Willox>
all these new thoughts
<elliottcable>
hm?
<Willox>
I feel broken
<elliottcable>
welcome to PLT.
<elliottcable>
now go learn befunge.
<elliottcable>
which is spectacularly uninteresting, theoretically.
<elliottcable>
but still mind-bending.
<gkatsev>
lol
<purr>
lol
<Willox>
but
<elliottcable>
Also, learn prolog, haskell, and E.
<Willox>
I kind of understand stacks I think, actually
<Nuck>
But you have to write the compiler in Befunge too
<elliottcable>
yep.
<Willox>
So
<elliottcable>
A self-hosting Befunge compiler.
<Nuck>
Exactly.
<Willox>
Write a compiler in Befunge
<Nuck>
Anyone up for porting LLVM to Befunge?
<Willox>
To compile befunge
<Nuck>
Exactly, Willox
<Willox>
Like I have the skill for that
<elliottcable>
also, it has to be a polyglot with brainfuck.
<elliottcable>
and in brainfuck, it has to be a self-hosting brainfuck compiler.
<elliottcable>
That may just be the single most difficult and pointless programming project possible. Wow.
<elliottcable>
I feel acheived just for having *conceived* it.
<Willox>
Befunge Interpreter in Lua is a go
<Nuck>
Wait, programming a brainfuck compiler in befunge, using a befunge compiler to compile the brainfuck compiler which then compiles a brainfuck compiler in itself?
<Nuck>
This sounds like a genius plan.
<Nuck>
Shall we try to get OFTN to make it?
<elliottcable>
nono
<alexgordon>
yes
<elliottcable>
you misunderstand.
<Nuck>
It's about as useful as most of their projects thus far
<Nuck>
:DDDDDDD
<elliottcable>
Polyglot, in that the source-code has to work whether executed as befunge *or* brainfuck.
<elliottcable>
Have you never written a polyglot before? D:
<alexgordon>
if this doesn't get on HN
<Nuck>
alexgordon: No lisp
<elliottcable>
-find oftn
<purr>
elliottcable: Found: source, paws viewer, oftnisbest, and forum