»ö« Welcome to Perl 6! | perl6.org/ | evalbot usage: 'perl6: say 3;' or rakudo:, niecza:, std:, or /msg camelia perl6: ... | irclog: irc.perl6.org | UTF-8 is our friend! Set by sorear on 25 June 2013. |
|||
00:01
denis_boyun left
00:04
kivutar left
|
|||
dalek | osystem: f31aa9e | (Andrew Egeler)++ | META.list: Add Compress::Zlib |
00:07 | |
00:08
jnap left
|
|||
segomos | raiph: if you have a back up somewhere i can throw it up on a site | 00:08 | |
building jvm p6, panda doesn't like moar yet i guess :-) | |||
00:09
pecastro left
00:20
dayangkun left,
dayangkun joined
|
|||
dalek | rl6-most-wanted: c98cda9 | (Andrew Egeler)++ | most-wanted/bindings.md: Add Compress::Zlib WIP |
00:22 | |
00:23
kbaker joined
|
|||
TimToady | r: my \m = 1000; say m; # oops | 00:23 | |
camelia | rakudo-parrot 934c48, rakudo-jvm 934c48, rakudo-moar 934c48: OUTPUT«===SORRY!=== Error while compiling /tmp/tmpfileRegex not terminatedat /tmp/tmpfile:1------> my \m = 1000; say m; # oops⏏<EOL> expecting any of: argume…» | ||
TimToady | this discussion reminds me we need to do something about that | ||
segomos | r: my \m = 1000; m.say; | 00:24 | |
camelia | rakudo-jvm 934c48, rakudo-moar 934c48: OUTPUT«===SORRY!===Unrecognized regex metacharacter ; (must be quoted to match literally)at /tmp/tmpfile:1------> my \m = 1000; m.say⏏;Couldn't find terminator .at /tmp/tmpfile:1------> …» | ||
..rakudo-parrot 934c48: OUTPUT«␀␀␀[␀␀␀3␀␀␀1␀␀␀m␀␀␀=␀␀␀=␀␀␀=␀␀␀␀␀␀[␀␀␀0␀␀␀m␀␀␀S␀␀␀O␀␀␀R␀␀␀R␀␀␀Y␀␀␀!␀␀␀␀␀␀[␀␀␀3␀␀␀1␀␀␀m␀␀␀=␀␀␀=␀␀␀=␀…» | |||
TimToady | there are a number of keywords that ought to be demoted to macro names | ||
segomos | cool error message | ||
00:30
hoverboard left
00:46
hoverboard joined
00:56
woosley joined
01:02
raiph left
01:09
kbaker left
|
|||
TimToady | hi guys, you're on screen a De Anza College in Cupertino :) | 01:30 | |
01:30
fridim__ joined
|
|||
JimmyZ | std: my \m = 1000; m.say; | 01:48 | |
camelia | std 09dda5b: OUTPUT«===SORRY!===Regex missing terminator (or semicolon must be quoted?) at /tmp/grUz9n_zx2 line 1 (EOF):------> my \m = 1000; m.say;⏏<EOL>Parse failedFAILED 00:01 124m» | ||
JimmyZ | std: my \m = 1000; say m; | 01:49 | |
camelia | std 09dda5b: OUTPUT«===SORRY!===Regex not terminated at /tmp/cjk9tn3dSF line 1 (EOF):------> my \m = 1000; say m;⏏<EOL>Parse failedFAILED 00:01 122m» | ||
[Coke] | aaahaahahah. I checked the whois, found a name, checked on linkedin... twgil dude has 2 recommendations for perl. :) | ||
01:52
cooper left,
erdic left,
erdic joined
01:56
iolympian1 joined
01:59
cooper joined
|
|||
lue | TimToady: really? | 02:02 | |
TimToady | yes, really | 02:03 | |
run something to show it off :) | |||
like maybe | 02:04 | ||
m: say [*] 1..10 | |||
camelia | rakudo-moar 934c48: OUTPUT«3628800» | ||
lue | r: sub postfix:<!>($a) { [*] 1..$a }; say 5!; | ||
camelia | rakudo-parrot 934c48, rakudo-jvm 934c48, rakudo-moar 934c48: OUTPUT«120» | ||
lue | hey look, we picked the same reduction op :P | 02:05 | |
TimToady | why did we multiply by 1? | ||
lue | TimToady: that's just the canonical definition of factorial, I didn't make it up. :) | ||
TimToady | j: say [*] 1..10 | 02:06 | |
camelia | rakudo-jvm 934c48: OUTPUT«3628800» | ||
TimToady | p: say [*] 1..10 | ||
camelia | rakudo-parrot 934c48: OUTPUT«3628800» | ||
JimmyZ | r: say [*] 1..30 | ||
camelia | rakudo-parrot 934c48, rakudo-jvm 934c48, rakudo-moar 934c48: OUTPUT«265252859812191058636308480000000» | ||
skids | gist.github.com/skids/9634210 # this something that's RTed yet? | 02:07 | |
lue hopes there's a way to check for invalid var names without maintaining a list of keywords for at least part of it :/ | |||
TimToady | p6: say 42 | ||
camelia | rakudo-parrot 934c48, rakudo-jvm 934c48, rakudo-moar 934c48, niecza v24-109-g48a8de3: OUTPUT«42» | ||
JimmyZ | r: my $time = time; say [*] 1..32; say $time - time | 02:08 | |
camelia | rakudo-parrot 934c48, rakudo-jvm 934c48, rakudo-moar 934c48: OUTPUT«2631308369336935301672180121600000000» | ||
lue | r: say [*] 1..32; say now - BEGIN now | ||
camelia | rakudo-moar 934c48: OUTPUT«2631308369336935301672180121600000000.04657962» | ||
..rakudo-parrot 934c48: OUTPUT«2631308369336935301672180121600000000.05436981» | |||
..rakudo-jvm 934c48: OUTPUT«2631308369336935301672180121600000000.077» | |||
JimmyZ | :) | ||
lue | r: say (1,2,3) ∪ (2,3,4); say (1,2,3) ∩ (2,3,4); say (1,2,3) ∖ (2,3,4); say (1,2,3) ⊖ (2,3,4) | 02:12 | |
camelia | rakudo-jvm 934c48: OUTPUT«set(2, 1, 4, 3)set(2, 3)set(1)set(1, 4)» | ||
..rakudo-parrot 934c48, rakudo-moar 934c48: OUTPUT«set(1, 2, 3, 4)set(2, 3)set(1)set(1, 4)» | |||
TimToady | r: say (1,2,3) (|) (2,3,4) | ||
camelia | rakudo-parrot 934c48, rakudo-moar 934c48: OUTPUT«set(1, 2, 3, 4)» | 02:13 | |
..rakudo-jvm 934c48: OUTPUT«set(2, 1, 4, 3)» | |||
lue | ... and just now I realize that script I wrote a couple days ago could have used ⊖ instead of putting two lists into a Bag and finding the unique ones. :P | ||
TimToady | eval: say | 02:16 | |
do we have a P5 here? | |||
lue | also, TimToady: think the set operators for regex assertions should 1) follow the (^) etc. form for the texas versions, instead of the ()-less versions they are now, and 2) have Unicode versions? | ||
p5: say | |||
TimToady | p6: say | 02:17 | |
camelia | niecza v24-109-g48a8de3: OUTPUT«===SORRY!===Unsupported use of bare 'say'; in Perl 6 please use .say if you meant $_, or use an explicit invocant or argument at /tmp/tmpfile line 1 (EOF):------> say⏏<EOL>Unhandled exception: Chec…» | ||
..rakudo-parrot 934c48, rakudo-jvm 934c48, rakudo-moar 934c48: OUTPUT«» | |||
lue | ( that is, <rule1 ∪ rule2> and <rule1 (|) rule2> instead of what it is now, <rule1 | rule2> ) | ||
02:17
fridim__ left
|
|||
TimToady | p6: $_ = 'foo'; .say | 02:17 | |
camelia | rakudo-parrot 934c48, rakudo-jvm 934c48, rakudo-moar 934c48, niecza v24-109-g48a8de3: OUTPUT«foo» | ||
TimToady | m: for my $x (@_) {...} | 02:19 | |
camelia | rakudo-moar 934c48: OUTPUT«===SORRY!=== Error while compiling /tmp/2xMfoWrng7This appears to be Perl 5 codeat /tmp/2xMfoWrng7:1------> for ⏏my $x (@_) {...} expecting any of: statement list» | ||
TimToady | m: 42.chars.say | 02:21 | |
camelia | rakudo-moar 934c48: OUTPUT«2» | ||
02:22
xragnar left
02:24
xragnar joined
02:25
airdisa left
|
|||
TimToady | m: say <a b c> ~ 1,2,3; | 02:29 | |
camelia | rakudo-moar 934c48: OUTPUT«a b c123» | ||
TimToady | m: say <a b c> Z 1,2,3; | ||
camelia | rakudo-moar 934c48: OUTPUT«a 1 b 2 c 3» | ||
02:29
iolympian1 left
|
|||
TimToady | m: say <a b c> Z~ 1,2,3; | 02:29 | |
camelia | rakudo-moar 934c48: OUTPUT«a1 b2 c3» | ||
TimToady | m: say <a b c> X~ 1,2,3; | 02:31 | |
camelia | rakudo-moar 934c48: OUTPUT«a1 a2 a3 b1 b2 b3 c1 c2 c3» | ||
TimToady | m: say 5 / 3 | 02:32 | |
camelia | rakudo-moar 934c48: OUTPUT«1.666667» | ||
TimToady | m: say 5 R/ 3 | ||
camelia | rakudo-moar 934c48: OUTPUT«0.6» | ||
TimToady | m: say <a b c> XR~ 1,2,3; | 02:34 | |
camelia | rakudo-moar 934c48: OUTPUT«1a 2a 3a 1b 2b 3b 1c 2c 3c» | ||
02:52
klapperl left
02:54
klapperl joined
02:56
FROGGS_ joined
03:00
FROGGS left
|
|||
BenGoldberg | p6: say [R,] 1..4 | 03:09 | |
camelia | rakudo-parrot 934c48: OUTPUT«Too many positional parameters passed; got 4 but expected 2 in block at gen/parrot/CORE.setting:17009 in sub at gen/parrot/CORE.setting:17151 in block at /tmp/tmpfile:1» | ||
..rakudo-moar 934c48: OUTPUT«Too many positional parameters passed; got 4 but expected 2 in block at src/gen/m-CORE.setting:16808 in sub at src/gen/m-CORE.setting:16950 in block at /tmp/tmpfile:1» | |||
..niecza v24-109-g48a8de3: OUTPUT«Unhandled exception: Excess arguments to ANON, used 2 of 4 positionals at /tmp/tmpfile line 0 (ANON @ 1)  at /home/p6eval/niecza/lib/CORE.setting line 2767 (reduceop @ 12)  at /tmp/tmpfile line 1 (mainline @ 3)  at /home/p6eval/niecza/…» | |||
..rakudo-jvm 934c48: OUTPUT«Too many positional parameters passed; got 4 but expected 2 in block at gen/jvm/CORE.setting:16754 in sub at gen/jvm/CORE.setting:16896 in block at /tmp/tmpfile:1» | |||
03:14
SamuraiJack joined
03:23
perigrin_ joined
03:24
perigrin_ left,
perigrin_ joined,
perigrin_ left
03:44
SamuraiJack left
03:58
yoleaux left
03:59
yoleaux joined,
ChanServ sets mode: +v yoleaux
|
|||
segomos | perl6 is awesome | 04:13 | |
04:40
xybre joined
|
|||
xybre | Whats the proper syntax to use the "continue" modifier in a rule block? I've tried a few combinations, but the only one that parsed said :c wasn't a modifier. Is it not implemented yet? | 04:42 | |
TimToady | :c is mostly for bare regex; once you're in a grammar things automatically continue where they're supposed to, generally speaking | 04:46 | |
so I don't think anyone has ever tried to use :c in a rule, offhand | 04:47 | ||
xybre | Interesting, I'll look more into the grammar documentation then. Thanks. | 04:49 | |
TimToady | well, it's documented that you can use it internally, but I guess nobody's tried it yet | 04:50 | |
everyone thinks of it as a modifier to m// or s/// | |||
I'm not sure <at()> is impleented either | 04:51 | ||
m: 'foo' ~~ /...<at(3)>/ | |||
camelia | ( no output ) | ||
TimToady | m: say 'foo' ~~ /...<at(3)>/ | ||
camelia | rakudo-moar 934c48: OUTPUT«「foo」 at => 「」» | ||
TimToady | I guess it is | 04:52 | |
m: say 'foo' ~~ /.*?<at(3)>/ | |||
camelia | rakudo-moar 934c48: OUTPUT«「foo」 at => 「」» | ||
TimToady | I guess there aren't a lot of parsing problems where you have to go jumping around in the string | 04:53 | |
that feels more like SNOBOL-think to me... | 04:54 | ||
certainly we have the capability of setting the current position, but :c is perhaps not the best interface for that | 04:56 | ||
I don't think the current position setter is going to be found in S05 though | |||
and now that I grep for it, it looks like primarily an nqp operation, so dunno if it's visible in P6-land | 04:58 | ||
m: say 'foo' ~~ /<.cursor_pos(3)>$/ | 04:59 | ||
camelia | rakudo-moar 934c48: OUTPUT«No such method 'cursor_pos' for invocant of type 'Cursor' in method ACCEPTS at src/gen/m-CORE.setting:12825 in method ACCEPTS at src/gen/m-CORE.setting:798 in block at /tmp/A05w87Om41:1» | ||
TimToady | it would be something resembling that | ||
m: say Cursor.^methods | |||
camelia | rakudo-moar 934c48: OUTPUT«No such method 'gist' for invocant of type 'NQPRoutine' in method gist at src/gen/m-CORE.setting:7022 in method gist at src/gen/m-CORE.setting:1053 in sub say at src/gen/m-CORE.setting:13366 in block at /tmp/4FJ1Kdr0np:1» | ||
TimToady | heh | ||
grammars aren't quite HLLized completely in rakudo yet | 05:00 | ||
05:00
kaare_ joined
|
|||
TimToady | m: say Cursor.^methods».name | 05:01 | |
camelia | rakudo-moar 934c48: OUTPUT«MATCH MATCH_SAVE INTERPOLATE OTHERGRAMMAR INDRULE RECURSE orig target from pos CAPHASH !cursor_init !cursor_start_all !cursor_start !cursor_start_cur !cursor_start_fail !cursor_start_subcapture !cursor_capture !cursor_push_cstack !cursor_pass !cursor_fail …» | ||
TimToady | m: say 'foo' ~~ /<.'!cursor_pos'(3)>$/ | 05:02 | |
camelia | rakudo-moar 934c48: OUTPUT«===SORRY!===Unrecognized regex metacharacter < (must be quoted to match literally)at /tmp/bVOGMsVHSu:1------> say 'foo' ~~ /<.⏏'!cursor_pos'(3)>$/Unrecognized regex metacharacter . (must be quoted to match…» | ||
TimToady | m: say 'foo' ~~ /<."!cursor_pos"(3)>$/ | 05:03 | |
camelia | rakudo-moar 934c48: OUTPUT«===SORRY!===Unrecognized regex metacharacter < (must be quoted to match literally)at /tmp/PsYa6Z1Sd1:1------> say 'foo' ~~ /<.⏏"!cursor_pos"(3)>$/Unrecognized regex metacharacter . (must be quoted to match…» | ||
TimToady | well, might have to write it more nqp-ish than that, I guess | 05:04 | |
anyhoo, the functionality is certainly there somewhere hiding | |||
TimToady hides | 05:05 | ||
JimmyZ | Cursor.pm needs some love, me thinks | 05:06 | |
05:10
logie_ left
05:13
BenGoldberg left
05:15
xenoterracide left
05:25
[Sno] left
05:26
[Sno] joined,
[Sno] left
05:27
[Sno] joined,
[Sno] left
05:36
rurban1 left
|
|||
moritz | \o | 05:39 | |
05:43
kaare_ left
05:48
pdcawley left
05:49
pdcawley joined
06:09
kaare_ joined
06:16
logie_ joined
06:18
kaare_ left
06:20
kaare_ joined
06:25
hoverboard left
06:27
[Sno] joined
06:34
Khisanth left
06:56
Khisanth joined
06:57
sftp left
06:59
sftp joined
07:00
Khisanth left
07:09
hoverboard joined,
FROGGS_ left
07:10
arnsholt left
07:12
hoverboard left
07:15
darutoko joined
07:30
kaleem joined
07:38
FROGGS joined
07:41
Khisanth joined
07:46
rindolf joined
07:49
arnsholt joined
07:50
dwarring_ left
07:56
zakharyas joined
|
|||
arnsholt | nqp: say(nqp::reprname(+[])) | 08:14 | |
camelia | nqp-parrot: OUTPUT«Can only use repr_name with a SixModelObjectcurrent instr.: '' pc 49 ((file unknown):57503018) (/tmp/tmpfile:1)» | ||
..nqp-moarvm, nqp-jvm: OUTPUT«P6num» | |||
arnsholt | jnthn: Do we consider that a bug, or merely unexpected? | 08:15 | |
JimmyZ | nqp: say(nqp::reprname((+[])).WHAT) | 08:16 | |
camelia | nqp-parrot: OUTPUT«Can only use repr_name with a SixModelObjectcurrent instr.: '' pc 49 ((file unknown):48512506) (/tmp/tmpfile:1)» | ||
..nqp-moarvm, nqp-jvm: OUTPUT«» | |||
FROGGS | arnsholt: it is the "that happens when 6model is not fully supported/implemented" thing | 08:17 | |
arnsholt: but when you glance at #parrot, then you see commits from rurban++ about implementing 6model | |||
arnsholt | Oh, the problem isn't that it doesn't work on Parrot | 08:18 | |
Sorry, that wasn't entirely clear | |||
The +@thing returns the length of the array, which we'd normally expect to be a P6int | |||
But prefix:<+> only returns nums | 08:19 | ||
08:19
xinming_ joined,
dmol joined
|
|||
FROGGS | arnsholt: that is known | 08:22 | |
and for some reason we were unable to just change it | 08:23 | ||
but I can't remember why | |||
arnsholt | It's because the op driving prefix:<+> has to return a num in some other contexts, so it has to do that for everything | 08:30 | |
08:54
kivutar joined
|
|||
timotimo | o/ | 09:03 | |
arnsholt | 'lo \o | 09:15 | |
09:23
pecastro joined
09:28
fhelmberger joined
09:29
virtualsue joined
09:35
SamuraiJack joined
|
|||
arnsholt | Oh fun. infix:<+> of two ints produces a num too | 09:52 | |
timotimo | it always does? oops. | 09:54 | |
in nqp we already have an optimization that turns num additions into int additions if it's obvious | |||
on rakudo itself, that may be harder, because the additions aren't always inlined (or are they?) | 09:55 | ||
arnsholt | Looks like from what I'm seeing | 09:56 | |
nqp: my $a := 1; my $b := 2; say(nqp::reprname($a)); say(nqp::reprname($b)); say(nqp::reprname($a+$b)) | |||
camelia | nqp-moarvm, nqp-jvm: OUTPUT«P6intP6intP6num» | 09:57 | |
..nqp-parrot: OUTPUT«Can only use repr_name with a SixModelObjectcurrent instr.: '' pc 52 ((file unknown):45) (/tmp/tmpfile:1)» | |||
arnsholt | Yup | ||
timotimo | o_O | ||
tadzik | o: | ||
moritz | nqp: say(nqp::reprname(1+2)) | ||
camelia | nqp-moarvm, nqp-jvm: OUTPUT«P6int» | ||
..nqp-parrot: OUTPUT«Can only use repr_name with a SixModelObjectcurrent instr.: '' pc 46 ((file unknown):62151977) (/tmp/tmpfile:1)» | |||
timotimo | well, at least that works. | ||
arnsholt | I could fix it by doing +| instead (since that's what it actually wanted to do), thankfully | ||
timotimo | nqp: my int $a := 1; my int $b := 2; say(nqp::reprname($a+$b)) | 09:58 | |
camelia | nqp-moarvm, nqp-jvm: OUTPUT«P6int» | ||
..nqp-parrot: OUTPUT«Can only use repr_name with a SixModelObjectcurrent instr.: '' pc 53 ((file unknown):45) (/tmp/tmpfile:1)» | |||
timotimo | ^ | ||
arnsholt | \o/ | 09:59 | |
Direct JAST compilation stage1 compiler now manages to compile the stage2 compiler | |||
I wonder what hilarious bugs the stage2 compiler now has =D | |||
timotimo | \o/ | ||
this will decrease startup time measurably, aye? | 10:00 | ||
well, at least compile-time? | |||
arnsholt | Wait, what? It didn't explode... | ||
timotimo | well, stage JAST only, really | ||
10:00
woosley left
|
|||
arnsholt | Hoping it'll cut down on compile time a bit yeah | 10:00 | |
moritz | arnsholt: when it gets as far as building stage2, chances are good that it's not all that messed up :-) | 10:01 | |
arnsholt | Apparently =D | 10:02 | |
Let's see what happens if I make j-test | 10:03 | ||
timotimo | oooh, if all is well, this could go in this month's release! | 10:05 | |
moritz | timotimo: you do realize that that's tomorrow already? | ||
I'm not a fan of rushing things into releases | 10:06 | ||
after all, the next one is only a month away :-) | |||
timotimo | hehe. | ||
we've had holes in the Star releases recently, though | |||
arnsholt | I'd like to at least get jnthn to review it first | ||
timotimo | that's fine | ||
i always get a bit too excited about these things that happen immediately before a release | |||
arnsholt | All tests passing so far though | 10:07 | |
"All tests successful." =D | 10:08 | ||
timotimo | well, i like the sound of that :) | 10:10 | |
10:23
telex left
10:24
telex joined
11:25
denis_boyun joined
11:40
SamuraiJack left,
fhelmberger_ joined
11:44
fhelmberger left
11:54
skids left,
rindolf left
|
|||
timotimo | how much work would it be to make rakudo-moar capable of running STD? | 12:12 | |
nwc10 | what does STD currently run on? | ||
timotimo | viv | ||
and thus, perl5 | |||
jnthn | o/ | 12:13 | |
12:13
brrt joined
|
|||
timotimo | o/ jnthn | 12:14 | |
how's the tuit supply today? | |||
nwc10 | hey, can we have 12 sided tuits soon? :-) | ||
jnthn | Tuit supply a bit disrupted by internet access failure | 12:15 | |
But it's OK; I needed to do a run to the office sometimes today or tomorrow, so I did it today :) | |||
timotimo | arnsholt: were you able to compile a full rakudo with the new jast compiler yet? | 12:17 | |
jnthn | On NQP, it basically resorts to floating point most of the time. | 12:18 | |
Unless you give it things typed as int. | |||
arnsholt | timotimo: Compiles, but for some reason weird things happen if I try to make j-test | 12:19 | |
Gonna recompile NQP to master and see what happens | |||
timotimo | okay | ||
arnsholt | O hai, jnthn! | 12:20 | |
jnthn | arnsholt++ # awesome progress | ||
I'm too risk averse to have it in the monthly :) | |||
I'll bet it saves some off setting compilation time on JVM. :) | |||
arnsholt | Hopefully. As long as it's not broken in some subtle way | 12:21 | |
Had weirdness with the test suite | |||
jnthn | For such a big change, I expect there'll be a few things to work through :) | ||
arnsholt | make j-test gets me "no tests run" errors, but ./perl6-j t/$a_test_file seemed to work fine | ||
Recompiling NQP right now, but once the compilations are done I'll push what I have so far | 12:22 | ||
timotimo | you should try it on master, see if it's supposed to work at all in a vanilla state | ||
because "no tests run" is what i get most of the time for the j-spectest | |||
arnsholt | Aha | ||
jnthn | Yeah, that seems to happen on some JVM versions :S | 12:23 | |
arnsholt | From a skim of the harness script, it looks like it might not be running ./perl6-j on JVM | ||
jnthn | Yeah, it uses the evalserver for spectest | ||
timotimo | yeah, it may be running the ... yes | ||
hmm. a huge piece of slowness for the perl6-j benchmarks is attributed to stage parse, at least if --stagestats is to be believed | 12:25 | ||
does that also contain loading and deserializing the setting? | |||
jnthn | Yes. | ||
Happens for the fist thing you parse | 12:26 | ||
uh, first | |||
timotimo | hmm. that won't get any benefit from the jast speed improvements | ||
it would seem like loading the setting is to blame for by far the biggest chunk of time wasted on startup for rakudo-jvm benchmarks | 12:27 | ||
jnthn | Well, it's not waste if you gotta do it :P | 12:29 | |
Question is what exactly takes time, and what aspects of it re slow. | |||
timotimo | i'm assuming that there's something to be gained there ;) | ||
12:31
kaleem left
|
|||
jnthn | Me too :) | 12:31 | |
timotimo | which tool would give me help with that? jvisualvm? | 12:32 | |
jnthn | maybe that, or maybe there are some profiling options that can be passed to the JVM invocation too | 12:33 | |
12:34
fhelmberger_ left
|
|||
arnsholt | Hmm, looks like it works with plain perl6-j | 12:34 | |
12:34
fhelmberger joined
|
|||
dalek | p/jastcompiler: 7e6d19f | (Arne Skjærholt)++ | src/vm/jvm/QAST/Compiler.nqp: Make sure all handler indices are ints. Prior to this, some indices would be nums; one because the construct "$a+$b" returns a num, even if both variables are ints (fixed by using logical or instead, since those are the semantics we actually wanted anyways), and one because "+@array" also returns a num (fixed by using nqp::elems instead). |
12:34 | |
p/jastcompiler: fe4a4ac | (Arne Skjærholt)++ | / (18 files): Direct compilation of JAST nodes to bytecode. |
|||
arnsholt | That's the branch, at any rate | 12:35 | |
Should probably do some $dayjob things today, too =) | |||
JimmyZ | timotimo: java.dzone.com/articles/java-profiling-dtrace | ||
timotimo | thank you :) | 12:36 | |
JimmyZ | I know the oracle dbas is using it | ||
timotimo | so all i need to do is install a solaris and build rakudo-j on that! | ||
arnsholt | You can get dtrace on Linux as well, I think | ||
JimmyZ | docs.oracle.com/javase/6/docs/techn...trace.html | 12:37 | |
arnsholt | But it's not in the mainline kernel because the dtrace licence isn't compatible with the GPL | ||
timotimo | right | ||
JimmyZ | yeah, github.com/dtrace4linux/linux | ||
timotimo | did i mention i can't profile perl6-j because the jvm segfaults when i click the "profile" button? | 12:38 | |
12:40
kivutar left
|
|||
timotimo | i can only let it sample every 20ms | 12:41 | |
jnthn | wow | 12:42 | |
Try a newer/different version? | |||
timotimo | it also spews a bunch of warnings before that | ||
probably related to the way we create lots of classes at run-time | |||
gist.github.com/timo/0c08d358a2357e098da7 | 12:43 | ||
jnthn | wow | 12:44 | |
fail | |||
moritz | timotimo: do submit a bug report to the JVM devs :-) | 12:46 | |
timotimo | i'm afraid they'll tell me it's a DIHWIDT | 12:47 | |
12:53
guru joined,
guru is now known as Guest94710
12:54
Guest94710 is now known as ajr_
12:59
kbaker_ joined
|
|||
dalek | kudo/nom: 4869942 | rurban++ | src/vm/parrot/ops/perl6.ops: parrot/ops/perl6.ops: add missing prototype decl for Parrot_lib_perl6_ops_init required for parrot-6.1.0 which fatalizes missing prototype declarations |
13:01 | |
kudo/nom: 01d16c2 | (Tobias Leich)++ | src/vm/parrot/ops/perl6.ops: Merge pull request #252 from rurban/nom parrot/ops/perl6.ops: add missing prototype decl for Parrot_lib_perl6_op... |
|||
13:12
Sqirrel joined
13:22
lowpro30 joined
|
|||
timotimo | i'm wondering if it would be wise to let int + int give int given ints range limitations; but that might be what the user wants anyway, since nqp doesn't give you bigint semantics for int | 13:23 | |
FROGGS | that sounds pretty sane for nqp me thinks | 13:25 | |
jnthn | NQP does not have to be a general purpose language. It just needs to be good for writing compilers. :) | ||
JimmyZ | and for C :P | ||
jnthn | To be honest, it's floating point we should probably make cost. | ||
And assume int in general. | |||
Since compilers rarely need to do scientific math :) | 13:26 | ||
JimmyZ | there is XXX in the nqp that is nqp really wants constants | ||
timotimo | aye; but for now we can probably teach prefix:<+> before an @-variable to return an int | ||
jnthn | Yeah, that's a todo :) | ||
timotimo: yes, that is an acceptable thing to do for now. | |||
timotimo: In fact, we can even re-write it directly to an elems call | 13:27 | ||
timotimo | not 100% sure where that goes, though | ||
13:31
lowpro30_ joined
13:32
lowpro30 left
13:39
lowpro30_ left
|
|||
arnsholt | timotimo: The grammar bit handling prefix:<+> probably | 13:43 | |
timotimo | yeah, probably | ||
arnsholt | Then it can special-case if its argument is a variable with the @ sigil and compile to the elems op, instead of numify | 13:44 | |
Er Actions, not grammar, really | |||
timotimo | yes | ||
13:47
AW3i joined
|
|||
jnthn | I think maybe in NQP::Ops, which is backend-specific. | 13:48 | |
arnsholt | Oh, you mean fiddling with the AST directly in QAST::Compiler? | 13:49 | |
jnthn | No, it's that the numify thing is implemented differnetly by backend. | ||
iirc | |||
arnsholt | Oh, that | 13:50 | |
But at least on JVM the return type of the numify op is Double | |||
I was thinking that the grammar would just emit an elems op when the argument is a literal variable whose sigil is @ | 13:51 | ||
jnthn | Well, it's not the grammars jot to emit anything | 13:53 | |
13:53
rurban1 joined
|
|||
jnthn | It'd be in the actions if anywhere | 13:53 | |
FROGGS | <arnsholt> Er Actions, not grammar, really | ||
arnsholt | Yeah, I keep saying grammar, but it's the actions of course >.< | 13:54 | |
I think my brain just doesn't want to separate the actions and the grammar =) | |||
timotimo | worst case, the optimizer can do it. | ||
because the important point is that everything downstream from the optimizer gets to know that it returns int. | 13:55 | ||
FROGGS .oO( worst case, the timotimo can do it ) | |||
jnthn | optimizer feels wrong | ||
Actions can work. | |||
FROGGS | I always think "timotimo" when I read "optimizer" for some reason :o) | ||
timotimo | fair enough, i'll have a look | ||
13:56
ajr_ left
|
|||
arnsholt | timotimo: I took a peek at the code, and prefix:sym<+> in NQP::Grammar sets the op via the <O()> directive | 13:56 | |
moritz | IMHO it's not a job for the grammar | 13:57 | |
but rather for the code-gen or the optimizer | |||
timotimo | i see that | ||
in theory, the prefix:<+> rule could do a lookahead for an @ character | |||
and generate a nqp::elems instead | 13:58 | ||
13:58
btyler joined,
guru joined
|
|||
arnsholt | Don't even have to touch the grammar. The action can just make a different AST based on the type of the AST of its argument | 13:58 | |
13:59
guru is now known as ajr_
|
|||
arnsholt | moritz: That's true too, but then we'll have needlessly duplicated code to handle this | 13:59 | |
timotimo | arnsholt: but then i'd have to replace the functionality of the O in that case :) | 14:00 | |
probably would just have to remove the :op piece, though | |||
FROGGS | - token prefix:sym<+> { <sym> <O('%symbolic_unary, :op<numify>')> } | 14:01 | |
+ token prefix:sym<+> { <sym> [ <?[@]> <O('%symbolic_unary, :op<elems>')> || <O('%symbolic_unary, :op<numify>')> ] } | |||
won't that work? | |||
timotimo | that's pretty much the change i have ,except i put a <![@]> in there for good measure | ||
so that failure won't be weird | |||
arnsholt | Does token have sigspace? I can't remember... | 14:02 | |
14:04
jnap joined
14:05
treehug88 joined
|
|||
timotimo | no, that's rule | 14:05 | |
with that change, tests still pass apparently. i'll try rakudo now. | |||
arnsholt | Right. In that case, that grammar tweak will fail on "+ @array" I think | ||
timotimo | 41 wallclock seconds on parrot, 14 on moar ♥ | 14:06 | |
that's not prefix:<+>, though | |||
14:07
jnap left
14:10
jnap joined
14:12
AW3i left
|
|||
moritz | <?before \s*\@> <O('%symbolic_unary, :op<elems>')> || <!before \s*\@> <O('%symbolic_unary, :op<numify>')> | 14:13 | |
timotimo | nqp: my @foo; say(+ @foo); | 14:14 | |
camelia | nqp-moarvm, nqp-jvm, nqp-parrot: OUTPUT«0» | ||
FROGGS | nqp-p -e 'my @array; say(nqp::objprimspec(+@array))' # gives 1, which might be correct | ||
timotimo | oh, huh. | ||
FROGGS | moritz: prefix '+' has no whitespace afterwards | ||
timotimo | FROGGS: apparently it does, though | 14:15 | |
see my eval above | |||
moritz | FROGGS: the OPP eats that, iirc | ||
FROGGS | true, --target=ast shows it delegates to prefix:<+> | ||
timotimo | i'll add the whitespace then. | 14:16 | |
and now it would be nice to teach the optimizer that infix:<+> will turn a list into an int. | |||
FROGGS | but I would not add a <!before in the second branch when using a sequential alternation | 14:17 | |
timotimo | OK | ||
14:20
kaare_ left
|
|||
moritz hopes that terminating LTM doens't cause any extra warts | 14:21 | ||
14:21
kaleem joined
|
|||
hoelzro | o/ #perl6 | 14:22 | |
FROGGS | hi hoelzro | ||
moritz | does NQP need floating point numbers at all? | ||
timotimo | sometimes they're nice to have | 14:23 | |
FROGGS | moritz: at least for --stagestats :o) | ||
14:24
salv0 left
|
|||
moritz | FROGGS: well, that could be done with nqp::div_n ops etc. | 14:27 | |
FROGGS: so more on the "library" level than on the "language" level | |||
FROGGS | yeah | 14:28 | |
I don't need nums in nqp fwiw | |||
at least not as a result of an expression | |||
timotimo | hm | ||
14:34
Alula joined
14:41
jnap1 joined,
salv0 joined
|
|||
[Coke] | I would like to start keeping something very vaguely resembling a project plan. We've talked about what has to be done for "6.0", I'd like to get a list, not to set anything in stone, but to help communicate to people looking for impactful things to help with, or people asking "how soon?". If you have anything you're working on that might go on such a thing, or know of tasks that are currently not claimed (like a syn that's been in draft for a while), feel fre | 14:41 | |
FROGGS | diakopter created such a list | 14:42 | |
perhaps I am able to find it | |||
14:42
jnap left
|
|||
timotimo | we still have the roadmap in rakudo's repository i believe | 14:43 | |
colomon | item for list: ecosystem fully functional on all three backends. | ||
timotimo | now the optimizer turns 10 + @list into an add_i, too | ||
FROGGS | [Coke]: ethercalc.org/i982ooyabg.html | ||
14:44
arnsholt left
|
|||
FROGGS | [Coke]: this list is not complete | 14:44 | |
[Coke]: if a synopsis is missing there, it is more likely that one needs to record issues rather than beeing implemented fully | 14:45 | ||
timotimo | FROGGS: do you have a date with that? | 14:48 | |
colomon | FROGGS: It seems to me that list is too detailed … at least for what I'd imagined [Coke]++ meant | ||
[Coke] | yah. I could see drilling down to something like that, though. | 14:49 | |
colomon: you're a music guy: share and enjoy my son's arrangement of this song: www.youtube.com/watch?v=i6ZOAQU44es | 14:50 | ||
FROGGS | timotimo: around May 2013 | ||
colomon: true, but you only can record the details, and then put it in boxes labeled with a nice task description | 14:51 | ||
timotimo | oh, not terribly old then | ||
colomon | [Coke]: nice job he did! | 14:53 | |
14:53
ajr_ left
14:54
guru joined,
guru is now known as Guest54850,
Guest54850 is now known as ajr_
|
|||
timotimo | aye, not bad! | 14:55 | |
[Coke] | colomon: danke. | 14:57 | |
pmichaud | what's going on with issue #253 ("add env handling to parrot qx") ? | 15:06 | |
timotimo | it seems like a non-negligible amount of people visit my blog, but none are interested in the LHF i'm posting | 15:07 | |
i wonder if i should continue digging for LHF to post on my blog | |||
pmichaud | good morning, #perl6 | ||
timotimo | pmichaud: currently parrot will not propagate changes to %*ENV when using qx to execute stuff | ||
pmichaud | I understand the problem, I don't understand the proposed solutions. | ||
timotimo | reini made changes to parrot and rakudo to make it work again | ||
pmichaud | ...except that reini keeps posting failing tests | ||
timotimo | i haven't a clue what exactly is going on | 15:08 | |
that branch will have to wait another month anyway, though | |||
FROGGS | pmichaud: yes, there is some sort of confusion going on | 15:09 | |
I commented again right now | |||
pmichaud | also, reini's proposed patch (c87126f2) is going absolutely in the wrong direction... replacing nqp:: calls with pir:: calls | 15:10 | |
timotimo | only inside the #?if parrot block, though | ||
pmichaud | I'm not ever a fan of putting more pir:: into the rakudo codebase | 15:11 | |
whether it's in an #?if parrot or not | |||
beyond that, #?if parrot should be a rarity, not the norm | |||
timotimo | fair enough | ||
FROGGS | pmichaud: I think we can replace that with an nqp::open(... 'rp') | ||
timotimo | that block was there all along ;) | ||
pmichaud | well, all of these #?if thingies have been added since I was last active. I agree we'll need some... but they should be rare | 15:12 | |
FROGGS | true | ||
pmichaud | having the ability to shell out with an environment in place should be an nqp-feature, not a rakudo one. | ||
timotimo | mhm | ||
that makes sense, yeah | |||
pmichaud | or, at least, we should be solving it at the nqp level | ||
FROGGS | pmichaud: when the code in parrot works, we can make the nqp::openpipe op do all the work, like on moar and jvm | 15:13 | |
pmichaud | switching VTABLE void set_pmc_keyed(...) to be METHOD void set_pmc_keyed() is almost certainly wrong. | 15:14 | |
for that matter, $pipe.set_keyed('env', $env); is almost certainly wrong also. | 15:16 | ||
jnthn | That looks odd to me too | 15:17 | |
15:17
hoverboard joined
|
|||
FROGGS | I am all ears | 15:17 | |
jnthn | I thought nqp::openpipe was the thing we were putting this behind? | ||
pmichaud | jnthn: yes, I agree it should go somewhere like that | ||
FROGGS | jnthn: still, parrot should support the env handling first (unless we do that on our own like we do for shell/run) | ||
pmichaud | but I don't quite understand Parrot's patch either.... it seems odd to put the environment into the filehandle | ||
jnthn | Are we looking at something that never worked on Parrot here, or are we dealing with a regression of some kind? | 15:18 | |
FROGGS | jnthn: env handling in qx{} never worked | 15:19 | |
jnthn | OK. | ||
But does on Moar/JVM? | |||
FROGGS | yes | ||
tadzik | problem solved :P | ||
jnthn | OK, then it's not a regression, so we needn't hurry on this ahead of release. | ||
FROGGS | true | ||
pmichaud | I'm more worried that a parrot misfeature is starting to turn into a rakudo misfeature | ||
jnthn | Yeah | 15:20 | |
My expectation is that April's Star release will suggest Moar as the default thing. | |||
brrt | pmichaud, i think i can think of a reason for that | ||
pmichaud | and the comments I'm seeing betray an unfamiliarity with Parrot internals | ||
FROGGS | jnthn: that seems reasonable | ||
brrt | just wait until i renember | ||
:-) | |||
FROGGS | pmichaud: I am here! you can say that my comments prove that :o) | 15:21 | |
brrt | nope, forgotten | ||
FROGGS | heh | ||
pmichaud | the whole pipe['env'] = env approach seems very wrong to me. it seems to me that opening a pipe in parrot should automatically accept the current environment... there shouldn't need to be an explicit pipe['env'] = env step | 15:22 | |
FROGGS | pmichaud: the current env ist just a hash from rakudo | ||
pmichaud | FROGGS: that's an imprecise statement. | 15:23 | |
regardless, I reject the patch proposed in #253 | |||
FROGGS | m: %*ENV<foo> = "bar" # we do not call setenv here | ||
camelia | ( no output ) | ||
pmichaud | FROGGS: I understand what you're saying. | 15:24 | |
FROGGS | (or putenv or whatever) | ||
pmichaud | FROGGS: the %*ENV hash is not the current environment... it's rakudo conception of what the current environment ought to be | ||
so saying "the current env is just a hash from rakudo" is imprecise. | |||
FROGGS | so we need to pass %*ENV around, like here to a CreateProcess or spawn or so | ||
15:24
xenoterracide joined
|
|||
pmichaud | FROGGS: yes, I know that. I'm the one that created that approach. | 15:25 | |
FROGGS | pmichaud: %*ENV is our understanding of the current environment | ||
15:25
arnsholt joined
|
|||
pmichaud | I'm saying that passing the environment through Parrot's FileHandle object is not the way we should be doing it. | 15:25 | |
FROGGS | so I say "current environment" of the viewpoint of a Perl 6 hacker | ||
moritz | what does FileHandle have to do with it? | 15:26 | |
FROGGS | yes, passing it to the thing that spawns the process might be saner | ||
moritz: opening a pipe seems to be a method on a filehandle | |||
moritz | aaaarrg | ||
FROGGS | :o) | ||
pmichaud | again, imprecise | ||
FROGGS | meh | 15:27 | |
pmichaud | well, not too bad | ||
FROGGS | meh! | ||
jnthn | As I understand it, nqp::openpipe should take the environment to use for the created process as one of its arguments. Exactly what that boils down to at the Parrot level is up for debate, but Rakudo should absolutely be using nqp::openpipe, meaning that it's NQP that should have any funky code-gen-y things. | ||
15:27
kaare_ joined
|
|||
pmichaud | in Parrot, the way one opens a pipe is to create a FileHandle PMC, then invoke the 'open' method using 'rp' as one of the arguments | 15:27 | |
jnthn: I agree, except I suspect that at some level NQP ought to be environment-aware. | |||
and should provide an API that rakudo could use that more smartly handles things like %*ENV | 15:28 | ||
i.e., we need to push more of Rakudo's environment-handling down into NQP | |||
jnthn | pmichaud: It's not clear to me that'd be better, nor worse. :) | ||
pmichaud: That is, "I think you might be right but I don't see it right away" :) | |||
pmichaud | jnthn: well, if spawning and openpipe are at the nqp level, then environment handling probably need to be there also | ||
jnthn | Since %*ENV is contextual in nature. | ||
pmichaud | well, it could be contextual in nqp, too :) | 15:30 | |
jnthn | :) | ||
Point. | |||
15:30
rindolf joined
|
|||
pmichaud | anyway, we're in agreement that nqp needs to know more about the environment, whether nqp manages it or lets the hll manage it is open for discussion | 15:30 | |
jnthn | I'm happy with such a factoring, anyway. Fully agree that we shouldn't be doing more pir::'ing in Rakudo. | ||
And yes, #?if mechanism is an escape hatch. | 15:31 | ||
The goal is to need them less. | |||
JVM and Moar often have the same ideas about things. | |||
pmichaud | I just added my summary/comments to #253 | 15:34 | |
FROGGS | and since nqp should be the glue language for backend specificas, we should be able to factore stuff there (src/vm/...) | 15:35 | |
15:38
sqirrel_ joined
|
|||
japhb__ | FWIW, I believe this *is* a regression, I just don't know when it happened -- because perl6-bench has some code that depends on it, but since last June it's mostly been timotimo++ working on it, so he may have been lucky and not run into the bug before now. | 15:46 | |
FROGGS | japhb: well, there was a time when we actually changed the environment of our own process | 15:48 | |
japhb__ | FROGGS: Ah, interesting. That would certainly explain it. But it does mean it's a regression from the end-user's point of view, just not a regression in parrot per se. | 15:50 | |
FROGGS | japhb__: yes, but not a regression happened since the last releases (I know, that does not help much) | 15:51 | |
japhb__ | FROGGS: Sure -- as I said, I've about a 9 month window when it could have happened. :-/ | 15:52 | |
15:54
xinming__ joined
|
|||
pmichaud | if it's a regression, then that would indicate that rurban's parrot branch isn't needed. | 15:56 | |
unless something regressed in parrot also | 15:57 | ||
that's pretty easy to check, actually. | |||
I have to run an errand now but might write a short test program when I return. | |||
15:57
xinming_ left
|
|||
FROGGS | it is a regression caused by rakudo | 15:57 | |
pmichaud | so a parrot change isn't needed, right? | ||
FROGGS | because, IIRC, we used to have a proxy in %*ENV that does a setenv/putenv of our process | 15:58 | |
15:58
virtualsue left
|
|||
FROGGS | a parrot change is needed to cope with our %*ENV hash | 15:58 | |
pmichaud | that's the wrong approach. | 15:59 | |
FROGGS | either that or we move the entire openpipe code to nqp, as we did with run() and shell() | ||
pmichaud | I suspect that parrot's openpipe already properly handles the environment. | ||
because it apparently used to do so. | 16:00 | ||
FROGGS | the question is: which environment | ||
pmichaud | *the* environment -- the process' environment. | ||
FROGGS | yeah, but we do not touch it enymore, which is a good thing | ||
pmichaud | the fact that rakudo has a separate %*ENV hash is not something that parrot should be considering. | ||
in particular, let's just establish up front that Rakudo's %*ENV is not "the environment". | 16:01 | ||
so, if I say "the environment", I'm not talking about %*ENV | |||
(if I want to talk about %*ENV, I'll say "%*ENV") | |||
FROGGS | k | ||
pmichaud | anyway, I have to run my errand, I'm back in 20. | ||
FROGGS | k | 16:02 | |
japhb__ | .oO( Do not try to unconfuse Professor Michaud. He is not confused. ) |
||
moritz | so, nqp should call setenv before launching stuff? | ||
japhb__ | moritz: Yeah, I think we're generally agreed that nqp is the right layer for abstracting the VM's env handling. Unless I misunderstood the backlog. | 16:04 | |
FROGGS | moritz: that might be a solution, except on machines where you are not allowed to setenv at all | 16:06 | |
moritz | and there seem to be two general methods: setenv before doing stuff, and passing an env hash to operations | ||
FROGGS | moritz: I am currently searching for informations about that, since I hit that problem back in 2008 or so | ||
segomos | is there a good write up on how to write better modules using roles and "new" stuff now or is it still kind of in an infancy stage? i'm wanting to write something similar to dbix and i want to use cool new shiny stuff | ||
16:11
lembark joined
16:12
denis_boyun left,
sqirrel_ left
16:19
spider-mario joined,
isBEKaml joined
|
|||
pmichaud | I propose we create nqp::setenvhash(hash) which updates the current process environment to match 'hash' | 16:20 | |
openpipe should continue to assume the current process environment is to be passed to the pipe process | |||
16:22
kaleem left
|
|||
rurban | well, it should restore the old env on openpipe exit, I assume | 16:23 | |
and it should do nothing on empty cwd and env args | 16:24 | ||
pmichaud | gist.github.com/pmichaud/9645412 # parrot already properly passes its environment to child pipe subprocesses | ||
16:28
slavik left
|
|||
pmichaud | I've updated Parrot issue #1065 with this gist. | 16:28 | |
synopsebot | Link: rt.perl.org/rt3//Public/Bug/Displa...ml?id=1065 | ||
16:29
[Sno] left
16:30
pmurias joined,
pmurias left,
pmurias joined
|
|||
pmurias | pmichaud: so shell shouldn't take the env as an argument anymore? | 16:31 | |
16:31
brrt left
|
|||
pmichaud | pmurias: I'm not sure about that coupling. It seems to me as though "set the environment" ought to be decoupled from shell | 16:31 | |
FROGGS | pmurias: are you talking about nqp::shell or rakudo's shell() ? | 16:32 | |
pmichaud | because there are many places where we might want to set the process environment -- it should be factored out. | ||
TimToady | seems like the general idea is that we either pass the proto-environment via dynamic %*ENV, or we pass it via an actual set environment, but rarely/never as an argument | ||
pmichaud | TimToady +1 | 16:33 | |
FROGGS | ahh, hmmm, for some reason I thought rakudo's shell() would take an optional env hash... but it does not | ||
pmichaud | passing it as an argument certainly has precedence in C, though | ||
TimToady | yup | ||
pmichaud | still, I think I prefer to keep "set environment" as its own separate operation | ||
or, put another way: we should definitely have an nqp:: set environment operation. Given that, I'd tend to not want another way to do it via nqp::shell(). | 16:34 | ||
(i.e., DRY) | |||
I might reconsider if JVM expects an environment as an argument to however it does the shell equivalent | 16:35 | ||
TimToady | it's a bit like the boundary enforcement for NFG--we let our semantic model drift from what the world expects in the interests of better internal consistency, but then enforce the world's view at the edges of the process | 16:36 | |
pmichaud | correct. | ||
similarly, I don't know that nqp::shell() should have a separate $cwd argument; it should use the process cwd. But I'm less certain about that one. | |||
TimToady | there maybe trapdoor functions hiding there, if it ever tries to relocate itself relatively, or we can't find an absolute path that works | 16:37 | |
16:37
ajr_ left
|
|||
TimToady | the environment is a bit better behaved that way | 16:38 | |
FROGGS | pmichaud: the jvm does not provide a way to chdir, so you have to keep what the user thinks is the cwd, and pass that along | ||
pmurias | pmichaud: JVM expecting an argument to the internal shell thing is the reason we pass the env as an argument currently | ||
TimToady | the chdir semantics get excercised at the boundary much more frequenetly than spawning does, I think | 16:39 | |
pmichaud | FROGGS: I agree except with the "you have to pass that along" part. There are other ways to do that. | ||
16:39
guru joined,
guru is now known as Guest94161
|
|||
pmichaud | pmurias: what's the JVM command for a shell (i.e., where can I see the API/docs for it?) | 16:39 | |
16:39
Guest94161 is now known as ajr_
|
|||
FROGGS | pmichaud: "you have to feed it to the jvm when invoking a shell" to be more clear | 16:39 | |
pmichaud | I'd like to see the actual code or API | 16:40 | |
FROGGS | nqp/src/vm/jvm/runtime/org/perl6/nqp/runtime/Ops.java:877: public static long shell3(String cmd, String dir, SixModelObject envObj, ThreadContext tc) { | ||
pmichaud | looking. | ||
pmurias | it uses ProcessBuilder | ||
FROGGS | ProcessBuilder pb = new ProcessBuilder(args); | 16:41 | |
pb.directory(new File(dir)); | |||
Map<String, String> pbEnv = pb.environment(); | |||
[...] | |||
TimToady | well, if a VM requires it as an argument, then that's one of those process boundaries at which we have to do what the world expects | 16:42 | |
pmichaud | okay, so it's not JVM that expects it as an argument -- that's an API we created. | ||
TimToady | but if, yeah, that | ||
pmichaud | I'm saying there's a different refactoring that doesn't require env/cwd as an argument. | 16:43 | |
16:43
SamuraiJack joined,
jeffreykegler joined
|
|||
pmichaud | what JVM is doing seems much closer to POSIX than what we're using as an API | 16:43 | |
TimToady | does ProcessBuild default to the current envinronment? | ||
*er | |||
pmichaud | TimToady: it appears so | ||
TimToady | then really we can decide one way or the other based on which is more efficient or "safer" | 16:44 | |
pmichaud | but ProcessBuilder appears to allow you to set the cwd of the new process | ||
TimToady | specified as a race condition^W^Wstring? | ||
FROGGS | so we should call nqp::getlexdyn('$*CWD') at that point instead of getting it passed to, say, shell()? Is that what we want? | 16:45 | |
pmichaud | FROGGS: that's not exactly what I'm proposing, now. | 16:46 | |
*no | |||
FROGGS | k | ||
pmichaud | I'm proposing that creating a HLL shell operation should be some combination of: nqp::setcwd($*CWD); nqp::setenv(%*ENV); nqp::shell(cmd); | 16:47 | |
timotimo | the good thing about enforcing environment and cwd at boundaries only is that we can have "my $*CWD" and friends work out naturally | ||
pmurias | nqp::setenv will have to be emulated on the jvm | ||
pmichaud | it has to be emulated pretty much anywhere | 16:48 | |
and it should be nqp::setenvhash(%*ENV) | |||
(typo in my original -- "setenv" actually has another meaning to folks) | |||
but it seems to me that nqp::setenvhash() is just | |||
Map<String, String> pbEnv = pb.environment(); | 16:49 | ||
pbEnv.clear(); | |||
pbEnv.putAll(env); | |||
with some slight variation to handle the different forms that env might take | |||
16:50
ajr_ left
|
|||
pmurias | but that sets the env variables for the new process but doesn't change the env variables in the current one | 16:50 | |
pmichaud | it doesn't? | ||
timotimo | no, the pb will be recreated for each invocation of nqp::shell | ||
pmichaud | huh? | 16:51 | |
pmurias | it seems to be impossible to change the current env variables | ||
timotimo | there has to be some internal variable that carries the data from nqp::setenvhash to nqp::shell | ||
on the java side, that is | |||
pmichaud | that's not how I'm reading the code | ||
isBEKaml | pmichaud: that's from processbuilder. That's only if you're planning to execute any programs off the current shell. If you want to access env variables, you can use System.getenv("prop name") | ||
timotimo | i should look closer | ||
FROGGS | timotimo: that is what we currently have in the HLL :o) | ||
isBEKaml | pmichaud: That said, it's good to see you back here. :-) | ||
pmichaud | I'm looking at the code now, and the way that the environment is being set is by simply modifyinb pbEnv. I don't see anywhere that pbEnv is being linked up with the ProcessBuilder object. | 16:52 | |
isBEKaml | pmichaud: Can you post link? | ||
pmurias | pbEnv = pb.environment() | ||
timotimo | ah | 16:53 | |
isBEKaml | pmurias: pb --> ProcessBuilder | ||
pmichaud | github.com/perl6/nqp/blob/master/s....java#L931 | ||
timotimo | now i see where your confusion comes from | ||
pmichaud | oh, I get it. | ||
timotimo | note that th ebeginning of the "private" spawn method is to create a new ProcessBuilder | ||
pmichaud | yes, I see the link now. | ||
pbEnv is the pb's environment | |||
okay. | |||
isBEKaml | pmichaud: yes. exactly. | ||
FROGGS | so we have exactly the same problem for cwd and env, which is not a bad thing | 16:54 | |
(on jvm) | |||
pmichaud | well, not necessarily | ||
because pb.environment() defaults to the current process environment | |||
FROGGS | in kinda inherits from it, yes | 16:55 | |
if we had a way to change the current env... | |||
timotimo | sadly, my optimizer changes to nqp to make +@foo and 1 + @foo give integer operations caused S03-operators/identity.rakudo.moar to regress | 16:56 | |
FROGGS | pmichaud: stackoverflow.com/questions/318239/...-from-java | ||
pmichaud | and yes, it appears that jvm doesn't provide a clean way to change the current process' environment. I'm not necessarily sad about that, but I do want to rethink the API a bit | ||
16:57
hoverboard left
16:58
jeffreykegler left,
myfree joined
|
|||
pmichaud | what's the JVM equivalent of exec(), ooc? | 16:59 | |
16:59
lembark left
|
|||
pmichaud | or is there no such animal? | 17:00 | |
isBEKaml | awkward animals. | ||
FROGGS | www.javaworld.com/article/2071275/c...won-t.html | 17:01 | |
isBEKaml | pmichaud: ProcessBuilder and Runtime.exec were meant for that. It turned out that inheriting environments isn't always quite feasible. | ||
pmichaud: so you end up building your own set of properties to use and importing them into spawned processes. | 17:02 | ||
pmichaud | isBEKaml: in other words, there's not an exec() exact equivalent | ||
i.e., one that replaces the current process with a new command | |||
isBEKaml | pmichaud: that's where we use Map<String, Object> objects. | ||
masak | Util++ # Parrot release mail quote | ||
pmichaud | isBEKaml: those all sound as though they're creating new processes, though | 17:03 | |
isBEKaml | pmichaud: Nothing exactly same as system() or backticks. No. | ||
pmichaud | system() creates a new process. backticks create a new process. exec() replaces the current process image with a new image. | ||
so, I'm not looking for a system() or backtick equivalent, I'm looking for an exec() one. | 17:04 | ||
isBEKaml | pmichaud: No, we don't have one on the JVM side of things. | ||
dalek | c: 8535ec3 | Mouq++ | lib/modules.pod: Blindly copy module information from archived wiki (This will need to be updated) |
17:05 | |
pmichaud | okay. so that's something we'll only be able to emulate (badly) or declare is not supported | ||
17:06
treehug8_ joined
|
|||
isBEKaml | pmichaud: well, if you understand that JVM by itself is a sandboxed environment, you'll see that it's meant to not execute off its current environment. So out goes exec() -- though I remember seeing something like that somewhere. Let me do some searching to see if there's one. | 17:07 | |
pmichaud | isBEKaml: yes, I understand it -- just needed some confirmation that this is the case | ||
exec() is the only place where I can think of that it'd be important to get the process environment to match %*ENV | |||
although TimToday++ undoubtedly will know if there are others :) | |||
timotimo | and jvm doesn't have exec() | ||
so we can probably safely emulate %*ENV for everything on jvm | 17:08 | ||
pmichaud | well, I think we have to emulate %*ENV everywhere | ||
timotimo | if someone choses to exec using NativeCall ... | ||
they'll likely run into other problems :) | |||
pmichaud | well, via NativeCall we'd be able to modify the current process environment, yes? | ||
(I'm not familiar with how NativeCall works either... I'm about a year out of date) | 17:09 | ||
arnsholt | jnthn: Could you try nqp/jastcompiler and Rakudo a whirl, BTW? | ||
I suspect I've broken something, but I'm not entirely sure =) | |||
17:09
treehug88 left
|
|||
timotimo | oh, yeah, with NativeCall the user probably could | 17:09 | |
wouldn't be terribly surprised if the JVM laid some more stones in our way for that, though >_> | |||
masak | feature request for Rakudo: make it impossible to build Rakudo on an outdated NQP or Moar. | 17:10 | |
timotimo | masak: well, if you constantly Configure.pl like any sensible person ... ;) | ||
pmichaud | masak: ??? Doesn't rakudo already do that check? | ||
I don't believe in making it "impossible". | 17:11 | ||
I would be okay with having a check done at each 'make' invocation, instead of only at Configure.pl time | 17:12 | ||
timotimo | oh, whoops | ||
FROGGS | it only croaks if you reconfigure | ||
err, yes | |||
timotimo | letting prefix:<+> look ahead for a @ can easily break down | ||
for example in this line: return +@!BLOCKS[$i].symbol($symbol) | |||
(this type doesn't support elems) | 17:13 | ||
pmichaud | doing a lookahead for syntax is almost certainly wrong | ||
masak | ok, "impossible" is a strong word. | ||
timotimo | aye. | ||
masak | I meant, used to be with Parrot the `make` invocation told me if the dependencies were too old, and refused to build. | ||
timotimo | should have realized that earlier :) | ||
masak | I'd like that. | ||
timotimo | masak: are you sure you're not thinking of having an older Makefile than Makefile-Parrot.in? | 17:14 | |
pmichaud | we can easily come up with a build tool that checks dependencies | ||
does Parrot no longer check the dependencies? | 17:15 | ||
er | |||
masak | timotimo: I don't know the exact circumstances. | ||
pmichaud | do we no longer check the dependencies even for Parrot builds? | ||
masak | timotimo: but I know this: I git `git pull`, `make`, and then the build failed. | ||
timotimo | Configure.pl will loudly complain if the *_VERSION files are not met | ||
17:15
SamuraiJack_ joined
|
|||
timotimo | but make alone will never do thtat | 17:15 | |
pmichaud | timotimo: make used to do that | ||
masak | timotimo: it was *fixed* when I re-configured, but I think `make` should be clever enough to not waste time building something that won't build. | ||
17:16
kaare__ joined,
zakharyas left
|
|||
masak | yes, make used to do that. | 17:16 | |
it was nice. | |||
timotimo | oh, ok | ||
pmichaud | geez, so many absolutes in this channel now! "impossible" "never" | ||
timotimo | must have been before my time :P | ||
masak | pmichaud: :P | ||
why *shouldn't* make do that? | |||
isBEKaml | pmichaud: we even have P6BP! :P | ||
timotimo | (which obviously doesn't mean "make will never do that" is wrong. because if it ever did, it did so before my time! which, you see ...) | ||
masak | isBEKaml: we do!? | 17:17 | |
isBEKaml | masak: well, there you are. :P | ||
17:17
SamuraiJack left
|
|||
pmichaud | maybe I should just crawl back under a rock for another year :) | 17:17 | |
masak | no please stay | ||
timotimo | oh, btw, who am i going to see at the GPW? | ||
pmichaud | I'm still working out my schedule after having had my spring/summer completely jumbled around for a couple of weeks. | 17:18 | |
FROGGS | <--- | ||
isBEKaml | pmichaud: No -- please don't ! It's fun to see someone who says "OMG, where has the world gone to??!!" :D | ||
17:19
kaare_ left
|
|||
pmichaud | well, I have to take a break for a bit... bbl | 17:19 | |
17:19
myfree left
|
|||
FROGGS | soup & | 17:19 | |
17:19
FROGGS left
|
|||
[Coke] | masak: yes, that should be doable. Please open a ticket. We can figure out that dependancy. | 17:23 | |
masak submits rakudobug | 17:24 | ||
17:24
SamuraiJack_ left
17:25
denisboyun joined
|
|||
[Coke] | very excited to see progress on parrot #582 | 17:27 | |
(Add 6model to Parrot) | |||
isBEKaml | [Coke]: how goes mojo port to perl6? :-) | 17:31 | |
17:39
pmurias left
17:43
isBEKaml left
17:46
guru joined,
[Sno] joined,
fhelmberger left,
guru is now known as Guest23952,
Guest23952 is now known as ajr_
|
|||
[Coke] | isBEKaml: work is interfering. haven't had a lot of cycles. | 17:50 | |
17:52
SamuraiJack_ joined
|
|||
masak | [Coke]: here you go: 🚲 | 17:53 | |
[Coke] | ooh, a diamond with a question mark. | ||
sweet. | |||
masak | :P | 17:54 | |
masak .oO( clearly it's an empty rectangle, not a diamond with a question mark ) | 17:55 | ||
17:55
SamuraiJack_ left
17:59
FROGGS joined
18:00
rylinaux left
18:01
rylinaux joined,
rylinaux is now known as Guest10848
18:05
Guest10848 left
18:06
Ryan_ joined
18:13
Ryan_ is now known as rylinaux
|
|||
[Coke] | masak: as someone who is about to try to convince a PM to use stylized unicode numbers rather than going out to find an icon set of numbers, I sympathize. | 18:14 | |
timotimo | a perl monger? | 18:15 | |
prime minister? | |||
arnsholt | Project Manager, probably | 18:16 | |
timotimo | ah | ||
that makes more sense | |||
TimToady | someone should rewrite irssi in Perl 6, and fix everything that's wrong with it :) | 18:17 | |
vendethiel | Does somebody have a graph for perl6-jvm perfs when the JIT is hot ? | ||
arnsholt | I must confess I don't really have any things that really annoy me with irssi | 18:18 | |
TimToady | yes, somebody does :) | ||
vendethiel | Trying to get somebody interested in perl6 :p. | ||
TimToady | arnsholt: well, not rendering characters that I have the fonts for, for one | 18:19 | |
timotimo | vendethiel: t.h8.lv/p6bench/2014-03-09-every_perl.html | ||
(but please mention that the microbenchmarks are not very good) | |||
vendethiel | timotimo++ # which ones are the least-micro ? | ||
arnsholt | TimToady: Oh, that does sound annoying. OTOH, it does sound like a bug in your terminal emulator rather than irssi =) | 18:20 | |
timotimo | vendethiel: at the very very bottom | ||
arnsholt | rc-forestfire shows the JIT at work | 18:21 | |
TimToady | arnsholt: yes, that's certainly possible | ||
timotimo | aye, the forestfire benchmark is a good one for seeing how the jit warms up | ||
vendethiel | arnsholt: yeah, I took this one :-) | ||
arnsholt | Rakudo doesn't do very well on it, but the graph for nqp-jvm is nice | ||
TimToady | perhaps the most important thing to point out is that the performance of Perl 6 will approach the performance of nqp as our optimizer gets better | ||
arnsholt | Starts out pretty slow, but as the JIT heats up it actually ends up faster than Perl 5 | 18:22 | |
vendethiel | timotimo: need to do it again with jdk 1.8 :-) | ||
timotimo | will have to, yeah | ||
also point out by how much the rakudos and nqps get faster between the regular and _native variants of some of the microbenchmarks | |||
TimToady | in particular, forest-fire uses 2-D arrays that will be much, much faster someday soon | ||
once we have shaped arrays of known, preallocated sizes | 18:23 | ||
timotimo | and when the type specializer (perhaps) starts removing bounds checks | ||
TimToady | of native values | ||
timotimo | when we have very fast, shaped native arrays, that'll give us something nice for Modern OpenGL™ | 18:24 | |
TimToady | not so much the bounds checks as it is all the redispatch to at_pos, and the checking for element existence for autoviv | ||
timotimo | ah, yes, shaped arrays of natives won't ever do autoviv | ||
right? | |||
TimToady | no, but we need to teach the compiler about lvalues, which it's pretty ignorant of currently | 18:25 | |
same problem as doing $a++ on a native, basically | |||
timotimo | ah, that one | ||
that keeps cropping up more and more often | 18:26 | ||
18:26
hoverboard joined
|
|||
TimToady | we need something like C's pointer to native types to be able to talk about lvalues | 18:26 | |
though one can fake it up to a point | 18:27 | ||
and indeed JVM kinda forces you to fake it | |||
vendethiel | Also -- I'm trying to get the post of perl6advent that adds custom operators, like the exponential one, describes a macro `/* */` but my search do'nt bring anything up | ||
TimToady | so our "pointers" are likely to be array/hash refs with precalculated sublocations when we can't use C pionters | 18:28 | |
*oi | |||
vendethiel: need a link to understand what yer askin' | 18:29 | ||
vendethiel | TimToady: I need a link myself, actually ;-) | 18:30 | |
TimToady: There's a really cool perl6advent post that got me interested in perl6 in the first place, creating custom operators to deal with error percents | 18:31 | ||
and some other mathematical notations (basically introduces sub infix:...) and also has, IIRc, an example of a macro that could parse `/* */` comments | 18:32 | ||
timotimo | perlgeek.de/blog-en/perl-5-to-6/13-...ators.html ? | ||
oh, actually notd | |||
18:33
bjz left
|
|||
vendethiel | timotimo: I do believe it was a perl6advent blog post | 18:33 | |
TimToady | actually, to do /* */ correctly requires not a macro, but a tweak to the definition of whitespace | ||
vendethiel | TimToady: it was maybe a "fake" example in that it didn't actually really work, but demonstrated a possibility | 18:34 | |
TimToady | our current macros can only replace a term, really | 18:35 | |
once we generalize that to replacing any syntactic category, then you could put a macro into the comment: space instead | |||
timotimo | perl6advent.wordpress.com/2012/12/1...is-futile/ ? | 18:36 | |
TimToady | it's vaguely possible it could be forced to work currently somehow | ||
vendethiel | timotimo++ # thanks ! I believe that's it ! | ||
Definitely :-) | 18:38 | ||
I'll try to look for the macro and stuff one later, though. | |||
TimToady | m: macro comment:</* */> () { '' }; say 1 /* phooey */ + 41 | ||
camelia | rakudo-moar 01d16c: OUTPUT«===SORRY!=== Error while compiling /tmp/RURkzDIp31Cannot add tokens of category 'comment'at /tmp/RURkzDIp31:1------> macro comment:</* */> ⏏() { '' }; say 1 /* phooey */ + 41 expecting any of: …» | ||
TimToady | yeah, not supported yet | ||
or augment slang might work someday too | 18:39 | ||
but that all probably depends more on the HLLization of the P6 parser that I mentioned yesterday | 18:40 | ||
we can't really claim that all other languages are just dialects of Perl 6 till that happens :) | |||
vendethiel .oO(Perl6 is getting slower yet) :p | |||
TimToady | well, we can pessimize it lazily at the point where you try to make it do something fancy :) | 18:42 | |
it would be fun to try to write a yacc grammar for the subset of Perl 6 that people usually use, and switch out to the recursive descent when yacc isn't suitable, for instance | 18:44 | ||
there are also probably ways to cheat on how often we have to generate a new lexer, which slows things down when you define new operators | 18:46 | ||
or to remember the lexer you generated last time you were here | 18:47 | ||
at some point it starts looking more like an incremental compiler if you do that | 18:48 | ||
but obviously there's still lots of room for improvement, and we hope that we're not locking anything into the design that precludes such improvements | 18:50 | ||
18:52
tgt joined
|
|||
TimToady | another way to cheat is to keep short exception lists in grammatical categories, so, for instance, a few unambiguous postfixes might just be added to an exception list rather than being immediately compiled into a new lexer, especially if it's easy to recognize the exceptions based, say, on their first character | 18:55 | |
there are no other postfixes that start with ! for instance, so it's really easy to look up a ! postfix as an exception to the current postfix lexer | 18:56 | ||
likewise most unicode symbols will be unique in the first char | |||
so basically you install a 1-level trie in front of the lexer for the category in question | 18:57 | ||
18:57
logie_ left
|
|||
TimToady | you could add all the operators in that advent post without ever recalculating a new lexer | 18:59 | |
PerlJam | hmm. | 19:01 | |
TimToady | or another way to view it would be to say that the lexer is really allowed to decide when it needs to redo the FSA | ||
PerlJam | TimToady: you seem to be feeling much better; is this true? :) | 19:02 | |
TimToady | or perhaps more importantly, the distinction might be whether the lexer is allowed to mutate itself in place | 19:03 | |
PerlJam: well, considering I hacked in all the Unicode stuff while I was having pneumonia, I dunno how you'd tell the difference :) | |||
PerlJam | volumetric analysis of your text + cogency ;) | 19:04 | |
nwc10 | pmichaud: this blog post about how JRuby fights the JVM to do fork, exec, etc might be relevant: blog.headius.com/2013/06/the-pain-o...ocess.html | 19:05 | |
timotimo: I'm going to the German Perl Workshop | |||
TimToady | { Language A .... mutate-to-lang(B) .... Language B }; as long as there's no need for Language B to ever refer to Language A as a subset, you can just mutate the current Language A lexer into Language B | 19:06 | |
and you just throw away the mutated lexer at the end of the block anyway | |||
but that's assuming Langauge A didn't come from outside the block | |||
so you have to clone the langauge at least once, but after that you can just mutate in place | 19:07 | ||
s:g/gauge/guage/ | 19:08 | ||
timotimo | nwc10: cool :) | 19:09 | |
TimToady | you can do the same sort of cheating with Cursors when you know the old Cursor isn't going to be reused to backtrack with, for instance | 19:10 | |
nwc10 | I assume that FROGGS is, given that he's speaking: act.yapc.eu/gpw2014/talk/5252 | ||
FROGGS | nwc10: \o/ | 19:11 | |
nwc10 | wendy and Liz are "confirmed" according to act | 19:12 | |
19:13
darutoko left
19:25
kivutar joined
|
|||
TimToady | .oO(The JVM interprets sanity as damage and routes around it.) |
19:31 | |
geekosaur | ain't that the truth | 19:34 | |
19:35
Rotwang joined
|
|||
lizmat | nwc10: indeed | 19:50 | |
Sex and Violence: Social and Technical Lessons from the Perl 6 Project ( www.linux-gull.ch/GestionActiviteDo...40401.html ) | 19:51 | ||
another TheDamian presentation | |||
nwc10 | PHP 353, Perl 12. We lose | 19:52 | |
www.cvedetails.com/product/128/PHP-...ndor_id=74 vs www.cvedetails.com/product/135/Larr...ndor_id=81 | |||
that really is quite a spectacular difference. :-/ | |||
19:54
brrt joined
|
|||
PerlJam | Why does the perl data stop at 2007? | 19:57 | |
nwc10 | yes, good question. | ||
OK, 353 vs 15: www.cvedetails.com/product/13879/Pe...or_id=1885 | 19:58 | ||
The[ir] data is crap | |||
PerlJam | clearly | 19:59 | |
But if people are going to use TIOBE to say that Perl is dying, we can use this to say Perl is secure ;) | |||
20:02
btyler_ joined
|
|||
masak .oO( Eskimoes interpret fifty words for snow as damage, and route around them ) | 20:03 | ||
20:06
xinming__ left,
btyler left
|
|||
rjbs | PHP interprets security as damage and routes around it? | 20:07 | |
20:07
FROGGS_ joined,
FROGGS left
|
|||
lizmat | .oO( 353 shades of grey? ) |
20:08 | |
20:08
treehug8_ left,
treehug88 joined
|
|||
nwc10 | I wonder whether their data cleaned up could be made into a graph that superficially looks like usage | 20:10 | |
(with Perl really low) | |||
but then the punchline is that it's CVEs | |||
rjbs | haha | 20:11 | |
brrt | easy shots at php again :-) | ||
i think the CVE-count is pretty low for perl6 as well | |||
rjbs | of course, the counter-snipe is that it IS about usage | ||
"perl has so few CVEs because nobody targets it" | 20:12 | ||
nwc10 | Python is split between www.cvedetails.com/product/18230/Py...r_id=10210 and www.cvedetails.com/product/2147/Pyt...or_id=1238 | ||
rjbs | bunk, but would get airplay | ||
nwc10 | Python and Ruby are (also) much lower than PHP | ||
brrt | php has lots of bugs, surprising no one | ||
nwc10 | so would need some data cleanup to try to be fair | ||
PHP manages to have CVEs on its CVE fixes | 20:13 | ||
rjbs | hah | ||
nwc10 | and create CVEs due to shipping a version with failing tests | ||
rjbs | strikes me as useful to discredit PHP, which nobody needs to do | ||
publicizing it would be a bit like kicking a guy while he's down | |||
vendethiel | php contributors are known not to update related tests, though ... At least they used to | 20:14 | |
nwc10 | yes, agree | ||
PerlJam | Better that we not bash on any other language, but rather tout the merits of the language(s) we love. | 20:15 | |
20:15
xinming_ joined
|
|||
nwc10 | yes, agree. | 20:16 | |
This was partly a thought experiment, and partly shock at *how* big the difference is | |||
masak | everything about PHP is depressing. even its lack of security. | 20:17 | |
it's as if someone deliberately designed a language for people who just plain don't care. | 20:18 | ||
nwc10 | implemented by people who don't care (too lazy to look up "Paamayim Nekudotayim") with code review that didn't care either | 20:20 | |
perigrin | masak: actually I think basedon the quotes I've heard ... that *is* the design principle behind PHP. | 20:21 | |
PerlJam | That's close to factual I think. | ||
Didn't petdance offer to help clean up the PHP codebase (by providing patches) and got a "thanks, but no thanks" ? | 20:22 | ||
huf | they did basically fire the one guy who seemed to care about security :D | ||
years and years ago | |||
perigrin | "I really don't like programming. I built this tool to program less so that I could just reuse code." - Rasmus | 20:23 | |
20:23
bjz joined
|
|||
masak | nwc10: "Although it has been confusing to many developers who do not speak Hebrew, it is still being used in PHP 5" -- what. the. phaamayim. | 20:24 | |
to be fair, that's the first thing about PHP where I crack a reluctant smile, rather than putting my head in my hands or banging it against a wall. | 20:25 | ||
huf | that's honestly the least of the problems, yeah | ||
masak | it's just so... inept. | ||
huf | not even that, it's just a quirk | ||
"0e8217321" == "0e171717" is the really inept thing. | |||
much more "representative" of a fuckup than the ivrit token name | 20:26 | ||
masak | yep. | ||
that puts me back to "depressed" again. | 20:27 | ||
huf | and this isnt even an implementation bug, it's a "spec" bug :D js has similar ones. | ||
PerlJam | So ... how about those awesome feed operators in Perl 6? And the neat-o asynchrony? | ||
huf | probably not *quite* as bad, but if you treat types as suggestions AND have operator overloading, you're gonna have these | ||
masak | PerlJam: yeah. we should all build awesome indespensible apps on top of that. | 20:28 | |
vendethiel | huf: don't make me more sad hahaha | 20:29 | |
huf | vendethiel: sorry, i'm a cloud of depression. | ||
20:29
stevan_ left
20:32
stevan_ joined
20:34
stevan_ left
20:45
kbaker_ left,
kbaker_ joined
20:55
BenGoldberg joined
20:56
rindolf left
21:01
dayangkun left
21:02
bjz left
21:04
kbaker_ left,
kbaker_ joined
21:09
treehug88 left
21:17
dayangkun joined
21:32
kaare__ is now known as kaare_
|
|||
moritz | std: | 21:35 | |
eeks | |||
std: my Int|Str $foo | |||
camelia | std 09dda5b: OUTPUT«===SORRY!===Multiple prefix constraints not yet supported at /tmp/35yFfqrnUQ line 1:------> my Int⏏|Str $fooMalformed my at /tmp/35yFfqrnUQ line 1:------> my Int⏏|Str $foo expecting any…» | ||
lizmat | std: my IntStr $foo | ||
camelia | std 09dda5b: OUTPUT«===SORRY!===In my declaration, typename 'IntStr' must be predeclared (or marked as declarative with :: prefix) at /tmp/QfVsFl253U line 1:------> my IntStr⏏ $fooMalformed my at /tmp/QfVsFl253U line 1:------> …» | ||
lizmat | weren't there some dual types specced but not implemented yet ? | 21:36 | |
vendethiel | std: subset IntStr where Int | Str; my IntStr $a; | ||
camelia | std 09dda5b: OUTPUT«ok 00:01 124m» | ||
vendethiel | lizmat: Int|Str and Int&Str are speced | 21:37 | |
brrt | folks, help me out here | 21:39 | |
somebody claims that to sum numbers from 1 to N, you'd need O(N^2) | 21:40 | ||
not sure of space or memory, but whatever | |||
i can sum numbers from 1 to n in constant time | |||
21:40
ajr_ left,
kaare_ left
|
|||
tadzik | somebody is wrong :) | 21:41 | |
you can do that in constant time and space alright | |||
brrt | i'd think so | ||
maybe he means the solution is on the order of n^2, which is true | 21:42 | ||
but that is not the right way to use O | |||
moritz | tadzik: that's not true | ||
21:42
kbaker_ left
|
|||
moritz | tadzik: the result needs O(log(N)) bytes, which you can't compute in O(1) | 21:43 | |
tadzik | oh, heh | ||
brrt | .... such truth | ||
brrt tends to take integer arithmetic as constant-time-always | |||
especially with 64 bit | |||
moritz | I'm not sure about the time complexity of multiplying numbers, but it's not O(1) | 21:44 | |
brrt | 64 bit ought to be enough for everybody | ||
tadzik | yeah, I wanted to say "unless you jump into bigints", but found that to be bikeshedding :Y | ||
brrt | you can do multiplication in O(1) if you have enough transistors | ||
moritz | well, that kind of bikeshedding is what complexity theory is all about | ||
PerlJam | masak: He didn't say O(1), he said O(C) ;) | ||
er, moritz | |||
moritz | PerlJam: and C = log(N) ? :-) | ||
tadzik | I assumed int operations being all O(1) in a hypothetical tool used to compute that | ||
which is not true in a general case :) | 21:45 | ||
PerlJam | If you have a quantum computer, all algorithms are O(C) :) | ||
brrt | i still don't actually believe that | ||
flussence | rakudo-m: gist.github.com/flussence/3007551 | ||
does... that not work? | 21:46 | ||
perl6: gist.github.com/flussence/3007551 | |||
huh. | |||
it used to. | |||
camelia | rakudo-parrot 01d16c, rakudo-jvm 01d16c, rakudo-moar 01d16c, niecza v24-109-g48a8de3: OUTPUT«125000250000» | ||
flussence | -ENOPATIENCE | ||
moritz | ECAMELIASLOW | 21:47 | |
brrt sometimes forgets p6 can be quite nice and readable | 21:48 | ||
dalek | ecs: 57750d0 | (Elizabeth Mattijsen)++ | S22-package-format.pod: Some more clarifications, especially with provides |
21:49 | |
lue | Int|Str doesn't exist anymore IIRC | ||
moritz | correct | ||
it never really existed | |||
just as a vague, unimplementable idea in the specs | |||
geekosaur | the specs used to include a lot of pie in the sky ideas | 21:50 | |
they probably still do in places | |||
PerlJam | b: say "hi" | 21:53 | |
camelia | b : OUTPUT«sh: 1: install/bin/perl6: not found» | ||
PerlJam | IS that meant to still work? | ||
tadzik | what's b? | ||
PerlJam | beta | 21:54 | |
tadzik | oh | ||
right, pre-nom :) | |||
PerlJam | and old incarnation of rakudo | ||
21:58
spider-mario left
|
|||
moritz | bejing, actually | 21:58 | |
PerlJam | oh. that's right. | 21:59 | |
moritz | it's meant to work, but I don't think I can be bothered to fix it | ||
PerlJam | .oO( so many old things ) |
||
22:07
woolfy left
22:11
woolfy joined
|
|||
lue | heh, on a wiki page listing reasons various languages suck, for Perl: "what's with all the $,@,%,& things in front of variables? It takes a lot of effort to type those redundancies every single time" | 22:12 | |
22:12
dmol left
22:15
clsn left
22:16
stevan_ joined
|
|||
perigrin | PerlJam: are you commenting on the code? or the channel's participants ... | 22:18 | |
22:19
bjz joined
22:20
kivutar left
|
|||
brrt off | 22:27 | ||
22:27
brrt left
22:32
stevan_ left
22:33
stevan_ joined
22:40
treehug88 joined,
treehug88 left
22:41
treehug88 joined,
stevan_ left
22:48
denisboyun left
22:49
FROGGS_ left
22:54
btyler_ left
22:57
rurban1 left
22:58
kurahaupo left
23:03
treehug88 left
23:04
Rotwang left
23:06
hoverboard left,
skids joined
|
|||
masak | moritz++ # "You can't just slap on union types onto an existing type system, and have it magically work out." | 23:10 | |
as I mentioned the other day, sum types are weird. | |||
they basically represent runtime indecision. | |||
(whereas product types only represent combination) | 23:11 | ||
'night, #perl6 | |||
23:15
tgt left
|
|||
japhb__ | .tell jnthn Segfault and oddness in perl6-debug-m; see irclog.perlgeek.de/moarvm/2014-03-19#i_8463775 | 23:25 | |
yoleaux | japhb__: I'll pass your message to jnthn. | ||
23:37
ilogger2 joined,
ChanServ sets mode: +v ilogger2
|
|||
jnthn | Yeah. I'll ahve to get 'em to have a look. | 23:37 | |
japhb__ | Depending on the quality of your telco/ISP, they can run tests relatively easily that can tell them not just what the failure is likely to be, but where it is (how many virtual meters from the CO equipment, where the "virtual" part comes from equipment latency masquerading as distance) | 23:40 | |
23:41
pecastro joined
|
|||
japhb__ | One of the DSL testers at my previous company used to say "If the answer is less than 100 feet, it's inside the CO building -- which generally means the telco accidentally disconnected or misconnected the wires." | 23:42 | |
Happens surprisingly often. | |||
23:44
slavik joined
|
|||
jnthn | Yeah, I had an incident like that happen to be back in Slovakia. Came to fix/install something for somebody else, and accidentally knocked mine out while there. | 23:46 | |
23:54
stevan_ joined
23:57
guest93 joined
|