pugscode.org <<Overview Journal>> | pugs.kwiki.org | logged: xrl.us/e98m | FBSD_4.11:r1257(2/3212) win2k:r1197(105/3116) Linux:r1197(105/3116) MacOSX:r1197(105/3116) **[793 tests TODO]** Set by kungfuftr on 27 March 2005. |
|||
Juerd | Seeing autrijus' photo was rather disappointing - he doesn't look like the mad genius I had pictured... :) | 00:27 | |
He actually looks normal. | |||
theorbtwo | Mmmpf, I'm drifting something horrible. | 00:29 | |
metaperl | Juerd, I feel sorry for you | 00:50 | |
PLP is nicer than Mason, yet they are madly popular... how does that make you feel? | 00:51 | ||
Juerd | "nicer"? | 00:53 | |
It's leight weight and fast | |||
But Mason is a programming framework | |||
They don't really compete. | |||
s/leight/light/ | |||
And I should note that I don't use PLP much myself, except as a CGI-replacement | 00:54 | ||
That is: "<:" has taken over "#!/usr/bin/perl" | |||
Because this lets me develop as easy as things go with CGI, but with mod_perl's speed | 00:55 | ||
metaperl | I see... I am a CGI::Prototype fan | 01:06 | |
Juerd | You can probably very well use that from within PLP | 01:10 | |
metaperl | perhaps, but if I invented Seamstress, I need to use it | 01:13 | |
Juerd | Why that? | 01:14 | |
xmath and I invented Attribute::Prototype, but you don't see any one of us use it :) | |||
metaperl | yes, I like the Seamstress approach though... it's a bit indirect, but it gives me the non-invasive approach that I demand | 01:15 | |
you know, you should ask to be in Perrin's "choosing a templating system" doc at perl.apache.org | 01:16 | ||
Juerd | Why? | 01:25 | |
metaperl | exposure | 01:27 | |
Juerd | Exposure for PLP isn't necessarily a good thing. | 01:28 | |
metaperl | oh? why? | ||
Juerd | It needs to be rewritten and I don't want to spend the little time I have on that | ||
metaperl | oh | 01:29 | |
Juerd | PLP works, but it's UGLY | ||
And has some weird features that the world really would be better without. | |||
theorb | Sigh... I know I still have problems with testgraph, but they seem to be firefox bugs, and I haven't a clue what to do with them... anybody have another project to suggest? | 02:14 | |
stevan | theorb: how about sleep? you sound tired :) | 02:21 | |
theorb | I'm not tired, just depressed. | 02:22 | |
stevan | nothingmuch and I were talking about forking the testgraph stuff off into its own module | ||
it would be useful in other contexts | 02:23 | ||
theorb nods. | |||
I certianly wouldn't be opposed to such a thing. | 02:24 | ||
jabbot | pugs - 1264 - adding in two new tests, one for rx:perl | 02:27 | |
pugs - 1263 - making the exceptions lexical classes | |||
stevan | theorb: have you ever tried 'make optimized'? | 02:28 | |
theorb | I have, but not for quite a while. | 02:29 | |
stevan | I am wondering if it worth it? | ||
I suppose I should give it a try | |||
theorb | In fact, come to think of it, I never have, but I'm the one who poked people into making it. | ||
stevan | :) | 02:30 | |
theorb | Last I timed it, a compile-from-clean + run all tests ran longer with a -O1 and -O3 then with the default. | ||
stevan | but was that all in the compile time? | 02:31 | |
if you are looking for another project though, maybe you can port File::basename | 02:32 | ||
iblech started it | |||
but it doesn't work, he just ported | |||
you could hack it like I did File::Spec | |||
its frustrating and satisfiying at the same time | 02:33 | ||
jabbot | pugs - 1265 - un-TODO-ing the tests and making things | 02:37 | |
cm | you guys are so motivated :) | 02:41 | |
stevan | cm: it keeps me out of trouble :) | 02:51 | |
theorb | It just keeps me depressed. | 03:01 | |
cm | :) | 03:06 | |
does larry wall sometimes visit this channel? | 03:09 | ||
theorb | Not that I've seen. | ||
kungfuftr | larry, irc? | 03:10 | |
theorb | He's been known to talk on occasion on the CB of Perlmonks. | 03:11 | |
cm | what's "CB"? | 03:12 | |
theorb | Chatterbox. Go to perlmonks.org, it's the thing near the top-left with conversation in it. | ||
(Assuming anybody has said anything recently.) | |||
cm | ah ok | ||
theorb | Perlmonks: the reason I can put "god" on my resume and mean it. | 03:14 | |
kungfuftr | anyone ever built maxdb at all? | 03:22 | |
jabbot | pugs - 1266 - * fix warning | 03:27 | |
pugs - 1267 - fix pugsrun tests. '&>' will go backgoun | 03:47 | ||
pugs - 1268 - r1269@scwnb: scw | 2005-03-27 21:45:10 | 03:57 | ||
pugs - 1269 - r1306@scwnb: scw | 2005-03-28 12:00:12 | 04:07 | ||
mugwump | scw: use svk push --verbatim | 04:10 | |
scw | mugwump: Err, there are two things but I cannat find a way to push twice | 04:18 | |
So I decided to push without verbatim.. | 04:19 | ||
oop, I forgot to use --verbatim in r1269, is there some where to write it in config file? | 04:21 | ||
jabbot | pugs - 1270 - more work on Pod::Stream::Parser; Added | 04:27 | |
pugs - 1272 - Fix :key(val) and unTODO tests. | 04:47 | ||
pugs - 1271 - Local redo. | |||
gaal | mornin | 04:54 | |
masak | mornin | 05:01 | |
07:05
cls_bsd__ is now known as cls_bsd
|
|||
nothingmuch | hello | 07:17 | |
crysflame | . | 07:21 | |
scw | Hello, any one knows the meaning and rule of :key{ a => 1 } ? | 07:23 | |
nothingmuch | yes | ||
that's a pair | |||
scw | e.g. what should it produce? can there be more than one pairs in {}? | 07:24 | |
nothingmuch | whose key is "key" | ||
and whose value is an anonymous hash | |||
with one pair inside it | |||
(a => 1) | |||
S04 discusses disambiguating blocks from hashes | |||
scw | so :key{ a => 1, b => 2 } is also valid? | ||
nothingmuch | yes | ||
it's really the same as key => { a => 1, b => 2 } | |||
or :key{ :a(1), :b(2) } | 07:25 | ||
scw | great! | ||
nothingmuch: thank you vry much :) | |||
nothingmuch | you're welcome =) | 07:26 | |
this pair syntax is everywhere, btw | |||
double angle quotes know how to use it | |||
for example, enum <<:a(4) b c d>> means: | |||
scw | I saw many :key('val'), :key<val> | ||
nothingmuch | <val> and ('val') are equivelent | 07:27 | |
back to the enum: | |||
the quotes make a list: | |||
((a => 4), 'b', 'c', 'd') | |||
the enum gets that list | |||
and sees that a is a pair, so it enumerates 'a' with the value in the pair | 07:28 | ||
and then ++'s the value | |||
scw | make things quite clear | ||
nothingmuch | =) | ||
for each element that isn't a pair | 07:29 | ||
so b gets 5, etc | |||
scw | btw, is :key(1, 2) also valid? I guess it should be 'key' => [1, 2] ? | 07:30 | |
nothingmuch | i think yes, but i'm not 100% sure | ||
luqui should probably know | 07:31 | ||
if $a = (1, 2) puts an array reference into $a then yes | |||
looks like yes | 07:32 | ||
pugs> my $a = (1, 2); | |||
pugs> ref $a | |||
'List' | |||
it's pugs> my $b = [1, 2]; | |||
pugs> ref $b | |||
'List' | |||
scw | Hmm.. so perl 6 is intuitional and implementation contains many reuses :p | 07:36 | |
luqui | I should know what | 07:38 | |
luqui is reading | |||
nothingmuch | about how lists scalarify | 07:39 | |
nothingmuch hasn | |||
't yet read those parts thoroughly | |||
luqui | Yeah, pretty sure :key(1,2) means :key([1,2]) | ||
scw | luqui: And are :key('val') :key<val> :key{ k => 'v' } all the forms using 'key' as key? | 07:43 | |
luqui: besides from key => 'val' and alternatives like :key .('val) | |||
luqui | hmm... | 07:44 | |
I wonder if :key[stuff] is valid | |||
for certain values of stuff | |||
ahh, :key[1,2,3,4] is valid | 07:45 | ||
autrijus | cool. | ||
scw | equivalent to :key(1, 2, 3, 4) ? | ||
luqui | Yeah... | ||
autrijus | luqui: you've seen my IMCC.hs plan? thanks it's sane? :) | ||
luqui | which begs whether one of those should not be allowed | ||
autrijus | s/thank/think/ | ||
well, :key[1] is explicitly a list | 07:46 | ||
luqui | haven't seen it | ||
autrijus | while :key(1) is an element | ||
probably makes sense | |||
luqui | yeah | ||
scw | agree | ||
autrijus: I can't find out how (1, 2) is parsed in pugs! | |||
autrijus | luqui: oh ok. the plan is to ditch the Eval.hs (pugs evaluator) | ||
scw: it's just a binary op "," I think, no? | 07:47 | ||
luqui | good, I never understood that part of it anyway :-p | ||
autrijus | luqui: and merge Compile.Haskell (haskell compiler) with Compile.Parrot (IMCC compiler) | ||
the new architacture will be | |||
Perl 6 Source comes in | |||
we parse it to Pugs AST (ASTh.s) | |||
(AST.hs) | |||
then we compile it to IMCC AST | |||
(IMCC/AST.hs) | 07:48 | ||
then we translate that into Template Haskell | |||
then we evaluate the haskell code. | |||
using Haskell itself. | |||
luqui | IMCC is referring to parrot's IMCC? | ||
crysflame | hmmm | ||
autrijus | the haskell code will just be a IMCC emulator | ||
crysflame | neat | ||
autrijus | re, I mean IMC (aka PIR) | ||
luqui | oh.. | ||
scw | Oh, listSyn " , " | ||
luqui | so you're going to write a pir evaluator in haskell? | 07:49 | |
nothingmuch | why don't we just depend on parrot while we're at it, and spew things to it directly, via embedding or whatever? | 07:51 | |
luqui | I think that's a better idea than trying to emulate (ever-changing) pir | ||
autrijus | right. | 07:54 | |
not quite pir evaluator | |||
pir->to->nativehaskell compiler | 07:55 | ||
which can be compiled and evaulated on the fly | |||
luqui | do you realize how many parrot ops there are? | ||
autrijus | pir-relatd ones are few. | ||
it's just Perl*.imc | |||
no? | |||
Perl*.imc and Continuation and a few primitives | |||
don't need to be complete | 07:56 | ||
luqui | opcodes, not pmcs | ||
autrijus | should I care? :) | ||
luqui | (maybe I'm not understanding) | ||
autrijus | I'm not implementing a pasm cpu | ||
I'm merely implementing the small subset of pir/imc that is neccessary to run pugs | |||
luqui | oh.. right | ||
autrijus | nothingmuch: because: | 07:57 | |
1) embedding parrot is very hard at the moment. | |||
(mainly because embed.h was not installed and theere's no ExtUtils::Embed like things) | |||
2) a reference IMC implementatino will free us from the dreaded deadlock situation with PIR bugs and shortcomings | 07:58 | ||
3) We can then understand the operational semantics of IMC without having to trace .c code. | |||
4) The tests can be shared between IMC and Pugs. | |||
luqui | are you going to write a register allocator too? | ||
or just stick everything in separate registers | 07:59 | ||
nothingmuch | i think we don't care about that | ||
unless we want performance | |||
parrot is supposed to be smart about mapping to real CPUs, right? | |||
luqui | yeah, i realized that at some point between my two comments :-) | ||
autrijus | right. | 08:00 | |
I don't care :) | |||
nothingmuch thinks it could be an interesting way to learn IMCC | |||
autrijus | $I* is just a (Map Int Int) | ||
nothingmuch | how complex is it, btw? | ||
autrijus | and $S* is just (Map Int Strnig) | ||
nothingmuch: extremely simple :) | |||
nothingmuch | so basically pugs will be: | ||
luqui wonders, if it's so simple, what parrot has been doing for three years | 08:01 | ||
nothingmuch | parser -> our p6 AST -> lazy compiler for IMCC -> evaluator for IMCC | ||
luqui: i think parrot's focus has been robustness and correcness and portability and efficiency, no? | |||
also, the design is not simple | |||
you have to theorize on how things will look | |||
and then abstract them | 08:02 | ||
and then break them down, discover their common roots | |||
and design a language to take care of that | |||
plus there's some implementation details that are easier in haskell | |||
GC, and threads, and whatnot | |||
luqui | like the fact that GC is already taken care of | ||
nothingmuch | ooh | ||
do we have a GC test? | |||
nothingmuch reaaaally wants it to be a bug for things /not/ to be destroyed as soon as possible | 08:03 | ||
it's one of the most useful things in p5, | |||
luqui | nothingmuch: no luck | ||
parrot has to do it then, too | |||
and parrot probably won't | |||
nothingmuch | ? | ||
i thought parrot has means for smart and refcount GC | 08:04 | ||
and you get a sort of hybrid system | |||
luqui | no refcount | ||
nothingmuch | oi vey! | ||
luqui | (unless there have been new developments recently) | ||
nothingmuch | so much for compatibility | ||
how are they going to port Ponie? | |||
luqui | by hijacking perl5 somehow | ||
nothingmuch | that's just plain stupid | ||
GC can be overkill | 08:05 | ||
crysflame | ponie replaces SVs with a PMC-based SV | ||
nothingmuch | refcounting is fast | ||
and good | |||
crysflame | port it to what? | ||
nothingmuch | and enough 80% of the time | ||
crysflame goes back to listening. | |||
luqui | according to the studies that Dan read, apparently, refcounting is not fast | ||
(and /me really wants to be able to use circular references liberally) | 08:06 | ||
why is everyone so attached to timely destruction? | |||
nothingmuch | timely destruction helps me manage resources | ||
it's a way to do cleanup | |||
but encapsulate it | |||
instead of saying $obj->im_done | |||
you just throw it away | |||
and $obj takes care of itself | 08:07 | ||
luqui | how have you used that? | ||
nothingmuch | i have a big system that runs tests on remote machines | ||
i have resource allocation for things like remote shells, semaphores representing remote resources | |||
daemons, work directories, etc | |||
it's not a big change to add $obj->im_done | |||
to the superclass that implements the job stealing resources from people | |||
but it's yet another thing i don't want to worry about | 08:08 | ||
luqui | i understand completely | ||
luqui just had to write cleanup() callbacks for Logic.pm | |||
and it's a pain, even though it's not | |||
nothingmuch | and /maybe/, /sometime/, perhaps they will be destroyed | ||
it's more of the horror stories from the other side that scare me | 08:09 | ||
lumi said something along these lines about java: | |||
you have objects, and err, then you're done with them | |||
he said it was very annoying | |||
luqui | well, perl 6 has lexical hooks, which takes a good 80% off of the need for timely destruction | 08:10 | |
but there's still that 20% | |||
nothingmuch wonders why a hybrid system can't be formulated | 08:11 | ||
luqui | because Dan has been opposed to it | ||
and leo has been silent about it | |||
but maybe Chip will listen :-) | |||
leo has been trying to work in a generational gc for awhile | |||
luqui hasn't really followed that | |||
nothingmuch | a hybrid system pleases both sides | 08:12 | |
you get "proper" garbage collection | |||
which takes care of loops, in some smart way | |||
and some kind of reference count like system to invoke small increments of that thing when things are thrown away | |||
luqui | you know that you can never get timely destruction on circular structures | 08:13 | |
so what if people start expecting timely destruction, and they have a circular structure, and then it doesn't work | |||
as opposed to saying up front "there is no timely destrution" | 08:14 | ||
if we say "there is timely destrution most of the time" | |||
then bugs will be subtler | |||
nothingmuch | what if a generational GC was triggerred by a refcount system? | 08:15 | |
or at least a container destruction system/ | 08:16 | ||
i mean, say a block exits | |||
it's lexical scope is thrown away | |||
luqui | scw, to get back to you about an hour ago: there is also :key<<value1 $value2 value3>> | ||
nothingmuch | the generational GC can then treat the young generation as the stuff that was referred by the pad | ||
luqui | because you still need to do a full sweep to guarantee anything | 08:17 | |
otherwise you're just guessing, and getting it right most of the time | |||
but not all the time | |||
nothingmuch | what about introducing mutual weakness at the reference level? | ||
trying to detect what is circular | |||
and when one of these links is traversed, it and it's siblings are weakened | 08:18 | ||
luqui | I wonder if there's a good way to detect when you have circular structures | ||
scw | luqui: How about unicode version of << >> ? they should be equivelant? | ||
nothingmuch | detecting circularity in this manner shouldn't be too complicated | ||
luqui | I was actually referring to the unicode versions, but I believe they're equivalent everywhere | 08:19 | |
the question is, can you do it efficiently enough | |||
nothingmuch is really not familiar with graph theories | |||
should go learn compsci some time | |||
luqui | the problem is that most of these "detections" are O(n) | 08:20 | |
and n is all the objects in the program | |||
which brings you right back to what we have, mark-sweep | |||
nothingmuch | www.cs.cornell.edu/boom/2004sp/Proj...dex16.html | ||
brentdax | My God, you Pugs people have been busy. | ||
nothingmuch | that's interesting, though it doesn't solve our problem | ||
luqui | I've hard of that | ||
heard | |||
Kim wrote an article about it | 08:21 | ||
(Kim Burchett, of kimbly.com) | |||
(one of Dan's favorite blogs, it seems) | |||
heard it was very awkward | |||
nothingmuch | how do ddd and other similar programs work? | 08:22 | |
luqui | I think they annotate the memory allocation structures | 08:23 | |
and then test whether any are remaining at program exit | |||
like valgrind | |||
A friend points us here: dev.perl.org/perl6/exegesis/E07.html | 08:24 | ||
er not there | |||
here: www.cs.colorado.edu/~lizb/private/p...diwan2.pdf | |||
lightstep | some early smalltalk systems had a hybrid system: you had refcounts, when they overflowed the object was delegated to the gc, and once in a while they did a full sweep | 08:25 | |
nothingmuch | citeseer.ist.psu.edu/context/13435/2716 | ||
lightstep | but this scheme wasn't good at all | ||
luqui | what were the weaknesses? | 08:26 | |
nothingmuch | can we use typing to make GC sweeps less slurpy? | ||
or does parrot not support typing? | |||
autrijus | sorry, bbiab :) | ||
nothingmuch | ciao autrijus | 08:27 | |
luqui | well we certainly can't rely on it | ||
lightstep | luqui, it was slower than generational gc | ||
luqui | and most of the languages we support wouldn't give it any information | ||
nothingmuch | but in theory a language compiler that is smart enough could help the GC system be quick | 08:28 | |
lightstep | nothingmuch, i don't understand. are you worried about memory leaks or about activation of finalizers? | ||
luqui | it started as the latter :-) | ||
nothingmuch | both | ||
=) | 08:29 | ||
i prefer activation of finalizers | |||
but most people prefer being trigger happy with circular structures | |||
my style for increasing robustness is to put all annoying details together | |||
in the begining | |||
that is, all refcount weakening is centralized | |||
for the same object | |||
unless I really can't pull that off | |||
this lets me rely on refcounting to stay pretty | |||
and for me it's worth the effort | |||
luqui | have you seen what POE has to do to get around the circular structure bs? | 08:32 | |
it has to implement its own refcounter | |||
nothingmuch guesses his programming style will have to change | |||
ook | |||
i've done that once | |||
i wanted to have an LRU cache that purges at O(1) | |||
ofcourse, it didn't, since it was using perl structures | 08:33 | ||
but it was just an excercise | |||
and when it's accessed it's spliced up to the top | |||
it had a doubly linked list, where references go in | |||
the hash that caches contains a reference to the link element | 08:34 | ||
when the cache overflows elements are popped off the list | |||
nothingmuch loves writing things and feeling really clever, when he tries to understand a feature | |||
since then, when I learned about refcounting, and made myself face it the hard way, i like it | |||
because what it gives me, it gives at a cost i'm willing to pay | 08:35 | ||
luqui | basically, which cost is the general programming public willing to pay? | ||
lightstep | the common wisdom is that gc is at least as fast as refcounts (less page faults) | ||
luqui | learning about refcounting, or calling .close on things | 08:36 | |
yeah, cache locality is a big issue, so I'm learning while working on parrot | |||
nothingmuch | Cocoa has a | ||
weird feature | |||
they call them allocation zones | |||
luqui | go on | 08:37 | |
nothingmuch | which are a techinque to help optimize the allocation, so that related objects are paged from the swap together | ||
lightstep | oh | ||
there's talk about regions in dome papers, but i don't know what they are | |||
luqui | is cocoa refcounted? | 08:38 | |
lightstep | maybe it's related | ||
nothingmuch | so the NSObject base class has [class alloc] and [class allocWithZone:Zone] | ||
kakos | Obj-C is | ||
nothingmuch | cocoa is refcounted manually | ||
luqui | ok | ||
nothingmuch | kakos - objective c isn't, it's just C | ||
kakos | nothingmuch: Really? My bad then. | ||
nothingmuch | but you have a shortcut | ||
cocoa is, by supplying the allocation pool objects | 08:39 | ||
anyway, what you have is a sort of singleton | |||
objc/cocoa are very tightly coupled though, so it seems like it =) | |||
except it's really a stack | |||
you push an allocation pool onto it | |||
luqui | are you really typing that fast? | ||
nothingmuch | and then you tell objects to autorelease | ||
and they say to the release pool, destroy me whenever | |||
and when the pool is destroyed it refcounts it down | |||
yes, i am ;-) | |||
luqui | you type faster than I read | ||
nothingmuch | i type too slow, IMHO, or rather, I think that I think too fast | 08:40 | |
i need to type slower, and think much slower, and then maybe i could make some sense | |||
languages have never been my friend | |||
luqui | well, I've wasted far too much time | 08:41 | |
here | |||
"wasted" | |||
nothingmuch | ditto =( | ||
luqui | I need to get back to my homework which is due in six hours | ||
luqui & | 08:42 | ||
nothingmuch | good luck, luqui | 08:43 | |
www.google.com/url?sa=U&start=4...amp;e=7152 | 08:44 | ||
i think i'm reading that right now, not too sure | |||
it looks like generational meets alloc zones, or whatever | |||
nothingmuch wonders if a zone system with an index of all refererences to and from foreign objects could be used to try and search for circular objects in a more graphical manner | 08:55 | ||
tightly related objects link within the zone | |||
so to not cause too much overhead | |||
with multiple zoning levels, and circularity between zones dealt with traditionally, you could move the complexity to a smaller N, i think | 08:58 | ||
the cost being at reference time | 08:59 | ||
within zones, an optimistic GC could be safer, because it knows what objects are foreign | |||
zones should be per object at the lowest level, and if two zones share a great number of links, then they are bound together in a new zone | 09:01 | ||
and insignificant zones can subsequently be optimized away | |||
which is really where there is a gamble | |||
since then you can't repartition a zone easily | 09:02 | ||
lightstep | but when creating the program you have some idea of the memory allocation patterns. throwing it away and reconstructing in runtime is bad | 09:03 | |
nothingmuch | you mean, the object definitions, etc? | ||
lightstep | the zones | 09:04 | |
the programmer, and even the compiler, have data that can significantly improve the zone tree | |||
nothingmuch | right | 09:05 | |
lightstep | and using this impormation might obviate the repartitioning at runtime | ||
the need for | |||
nothingmuch | exactly | ||
with that data | |||
and also statistics | |||
either gathered, saved, and learned | |||
or during runtime, for prediction | |||
could help the GC throw away zones which can be safely forgotten about | 09:06 | ||
jabbot | pugs - 1275 - Testing the wrong thing. | 11:57 | |
pugs - 1274 - Accepting :key('val1', 'val2') and :key[ | |||
pugs - 1273 - Accepting :key<val1 val2>. | |||
autrijus | wow.i | 11:58 | |
nothingmuch | ? | ||
autrijus | :key[] :key<> and :key() | ||
so nice. | |||
obra | hey autrijus | ||
autrijus | hey obra. | ||
MRT++ # fast fast wireless | 11:59 | ||
obra | nice | ||
autrijus: how'd you solve their issue? | |||
autrijus | scw++ # mad and motivated | ||
obra: I had. | |||
clkao | svk branched for 1.0 release engineering | ||
luqui | hey autrijus, have you begun BEGIN? | ||
autrijus | obra: their visual basic component was not freeing its handles. | ||
luqui: no, feel free to work on it. | |||
obra | is that the issue? | ||
nothingmuch | if it weren't for crazy people pugs would never have been... =) | ||
obra | the whole issue? | ||
autrijus | luqui: it's part of the 3-stage compilation plan. | ||
obra: well, there's various complications. | |||
obra: I switched DBD::ODBC to DBD::ADO; that fixed threaded contention | 12:00 | ||
then I increased timeout, which fixed starvation | |||
luqui | hmm... I'm thinking the best way to do it is to implement macros | ||
nothingmuch | autrijus: give me an idea for something to do for pugs | ||
i'm a bit sick of fighting with vim | |||
autrijus | but the core bug is that their VB component was not doing things correctly. | ||
luqui | and BEGIN is a very simple macro | ||
autrijus | luqui: explain. BEGIN is compilation time, not runtime | ||
luqui | fighting with vim? | ||
vim is wonderful | |||
autrijus | obra: so I'm like, charging them fully, because that's outside my contractual obligation. | 12:01 | |
nothingmuch | it is | ||
Text::VimColors is not, though | |||
luqui | autrijus: macros are also compile time | ||
nothingmuch | for some reason, even though it display =pod .... =cut as comments normally | ||
autrijus | luqui: oh. macros with side effects, eh. | ||
obra | autrijus: nice | ||
autrijus | luqui: sure... I punted macros only because they are not specced at all. | ||
nothingmuch | the html from Text::VimColors has the pod parsed as perl | ||
luqui | they are a little bit | ||
anyway, should I just use what's in place in Eval.hs? | 12:02 | ||
autrijus | luqui: not to my eyes, so feel free to work on it :D | ||
nothingmuch | the mysterious 'is parsed' trait is sooooo scary | ||
autrijus | luqui: sure. none of Eval monad will be invalidated | ||
luqui | okay cool | ||
autrijus | it will just magically become a compiler. | ||
that's the point of this whole monadic revolution :) | |||
nothingmuch | we're thinking of forking the test reporting stuff into another project | ||
what should we call it? | |||
luqui | nothingmuch: but is parsed is not a macro-only thing | 12:03 | |
autrijus | nothingmuch: look at test failures and pick some easier ones? | ||
nothingmuch | it should do the doc backlinking, the pretty graph things, and whatever | ||
luqui | it's quite orthogonal | ||
autrijus | nothingmuch: Test::Visualize ? | ||
nothingmuch | smoker data consolidation | ||
it's more a collection of scripts | |||
why not | |||
scw | autrijus: I just want the function call write "something", :bold | 12:04 | |
:p | |||
autrijus | scw: and it works now? | 12:05 | |
scw | autrijus: definitely :) | 12:07 | |
nothingmuch wonders where his funky GC scheme is utterly broken | |||
luqui: did you read a bit? | |||
scw | autrijus: t/subroutines/sub_named_params.t:88 | ||
luqui | no, I finished my math test :-) | ||
autrijus | scw: wonderful! | ||
luqui | nothingmuch: it might be good to outline it in a little doc | 12:08 | |
so people can think about it concretely | |||
nothingmuch | are you sure that isn't pointless? | ||
it was more of an excercise in triz like thinking | 12:09 | ||
nothingmuch tries anyway | |||
luqui | well, mostly because I have no idea what your scheme is... | 12:10 | |
nothingmuch | ok | ||
luqui | and I'm not paying enough attention right now to listen | ||
nothingmuch | so i'll write =) | ||
autrijus needs to work on PA02 too. | 12:11 | ||
but, taking MRT back home & | |||
gaal | nothingmuch: how about Smoke and Mirrors? (S&M for short :) | 12:15 | |
nothingmuch | gaal: that's not very search.cpan.org savvy | ||
gaal | the yaml harness is almost entirely not dependent on pugs | ||
it needs some smarts to detect other source control system | |||
s | |||
nothingmuch | what I think we'll do: | 12:16 | |
create a test reporter | |||
that creates YAML | |||
and inserts revision/arch info | |||
the YAML harness is used by it, but unrelated | |||
gaal | plus there's one place where i get the version of pugs itself, but if there's a contract that the project declares its version somewhere clear, i could use that | ||
nothingmuch | then we have data consolidation | ||
i think YAML harness should take that data out, and deal only with actual test results for now | 12:17 | ||
gaal | "test reporter" can just be another output mode for Test.pm, no? | ||
jabbot | pugs - 1276 - | ||
nothingmuch | the catalogging thing should be decoupled too | ||
into a doc/test link system | |||
where you can declare shortcuts for doc names | |||
so we can retain S02 | |||
the grapher should be a bit smarter, and take consolidated results as a data structure | 12:18 | ||
and display them as such | |||
the consolidator takes YAML, and makes a structure for the grapher | |||
and lastly Test::Builder should have the $?CALLER::CALLER::POSITION hack for graph->file linking | 12:19 | ||
gaal | that's a useful extentsion to TAP, in any case | 12:21 | |
nothingmuch | yah | ||
we should delegate that responsibility to andy lester | |||
gaal | petition for it, you mean :) and offer our current Test.pm with our appeal | 12:22 | |
leo_ | fireall test | 12:26 | |
luqui | is leo leo? | ||
leo_ | leo is leo :) | ||
nothingmuch | leo_: pond | ||
luqui | hi leo | 12:27 | |
nothingmuch | s/d$/g | ||
leo_ | my first visit to IRC ever - just looking what my firewall says | 12:28 | |
obra | heya leo | ||
clkao | leo! | 12:30 | |
q[acme] waves | |||
leo_ | yes? | ||
Juerd | Hi leo_ | 12:33 | |
nothingmuch | leo_! leo_! leo_! | 12:34 | |
leo_ | hi all | ||
nothingmuch mimicks someone elses voice: "is leo_ here?" | |||
leo_ | yes - first time on IRC | ||
q[acme] | and what does the firewall say? | ||
leo_ | not sure yet but modeprobing ip_mask_irc seems have done it | 12:35 | |
autrijus | hi leo! | ||
I'm in middle of MRT station | |||
it only stops for 10 secs | |||
leo_ | hi autrijus | 12:36 | |
autrijus | so... brb :)) | ||
Juerd | Hi autrijus, Bye autrijus. | ||
autrijus | = be right back | ||
hcchien | fg | 12:37 | |
ouch..... | |||
Juerd | heh | ||
leo_: How have you managed to live without irc? :) | |||
autrijus | :) at jian tan station now | ||
err, shih lin | |||
obra | hey autrijus | 12:38 | |
Juerd | I'm 21, and spent the last 10 years on IRC... :) | ||
I can't imagine life without :P | |||
obra | we got clkao to branch svk | ||
leo_ | well - the metered ISDN line. it already dropped the line once | ||
hcchien | autrijus: back to Danshui? | ||
leo_ | I'm 47, and spent the last 12 minutes on IRC ;) | 12:39 | |
Juerd | Heh, I imagined you younger (no offense) | 12:40 | |
leo_ | I feel younger | 12:41 | |
are there any Parrot related questions? | 12:42 | ||
Juerd | Does IRC make you feel younger? :) | ||
I have no questions at this moment | |||
leo_ | IRC looks still very strange to me - but I get used to it | 12:43 | |
Juerd | If you need any help, just ask for it | ||
leo_ | thanks, not yet, I've to explore it a bit first | 12:44 | |
pjcj | Do you know where #parrot is? | 12:48 | |
q[acme] | pjcj: you scared him off! | ||
Juerd | Not there :) | ||
nothingmuch | luqui: nothingmuch.woobling.org/gc_zones.txt | ||
i have only thought about it about 10 minutes though | 12:49 | ||
so it's likely to have big holes | |||
but it appears to me that with a certain overhead when you refer to other objects, you can gain a lot later when looking for objects to destroy | |||
leo_: this might interest you too... ./configure --disable-layout --disable-tests --disable-samples | |||
oops, nothingmuch.woobling.org/gc_zones.txt | |||
though please take it with a grain of salt, as I have no clue what I'm doing. | 12:50 | ||
integral | ah, zones can't form loops so it's safe to ref count them? | 12:52 | |
oh, not at all. | 12:53 | ||
nothingmuch | integral: ah? | 12:55 | |
zones are a tree of partitions and sub partitions | |||
a zone can have only one parent | |||
and knows about zones it's children relate to | |||
a zone whose children relate to no one | |||
not even the roots of the data tree (registers, or the stack) can be simply deleted as is | |||
integral | oh, so the zones nest, rather than partition the whole of memory | 12:56 | |
nothingmuch | right | ||
if they nest down to the lowest level, then you get nothing | |||
the real issue is to know what zones don't help you | |||
ideally many levels of leafs | |||
so that your low level zones are several hundred objects, maybe a little less, maybe a little more | 12:57 | ||
integral: am I being too naive? | |||
integral | I don't really know enough to tell. How are the low-level zones being built? | 12:58 | |
Are they created from compile-time information? | |||
nothingmuch | well, in theory each object has it's own zone when it's constructed | 12:59 | |
and when it reaches out to other objects it should have it's zone optimized away very quickly | |||
in practice you could pre optimize, maybe | |||
compile time info helps you partition the zones more wisely, methinks | |||
by using type constraints you can know where zones won't touch, because their objects can't reference each other | |||
the hosted language could provide this data to the GC | |||
Juerd | Holy crap, this channel has 86 nicks in it | ||
nothingmuch | Juerd? | 13:00 | |
Juerd | nothingmuch: I don't know any other channel that has grown this fast | ||
nothingmuch | err, not provide | ||
but help the GC | |||
ah | |||
it grows by about 5 people a week, on avg, afaict | |||
Juerd | No, much faster. | 13:01 | |
nothingmuch | it seems like a lot, but then again, i have never lurked on IRC | ||
Juerd | It has existed less than two months. | ||
nothingmuch | i mean over the last 3 weeks or so, since i joined | ||
integral | I don't know any project that has gathered commiters so fast either :-) | ||
tombom | the only reason i came was because of ghc 6.4 reporting an impossible error in main.hs | ||
nothingmuch | that is what's really impressive =) | ||
Juerd | integral: yea | ||
nothingmuch | (to me) | ||
so, does anybody have on opinion about that GC scheme? | 13:02 | ||
leo__ | line dropped again :( | 13:05 | |
Juerd | leo's collecting underscores | 13:06 | |
nothingmuch | i was just about to make a joke about leo___ | 13:07 | |
leo__ | I don't yet understand gc_zones.txt | ||
yeah, what are these underscores? | |||
nothingmuch | when the nick is taken | ||
since the old you did not log out yet | |||
Juerd | leo__: When you reconnect and the old client is still "connected" to the server, the old nick is taken | ||
leo__ | by me | ||
nothingmuch | then you get a temp | ||
Juerd | leo__: Your client then has to make up another nickname, usually formed by ~= "_" | ||
nothingmuch | anyway, the zones basically are: | 13:08 | |
Juerd | leo__: Use /nick leo to return to the original one | ||
nothingmuch | a way to group objects into groups | ||
for the sake of simplifying grabage collection | |||
so that it's feasable to do something equivelent to a full sweep | 13:09 | ||
in a complexity closer to reference counting | |||
except that it's a bit more complicated than reference counting, and possibly (probably) completely wrong | |||
leo__ | one group per object kind? | ||
nothingmuch | that's how it starts | ||
skypp | #haskell | ||
Juerd | skypp: Type /join #haskell to join that channel | ||
nothingmuch | but very quickly the leaf level zones should be forgotten | ||
Juerd | skypp: Without the /join, it's a normal message. | ||
nothingmuch | and the objects close to each other just packed directly under one medium sized zone | 13:10 | |
lumi | "delete whole zones at a time" -- In what order are the objects destroyed? | ||
nothingmuch | lumi: =P | ||
lumi | Frankly I'll just be glad for finalizing at all... :P | ||
nothingmuch | where do you start to destroy a cyclic structure? | 13:11 | |
at the node that was first refcounted to zero? | |||
brb, i've got to rescue someone | |||
lumi | True, but that's not an answer | ||
nothingmuch | i don't know | 13:13 | |
lumi | I guess they'd need to order themselves if it's important | ||
nothingmuch | i think that's for the language design to decide | ||
or provide hooks for | |||
in theory you have a set of object | |||
s | |||
unordered | 13:14 | ||
in a zone | |||
you could destroy based on reverse chronological order of creation, if that's your thing | |||
i dunno | |||
leo__: is it any clearer? | |||
lumi: err, i've been doing a lot of 'echo powerpc-apple-darwin7.8.0; exit' in config.guess files | 13:15 | ||
leo__ | not much, no - need probably a picture of object/zone relations | ||
nothingmuch | think of a graph of objects | ||
and zones are non intersecting circles | |||
which could contain other smaller circles | |||
theorbtwo | Mornin, all. | 13:16 | |
nothingmuch | morning theorbtwo | ||
leo__ | I think a generational GC system has to tightly integrate with the interpreter | ||
e.g. it has to know, when a scope is created or destroyed | 13:17 | ||
nothingmuch | but generational GCs can't ensure immediate finalization, right? | ||
leo__ | we have to do a lazy GC sweep at scope exit | 13:18 | |
there are two cases: eagerly object is found - fine | |||
or not then the next older generation has to be considered | 13:19 | ||
theorbtwo | Is it just me, or is there a sharp increase in test fails? | ||
nothingmuch | theorbtwo: i thought there was a decrease | 13:20 | |
leo__: is a generational lookup equivelent (in terms of side effect) to a full seeep? | 13:24 | ||
swwp | |||
sweep | |||
damn | |||
leo__ | if e.g. the ParrotIO object is found in the youngest generation, only this generation is looked at | 13:26 | |
nothingmuch is a bit slow | |||
could this means that a now unreferred object exists in an older generation? | |||
like, if i explicitly 'undef' a global? | |||
or is that special case treated? | 13:27 | ||
leo__ | it depends. If someone was stuffing the IO object into an array, the generation of this arya has to be swept | ||
that cab of course get expensive | |||
nothingmuch | what my idea sort of tries to handle is to allow a reference counting like approach for finding data | 13:29 | |
but with mark & sweep safety/correctness | |||
by doing some cross indexing when objects refer to each other | |||
leo__ | ref counint is nasty, especially with shared objects | 13:30 | |
luqui | nothingmuch: re gc_zones, your system seems to incur too much overhead for what we're looking at (people complain that java programs are memory hungry, we'd rather not say the same) | 13:32 | |
but it does bring up an interesting idea | |||
nothingmuch | luqui: ofcourse, it's a question of balance | 13:33 | |
i think the overhead is big | |||
luqui | could we refcount on topological closures of objects | ||
if we could, then we could handle circular references | |||
nothingmuch | but if you optimize your zone tree like btrees are | 13:34 | |
with wide nodes (wide zones), in theory it could work | |||
explain please =) | |||
luqui | do you know what a graph closure is? | ||
nothingmuch | no clue | ||
nothingmuch only knows what 'edge' and 'dot' means | |||
luqui | it's the set of nodes, starting with one node, that that node "eventually" points to | ||
nothingmuch | oh, node is the term for dot =) | 13:35 | |
luqui | hehe | ||
theorbtwo | Yup. | ||
nothingmuch | how do you generate this closure? | ||
luqui | using the closure algorithm | ||
Limbic_Region | leo does IRC now? | ||
luqui | basically a simple breadth-first search | ||
Limbic_Region | welcome ;-) | ||
luqui | for instance, the LR parser makes closures of productions in order to figure out what states it needs | 13:36 | |
what if the GC objects were object closures? | |||
I'll have to think about this one a bit | |||
it might be really cool | |||
(and will probably be too expensive to do in practicality) | |||
nothingmuch | luqui: i think it's sort of the same | 13:37 | |
luqui | yeah | ||
gee, I wonder why I thought of it right after reading your description :-p | 13:38 | ||
Juerd | Speaking of closures, can join '', 1..5 => map { foo() } be written as { foo() } x 5? | ||
nothingmuch | =P | ||
luqui | Juerd: it's an interesting proposition | ||
but then we'd probably have to do (the much more commonly wanted) { foo() } xx 5 | 13:39 | ||
Juerd | Both. | ||
luqui | which would prohibit us from duplicating a closure that way | ||
but it might be a worthwhile trade-off | |||
Juerd | Why would you want 5 times the same closure? | ||
luqui | why would you want 5 times the same string? | ||
nothingmuch | luqui: what i think i tried to do, if i understand the closure idea, is to attempt to optimize some of them away | ||
Juerd | NOT SAME! :) | ||
That's the important thing. | |||
It should call foo() 5 times, as the map does | 13:40 | ||
luqui | I'm just saying that (list)x5 was in Perl 5 for a reason | ||
Juerd | Yes, I realise that | ||
nothingmuch | and use the statistics collected to create an approximate representation of them, while the references are built up | ||
Juerd | But I can't think of a reason for needing duplicate closures yet :) | ||
luqui | well, closures are objects too | ||
nothingmuch | Juerd: to trick something that thinks it's taking distinct closures | ||
Juerd | And if you need them, the "sub" keyword can probably disambiguate | 13:41 | |
luqui | I think if we do it purely on the syntactic level I think it should be okay | ||
my $foo = { bar() }; $foo xx 5; # five of the same closure | |||
Juerd | Or even double { } | ||
luqui | { bar() } xx 5; # call bar() five times | ||
Juerd | { { foo() } } xx 5; # 5 closures | ||
sub { foo() } xx 5; # 5 closures | |||
nothingmuch | how do you tell apart a closure with a closure | ||
luqui | Juerd: those would all be distinct (in your earlier example) | 13:42 | |
Juerd | { foo() } xx 5; # whatever the 5 foos returned | ||
nothingmuch | { { } } from { } | ||
at the user level? | |||
Juerd | nothingmuch: What is 'user level'? | ||
nothingmuch | using perl6 | ||
how could i know if closure x is { { } } | |||
and closure y is { } | |||
where is the difference? only at the syntax level? | |||
Juerd | You don't have to | ||
nothingmuch | if so, then it isn't reusable | ||
luqui | I think he's saying that if you execute the closure, you get another closure back | ||
Juerd | { { } } benefits from executing the outer closure, returning the inner. | ||
gaal | how do i declare a class constant? our $F_STORABLE is constant = 1; ? | ||
nothingmuch | if there is a difference, then i think it leads to inconsistency | 13:43 | |
ah | |||
ok | |||
i get it now | |||
luqui | but the closures you get back would all be distinct | ||
so that's a problem | |||
Juerd | (Note that I haven't read on hash/sub choices yet) | ||
luqui: Good point. | |||
nothingmuch | so basically what you want is for 'x' to interpolate /after/ it's repeated? | ||
luqui | So like I said, it's probably okay if we do it on the syntax level rather then the semantic level | ||
nothingmuch | i disagree with that | 13:44 | |
autrijus | leo_: greetings! | ||
luqui | nothingmuch: por que? | ||
autrijus | I'm now safely back to home. | ||
nothingmuch | it's not p6ish in the consistency approach | ||
it's a special case | |||
"why was this called 5 times?" | |||
luqui | Perl 6 has syntactic special cases | ||
Juerd | nothingmuch: No, I want a better syntax for the extremely often used map 1..x where 1..x is just to make it loop x times | ||
luqui | why does #line give me metainformation? | ||
nothingmuch | "well, if you read chapter 54.3.2.5 you would have seen that" | ||
luqui: but we want to minimize them, right? | |||
Juerd | nothingmuch: See ~~ - it has syntactic matches. | ||
luqui | yeah, that's true | 13:45 | |
Juerd | nothingmuch: These you can't pass as values, for example | ||
But they are useful. | |||
nothingmuch | isn't that better written as: | ||
~({ foo () } xx 5)? | |||
instead of { foo() } x 5? or { { foo () } } x 5? | 13:46 | ||
luqui | but that's the feature we're discussing | ||
whether that closure would execute | |||
or whether you'd just be trying to stringify the closure | |||
nothingmuch | i think the more general the case, the more desirable it is | ||
luqui | ? | ||
nothingmuch | you could express { foo() } x 5 in Juerd's way | ||
even though it's typical | |||
with perl6 semantics that have no special case | 13:47 | ||
Juerd | nothingmuch: I think the more practical use something has, the more desirable it is | ||
nothingmuch | at around 3 chars more | ||
Juerd: but then you block out a certain feature | |||
or require adding a special case | |||
Juerd | Perl stands for dwimmery more than for consistency. | ||
luqui | nothingmuch: your ~({foo()} xx 5) is not standard perl 6 | ||
and would be a special case | |||
nothingmuch | why is that a special case? | ||
luqui | because currently that would not execute the closure | ||
Juerd | nothingmuch: No, the other feature would require syntactic disambiguation, for example by adding a "sub" keyword. | ||
nothingmuch | Juerd: but reading that for the first time | 13:48 | |
without having read about the special case | |||
does not make any sense | |||
it's like pascal | |||
luqui | Juerd: I think adding a "sub" keyword is the wrong way to disambiguate, but I agree with you in principle | ||
I think it naturally falls out if we allow {foo()} xx 5 | 13:49 | ||
nothingmuch | inconsistencies with pascal that really hinder readability: | ||
in declaration you have 1 .. 5, in loops you have 1 TO 5 | |||
begin ... end; are symmetric, except where they aren't | |||
some block openings are two lines, others are one line, or else they don't match up well | |||
Juerd | This isn't pascal | ||
nothingmuch | var is used too often | ||
to declare the property of a name | |||
and it's behavior | 13:50 | ||
and a section where names are declared | |||
luqui | okay, I think you should go to #pascalrant | ||
:-) | |||
nothingmuch | these are things that perl sometimes exhibits | ||
though less obviously | |||
which is even more dangerous | |||
luqui | then give us perl examples | ||
nothingmuch | throwing a 'sub' to disambiguate is a bit yucky | ||
Juerd | It's a problem if the result is hard to spot | ||
nothingmuch | luqui: using parens and stuff to listify in p5 | 13:51 | |
() = .... | |||
() x 5 in list context | |||
Juerd | nothingmuch: I agree that 'sub' is probably not the right way | ||
nothingmuch | etc | ||
Juerd | It's the best thing I can think of rigth now. | ||
right | |||
nothingmuch | i really want this stuff to not exist in p6 | ||
Juerd | We're not discussing P5 either | ||
nothingmuch | so the language will be less 'well, you should have used this magic construct' | ||
Juerd | Without magic constructs, we end up with python, nothingmuch | 13:52 | |
That's not Perl. | |||
nothingmuch | the power of hebrew, for example, is that you can construct logical parts of the language | ||
with special cases that are obvious | |||
and find out how something will look like | |||
and understand something we haven't met yet | |||
luqui | and "obvious" is the subjective word here | ||
nothingmuch | by means of a thought process | ||
luqui | most everything in perl 6 is obvious to larry | ||
nothingmuch | and not only by looking at a reference doc | ||
Juerd | Maybe we can introduce X and XX | ||
nothingmuch | again, my point is still about arbitrary use of a keyword with a /lot/ of meaning and cargo, to disambiguate a special case | 13:53 | |
without some logical binding | |||
Juerd | Where @foo xx 5 is 5 times \@foo, and @foo XX 5 is foo's elements, 5 times | ||
and { foo() } xx 5 is 5 times that closure, and @foo XX 5 is 5 different return values of foo() | 13:54 | ||
nothingmuch | perhaps for consistency it could be made *x | ||
i don't see myself, as a newbie saying "oh, since the sub keyword is used, then it doesn't get executed till after it's repeated" | |||
Juerd: i like that much better | |||
luqui | I p6l'd the discussion | ||
nothingmuch | * has a strong link to flattenning vs. referencing | ||
Juerd | nothingmuch: I understand the problem you have with the syntax - but please note that I'm more suggesting a feature with some syntax to demonstrate, than I'm actually proposing a syntax change | ||
nothingmuch | Juerd: ok, sorry if i was a bit too nasty | 13:55 | |
luqui | Juerd: then you might want to reply and elaborate to my p6l message | ||
if you have any other ideas, that is | |||
rgs | are there q// strings in perl 6 ? besides qq// | 14:00 | |
luqui | yeah | ||
rgs | not implemented yet, then | ||
luqui | yeah they are | 14:01 | |
(I did that... unless they're broken) | |||
leo_ | I'm at #parrot now - bye | ||
luqui | I may have only done qq | ||
nothingmuch | leo_: #parrot is not on this network, btw | ||
so are you on freenode at all? | |||
luqui | yeah, looks like I only did qq | ||
Juerd | leo_: With a good IRC client (I suggest irssi), you can be connected to multiple servers and be in multiple channels at the same time. | ||
leo_ | on freenode and pobox - yes | ||
thanks I'm using irssi | 14:02 | ||
Juerd | Ah, you use irssi | ||
Then you can use /connect instead of /server | |||
And it'll *add* a connection, rather than replace it. | |||
leo_ | yep | ||
Juerd | Every window gets a number, meta+digit switches between the first 10 windows | ||
luqui | (something tells me he knows how to use irssi) | 14:03 | |
Juerd | (meta being alt or escape on a pc terminal) | ||
luqui: That'd be weird though, given that it's his first time on irc :) | |||
scw | qw// is in pugs, too | ||
lumi | Possibly spider sense, or tfm? | 14:04 | |
luqui | with closure interpolation and all | ||
scw | if you have more than 10 windows, (quite usual, isn't it :p), meta-q meta-w ... is used | 14:05 | |
luqui | and more than 100 is ^Zrm -rf / | 14:06 | |
Juerd | luqui: replied | ||
The string x is more important in this respect, I think | |||
Because join+map communicates the wrong thing | |||
luqui | agreed | 14:08 | |
well, now it's in larry's brain | |||
Juerd | heh | ||
luqui | (he's been holding forth, so maybe he'll have some insight about it) | ||
any('a'..'z')x5, eh? | 14:10 | ||
well, I think map { $_.pick } any('a'..'z')x5 would work | |||
nothingmuch | damnit, someone is spamming as me | ||
luqui | and now it's communicating the right thing | ||
s/x/xx/ | 14:11 | ||
gaal | i just ci'ed a small patch to util/perl6.vim to support $:x and %.y, luqui and all please see if this makes sense to you. | 14:40 | |
beh, $work. bbiab | 14:42 | ||
Juerd | I think I've just gone mad. | 14:44 | |
(See p6l) | |||
afk # typing hurts | 14:45 | ||
autrijus | gaal++ | 14:46 | |
autrijus is still brainracing with leo on #parrot. | |||
Alias_ | OH DEAR GOD NO!!! | ||
More operator modifiers! :( | |||
My brain should not have to hurt in order to add numbers to a list | 14:47 | ||
jabbot | pugs - 1277 - Treat $:x and $:.y as variables | ||
integral | hmm, I see the FiniteMap in Config.hs isn't exposed to perl6 code at the moment, would it be inappropiate to expose it as %*CONFIG? | ||
autrijus | it needs to be exposed separately as $*FOO | ||
I mean $?FOO | 14:48 | ||
since it's determined at compile time | |||
but please do | |||
integral | ok, I'll have a go at hacking that. Corion was asking for pugs version info to be accessible from perl6 you see | ||
autrijus | danke | ||
Alias_ sobs | 14:49 | ||
rgs | ultimately, this would be useful to know whether some code runs under pugs or another interpreter | ||
Alias_ | On of the things I really like about perl is that I'm so much less likely to get RSI than when writing Java... | 14:50 | |
Juerd | Alias_: The upside is that you can just combine operators instead of remember many | ||
Alias_ | Perl 6 is going to change all that | ||
PerlJam | Alias_: how so? | ||
Juerd | Yes, there are many bitwise operators | ||
But it's really just a very simple table of things you can combine | |||
Alias_: Haven't you seen how much typing ~- and [-] save you? | 14:51 | ||
Alias_ | PerlJam: Because the contortions I'm going to need to go into in order to do anything... | ||
Juerd | Adding features doesn't give you RSI - using them when another solution is better does | ||
Alias_ | PerlJam: $#$%#$...%%#$name = 'Alias'; | ||
PerlJam | Alias_: I don't see how it will be any different in perl6 as compared with perl5 | ||
Juerd | Alias_: That's $ and a comment ;) | ||
In fact, it stays meaningful syntax longer in Perl 5 than in Perl 6 | 14:52 | ||
rgs | I'm trying to add q/.../ to pugs | ||
Alias_ | PerlJam: !@#%@#!%#%!#lastname = $#$%#$...%#$name ~~~~~~~ 1; # <--- magical do what I mean operator | ||
Juerd | Alias_: No, that's called >>dwim<< :) | ||
stevan | Alias_: why is the double sigil so distasteful to you? | ||
Alias_ | stevan: Because something shouldn't have to matter... | ||
PerlJam | Alias_: for instance, perl6 cleans up perl's "cognitive space" by being more verbose in some areas, but you can easily alias the verbosity if RSI becomes a problem ;-) | ||
Juerd | I like secondary sigils, but think they are used too much. | 14:53 | |
Alias_ | It's forcing people to learn things way too early | ||
PerlJam | Alias_: I disagree. | ||
stevan | Juerd: but (at least IMO) they seem to be used very consistently | ||
Juerd | For example, I'd like to just have one object with lots of methods instead of many $*VARIABLES and $?VARIABLES | ||
stevan: That is true. | |||
PerlJam | Larry has jumped through hoops to *not* force people to learn too much too quickly. | ||
Juerd | stevan: If $*PID is an alias for %*<PID>, it's fine by me, but I'd like to be able to dump these things all at once. | 14:54 | |
afk | |||
stevan | Alias_: it seems to me that they follow very basic and consistent rules (but I have not read all there is too read on them, so I may be wrong) | ||
Limbic_Region | or use a slice to get just the ones I want (all at once) | ||
Alias_ | stevan: But that rule involves learning | ||
There are 5 different twigils yes? | |||
stevan | Alias_: whats wrong with learning :) | ||
PerlJam | Alias_: give or take. | ||
Alias_ | stevan: Because learning is _hard_, and it's a bad thing to increase the learning curve | 14:55 | |
Juerd | PerlJam: Heh, both given and take are new keywords :) | ||
stevan | Alias_: perl6 will involve learning no matter what | ||
PerlJam | Juerd: Lots of opportunities to pun in perl6 ;) | ||
Juerd | Alias_: Then why are we even creating Perl 6, and not just using Ruby instead? | ||
stevan | Alias_: it seems to me that the learning curve just has some steep plateaus in it, thats all | ||
Juerd | PerlJam: take my $wife = 'drunk'; | ||
stevan | Alias_: I think they will get smoother over time | 14:56 | |
Alias_ | I hope so | ||
stevan | Alias_: its still early | ||
metaperl | lol @ juerd "why are we even creating Perl 6, and not just using Ruby instead?" | ||
Limbic_Region | Alias_ - I am not sure I agree with your original sentiment | ||
Alias_ | I'd rather not have for someone to learn about the zillion execution phases in order to just get access to the PID | ||
Limbic_Region | given that I learned p5 less than 3 years ago, it is still fresh in my memory | ||
Juerd | Ruby is Perlishness without learning curve | ||
And it is rather boring. | |||
PerlJam | I haven't decided if people who know perl5 will have an easier or harder time with perl6. I hope it's the former, but there may be too many subtle differences. | ||
stevan | Alias_: thats what Ponie is for :) | 14:57 | |
Juerd | It does have minus for arrays though :) | ||
Limbic_Region | I was able to accomplish what I wanted to do (which was beginner stuff) with only a few hours of learning | ||
I very much expect p6 to be the same way for most | |||
metaperl | Perl6 is going to lose it's human feel. | ||
stevan | PerlJam: I think people who know perl5 AND some other langauges (java, lisp, etc) will find it easier | ||
Juerd | Alias_: Have you ever needed to learn the hooks tied to %ENV, or even that %ENV is a hash, in order to use $ENV{PATH}? | ||
You see one thing and copy it | |||
And when you have used many similar things, a pattern begins to form in yourmind | 14:58 | ||
Limbic_Region | on the other hand - once you get past the accomplishing 90% of the tasks to the remaining 10% - you could spend a lifetime mastering it ;-) | ||
Juerd | And then you have learned rules you can apply to more things. | ||
Alias_ | Juerd: "It's a magical HASH" | ||
Juerd | Alias_: But you don't have to know that in order to use it. | ||
integral | and from there people are copying perl5 like "&func(...)", and they then wonder why "&un('string')" doesn't work | ||
Juerd | Alias_: In the most basic form. | ||
Alias_ | Juerd: But now we need to know that it's a compile time variable? | ||
Juerd | A bash scripter who learns Perl first tries $PATH | ||
And then asks why that doesn't work. He gets told $ENV{PATH} | 14:59 | ||
PerlJam | why does it suddenly sound like everyone is saying that perl6 will be better for cargo cult programming than perl5? ;) | ||
Juerd | At that point, he may not already notice that all environment variables are in that hash. After all, bash makes local and environment variables look exactly the same | ||
Only after having seen another $ENV{HOME} like variable, the pattern is clearly visible | |||
Without reading any manual | |||
metaperl | Larry Wall said: "Perl was designed to grow in between shell and C" --- Perl6 is clearly not in line with that philosophy | 15:00 | |
Juerd | Alias_: No, and for that I agree secondary sigils are a bad thing. | ||
Alias_ | But now it's %*ENV? | ||
luqui | metaperl: Perl 6 is designed to grow in between Perl 5 and infinity (and beyond) | ||
Juerd | * Because it's special. I don't like the ? secondary sigil and think it should all be just * | ||
Alias_ | %?ENV? | ||
Juerd | $*PID, $*SUB, $*OS | ||
luqui | Yeah, now it's %*ENV, which can usually be abreviated %ENV | ||
Juerd | &*SUB that is | ||
eh | 15:01 | ||
&?SUB | |||
luqui | Juerd: the $? stuff is always compile time resolved | ||
Alias_ | Wait... so if I leave off the twigil, it will just do what I mean? | ||
rgs | guys, I've an implementation of q/.../ and '...' that works ; should I commit ? | ||
PerlJam | Alias_: yes! | ||
Juerd | luqui: Great, but as alias said: why does the programmer have to care about that? | ||
luqui | Alias_: in *'s case | ||
rgs | and should I remove the old '...' handling code | ||
Alias_ | what about in other cases | ||
stevan | rgs: does it past the quoting tests? | ||
luqui | Juerd: dunno, so he doesn't say &?SUB := sub { ... } | ||
rgs | stevan: it solves single_quoted_strings.t | ||
stevan | rgs: thats good | 15:02 | |
luqui | more like, $? stuff represents the environment the program was compiled in | ||
Juerd | luqui: That can be an error regardless of the secondary sigil. | ||
PerlJam | Alias_: In other cases the twigil means something that you can't get any other way. | ||
luqui | and $* stuff represents the environment the program is running in | ||
Alias_ | luqui: Who cares? Why force it in people's faces? | ||
PerlJam | luqui: and $?PID will do what exactly? ;) | ||
luqui | and that's a difference the programmer can care about | ||
PerlJam: $?PID will do "undefined variable" | |||
Alias_ | luqui: "can" or "must" | ||
Juerd | Can care about and then look up in documentation | 15:03 | |
integral | why is $* necessary? Can't you just replace $?PID with BEGIN { $*PID } ? | ||
s/\*/?/ | |||
Juerd | There's no specific reason these things need to be reflected in code | ||
luqui | $?PID doesn't mean anything! | ||
Juerd | They have nothing to do with the code | ||
They have nothing to do with the program you're writing | |||
luqui | what about &?SUB? | ||
PerlJam | integral: $?FOO is compile-time, $*FOO is run-time. You don't see a need to differentiate? | ||
Juerd | Where the PID comes from is utterly irrelevant, as long as you get the PID. | ||
PerlJam: Is there any FOO that exists in both then? | |||
integral | PerlJam: not when the former can be obtained by adding a BEGNI{} block | 15:04 | |
luqui | okay, forget about environment stuff. we might encapsulate those in objects somehow... | ||
Juerd | luqui: I think the entire .* and .? thing needs to be objects | ||
Alias_ | If you _really_ care which it is, and that is a rare case, then you get a special method in a special package | ||
luqui | Juerd: so tell me about &?SUB | ||
Alias_ | Scalar::Util::is_compile_time_variable( $*FOO ) | ||
schoch | arn't objects sometimes slower? | 15:05 | |
Juerd | luqui: $PROCESS.PID, %$PROCESS.ENV, &$PROGRAM.SUB | ||
Alias_ | or something of that nature | ||
Juerd | luqui: $CONFIG.OS | ||
PerlJam | integral: Hmm. I think I agree with you. | ||
luqui | schoch: quiet. we're language designers. :-) | ||
PerlJam | schoch: yeah, and sometimes their *faster* too | ||
integral | PerlJam: it seems a bit more perl5ish to just use an existing feature than to invent something specific | ||
luqui | I definitely agree with $CONFIG.OS, but I think $? is still necessary to reflect the lexical environment | ||
Limbic_Region | schock - p5 objects are almost always slower because of the way they were shoe-horned in | ||
Juerd | luqui: That is, if we really need to note where things come from | ||
integral | &?SUB could be BEGIN { $*compiler.get_current_subroutine } | ||
Juerd | luqui: For all I care, $PID, %ENV, &SUB, $OS are more than good enough. | 15:06 | |
Limbic_Region | they are taking more of a central role in p6 | ||
schoch | i'm a java user, one of the things I liked about perl is being able to chose an object model when i need one, or not | ||
Juerd | Add a secondary sigil to avoid clashing with your own variables | ||
luqui | integral: ahh yes, and it was introduced to make anonymous recursion easy. there that goes. | ||
Juerd | $*PID, %*ENV, &*SUB, $*OS | ||
luqui | Juerd: and %MY? | ||
PerlJam | integral: Well, I'd expect some sort of hook to grab the entire compilation environment in one go though. | ||
Juerd | luqui: That's ::MY | ||
Isn't it? | |||
luqui | no, it's MY:: | ||
Limbic_Region | schock - p6 should mostly still let you do that | ||
Juerd | luqui: That's ::MY:: :) | ||
luqui | but %MY is a namespace hash | ||
integral | PerlJam: (NEGIB { $*compiler}).get_current_subrtouine ;-) | ||
Juerd | luqui: :: is the namespace sigil too | ||
luqui | (maybe it's %MY::) | 15:07 | |
Juerd | luqui: Then that can be %MY or %*MY | ||
luqui | Juerd: er, symbol table | ||
Juerd | But I really, really don't care where it comes from. | ||
luqui | %*MY doesn't make sense, because it's not global | ||
schoch | i never liked the BEGIN{} either though | ||
luqui | schoch: what would you prefer? | ||
PerlJam | schoch: why not? I've always thought BEGIN was one of the things perl did right. | ||
Juerd | luqui: Why the heck care? In Perl, scope isn't visible in variable names. Type is. | ||
schoch | not sure but it behaved oddly with some modules | ||
PerlJam | schoch: Though my eyes tend to glaze over when you talk about INIT and CHECK subs ;) | 15:08 | |
luqui | Juerd: and scope. $^ is a scoper. $* is a scoper (but you're arguing it) | ||
$. is a scoper | |||
Juerd | luqui: Declaration defines scope, not the sigil. In Ruby, sigils are for scope, in Perl, they're not. This shouldn't be any different for special variables. | ||
PerlJam | schoch: BEGIN has never behaved oddly. It's always quite predictable | ||
Juerd | $.foo is just a lexical declaration | ||
luqui | Juerd: then what are secondary sigils for, if not scope? | ||
schoch | not with par | ||
Juerd | It happens to be an alias for the foo attribute of the current invocant | ||
schoch | i don't rememeber the details... | ||
Juerd | But that's not a scoping issue. | 15:09 | |
Alias_ | I like $.foo | ||
schoch goes back to lerkin | |||
Juerd | I like it too. | ||
luqui | Juerd: so what do secondary sigils stand for? | ||
Alias_ | It's special in a predictable way | ||
luqui | Juerd: what does even one secondary sigil stand for? | ||
Juerd | luqui: When things are defined, where they come from, and certainly not scope... | ||
luqui | Juerd: example | 15:10 | |
Juerd | $*PID, * indicating that it comes from the system, as with %*ENV | ||
luqui | to me, the secondary sigils represent those scopes that aren't declared. | ||
Juerd | $?OS, indicating it came from the compiler | ||
&?SUB, etc | |||
luqui | the * sigil means simply "global" | ||
nothing more | |||
Juerd | Exactly how global is %*ENV when you've made it local, which should be possible in Perl 6? | 15:11 | |
PerlJam | luqui: well, * is runtime global, and ? is compile-time global n'est pas? | ||
autrijus | temp %*ENV | ||
luqui | Juerd: you know how temporization works better than to ask that, I think | ||
Juerd | Eh, ignore that. | ||
luqui | PerlJam: ? is compile-time lexical | ||
Juerd | luqui: Yes, a stupid question it was. | ||
PerlJam | luqui: er, right. | ||
Juerd | luqui: Why are we indicating scope? | 15:12 | |
luqui | because we don't want to declare $^a | ||
Juerd | And why can't secondary sigils just mean they're *special*? | ||
luqui | well, they could | ||
Juerd | And have only three | ||
* for special | |||
luqui | but so far all the specials indicate types of scope | ||
Juerd | . for aliased to public attribute | ||
: for aliased to private attribute | |||
luqui | (sometimes odd ones, like $.) | ||
PerlJam | Juerd: and ^ ? | 15:13 | |
Juerd | OR be consistent, and remove our/my | ||
And use secondary sigils for that. | |||
luqui | Juerd: and state | ||
Juerd | PerlJam: I don't know that one. What does it currently do? | ||
luqui: Yes, and state. | |||
luqui | sort { $^a <=> $^b } | ||
Juerd | Oh, right | ||
PerlJam | Juerd: implicit sub parameter | ||
Juerd | That's a lexical thing | ||
luqui | it's implicitly declared | ||
Juerd | They're special in that they're implicitly declared and they're actually parameters too | 15:14 | |
luqui | Juerd: well, I don't know the deeper reasons... | ||
Juerd | Like with $. and $:, they're aliased to other values. | ||
luqui | I've given a good argument, I think, but you might just have to ask larry for this one :-) | ||
I know I like it | |||
Juerd | The problem with ., : and ^ is that people think they indicate scope. | ||
They do not - the scope is lexical | 15:15 | ||
However, the variables are bound/aliased | |||
luqui | well, . isn't exactly lexical | ||
Juerd | It is too. | ||
$.foo is one alias for many variables. | |||
luqui | hmmm... I guess since method Foo::bar () is outlawed | ||
You could think of it that way | 15:16 | ||
Juerd | But the scope of the variable is defined entirely outside the class | ||
luqui | Or you could think of it as "object scope", which is a weird kind of dynamic scope | ||
Juerd | The scope is determined by construction and destruction | ||
Not by anything else | |||
Just like how our creates a LEXICAL alias for a GLOBAL variable | 15:17 | ||
jabbot | pugs - 1278 - * Implement q/.../ string literals | ||
Juerd | The scope is determined by that the variable is never destroyed except at the end | ||
luqui | Juerd: ok. there are a lot of ways to think about abstract programming language concepts. | ||
Juerd | Not by where the variable is declared. | ||
It's really important to separate variables from their names | 15:18 | ||
$foo is not a variable, it's just its name | |||
luqui | that depends on how you're defining variable | ||
Juerd | Well, explain to me what $foo := $bar does if $foo is anything other than a name. | ||
rgs | woot. | ||
Juerd | It binds the name $foo to the variable that is also called $bar | ||
It's the same variable, though | |||
Variables don't exist at syntax level | 15:19 | ||
We call these names "variables" in every day English, because that makes discussing things a whole lot easier | |||
luqui | take: $foo is a container, as is $bar, for a thing that holds values. := takes the thing that holds values in $bar and puts it in $foo. | ||
Juerd | No, container == variable | 15:20 | |
Two containers cannot both contain the same value | |||
(Note: same isn't the same as equal) | |||
luqui | Juerd: not always. you're getting into semantics here. | ||
Juerd | Think of real life containers | ||
PerlJam | Juerd: sure they can! Superpositional containers :-) | ||
Juerd | You cannot put the same apple in both | ||
luqui | And I think you're beginning to define variable differently from what we think when we say "varaible" | ||
and perl is designed to coincide with how we think | |||
Juerd | luqui: When we say variable, we usually mean mutable container. | ||
schoch | how do references work in this context? | 15:21 | |
Juerd | schoch: A reference is a VALUE (that lives in a single container, that in turn can have any number of names) that refers to any single container | ||
Possibly its own container. | |||
(Circular-reference-in-one) | |||
Names, containers and values are the three things a programmer/programming language deals with | 15:22 | ||
luqui | Juerd: think about what my proposals do. They take the existing language, rip out its guts and replace them with new ways to think about it without changing the syntax or semantics (or if so, in a very slight way). | ||
Juerd | Names exist at syntax level | ||
luqui | There's more than one way to think about thing. | ||
s | |||
Juerd | They're how we, programmers, address variables | ||
Containers are locations in memory. It's how the computer accesses the values | |||
luqui | and language design is about finding the right way to think about things | ||
and containers are certainly more than locations in memory for a high level language | 15:23 | ||
Juerd | And the values are the actual values, and cannot be addressed by anything other than their container. A single scalar container has one value (disregarding dualvars), array or hash containers have many values, they being other containers) | ||
luqui | In other words, you're cramming a way of thinking down our throats (not to say that that's bad, there's a famous saying about that :-) | ||
When we're not even sure whether the way we're thinking is right. | 15:24 | ||
Juerd | Given how references and objects work in Perl, this is a good way of thinking | ||
luqui | And Larry is _incredibly_ good at thinking about _everything_ in many different ways. | ||
Juerd | This model can't easily be used with, for example, Python | ||
Where "same" and "equal" are the same thing. | |||
luqui | So, try and think how larry is thinking when he introduced $? before saying that it's the wrong way. | ||
Juerd | And values are immutable. | ||
luqui: I haven't said it's wrong. | 15:25 | ||
luqui | okay, s/saying that it's the wrong way/when disputing it/ | ||
Juerd | luqui: I think it's unnecessary to add another sigil | ||
luqui | so it's an aesthetic issue? | ||
Juerd | Certainly. | ||
luqui | because you could have said that up front :-) | ||
and then the discussion is much less deep and much easier to, er, think about | |||
Juerd | You don't have to be able to see what kind of variable a variable is | 15:26 | |
And if we're convinced that it is important, then we should ditch declarators like my and our, and replace that with sigils too. | |||
I don't understand, for example, why has is spelled has, if there's ALSO a secondary sigil | |||
luqui | and then what does the null sigil stand for? | ||
Juerd | luqui: Null sigil stands for subroutine call or namespace :) | 15:27 | |
luqui | Juerd: because larry "got tired of reading C++ code and wondering whether something was a member or a global" | ||
jabbot | pugs - 1279 - Remove dead code corresponding to the ol | ||
luqui | Juerd: sry, null secondary sigil | ||
null twigil | |||
Juerd | luqui: I know people who got tired of reading Perl code and wondering whether something was lexical or global. They have found a solution in Ruby. | ||
autrijus | trigil! quaril! | ||
Juerd | luqui: User defined non-special variables (that is: names for them), I hope | 15:28 | |
Possibly user defin-able. | |||
luqui | like lexicals? | ||
Juerd | Scope is irrelevant. | ||
luqui | so then what does my do? | ||
Juerd | my initializes a container and declares a name for it. | ||
luqui | it defines one of these user defined non-special variables | ||
how about that | |||
Juerd | The name is lexical | ||
The container is destroyed when there are no more names (references) left | 15:29 | ||
(Either at block end or a more convenient moment) | |||
But the container CAN live on long after the name is no longer attached to it | |||
luqui | so um, what does the null twigil, in the new system where we've ditched my and our, mean? | ||
Juerd | I wouldn't want to think of that system, because I like my and our, and not having twigils/sigils for scope. | 15:30 | |
luqui | i'm trying to get you to think about something | ||
Juerd | But it could indeed mean the variable is lexical. That's huffmanly correct, and the way Ruby does it. | ||
luqui | and it does | ||
currently, even | |||
Juerd | Huh? | 15:31 | |
luqui | which lexical scope it is attached to is defined by "my" or "our", though | ||
Juerd | No, a user defined (twigilless) name is global unless declared otherwise | ||
no strict; | |||
$foo = 1; # not lexical! | |||
autrijus | use autolexical; | ||
$foo = 1; # lexical! | |||
autrijus grins | |||
Juerd | Yes, but that isn't default behaviour | ||
luqui | Juerd: I'll say treat that as a special case | ||
autrijus | Juerd: yours isn't the default. | ||
the default it neither. | |||
luqui | the default is "$foo not declared" | 15:32 | |
autrijus | yup | ||
Juerd | luqui: The scope of every explicitly declared name is lexical. | ||
PerlJam | autrijus: not in my one-liner it's not. | ||
Juerd | our, has, my | ||
The declaration, and thus the name, is lexical | |||
luqui | PerlJam: yeah, that's the "no strict" or "use autoglobal" case | ||
autrijus | PerlJam: maybe oneliners uses autolexical :D | ||
j/k. | |||
Juerd | The variable itself (the *container*), is global, object-dynamic, or lexical | ||
autrijus: It depends on whether you see strict as the default, or no strict as something you can load. | 15:33 | ||
luqui | Juerd: exactly | ||
and both ways of thinking define, conflicting, ways to think about what a twigil means | |||
Juerd | Yes, but now both ways of thinking are in Perl at the same time | 15:34 | |
luqui | yep | ||
which is what perl is best at | |||
Juerd | We use twigils to indicate scope, but only for special variables, because for normal user-definable variables, we use declarative keywords. | ||
That's inconsistent in a way that IMO gains nothing | |||
It's not as if the distinction between $* and $? makes it any EASIER to use | 15:35 | ||
PerlJam | btw, perl6 was starting to solidify ever so slightly in my head ... until I started paying attention to you guys ;) | ||
luqui | other than the fact that we've defined a meaning for the null twigil | ||
Juerd | To the contrary: you have to know more. | ||
luqui | PerlJam: solution, don't listen. We're rambling theorists :-) | ||
PerlJam | luqui: sure, but I had a belief of what was "right" and you've both shaken my belief | 15:36 | |
luqui | Juerd: $* is global. you can't say $*SUB because that's not global. | ||
rgs | autrijus: my three last commits are heavily cargo-culted. beware. | ||
Juerd | luqui: I'd love to ramble some more, but I can't because my hands hurt beyond what pain killers can fix | ||
So I will have to stop now. | |||
Sorry. | |||
luqui | do you have carpel tunnel or something? | ||
Juerd | Not exactly that, but similar | ||
autrijus | luqui: yes. (to save Juerd's typing) | ||
luqui | hehe | ||
any suggestions about how to avoid that? (I use my hands for everything) | 15:37 | ||
supposing you can type it | |||
Juerd | luqui: www.kinesis-ergo.com | ||
luqui | (don't let me impose) | ||
jabbot | pugs - 1280 - Factorize code between qLiteral and qqLi | ||
nothingmuch | Juerd: get Jouke to make a vocal IRC for you, or something ;-) | ||
Juerd | luqui: www.dvorak.nl | ||
luqui | okay | ||
Juerd | luqui: www.wacom.com | ||
luqui: Combine these three and you'll postpone it a long time | |||
afk | |||
nothingmuch | these guys are pretty cheap: store.ergocube.com/ | ||
because they are pretty much nonprofit | 15:38 | ||
luqui | cheap enough not to have a website | ||
n/m typo | |||
autrijus | journaling, bbiab | ||
Juerd | nothingmuch: They sell a lot that has nothing to do with ergonomics, or makes things worse. They also have the good stuff. | ||
afk | |||
autrijus | rgs: if it passes tests, cargo code is just fine :) | ||
nothingmuch | luqui: also excercise a lot while you can | 15:39 | |
autrijus | rgs: and it looks ok. | ||
luqui | nothingmuch: uh oh | ||
nothingmuch | Juerd: i have not yet bought any ergo stuff | ||
rgs | ok, then. bbl & | ||
nothingmuch | luqui: stringed instruments have kept my writsts in excellent condition | ||
running in highschool ruined my knees | |||
luqui plays piano and violin | |||
nothingmuch | guitars & double bass | 15:40 | |
Juerd | luqui: Ouch! | ||
luqui | where "plays" is defined loosely for violin :-) | ||
PerlJam | luqui: ouch. you've tripled your chances for RSI at least | ||
Juerd | luqui: 1. violin 2. computer 3. piano - top three rsi causes! | ||
afk | |||
nothingmuch | but they must be played properly, ofcourse =) | ||
Juerd | (for real) | ||
luqui | I know. that's why I'm asking for suggestions. | ||
nothingmuch | piano - i don't know about | ||
PerlJam | luqui: rest your hands. | ||
nothingmuch | violin - i've heard that it is stressful to hold it like that | 15:41 | |
luqui | it is... which is one of the reasons I don't practice much | ||
it hurts to do it for very long | |||
nothingmuch | on the bass everything is very round, and you are never supposed to do anything stressful. If there is discomfort, then it will sound horrible, and also hurt you | ||
and if it won't sound horrible, it will limit your progress | |||
the thumbing position for example, is very dangerous in this respect | 15:42 | ||
PerlJam | luqui: For the computer and piano you can use alternate forms of input (chorded keyboards with big fat keys, foot pedals, etc). You're pretty much stuck with the violin though. | ||
nothingmuch | i've been having lots of trouble with it | ||
luqui | I imagine the same for violin.... at first piano was stressful, but now I think it relaxes my hands | ||
nothingmuch | but my teacher never ever ever lets me go the cheap way | ||
i could just press harder, but that would ruin my thumb in no time, especially with my mother's genes controlling my joints | 15:43 | ||
PerlJam | luqui: you could always redesign the violin. Make an instrument with the same tonal qualities but less hand pain :) | ||
luqui | PerlJam: I'd love that :-) | ||
play it "topwise" | |||
Juerd | re | 15:44 | |
nothingmuch | PerlJam: that's what they've been doing for a long while, y'know ;-) | ||
was it paganini who ruined everything by making people stick it in their neck? | |||
luqui | when was paganini? | ||
Juerd | luqui: For any keyboard, make sure its keys are just heavy enough for your hands, and no key feels much different than the others. Make sure the feedback is good, both in feeling and hearing | ||
PerlJam | nothingmuch: "they" perhaps aren't as smart or creative as luqui (or other perl people for that matter ;) | ||
nothingmuch | i'm not sure, really | ||
luqui | 1782-1840 | 15:45 | |
Juerd | luqui: Church organists get rsi more quickly because of the delay there is between hitting the key and hearing the sound. | ||
luqui | I know beethoven stuck it in his neck | ||
Juerd | That's really bad feedback. | ||
luqui | huh, why does feedback make a difference? | ||
nothingmuch | i wonder if oboe players have rsi in their mouth ;-) | ||
luqui | lol | 15:46 | |
metaperl | lol | ||
nothingmuch | luqui: you automatically do more than you need | ||
luqui used to play oboe... yes. | |||
Juerd | The better the feedback is, the more you know (subconsciously) what the right pressure is, so you don't use more force than necessary | ||
PerlJam | The only time I ever played violin it felt completly natural ... Except that I can't play, so it probably sounded completely horrible too :) | ||
rgs plays piano, trumpet and trombone | |||
Juerd | luqui: Avoid cherry keyboards (silent and "soft touch" feeling) at all cost. | ||
PerlJam | Juerd: those people need more faith! | ||
luqui | oboe is stressful on the mouth. | ||
nothingmuch wants to learn trumpet | |||
luqui | Juerd: yay, I hate those things! | ||
metaperl | I want to learn guitar/sitar | ||
nothingmuch | luqui: what about the delay? how big is it? to me it's legend more than anything | ||
metaperl: guitars are probably the most accessible instrument after piano | 15:47 | ||
Juerd | luqui: For this reason, I don't think touchstream keyboards are any good. I'd have to try one first to be sure, though. | ||
PerlJam | metaperl: me too, but my fingers are too fat. (also why the violin sounded horrible I'm sure) | ||
nothingmuch | technically and otherwise | ||
price, popularity, etc | |||
luqui | and even moreso than piano if you consider price | ||
nothingmuch | PerlJam: most people fingers aren't too fat for the guitar | ||
luqui | nothingmuch: delay.. for oboe? | ||
nothingmuch | that's what my dad told me | 15:48 | |
oops, ride is leaving | |||
luqui | hadn't played any instruments before, so I didn't really have anything to compare it to | ||
and didn't get good enough | |||
PerlJam | nothingmuch: well, I think I'd need a wider neck on the guitar but then my fingers wouldn't be long enough | ||
metaperl | PerlJam, never underestimate yourself | ||
Juerd | I want 6 fingers on each hand. | ||
metaperl | Django Reinhardt kept playing after only having 2 fingers | ||
luqui | playing Liszt will stretch your hands as much as you need :-) | 15:49 | |
Juerd | Or a shorter alphabet. | ||
luqui | so I imagine your fingers could grow to a bigger guitar | ||
Juerd: just six? | |||
Juerd | Yes - with more than six, the keyboard would really require redesign | 15:50 | |
luqui | I want eight, because then I could count in hexadecimal | ||
Juerd | And we all know how long it takes for people to create a sane keyboard. | ||
luqui | haha | ||
Juerd | Why count in hex if you can already count to 31 on a single hand, in binary? | ||
31 is almost twice as much as 16 :) | |||
luqui | you could count to 256 then | 15:51 | |
Juerd | Yep. | ||
luqui | (255) | ||
Juerd | +(@foo = 0..255) | ||
[0..255].elems | |||
luqui is possibly one of the fast finger-binary counters ever... it just takes him a while to read back what he's counted to | |||
Juerd | Probably +[0..255] | ||
metaperl | playing piano was great for my career in the video game Joust | 15:52 | |
luqui | Joust? | ||
rgs | trumpet trains you to binary-count with 3 fingers. | ||
metaperl | you needed fast fingers to get the bird to flutter up | ||
Juerd | We used binary in school to communicate test answers | ||
metaperl | yes, a video game from the 80s | ||
Juerd | 31 > 26, so enough for the alphabet | ||
And after 3 letters you have enough to fill in the rest | |||
And it really draws NO attention if you keep your fingers horizontal | 15:53 | ||
luqui | except for when you stop at 4 ;-) | 15:54 | |
Juerd | Yes, the D can be troublesome. | ||
luqui | eh, I never liked 4 anyway. It was the first of the dreaded composites. | ||
Juerd | We had an IRC channel we used with several people from my class | ||
On it, "132" meant a certain two fingers :) | 15:55 | ||
So we used 4 and 132, in decimal (shorter) | |||
Even the non-nerds copied that. | 15:56 | ||
Hm, alias didn't like it... :| | 15:57 | ||
jabbot | pugs - 1281 - more Pod::Stream::Parser; improvement of | ||
luqui | Off to school. bye | 16:00 | |
luqui & | |||
obra | a | 16:30 | |
Juerd | I hate my brain | 16:31 | |
My brain has decided that bitwise ops should be ?+ for OR, ?- for XOR and ?* for AND | |||
And that stringy and numeric should thus be ~?+, ~?-, ~?* | 16:32 | ||
And +?+, +?-, +?* | |||
It's a good thing I'm not inventing this language | |||
mugwump *hic* | 16:45 | ||
jabbot | pugs - 1283 - Move PhD logo to advocacy directory | 16:47 | |
pugs - 1282 - First part - the DOM tree structure | |||
Juerd | tnx.nl/3689VBOF # mad consistency. | 16:49 | |
gaal | integral, still aroung? | 16:55 | |
integral | gaal: yep | ||
gaal | i was afk and backlogging now i noticed oyu wanted to workon %CONFIG | 16:56 | |
didn't finish reading up yet, but before you do anything, | |||
there's a thread where larry explains his plans for it | |||
doesn't look decided | |||
~6 March on p6l i think | 16:57 | ||
or search these logs for config | |||
integral | oh, ok. I asked autrijus and he just said go ahead. I'm just exposing the FM in Config.hs as a hash | ||
gaal | just wanted to warn you so you don't work a lot for nothing - sorry if someone already | ||
ESCdd | |||
okay :) | |||
but be aware that this is specifically likely to change... | 16:58 | ||
i had these same toughts myself. | |||
integral | oh, I've no problem with my code being ripped out :-) It's to access some pugs specific conf data though, so it's a hack anyway | ||
elmex | hi | ||
gaal | my %conf = map { split /:/, $_, 2 } `pugs -V`; # j/k :) | 16:59 | |
Juerd | chomp. | 17:13 | |
gaal | true, but i was being silly. | ||
Juerd | Then so am I :) | ||
gaal | also, the current separator is ": " | ||
and there's a leading \t | 17:14 | ||
and there's a header line | |||
and there are some @INC entries too | 17:15 | ||
Juerd is going to try to take a long break | |||
As you can see on p6l, I'm having too many thoughts right now :) | |||
gaal | yeah, and outsilliying contests are tiring :) | ||
Juerd | hehe | ||
Now you're just being silly | |||
:) | |||
gaal bows | 17:16 | ||
Juerd | I'm quitting - you win :P | ||
(this time) | |||
gaal | what are "foes" on use.perl.org? | 17:17 | |
lumi | Like in /. I think, the opposite of friends | 17:18 | |
And freaks are the opposite of fans | |||
gaal | i don't do /. | ||
i have a feeling that outsillies me | |||
so like if friends are those who read you regularly, foes are people who regularly don't read you? | 17:19 | ||
crysflame | freaks are people who are friends of your foes, i think | ||
lumi | No, friends are people whose opinion you value | ||
And foes are the opposite | 17:20 | ||
Freaks are people whose foe you are | |||
crysflame | aha | ||
lumi | (That parses, honest!) | ||
crysflame | freak, foe, fan, fum | ||
gaal | and that information needs site suppose because...? | ||
lumi | Because you could give the people you value a bonus, so you'll see their writeups more | ||
And people who value your opinion could give the people whose opinion YOU value a bonus | 17:21 | ||
That's the theory, I think | |||
e2 makes more sense though | |||
Or not | |||
gaal | i like my feeds a little more deterministic than that :) | 17:22 | |
lumi | It's for comments, not for main entries, as a rule | ||
gaal | anyway, i didn't mean to go off topic for so long, lets take this off-channel | ||
elmex | hi | 17:40 | |
gaal | ho | ||
elmex | hmpf | 17:47 | |
how fast is pugs at the moment? | |||
cm | schnell genug! | 17:48 | |
elmex | lol | ||
cm: _how_ fast | 17:49 | ||
cm | schnell wie der wind, wie der wihihind.. | ||
elmex: 370 | |||
elmex | in comparsion to eg. perl5 | ||
cm | i've no idea, i'll stop trolling :p | ||
elmex | cm: cuteee ;) | ||
cm | =( | 17:50 | |
PerlJam | elmex: It is about as fast | 17:52 | |
(as perl5) | |||
elmex | PerlJam: with pugs compilin to parrot? or interpretion? | 17:53 | |
PerlJam | both. Slightly faster when compiled to parrot, slightly (a little more so though) interpretted | ||
But all in all, they are about the same speed | 17:54 | ||
elmex | hmm, wonder how fast it may be with a nicely jit'ed parrot | 17:55 | |
cm | if it chips like a parrot, it surely is a parrot ;o | 17:56 | |
elmex | ? | 17:57 | |
cm: cuteee ;) are you female? | |||
cm | o_0 | 17:58 | |
xerox | ōæ½xC2 | ||
Whoops, sorry. | |||
elmex | cm: c'mon | 17:59 | |
cm | elmex: hm? | 18:01 | |
xerox | elmax /whois cm | 18:02 | |
elmex | xerox: no sign for male gender | 18:04 | |
xerox | elmex: 1) who cares 2) the name isn't enough? | 18:08 | |
elmex | xerox: ;) | 18:12 | |
kungfuftr | lo all | 18:15 | |
Corion | BTW - NickServ pesters me - should I really register my nick ? | 18:19 | |
elmex | if you want to, yes ;) | ||
Steve_p | freenode.net/faq.shtml#nicksetup | 18:21 | |
stevan | autrijus: are you still awake? | 18:25 | |
kungfuftr | shit... another tsunami | 18:27 | |
Jouke | yes? sure? Last I heard on the news was that there might be a new tsunami, but that it wasn't sure yet | 18:31 | |
integral | see ##quake | ||
kungfuftr | news.bbc.co.uk has a live video feed | 18:32 | |
Jouke reads about 'tsunami warnings' on CNN and bbc.co.uk, but not an official tsunami report yet | 18:35 | ||
jabbot | pugs - 1284 - Shifting argument to subroutine fails | 18:37 | |
gaal | Corion, you there? | 18:42 | |
Limbic_Region | Corion is jaw jacking at PerlMonks about his bike - you want me to get his attention? | ||
Corion | I'm also here :) | 18:43 | |
gaal | hey :) just a note about the parsefails since i read logs from last night : | ||
Corion | (and I get an annoying beep whenever somebody mentions my name here :) I should switch that off) | ||
Limbic_Region | how's that for timing ;-) | ||
gaal | nm and i are at no disagreement. | ||
if you get away with todo_is_eval on a test that doesn't parse, great. | 18:44 | ||
Corion | gaal: Ah! I think I got away with that, yes :) | ||
gaal | if the parsefail is "hard", though, it's b0rk eval, even, and that's what you need the comment + warning note in the form of a failing test for. | ||
Corion | Win2k:r1284 (118/3242) | 18:45 | |
gaal | but since this is a kludge, we agree on a convention for marking these things. | ||
Corion | ... so we now have scripts that fail their tests again :) | ||
gaal | fails are ok | ||
Corion | gaal: Aaah. OK - I hope I stay away from the eval-borking tests :) | ||
gaal | no, evalb0rktitude is fun :) | ||
Corion | gaal: But somebody converted lots of fails to todo_ stuff lately :) | ||
gaal | i, however, have a chance to go home now, and therefore shall now take my leave of you, kind sirs. | 18:46 | |
Corion | Oooo - somebody must have fixed the warning that my code created yesterday - I'll have to look at how, so I learn :) | ||
Corion is already home :) | |||
gaal & svn blame is your friend | |||
kcwu | i fixed it, but i don't know why it fixed ;) | 18:48 | |
Corion | kcwu: Heh :-) | 18:49 | |
kcwu: Ah - but that's exactly the fix I imagined - you have to tell Haskell somewhere what types you expect it to use for the numbers | |||
kcwu: And you introduced Int as the type to use, so Haskell is happy now :) | |||
... now, BEGIN {...} blocks need to be made to work, I guess :) | 18:50 | ||
kcwu | why tell haskell that? i image haskell will deduce that it is number, and use (compare) them without problems | 18:53 | |
Corion | Does anyone know off-hand how Perl5 handles C<-l> ? Is it translated into Perl code, like C<-e> ? Especially if you use "perl -l script.pl" ... | ||
(if nobody knows, I'll go source diving :) ) | |||
kcwu | Corion: i am sure is it you want: perl -MO=Deparse -le 'print 1' | 18:54 | |
chip | Anybody remember whether Perl 6 /foo/ is more like Perl5's /foo/ or qr/foo/? | 18:55 | |
autrijus | chip: yes. | ||
Corion | kcwu: Yeah - I know what Deparse outputs, but I don't know if that is some special fudging of B::Deparse or if Perl really created that code :-) | ||
autrijus | (go not to autrijus for counsel...) | ||
chip | I can't remember whether e.g. C<$a of Str where { /^a/ }> is good Perl6 or not | ||
autrijus | chip: in value context it does the match. | ||
otherwise it is rx//. | 18:56 | ||
kungfuftr | hhhmmm... is there a simple way in perl6 of declaring many constants at once? | ||
chip | "value context"? That's not a context I know | ||
autrijus | chip: i.e. not in direct RHS of a binding or assignment. | ||
Corion | kcwu: But my plan is (currently) to translate C<-l> to C<-e "BEGIN{...}"> - but then I get to the problem of having both, a file AND a -e fragment. I could move the whole file-loading into Perl, of course :-)) | ||
autrijus | chip: it's specced in the synopsis, although I question its sanity a bit. | 18:57 | |
chip | I guess my cunning plan to avoid scanning the [AES] docs has been thwarted | ||
Corion | svn blame is really cool btw ! I should add something similar to my Javascript SubEthaEdit clone :-) | 18:58 | |
autrijus | Corion: wait, your *what*!? | ||
Corion: url! url! | 18:59 | ||
Corion | autrijus: zaphod.datenzoo.de - very early beta | ||
FireFox / Mozilla preferred, but it works in IE6 as well. Opera is dodgy | |||
autrijus | holy zaphod. | 19:00 | |
I can now sleep with the belief that there is hope in this world. :) | |||
autrijus waves & | |||
Corion | autrijus: VERY early beta | ||
Corion gave autrijus JS nightmares | |||
Corion watches the children at play | 19:04 | ||
(but some times, the children just time out :) ) | 19:05 | ||
kungfuftr | pugscode.org <<Overview Journal>> | pugs.kwiki.org | logged: xrl.us/e98m | FBSD_4.11:r1284(118/3242) win2k:r1284(118/3242) Linux:r1197(105/3116) MacOSX:r1197(105/3116) | 19:06 | |
Corion realizes just now that anybody can change the channel topic... | 19:07 | ||
so I don't have to report my Win2k test results but can update the topic myself! D'oh ! | 19:08 | ||
kungfuftr | yup | ||
there's some sort of DBI lite module somewhere, right? | 19:26 | ||
Corion | kungfuftr: Is there? There is DBD::SQLite, but I don't know of any Perl6 thing dbi-ish | 19:27 | |
kungfuftr | Corion: nah, i meant a lightweight version of DBI | 19:28 | |
kungfuftr has been looking at porting DBI::PurePerl, but it's a git | |||
Corion | kungfuftr: Not that I'm aware of - DBI is the only DB interface that Perl has (although I use `isql` :) ) | ||
kungfuftr: I was pondering to learn Haskell to implement some smallish SQL machine in it (it would rock to have a built-in SQL DB for Perl6 :) ) | 19:29 | ||
kungfuftr: But you could look at porting SQLite, together with DBI :-) | |||
kungfuftr | SQLite might be possible, but DBI is very very complex and uses a lot of perl5 specific things | 19:30 | |
Corion | kungfuftr: Ah - I would rather consider a reimplementation of the API, or at least connect, prepare, execute and fetch :-) | 19:31 | |
kungfuftr | DBI::PurePerl, is really DBI in disguise... it is used via an environment variable | 19:32 | |
Corion | kungfuftr: But I haven't looked at anything of the internals. Writing an SQL DB in Haskell should be "pretty easy", as Haskell can do parsers and lazy lists. It wouldn't be very efficient/performant, but bad performance is purely a hardware problem | ||
kungfuftr | ie: $ENV{PUREPERL} = 2; use DBI; # will use DBI::PurePerl instead of the XS based dbi | ||
i reckon porting of some more core modules like Symbol.pm etc would be required | 19:34 | ||
gaal | corion, you still at -l? | 19:38 | |
Corion | gaal: No - currently I'm hacking on a test to verify (multiple) -I switches (uppercase i, not lowercase L) | ||
gaal | perl.c:2756, more or less. :) | ||
Corion | gaal: But I plan moving back to -l tomorrow :) Oh - thanks for searching the stuff ! :) | ||
gaal | search? what search? :p | 19:39 | |
Corion | gaal++ # knows perl.c by rote | ||
Anyone got a good idea how to print out @INC (newline or \0 separated) without mentioning $_ ? pugs -e "print for @INC" doesn't compile for me | 19:40 | ||
(also, other shell metacharacters should be avoided, of course :) ) | |||
gaal | by heart, you mean -- and actually no, it just happened to be open in some screen window in the past few days :) | ||
@INC.perl.say | |||
Corion | gaal: Yes - I meant "By Heart" :) | ||
gaal: Ooooo ! Cool (except that I now have to parse that a bit more, but that's OK :) ) | 19:41 | ||
gaal | ./pugs -e 'map {say $_}, @INC' | 19:42 | |
Corion | gaal: That mentions $_ | ||
gaal | ah | ||
so it does :) | |||
./pugs -e 'map -> $x {say $x}, @INC' | |||
Corion | gaal: I want to stay as platform agnostic as possible, that means that the code should run in double quotes (Win32) and should not mention $_ (UNIX shells) | ||
gaal | see latest | 19:43 | |
Corion | gaal: It uses $x - which is as bad as $_ :-) No $ sign in shell oneliners | ||
gaal | aha! | ||
Corion | gaal: I'll go with the @INC.perl.say - documenting/introducing Perl6ish oneliners is also important! | ||
kungfuftr | hhhmmm... any idea about how we'll be doing tie() sort of stuff in perl6? | 19:45 | |
Corion | kungfuftr: Not at all, I hope ! :-) | 19:46 | |
Khisanth | isn't that what the my $foo is Bar; type of stuff is for? | ||
kungfuftr | yup, i would assume so, since hashes are just objects are anyways | ||
gaal | see e.g. <L09/"PDL support"> | 19:47 | |
L<S09> that is | |||
kungfuftr | Khisanth: yeah `my %hash is ixHash;` is what i'd reckon | ||
gaal | interesting short circuit, that. | ||
Corion | Grrr - the PCRE implementation seems to match dodgy ( or ~~ is broken ... ) - do we have C<like> implemented in Test.pm ? | 19:48 | |
kungfuftr has a read through the synopses again | |||
Khisanth | hmm is there an 'of' in perl6? :) | ||
Corion | Because "ok $got ~~ $expected" doesn't DWIM, even though $expected = rx:perl5/^('foo/; :-(( | 19:49 | |
(it's always true) | |||
gaal | Corion, we don't have like yet. | 19:50 | |
Corion | gaal: Ah - most likely, ~~ not DWIMming is the reason :-) So I'll go with substr() instead :) | ||
(except that now, the newline stuff becomes uglier...) | |||
gaal | then embed perl5 code. }:) | 19:51 | |
Corion | gaal: :-) | 19:52 | |
lumi | What I wouldn't give for Perl 6 rules, today | ||
In the next 10 minutes, in fact | |||
stevan | Corion: regexp support is spotty | 19:53 | |
best not to do like() yet | |||
Corion | stevan: Looks like it :) | ||
Anybody got a better idea than substr() to check if the first/last two lines in a scalar match what I expect? | 19:54 | ||
stevan | most of what works, autrijus put in because I begged him for it :) | ||
gaal | Corion, are you compiling a set of known p6 one-liners? | 19:55 | |
that would be a good node for perlmonks :) | |||
grep around for eyespoplikeamosquito's first ever p6 japh, which i don't understand | 19:56 | ||
Corion | gaal: Nope - I'm just writing a test script that checks that -I works properly. But your @INC.perl.say would be a good "verification oneliner" (that is, it should go into the docs IMO) - it has no shell metacharacters. | ||
gaal | in that case, ./pugs -I /idontexist -V | grep idontexist should work too | 19:57 | |
(does in p5) | |||
ninereasons | it's going to eventually be "print for @INC"; but that won't work right now, right? | ||
gaal | ah, also works in pugs! :) | ||
yes | 19:58 | ||
Corion | ninereasons: Yes. And also, it will require the user to put the stuff in quotes, which is error prone. That's what I like with @INC.perl.say - one shell-word | ||
gaal: I don't like grepping - that's error prone. I'm especially interested in the _order_ the stuff goes into @INC | |||
rgs | what is @*INC.perl ? | 19:59 | |
gaal | Schwern was here a few days back saying that @ can be a metacharacter in some makes, ifyou care about that | ||
elmex | f | ||
Corion | But I think I know how to fudge it - I simply "initialize" my reference scalar from a single unadorned call to pugs. | ||
gaal | rgs: think "Data::Dumper::Dump" | ||
elmex | ? | ||
Corion | gaal: Yes, but I don't care currently. This oneliner would be for shell verification and my test file :-) | ||
rgs wants a @*INC.yaml.say | 20:00 | ||
gaal | rgs, you're sure to get it when YAML.pm lands | ||
in fact grep the channel logs for autrijus' explanation of how easy this kind of thing is to add | 20:01 | ||
(modulo YAML.pm itself :-) | |||
kungfuftr needs to buy the perl6 book | 20:02 | ||
rgs | gaal: is it planned ? | ||
gaal | what, a yaml module for p6? of course! if for some reason ingy doesn't port it i'm sure someone else will | 20:03 | |
Limbic_Region | has autrijus mentioned what the plan is on p6 rules/regexes is? | 20:05 | |
nevermind | |||
# 6.283: Rules and Grammars. | |||
xerox | Limbic_Region: url? | ||
Limbic_Region | svn.perl.org/perl6/pugs/trunk/docs/...rview.html | ||
Corion | Err - if I have an array reference $t = [ "foo", "bar" ], what is the Perl6 equivalent to Perl5 @$t ? | 20:06 | |
Limbic_Region | xerox, if you haven't seen www.pugscode.org you might want to check that out too | ||
as well as autrijus's use.perl journal | |||
use.perl.org/~autrijus/journal | |||
xerox | Danke. | 20:07 | |
ninereasons | $t.elems | 20:08 | |
I think, Corion | |||
Corion | ninereasons: Looks good, at least no compiler error there anymore :) | 20:09 | |
ninereasons | I'm wrong, though. That's not a deref, as you asked for. | 20:10 | |
Corion | ninereasons: Yeah - I just fixed the other bugs, and now Pugs tells me that it doesn't know about .elems :) | 20:11 | |
ninereasons | a TODO | ||
Corion | Anyway - I get a real life timeout now, so -I test-hacking will have to be postponed. | 20:13 | |
later all! | |||
gaal | so, is it Boolean (S04) or Bool (S06)? latter wins, right? | 20:30 | |
schoch | hmmm | 20:33 | |
schoch is reading synopsis | |||
junctive types seems scary | 20:34 | ||
gaal | also: how are constants spelled? is thre no sigiless form? my $val is constant = 8; | ||
how does a constant imported from antoher class look like? | |||
kungfuftr | yay! looks like i can finally signup for safari! | 20:39 | |
kungfuftr pokes activestate people about getting special rates | |||
Khisanth | why poke activestate? | ||
wouldn't you want to poke O'Reilly? :) | |||
kungfuftr | Khisanth: activestate have a special safari arrangement... my company owns activestate | 20:40 | |
=0) | |||
Khisanth | hmm | ||
kungfuftr | Khisanth: ActivePerl Studio Perl includes a safari subscription | 20:41 | |
Khisanth only uses activeperl occassionally :) | 20:42 | ||
kungfuftr uses it only when he has to, but he gets it for free | 20:44 | ||
Khisanth | well I only use it on windows and with the lack of a decent shell/terminal it isn't very fun | 20:45 | |
kungfuftr | Khisanth: some of the pro dev tools help a lot in that respect | 20:47 | |
Khisanth assumes a bunch of GUI stuff | |||
kungfuftr | some commandline stuff too | 20:50 | |
schoch | wmic is quite nice | 20:55 | |
21:00
brentdax_ is now known as brentdax
|
|||
kungfuftr | wmic? | 21:05 | |
schoch | wmi command line | 21:06 | |
can do some crazy shit with it | |||
jabbot | pugs - 1286 - Regression test for -I | 21:07 | |
pugs - 1285 - Fixed typo | |||
schoch | kernel panics are fun | 21:08 | |
kungfuftr for example you can do class win32_processor get MaxClockSpeed | |||
on a remote box | |||
21:09
hide_ is now known as hide
|
|||
kungfuftr | ah | 21:09 | |
wilx | Hmm, what good is it for? I've never figured out what can onde do with WMC. | ||
s/onde/one/ | 21:10 | ||
schoch | WMI you mean? | ||
wilx | Err, right. WMI. | ||
wmic is the executable, right? | |||
schoch | lets say you need to figure out every winblows box on your network that has an admin user | ||
it makes that very easy | |||
wilx | Hm. | ||
schoch | almost everything in windows has a WMI interface | 21:11 | |
21:11
metaperl_ is now known as metaperl
|
|||
kungfuftr | schoch: search.cpan.org/~wyant/Win32-Proces...nfo/WMI.pm ? | 21:12 | |
schoch | i used it once to coordinate remotly start/stopping perfmon for a stress test accross several web boxen | ||
wilx | Heh, nice. | ||
schoch | www.windowsitpro.com/Windows/Articl...23854.html | 21:14 | |
i'm sure it can be used for dastardly evil stuff too | 21:15 | ||
jabbot | pugs - 1288 - renamed test for -I option | 21:17 | |
pugs - 1287 - 'make test' ignores test files with uppe | |||
kungfuftr | hhhmmm... does `%hash.kv -> $k, $v` bind variables? | 21:45 | |
stevan | kungfuftr: it should (i think), but i dont know if pugs can handle it yet | 21:46 | |
jabbot | pugs - 1289 - adding some io-in-loops tests | 21:47 | |
kungfuftr | stevan: hhhmmm... tbh, i can't really see a good reason to do it by copy as posed to bind | ||
stevan | oh | 21:54 | |
hmmm, didnt read the bind part of the question | |||
I would expect the keys to be immutable, since to do it any other way might get a little insane | 21:55 | ||
then I would also expect the values to do that as well | 21:56 | ||
schoch | krazy keys | ||
stevan | and use %hash{$k} = $new_value if you wanted to change something | ||
kungfuftr | stevan: yar, i suppose, not very dwim though | ||
stevan | I recall reading something somewhere about hash interators and thier caveats and limitations | ||
kungfuftr: what does p5 do with each(%hash) | 21:57 | ||
I think it copies IIRC | |||
schoch | iterators in java have some major problems in multithreaded apps | ||
stevan | iterators in any langauges can have problems multithreading :) | ||
kungfuftr | yar | ||
schoch | ya, the locking can be painfull | 21:58 | |
stevan | (except for some weird parrallel logic/dataflow languages like Lucid) | ||
schoch | will perl6 have any concept of threadsafe? | ||
stevan | schoch: I have no idea,.. my guess is that they might differ that to Parrot | 21:59 | |
or at least as much as the can possibly differ to parrot | |||
ingy: ping? | 22:02 | ||
ingy: just wondering if your battle with MakeMaker re: Test.pm and File::Spec was fruitful | 22:03 | ||
jabbot | pugs - 1291 - added END block to io tests to remove th | 22:17 | |
pugs - 1290 - more Pod::Stream::Parser work; better ve | |||
chip | Larry's last statement on threading was that Perl would expose whatever Parrot provided | 22:24 | |
At least, that was his last statement in my personal reference frame | |||
the grass is always greener on the other side of the light cone | 22:25 | ||
gcom | 22:37 | ||
kungfuftr | (p6 and parrot essentials)++ # good reference | 23:27 | |
ingy | stevan: hola | 23:54 |