ELLIOTTCABLE changed the topic of #elliottcable to: Embrace, extend, extuingish.
yorick has quit [Remote host closed the connection]
prophile has quit [Quit: The Game]
TheMathNinja has quit [Ping timeout: 272 seconds]
TheMathNinja has joined #elliottcable
Rusky has quit [Quit: Leaving.]
KillerX has joined #elliottcable
devyn has quit [Remote host closed the connection]
TheMathNinja has quit [Ping timeout: 260 seconds]
devyn has joined #elliottcable
TheMathNinja has joined #elliottcable
TheMathNinja has quit [Ping timeout: 255 seconds]
gkatsev has joined #elliottcable
<devyn>
alexgordon: what? you have to write custom SQL in ActiveRecord?
<devyn>
alexgordon: (not that I use it; I use Sequel which is much better and basically can do everything SQL can from a Ruby DSL)
<alexgordon>
devyn: for a moderately complex query, yeah
<devyn>
okay, well then AR sucks, and you should use Sequel
<devyn>
it does models too
<alexgordon>
no that's not the answer :P
gkatsev has quit [Quit: Changing server]
gkatsev has joined #elliottcable
<devyn>
lol
<purr>
lol
<joelteon>
moderately complex queries always suck
<joelteon>
no programming language is capable of properly expressing SQL
<joelteon>
except SQL
alexgord_ has joined #elliottcable
alexgordon has quit [Quit: My iMac has gone to sleep. ZZZzzz…]
alexgord_ is now known as alexgordon
KillerX has quit []
<devyn>
joelteon: I've only ever really had to use custom SQL once in Sequel; it's basically intended to support every feature of SQL directly and then build higher level abstractions on top of that
<devyn>
joelteon: and you can embed literal SQL strings in your expressions if you need to
<devyn>
without writing the entire query
<joelteon>
well
<joelteon>
but in ruby you don't have to worry about types
<ELLIOTTCABLE>
Hey, SwooshyCueb, when you have a moment, I need halp
<ELLIOTTCABLE>
SwooshyCueb: I need a "character name" from my account to recover my account. and Fuuuuuuck if I know any of my character's weird names.
<ELLIOTTCABLE>
SwooshyCueb: could you check your friends list? it's like, olivia kalus'sdottir or something.
<ELLIOTTCABLE>
SwooshyCueb: >: I appreciate it.
TheMathNinja has joined #elliottcable
<SwooshyCueb>
ELLIOTTCABLE I don't have GW2 installed right now, and the friends list only shows account names for folks who aren't logged in, anyway. I'll see if I don't have a screenshot with your username in it lying around somewhere.
<SwooshyCueb>
character name*
<SwooshyCueb>
You're not Eidolon Of Death, are you?
alexgordon has quit [Quit: Computer has gone to sleep.]
<devyn>
joelteon: could certainly be done in a type-safe system
<devyn>
joelteon: distinguish between the different types of expressions, and have a variant that is 'unsafe' that's just a string
<devyn>
for each
<devyn>
non-castable between them, so still type-safe
eligrey has quit [Quit: Leaving]
<ELLIOTTCABLE>
SwooshyCueb: nah >:
<vigs>
:< han
<devyn>
nah :>
<devyn>
nha
<devyn>
nha nha nha
<vigs>
hey hey hey
<vigs>
goodbye
<devyn>
eybdoog, my friend!
<devyn>
ugh it's 27, still
<devyn>
I can't take this
<devyn>
>_<
<SwooshyCueb>
ELLIOTTCABLE then you might wanna look through your own screenshots
<ELLIOTTCABLE>
but other than the specifics of some of the signature … yah!
<ELLIOTTCABLE>
bbl slep lel
<Cheery>
hmm
<Cheery>
now I have to adjust my compiler, to fit the new module format and vm.
<Cheery>
instead of dl_opening my library, it needs to convert the source code into module code.
Sgeo has quit [Read error: Connection reset by peer]
Sgeo has joined #elliottcable
yorick has joined #elliottcable
Sgeo has quit [Read error: Connection reset by peer]
Sorella has joined #elliottcable
alexgordon has joined #elliottcable
<glowcoil>
ELLIOTTCABLE: i think "simulating a machine with infinite memory" is a pretty bad way of putting gc
<glowcoil>
ELLIOTTCABLE: a machine with infinite resources would eg let you allocate an array of any size, no matter how big
<glowcoil>
ELLIOTTCABLE: which obviously gc doesn't let you do
<glowcoil>
:p
<Cheery>
glowcoil: ?
<Cheery>
glowcoil: it is silly, yes.
<Cheery>
glowcoil: but what else?
Willox has joined #elliottcable
gozala has joined #elliottcable
<katlogic>
Cheery: Greenlet is just semantics
<Cheery>
well..
<katlogic>
Implementation detail, ultimately all kinds of threading, parallel or cooperative are collectible :) Just-a-graph-of-objects in the end.
<Cheery>
same happens with generators, yes.
<katlogic>
Indeed generators are just crippled threads (thread state is kept in function invocation record instead of separate)
<katlogic>
Cheery: What kind of finalizers you had in mind?
<katlogic>
You mean try / except / finally?
<katlogic>
when one yields in try block?
<Cheery>
finalizers as in gc finalizer
<Cheery>
and those connected to dying generators/greenlets, that trigger finally -statements
<katlogic>
Those work perfectly ok. Careful about resurrection tho.
<katlogic>
finally is never executed *until* try block reaches end or exception is thrown
<katlogic>
so if you yield
<katlogic>
and the thread is collected
<katlogic>
well, tough luck, finally never happens
<Cheery>
true
<katlogic>
(Making it happen is indeed somewhat tough for it to not be ugly hack)
<Cheery>
I think I'll still leave finally -statements out of the initial language
<katlogic>
Nah, I think it's ok as long the behaviour is consistent ..
<katlogic>
Notably if the thread suddenly GCs something is very wrong
<katlogic>
in the context that you'd expect finally to execute
<katlogic>
(care to present where that would be actually helpful behavior?)
<Cheery>
there are few places where they represent that it's useful behavior.
<katlogic>
The thread has to be resumed for this to be lexically consistent
<katlogic>
If the thread is GCed it is obviously too late
<joelteon>
i thought you were making an IRC joke
<katlogic>
Also there are subtleties about what greenlets, threads, coroutines et al actually are. Greenlets usually preempt implicitly somehow. With that you can actually get finally working.
<katlogic>
But with traditional coroutines? No way.
<Cheery>
true. I think the finally: -statement may be otherwise useful, but I'm bit wondering how to get the execution pass through in normal situation.
<katlogic>
Hm, wrong actually. Green threads are implicit scheduling, greenlets are just coroutines with c stack.
<katlogic>
Cheery: It all boils down to scheduler.
<katlogic>
If there is implicit scheduling, it can be done from gc finalizer.
<katlogic>
If there is none, user has to resume the thread from his custom __gc handler if that's what he really wants.
<katlogic>
As long it is possible to provide gc finalizers, user can do whatever he wants.
<Cheery>
yes.
<katlogic>
(including resurrection)
<katlogic>
Cheery: I still can't think of where finally executing would be useful in context of coroutines :/
<Cheery>
the author of python gr eenlets presented few useful cases
<katlogic>
Yes, those were for async signals
<katlogic>
but for gc?
<Cheery>
situations where there are greenlets in infinite loops, the finalizers would close file handles by those loops when they are dropped.
<katlogic>
signals traveling across resume states (such as exception) can be done in various ways
<Cheery>
or generators in similar manner
<Cheery>
but I say.. I haven't in practise seen such situations.. and javascript users seem to survive just fine with their callback hell.
<Cheery>
so concluding the whole finalizer -thing isn't very important after all.
<katlogic>
Well it is important wrt exceptions thrown across schedule()
<katlogic>
Alas, the finally thing was broken in gevent where it would not be called - but gevent is full blown scheduler
<katlogic>
Scheduler is expected to make it look like continuous flow, not suddenly break it like that.
<katlogic>
So let's say you'd implement something to akin lua coroutines
<katlogic>
finally would definitely had to be invokable somehow, both for exceptions and cases like looping and reschedule, gc triggers
<katlogic>
but generally this should be handled in user code either way. schedulers embedded directly into language are evil, instead users should be able to use their own.
<Cheery>
yeah. even in python you could do that with crashing the bad coroutine with an exception.
<Cheery>
so there apparently is a mechanism to drop into the finally statement
<katlogic>
I think all you need is expose exception api of a thread
<katlogic>
ie say
<katlogic>
thread.throw() would raise exception there (and resume inside handler), thread.finally() would just resume in the block
<katlogic>
or even better, make try blocks user accessible objects (again, more akin to Lua, but lua's way is kinda crappy)
<katlogic>
Cheery: basically come up with some minimum but universal primitive, this stuff can be useful for fancy custom exception handling too.
sharkbot has quit [Remote host closed the connection]
sharkbot has joined #elliottcable
<ELLIOTTCABLE>
glowcoil: perhaps, but irrelevant
<ELLIOTTCABLE>
glowcoil: stole the description from Cheery's article, and it's an interesting thought.
<ELLIOTTCABLE>
"what if could generalized what-GC-does-for-memory, to apply to arbitrary "resources" with setup/tear down semantics?"
<katlogic>
Yeah, we call it reference counting.
eligrey has joined #elliottcable
Willox has quit [Quit: Connection closed for inactivity]
eligrey has quit [Quit: Leaving]
<devyn>
ELLIOTTCABLE: the 'a stuff tracks a particular "lifetime" of a reference (ensuring that a reference within a structure can't outlive the structure itself)
<devyn>
ELLIOTTCABLE: just like <T> is a type parameter, <'a> is a lifetime parameter, and then &'a self means "self is bound to the 'a lifetime" and Option<&'a Relationship> means "optionally, a reference bound to the 'a lifetime to a Relationship"
<devyn>
reference to self*
<devyn>
if you don't take references it's considered a "move", so that function now "owns" the value and the caller can't ever use that again
<devyn>
and all of this basically means you never have to use anything like free() or delete
<devyn>
it's all tracked for you, statically, at compile-time
<devyn>
which is something I've wanted for a long time lol
<purr>
lol
eligrey has joined #elliottcable
Sorella has quit [Quit: Ex-Chat]
<Cheery>
I wonder how to start documetning it..
<Cheery>
obviously I need references for all the standard libraries
<Cheery>
and the user manual
<Cheery>
in what format though?
<Cheery>
should be the kind that is easy to transform into purpose
vil has quit [Ping timeout: 255 seconds]
vil has joined #elliottcable
Sgeo has joined #elliottcable
prophile has joined #elliottcable
<ELLIOTTCABLE>
hi, all
<ELLIOTTCABLE>
devyn: hi
<joelteon>
hi guys
<joelteon>
does anyone here know about toml
<devyn>
ELLIOTTCABLE: hi, I'm at work but if you have stuff to say I will respond within a few minutes