Whateverable/query

## query
dead

## result-#moarvm.md

      
    Raw
  

              result-#moarvm.md
            
          
    also ,the deadlock in unblocking therad GC thing is a thing that debugserver introduced and then fixed, so i would leave it out of the chaneglog

Yeah, those two dead writes into rax would be wrong dodgy even if rax was legal in our JIT's scheme

¦ MoarVM: Revive removal of dead instructions after the first inlined function�

MoarVM build errored. Stefan Seifert 'Revive removal of dead instructions after the first inlined function

jnthn: when there is a dead instruction (result of a pure op not used anywhere) in the After: spesh dump, does that mean it's worth looking into removal of more dead instructions in MVM_spesh_optimize or is there some other layer where they are removed?

check how the "dead writer" flag is handled

It's something going wrong in dead BB elimination

Trying to get it to dump, just for this method, the outcome of each stage of dead BB elimination

It's fine after the last pass of dead BB elimination

eliminate_dead_ins(tc, g);

¦ MoarVM: Make instruction deletion within dead BBs a no-op�

¦ MoarVM: work would also be a waste of time, as the instruction is already dead

¦ MoarVM: by virtue of its enclosing BB being dead.

Hm, and it's not in the dead handlers list?

Take care of updating the dead handlers table also, if there are any

¦ MoarVM/master: f6db90aecb | ucd2c.pl: Streamline and rework code, remove dead code�

any deadlock experts around? Does the last comment in https://github.com/rakudo/rakudo/issues/1202 give any clues as what might be going on?

sorry, I'm not a deadlock expert

ok, but the if where repetitions == 0 is dead code, then?

If you only have 4 cores, and we have 4 types of worker, then the most you're going to then get without triggering the heuristic deadlock detection is one of each

I think the problem is actually because it needs to require a mutex, and to do that without risk of deadlocking the VM it has to have a GC safepoint

fwiw with or without that last PR the code example it contains, sans strace, always runs ~800 iterations before eeking out 1-3 more iterations really slow, after which point it seems to be deadlocked

its the only way to handle that situation without a deadlock waiting on data without knowing the size before hand

I wonder a tad if somehow there's insufficient affinity workers leading to a deadlock in the one above

I did consider having the supervisor steal from blocked affinity queues and shove the work into the general queue to try and break any such deadlocks

[SCHEDULER] Heuristic queue progress deadlock situation detected

[SCHEDULER] Heuristic queue progress deadlock situation detected

also, geth is dead, maybe

Turns out that making the emit "just not resume if the target supply is dead" isn't actually so easy after all

And use that as a "we might be deadlocked" heuristic also

in theory perhaps the done called by one of the interval ticks is deadlocking with something and keeping the lock held that way and the program just continues piling up new ticks that want to execute their code

OK, not terribly surprising, then. also more or less a dead-end :)

results in deadlock because it's currently in a whenever block, and trying to run another of its own whenever blocks

2) Once we reach that, try to figure out if we're making progress, and only add more threads if we're not (and thus are deadlocked)

jnthn: yep, i have a dead simple MVM_fixed_size_realloc that takes old and new sizes and just does MVM_fixed_size_alloc, memcpy, MVM_fixed_size_free

i hope this doesn't deadlock in spec tests or something

¦ MoarVM: Remove some dead returns.�

As it marks writers dead

¦ MoarVM: Do dead BB elimination pass after branch deletion�

¦ MoarVM: This means that writers in eliminated basic blocks will be marked dead

MoarVM build passed. Jonathan Worthington 'Do dead BB elimination pass after branch deletion

.tell brrt inlines can become dead code; there's a table of which ones did

14:56Z <jnthn> brrt: inlines can become dead code; there's a table of which ones did

I mean, since we already have the dead writer thing...

¦ MoarVM: 3e3f66ea3c | MasterDuke17++ (committed using GitHub Web editor) | src/spesh/dead_bb_elimination.c

¦ MoarVM: 877f88a46b | (Jonathan Worthington)++ (committed using GitHub Web editor) | src/spesh/dead_bb_elimination.c

and when you leave it's dead?

But know this makes more code dead

¦ MoarVM: Factor our and re-use dead BB elimination.�

¦ MoarVM: 39dbe1bd77 | (Jonathan Worthington)++ | src/spesh/dead_bb_elimination.c

I changed a bunch of inline-related things last week so we can actually deleted dead inlines.

Curious, it's a crash inside of eliminate_dead in graph building

It's a bit surprising such a graph would have dead BBs

¦ MoarVM/spesh-invoke: start to apply more aggressive dead basic block removal.

¦ MoarVM/spesh-invoke: Fix and expand dead basic block removal.�

¦ MoarVM/spesh-invoke: The specialization graph builder does dead basic block removal before

¦ MoarVM/master: 309da4c8dd | Fix and expand dead basic block removal.�

¦ MoarVM/spesh-invoke: Otherwise, dead instruction elimination throws it out and we guard it

¦ MoarVM: Remove a dead field.�

MoarVM build errored. Jonathan Worthington 'Remove now-dead newlexotic functions.'

¦ MoarVM/collation-arrays: 17a5752551 | Remove some dead code�

¦ MoarVM/spesh-worker: Remove dead variables; update comments.�

uh oh, i crushed it ... i think it's dead

Having just started to do it - yes, 'cus I think I found a dead field and code to go with it too :)

and throwing out any instruction now means the thing written to gets considered dead!

If you delete an instruction that writes something, surely its writer is dead

We really ned the r13(11) marked as dead there

turns out we kill dead bbs, but we don't properly throw them out of the "childrens" tree or something

so first the cleanup_dead_bbs function reduces the usage counts from that block that starts with the prof_allocated for the argument

¦ MoarVM: them again, seeing already-updated usage counts for actually-dead

And so many ways to deadlock

Oh, and I worry in sorting out the plumbing thing I've probably re-introduced the deadlock in reading from stdout/stderr

So there is at least a way out of the deadlock I guess.

So previously we'd return wrong results if the user neglected to wait. Now we wait for her and could run into deadlocks that way. Leaves two options: 1. just explode instead to make it obvious to the user that he's holding it wrong, 2. close everything instead of waiting, so there's no deadlock. Could cause other issues for the user though.

¦ MoarVM: This is dead code after the removal of synchronous processes. Leave

Yeah, the deadlocks from before were pretty icky

¦ MoarVM: Meaning that the default code becomes dead and gets removed properly,

¦ MoarVM: Clean up dead variables in PHI nodes.�

¦ MoarVM: we only care about the facts on the variable, not those on the (dead)

¦ MoarVM: Don't make dead_writer a facts flag.�

¦ MoarVM: Set dead writer when deleting instructions also.�

we don't decrease any usage counts when we kill a dead bb off?

mark_dead_writers will want a re-name, then (because that's where i put the code); handle_dead_instruction_facts?

i put in an extra eliminate_dead_ins after second_pass and now that particular wval is gone

¦ MoarVM/remove_dead_ins_after_dead_bb: f631a8dab1 | (Timo Paulssen)++ | src/spesh/optimize.c

¦ MoarVM/remove_dead_ins_after_dead_bb: discover registers from dead bbs, extra dead_ins pass�

¦ MoarVM/remove_dead_ins_after_dead_bb: review: https://github.com/MoarVM/MoarVM/commit/f631a8dab1�

¦ MoarVM/std-with-syncfile: Remove newly-dead code.�

¦ MoarVM/master: 0e3ab617c3 | Remove newly-dead code.�

nine: Yes, though perhaps with a #define, and at minimum a comment saying it's not used anywhere in the rest of MoarVM but for debugging, so don't delete it as dead code :)

¦ MoarVM/remove-sync-char-io: Remove now-dead MVM_io_file_s[lurp|pew].�

¦ MoarVM/remove-sync-char-io: Remove now-dead sync char input functions.�

Like adding threads when it looks like stuff is deadlocked

and most of these null instructions are likely from us clearing a frame with VMNull before the code runs; we have dead-code-elimination throw out unnecessary ones

i mean, normally when we exit we just have the other threads killed dead in their tracks by the process just ending

Turns out there was some way to get a deadlock

timotimo: That, but that's a deadlock rather than a data loss

Though yeah, the whole mechanism is a bit deadlock-vulnerable because of that mutex acquisition

Yeah, that's the possible deadlock I mentioned earlier

i'm far too distracted here to even look into the deadlock thing

Handing back the free lists of dead threads to the global one is a lock free operation, and I'm smart enough to know I'm not smart enough to get that right at 11:30pm :)

I also did a thinko in the library that made it dead slow

hm, so an extra pass that determines at what point a value becomes forever-dead might help?

Essentially, partitioning register contents into three: those things that are used in the call, those that are live but not used in the call, and those that are dead

Doing nothing for the dead, spilling the live-but-not-used-in-call directly, then using toposort to efficiently shuffle around those used in the call

the good thing about GC is that the more objects are already dead when we GC, the faster it is

then, prior to assignment to the work space registers, the collector can't find that object, and so would consider it's memory dead

in theory those warnings point out potential deadlocks, i think?

and valgrind is dead slow ...zzz

But that ran into a deadlock in some cases

I guess it could run into deadlocks with a full buffer, but that'd probably only hit jnthn ;)

(Caveats being stuff like: if you return mutable state to the outside world, all bets are off. And if you start calling monitors from monitors then you can create deadlock situations.)

¦ MoarVM: awaiting a true deadlock detector anyway.

MoarVM/fix-inline-and-threads: reentrant and also cannot lead to GC deadlocks. Unfortunately, spesh

MoarVM/work-lifetime: Remove dead variable/assignment.

we'll not reach that object, and thus consider it dead

(and also things might be considered dead if only the C stack was holding on to them)

MoarVM/utf8-c8-rewrite: Remove now-dead code.

MoarVM build failed. Jonathan Worthington 'Remove now-dead code.'

sorry dalek. that was 4 commits by the way, and MVMJitValue is now dead

Then deadlock

so it is not dead yet

MoarVM/multidimarray_view: deadf05 | timotimo++ | src/6model/reprs (4 files):

MoarVM/multidimarray_view: review: https://github.com/MoarVM/MoarVM/commit/deadf05de4

MoarVM: Remove dead code.

has it on dead tree

i'm expecting almost all the stuff i put in would be dead-code-eliminated when the --valgrind flag wasn't passed to Configure.pl

that definitely sounds like a deadlock too me

had to turn the while condition of the "eliminate dead bbs" loops to "cur_bb && cur_bb->linear_next" instead of just "cur_bb->linear_next"

MoarVM: we only ever pass NO_HINT here, so remove "dead" code for now

It's really flappy. Two runs dies right away, then many runs doesn't die: https://gist.github.com/zoffixznet/9ee7467b279b2801d3fdeada33498099

it's dead. they stoppped working at least 12 hours ago!

It looks more like a legit deadlock to me

jnthn: this still deadlocks: http://paste.scsys.co.uk/528614

the removal of dead code happens between the passes, but not afterwards, i expect

ASAN's verdict might still be "a dead mouse on your carpet"

hopes for another blog post before tonight's P6W deadline

MoarVM: compute the CFG, but before forming SSA. Then, let dead instruction

MoarVM/jnthn/opts: compute the CFG, but before forming SSA. Then, let dead instruction

Bah, so S07-hyperrace/race.rakudo.moar is now a reliable deadlock rather than a reliable crash :P

It either runs to completion or deadlocks

MoarVM/reframe: a worker thread to silently exit and typically resulting in a deadlock

Well, a bunch of tests went from "exploding" to "usually deadlock"

well, did it go from deadlock to works fine with that last commit? is what i meant

I was a little suspicious something in the changes I'd done was causing new deadlocks to appear

Looks like the deadlocking S17-procasync/no-runaway-file-limit.t doesn't any more either. Alas, it does exhibit a different problem.

ah, so after we're through completely once, we eliminate dead BBs and recalculate the dominance and such then

though that'd probably also just follow from dead instruction removal and grabbing the register that gets boxed rather than the box directly when descending into the inlined graph

and with 'dead ranges', i.e. a range were everything must be spilled...

jnthn: it seems that the stdout supply on a proc-async isn't closed properly, even when the process is definitely dead

(Of the "if we miss the deadlines people can die" kind)

[Coke]: I'm guessing it's a deadlock...

jnthn: something may be off in our "dead BB elimination", i have an example for you: https://gist.github.com/timo/6e049585004912f5f24d

is turning on link-time-optimization required to make dead code elimination better?

you can;t eliminate a dead global function unless you can do LTO, eiter manually by putting each function in its own file, creating a .a from them, and linking main() against that, or enabling compiler+inker LTO

src/core/interp.c:1015:37: runtime error: load of misaligned address 0xdeadbeef for type 'MVMuint16', which requires 2 byte alignment

MoarVM/line_based_coverage: dead-end for trying to get more lines covered

is "hang with cpu usage non-zero" livelock and "hang with no cpu usage" deadlock?

MoarVM: Fixes a deadlock on POSIX platforms.

do you think we've ever deadlocked on this problem cygx just fixed?

I think there was some report of a deadlock involving threads and require that may be related

(although if you're not careful it will bring you another dead mouse to try to encourage you to learn to be a better hunter)

oh, wait, moar jit is working, moar-nonjit is dead.

MoarVM: Toss a dead macro.

I guess what I mean to ask is if it's ok for the async thread to push something to the async queue, or if the queue will block when full and the async thread will deadlock itself

Brining a dead frame back to life

jnthn: http://paste.scsys.co.uk/496892 -- t/spec/S17-supply/start.t seems to be able to deadlock with 3 threads waiting

or maybe it's being declared dead, but then reached from another thread's GC?

jnthn: t/spec/S17-procasync/no-runaway-file-limit.t seems to be capable of getting itself deadlocked

hey, dead JIT issues?

well, i'm more worried about dead JITs than dead spesh

dead spesh typically means memory got corrupted somewhere

eh, dead JIT

dalek dead?

and, it's dead

would seem that a reentrant lock allows the second lock to proceed as if nothing happens; a non-reentrant lock would deadlock

ah, that one probably should deadlock

that piece of code would deadlock if the start is awaited within the lock protect block, not otherwise

hm, right, if the "outer" piece of code awaits the start block and the inside of the start block hopes for the lock to free up, then we'll reach a deadlock situation

in which case - by sheer luck! - the lock would be re-entered rather than deadlocked with

jnthn: do you think the very end of MVM_gc_collect would be a good place to analyze the nursery's contents for dead/promoted objects?

the problem i'm struggling with here is how to attribute a given dead object to the process call node it was allocated in

um ... huh? here's an instance where "dead_before_gen2" ends up a very, very big number, but the actual number allocated is 5

it's interesting how opossums are much uglier creatures than rats, pretty much without doubt, because the opossum uses that as a defense mechanism (it needs to look and smell dead)

interesting thing to note: the aztecs believed that literally all of their gods were dead, which explained perfectly reasonably why those gods could be in charge of the afterlife

and with multiple preceding worlds, the gods of the mortal world had themselves worshipped dead gods in a preceding version of reality, and I don't know what the view was on whether a world and an afterlife ago was a thing.  it makes you wonder if semantic versioning is much older than we thought :P

I'm mostly after "clean up obvious ones you know are dead that are yours" :)

If you want a dead simple Makefile, I've got one in the Snake repo (arnsholt/snake at GitHub)

arnsholt, I'm afraid dead simple makefile is not always the case on windows :)

There's 41 more (although 15 of those are dead stores, so not really bugs as such). I've found a couple of false positives, but the NULL-deref warnings have mostly been on point (of the ones I've been able to make sense of)

jnthn: unfortuantely 3 tests are deadlocked

otherwise you could have a deadlock

or is dalek dead

sorry for keeping moarvm dead for an hour >_>

jnthn: http://paste.scsys.co.uk/480344 -- GC managed to deadlock itself, with just one thread

isn't that a real achievement, deadlocking on one thread?

.oO( we have invented new groundbreaking single-thread deadlocking technology )

I guess that can be seen as a kind of zero-resource degenerate case of deadlocking.

a reason we may not want to just paste the contents of inlined BBs into their caller's bodies is that they have an "inlined" flag ... but perhaps we only need that flag because we don't fix up enough of our helper data structures yet to keep the dead bb elimination from throwing them out wrongfully?

Mebbe, though those don't deadlock

I once tried to write a colored-output script to autodetect whether the terminal had a light background or dark one and compensate, and I discovered that this seemingly easy thing is essentially completely brain-dead and non-portable.

oh, heh. If we inline something but then determine the branch we inlined it into is dead, I guess we could hit this issue...

Also we should retire dead-end specialization attempts at some point too

MoarVM: dead bb" and when a PHI is seen with arguments that are

MoarVM: from a dead bb, we can cut the register out of the PHI.

i don't really understand why we have to skip inlined BBs for dead bb elimination

timotimo: But yes, we do things like dead code elimination after inlining, for example.

well, you need to make parrot popular, then let the people improve it. unless it will be dead before you find better things than 6model :P

better red than dead code

.oO(what about the undead?)

Well, since Perl *was* dead, we're reviving it by making a better Moa,  a Moar  !

Hmm, using an extinct bird to promote a language that is considered dead by some people is not the best marketing ploy I know about...

speaking of optimize_coerce, is it trying to change coerce_in to const_n and let the eliminate_dead_ins function remove the pre const_i instruction?

question: how does moar handle dead coros? (no more yields left).

decrement_total_promoted_by is now a dead variable fwiw

dead...uh...stable :)

not dead yet!

under ASAN, things end up with that deadlock hang

i can use the dead code elimination to my advantage

I don't think I've tried the set removal patch again since fixing dead code elim's deopt issues...

And if they don't hang off something, then we'd kill them in dead BB analysis.

dead code elimination

Yes, the dead code elim is quite efficient :)

so the dead code eliminator killed the inserted instruction immediately :)

brrt: i assume you're aware of what the "firm pencils down" and "1. final evaluation deadline" mean?

I think brrt++ and I will be in the same place when the eval deadline arrives, anyway. :)

what's the last steps needed for GSoC? Some sort of final report, with a deadline when?

OK, fun, final deadline is the first day of YAPC::Europe.

is that the final final deadline? i thought the soft deadline was yesterday and the hard deadline today?

report deadline

timotimo: And if the instruction really isn't needed then dead instruction elimination will already get it

so the dead code elimination doesn't kill them yet

simply putting the lock before and unlock after the loop over the static lexicals when finishing the frame leads to a deadlock ... oh well

valgrind has some tool that helps with deadlocks, odesn't it?

er, anyway, something in the deadrat familty

It was doing a further pass of dead code elimination post-inlining

MoarVM: Don't redo dead instruction elim on inlinees.

MoarVM/moar-jit: Don't redo dead instruction elim on inlinees.

MoarVM: Toss dead macro.

flussence: There was one commit that deadlocked setting comp once on non-Windows.

MoarVM: This means we can mark extops pure so dead code elimination can kill

ok, but that screams deadlock to me

When I teach on deadlock I typically end up talking about the aggregate pattern as a decent structure that can avoid circular waiting arising.

MoarVM/moar-jit: bump. This means we won't kill a write to it when doing dead code

MoarVM: bump. This means we won't kill a write to it when doing dead code

origin/gen2-frames is probably dead

well, the ssh connection aint dead

I think it'll have deadlocked on itself.

Yeah, braindead copy pasto on my part. Sorry.

aaw, not much perl6? is perl6 dead? :(

It's...10 days away for the deadline for those :)

It's far more important to actually complete the mid term eval by the deadline than what the detail is

and, if reads need mutexes, deadlock becomes much easier.

and cross-invocation-dead-code-elimination and constant-folding?

i wonder if this leads to less dead code elimination than is necessary

And means that dynasm isn't going to be a dead end. :)

I'm guessing it could be dead instruction cleanup gone wild...

MoarVM/inline: Otherwise, dead code elimination will go swallowing all the things.

There's essentially 3 passes: fact addition/propagation, do the type-driven optimizations, do dead instruction elimination. So, just 3 passes at the moment.

i.e. a guard on something that's dead perhaps?

MoarVM/spesh_trace: Means we can optimize out some more dead instructions.

Turns out we really wanted a fixed point analysis on killing dead instructions.

We probably want to do it in the backwards analysis as we're killing dead instructions.

'cus then it's dead easy (memcpy) to grab them out when we de-opt

well that second branch is certainly dead at the moment

MoarVM/uthash_padding: this is much work; may be a dead end even.

.oO(dead code specialization)

Turns out it's the dead instruction removal that hoses the trig tests

So of course the unbox_n and decont were considered dead.

timotimo: The final "kill dead bbs" one

do we have something like dead code elimination?

otherwise there'll be a gap between istype and the dead code elimination still

eliminate_dead seems to already be factored out from all the rest

MoarVM/spesh: c&p eliminate_dead, remove children in addition to succ.

and with it, it'll probably also be able to do some dead code removal?

Because as soon as you're taking multiple you're asking for deadlocks.

Well, I've a concrete task, but it's one where if it's screwed up we'll get deadlocks.

uh, dead ones, no? :)

MoarVM/moar-conc: things, and removes some dead code.

write the best proposal you can, before the deadline

IIRC, it's acceptable to resumbit proposals, until the deadline, isn't it?

MoarVM/moar-conc: Causes a deadlock, couldn't figure out what it was trying to deal

jnthn: though on Moar concurrency - I think if you implement the idea of the GC freeing stuff in a different thread, you have to block the original thread from re-entering the GC. (Which it's not clear that is planned). Because having a worker thread free stuff means that fromspace is no longer dead memory, able to be re-used as a new tospace

MoarVM/moar-conc: is going away, we still can't go assuming its gen2 objects are dead.

motivation will dictate wether i'll spend my evening tuits on $dayjob to make the monday deadline or moarvm to get either heap allocation statistics or however much of little big ints i can build

something braindead simple, that says "hello!" or something

btw thanks for redoing my braindead-ness :)

I've been busy at work lately (article deadline last friday), but tuits aren't in quite as short supply these days

deadline went whooshing past and now all is calm? :-)

so that people don't claim perl6 is dead

OK, bother. Because if you hold it, you can deadlock the GC

Bit icky but better than a race condition (with the patch) or GC deadlock (without it)...

whoops, more than one --stagestats is deadly

the most frustrating part is when you *think* the connection is dead

so if you think you're waiting for me, you're deadlocked  :-)

looks my closing file handle patch is ending in a deadlock :/

FROGGS[mobile]: Rakudo is at a6eeb0b159b82f41a2088cb20105f651fdead89b

blink and you're dead


## result-#p6dev.md

      
    Raw
  

              result-#p6dev.md
            
          
    Rakudo build failed. Elizabeth Mattijsen 'Remove dead code'

rakudo/nom: Eliminate some dead code

rakudo/nom: Eliminate some more dead code

nqp: [js] Remove dead code.

And locking all precomp stores individually is a recipie for deadlocks :)

yeah... in any case, there was dead code there...

i'm not 100% sure whether the deadlock bug was due to the new code in jnthn's branch or an old one that's always been there

Ah, it deadlocks

I guess a boom would be easier to debug than a silent deadlock ;)

Well, the deadlock is seemingly that GC orchestration one that bites now and then

is dalek dead?

dalek dead ?

install-core-dist.pl also takes a while on rakudo itself ... but yours seems like it's deadlocked or something?

nqp: [js] Make some NIY error temporarly less deadly.

nqp: [js] Remove dead code.

rakudo/nom: circular wait, and thus a deadlock. However, there are probably platform

rakudo/nom: independent deadlocks that could have been caused by this bug, not to

nqp: supress section about nqp-rx. dead since 6 years

nqp: supress section about nqp-rx. dead since 6 years

nqp: [js] Remove dead code.

i came up with the coolest idea while my brane was refusing to let me continue to sleep ... a picture with a "DEADPERL" text on it and camelia fashioned to look a lot like deadpool's logo

not to beat a dead horse, but aside from inertia and masak and the pain of switching, why are we still using rt.perl.org ?

is spesh seeing that the code in { my int @a } is dead after the first iteration, or is there something else spooky going on ?


## result-#perl6-dev.md

      
    Raw
  

              result-#perl6-dev.md
            
          
    disk was deadslow nfs

btw did i remember to bring up the deadlock in promises i found?

¦ nqp/master: 0b24131045 | �[js] Remove dead code�

AlexDaniel, bisect log: https://gist.github.com/48deadf085d67157c66284bd34fc2e85

flashbacks to manually garabge collecting by making vals numb so its garbagec ollector can notice its dead

¦ nqp: d2da85f Revive removal of dead instructions after the first inlined function

<Grunt> Travis can't be bargained with. Travis can't be reasoned with. Travis doesn't feel pity, or remorse, or fear. And Travis absolutely will not stop, ever, until your project is dead.

¦ nqp/master: 54b8395e09 | �[js] Remove dead code�

when is 6.d planned? (what's the deadline for throwing away not yet specced bad tests :) )

¦ nqp: c1da6f96 Make instruction deletion within dead BBs a no-op

¦ rakudo: c1da6f96 Make instruction deletion within dead BBs a no-op

¦ rakudo: 5b80052 [jvm] Remove dead code

¦ nqp: �[jvm] Remove dead code�

fosdem video equipment is fine. There is a chest mirror and a good expensive camera on a tripod. The problem is the scale. Everything is pushed to a server through a complex black-box like system including specialized hw and a laptop. And once in a while something goes wrong with the recording (e.g. mic batteries dead) and the person manning the camera does not see it. Of a problem on the receiving end,

in fact, I plan to be dead by then :->

It's not quite the plan any more. The metacpan fork was limping all along and last time I got the update about it it was "stalled but not yet dead", which is why CPAN support was added to mp6o. My crystal ball says mp6o's featureset will slightly develop further for ~2 years, then there'll be move to write proper Rakudo version of the site. Perl 5 version just isn't working out, the way I see it.

AlexDaniel, https://gist.github.com/ce60156c9adeaddba49cc707d11e18c5

should nqp t/concurrency/01-thread.t and t/concurrency/02-lock.t be failing? thread.t seems like its been busted forever, but lock.t started segfaulting on test 7 in 2017.08 (before this it deadlocked at test 14)

¦ rakudo: �Oops, this is dead code now�

adding more threads is one mechanism we use to dislodge deadlocks that could be solved by finishing up some more work tasks

To try and break deadlocks

Beyond the CPU core count it'll reluctantly add threads if it things the program is deadlocked

"I see dead threads"

if run with RAKUDO_SCHEDULER_DEBUG, I get a lot of: Heuristic queue progress deadlock situation detected

¦ rakudo/nom: �Test for deadlock heuristic more�

¦ rakudo/nom: Check for deadlock even if we have some completed jobs but still

that's not really going to help, since anything another thread is doing could deadlock (taking the malloc() lock is a prime example)

¦ rakudo/nom: �Add hackish fix deadlock for supply in a sock�

.tell jnthn I golfed AlexDaniel`'s issue into a test: https://github.com/perl6/roast/commit/74445ddf8a and committed a hack that makes the test pass: https://github.com/rakudo/rakudo/commit/ce7e5444a2  but WebSocket module still fails its tests because I'm guessing it got more than one AffiniteWorker active so teh deadlock still happens and isn't fixed by my hack. No idea why the deadlock actually occurs

Rakudo build passed. Zoffix Znet 'Add hackish fix deadlock for supply in a sock

and update on RT#132343: bug seems something to do with $*AWAITER. The changes to it are commits https://github.com/rakudo/rakudo/commit/547839200a772e26ea164e9d1fd8c9cd4a5c2d9f and https://github.com/rakudo/rakudo/commit/26a9c313297a21c11ac30f02349497822686f507 that mention queuing and deadlocking... seems like exactly what's happening now and I'm guessing the new mechanism queues up the stuff to run

¦ rakudo/nom: �Revert "Add hackish fix deadlock for supply in a sock"�

¦ roast: �TODO-fudge supply-in-a-sock deadlock test�

¦ roast: Also fire off a few more socks to cover the deadlock that

04:41Z <Zoffix> jnthn: I golfed AlexDaniel`'s issue into a test: https://github.com/perl6/roast/commit/74445ddf8a and committed a hack that makes the test pass: https://github.com/rakudo/rakudo/commit/ce7e5444a2  but WebSocket module still fails its tests because I'm guessing it got more than one AffiniteWorker active so teh deadlock still happens and isn't fixed by my hack. No idea why the deadlock actually occurs

¦ rakudo/nom: �Fix deadlock with affinity workers�

¦ roast: �Unfudge now-passing supply-in-a-sock deadlock test�

When the box is busy with the rest of the stresstest, the heuristic for deadlock adds more workers and test passes. If the test ends up closer to end or whatever, the rest of the stresstest doesn't generate enough CPU use for deadlock heuristic to get triggered, so it never happens. I can't get it to complete when running with just RAKUDO_SCHEDULER_DEBUG=1 ./perl6 t/spec/S17-channel/stress.t on 24-core box

¦ rakudo/nom: - Prevent potential supervisor deadlock from elems'ing the queue

Zoffix, We are the dead

jnthn: if I run the code with RAKUDO_SCHEDULER_DEBUG I get messages like '[SCHEDULER] Heuristic queue progress deadlock situation detected'. Are these to be expected?

Oh oops.. Add MISC/bug-coverage-stress.t ... also include tests to cover mutex deadlock for RT#132042

Considering this feature is dead, it's kind'f indicative that it's not maintainable.

¦ rakudo/nom: �Remove dead code for `use v5`�

cool. i get finnish spam now. the "my dead client had lots of money" kind. google translate turned the second sentence into "I'm Andrew Allen, a lawyer and a lawyer"

Ha! The else block in src/NQP/World.nqp:353 is dead code. There hasn't been a replacecoderef op since parrot went away.

¦ synopsebot: �Remove dead code�

*whirr* *click*buzz* it's dead, Ji.

¦ rakudo/nom: �Remove dead test files from 6.d.proposals test file list�

I see the domain's dead for it :)

Rakudo build failed. Zoffix Znet 'Remove dead test files from 6.d.proposals test file list

¦ rakudo/nom: �Add "no queue progress" deadlock heuristic�

¦ 6.d-prep: �TODO: toss dead files�

¦ roast: 986f263ef4 | (Zoffix Znet)++ | S10-packages/require-and-use--dead-file.t

¦ roast: �Rename dead file squatting on a good name�

¦ roast: They were moved to require-and-use--dead-file.t in

¦ rakudo/supply-block-refactor: messages on a Supply being serialized, this would result in a deadlock

¦ rakudo/supply-block-refactor: active tap count. Prevents a potential deadlock if an `emit` gets

Maybe someone *thinks* they're sending announcements to a dead list?

¦ roast: The colabti.de links were not just dead but had been squatted.

i'm glad i still have about 21h until the deadline hits

¦ rakudo/better-sched: of a deadlock that may be resolved by an extra thread.

But it seems to result in a lot less threads (and thus memory) for things that just do the odd light bit of async (like run does behind the scenes, or a web app barely under load), converges on the number of available cores for CPU bound things, and can add up to 64 threads by default now (though will be reluctant to go far beyond the CPU core count unless it looks like there's a deadlock due to insufficient threads)

but I can't find where *that* is set, so I wonder if this is a piece of dead code >

"dead key"

They're ones that get killed off when BBs become dead

But George Carlin said real men don't go to the doctors unless they're legally dead!

timotimo: the `say` makes it deadlock

i wonder how the deadlock exactly happens

feels like a recipe for deadlock  :-(

rakudo-j dead?

there is no api to tell the gc "this is dead now, take care of it"

my atomicint $foo = 1; for ^50000 { start { say cas( $foo, -> $i { $i + 1 } ); }; }; say $foo; # this deadlocks at a random iteration unless the `say` is not called on cas(...)

also deadlocks if you do `my $x = cas(...); say $x`

well theoretically 3/2019 is a drop dead date, but  a number of things could happen

GlitchMr's twitter looks kind of dead, last tweet 2014

that's why lock files have the pid of the process in them so they can be removed when the pid in question is found to be dead?

¦ nqp: 35f82730 Factor our and re-use dead BB elimination.

hey all, i just wanna say thank you for your dedication and commitment to making perl6 a success... back in 2012, when i was doing perl5 development, my coworkers convinced me that perl6 was dead and that switching languages would be a good career move... i then took a job as a php/symfony developer and have been doing that since... although i enjoyed symfony development and was even pleased at the introduction of php7, i felt like

mst: since you somewhat followed the project: XTaTIK is dead :) my $boss has different ideas about our websites, so gutting the one XTaTIK website I had to make a smaller web app and that'll be it for it. Still in Perl 5/Mojolicious tho.

AlexDaniel: looks like .Supply causes a deadlock `futex(0x45551d4, FUTEX_WAIT_PRIVATE, 1, NULL` <- what it locks up at every time

¦ nqp: fdead1d448 | (David Warring)++ | examples/rubyish/t/interpolation.t

¦ nqp: �review: https://github.com/perl6/nqp/commit/fdead1d448�

then i did "console 11" (for hack) and got a dead terminal

dogbert17: yeah. https://github.com/perl6/roast/blob/master/S29-os/system.t#L83 - this test verifies (even though its on a nonexistent the result would still be the same: deadlock or pass)

you had to if you didnt know the full size. if you asked for a size that was too big it would deadlock

¦ nqp/master: 350d4a5d9b | �[js] Delete dead code�

its deadlocking

I think the complaint is that either it should work or it should throw, just not deadlock?

I think all that moving the deadline further back does is make us sit on our hands for that much longer before doing it all in ~3 months before the new date.

pmurias: I'd imagine vast majority haven't used it. "Perl" is just that to them. An old, dead language people make fun of. Same as people still peddle jokes about PHP despite latest version not sucking any more.

How many actually need a smartphone and could get along with a flip phone? Tons. I know I would. But I wouldn't be caught dead with one. It's what tech unsavvy old people use.

"of course, part of me loves that the new language derives from the old and has a similar spirit and creators. it just sucks that we have this 'perl is dead' hate out there. Rakudo Perl 6 is good. good luck!"

I'm just not convinced that if the branding is changed from a feeling of vague oldness and deadness people will start using Perl 6 more

Zoffix: the counter argument is that if we drop the Perl from the name it can be interpreted by people as claiming that Perl is something that we need to distanance ourself from or that is dead

Right now if I were lwn.net and wanted to report about things in the Perl 6 community, I'd cover...a heated discussion about a name change and if Perl is dead. Now that will attract a lot of... well no one :(

it's easier to deadlock with run compared to p::a

The past two years are a pretty clear indication to me that name "Perl" is unmarketable. Even on the coolest articles the comments quickly dwelve into why Perl is dead, whether trolling in tone or genuine polite discussion.

yes? you told it to capture stdout but nothing is reading it, so it could well lead to a deadlock

I'm a tad surprised it doesn't deadlock if the commands produce sufficient output

And just as predicted complains about Perl 6 https://irclog.perlgeek.de/mojo/2017-06-04#i_14684821 and depressing debates about whether Perl is dead https://irclog.perlgeek.de/mojo/2017-07-03#i_14819507

¦ rakudo/nom: �Remove dead code path from optimizer.�

I love how you're working on the schedule but neither the website, facebook or twitter ever announced the CFP or the CFP deadline

mst: current plan is to make a deadline of fri Jun 7 midnight and start a campaign on twitter/facebook/linkedin asap

¦ rakudo/nom: deadlock because the stdout and/or stderr handles were never read.

...or deadlock heh

https://gist.github.com/ugexe/50e9b6ec0a8db2f85339dc39fc63dd6d - heres a failing test, but not sure where to submit it since it will deadlock on rakudos prior to 2017.06

¦ rakudo/nom: Previously this command would deadlock:

¦ nqp/master: 7a323f810f | �[js] Remove dead code�

m: say "deadbeef" ~~ m:ex/.+/

rakudo-moar 14d757: OUTPUT: «(｢deadbeef｣ ｢deadbee｣ ｢deadbe｣ ｢deadb｣ ｢dead｣ ｢dea｣ ｢de｣ ｢d｣ ｢eadbeef｣ ｢eadbee｣ ｢eadbe｣ ｢eadb｣ ｢ead｣ ｢ea｣ ｢e｣ ｢adbeef｣ ｢adbee｣ ｢adbe｣ ｢adb｣ ｢ad｣ ｢a｣ ｢dbeef｣ ｢dbee…»

on the plus side it no longer deadlocks though :)

but doesn't it mean that “fail "Unknown integer type: {self.^name}";” is practically dead code?

Yes, it needs to be callsame there; were it nextsame, then the $!y = 18 would be dead code

I might have acute liver failure and be dead soon... so, if I stop committing... Flip the cushion :P

ZofBot: it's really dead in here!

But an object can't be all of dead, moved, or the new copy, so we can use a union for those 3 things and make every object smaller

but in roots.c:294 we are not checking anything about dead this collectable or not, and trying to mark_collectable, which tries to get sc_idx

*currently* if i spawn a process that itself spawns processes i seem to hit open 3 problem  deadlocks a lot

ugexe: That means we don't deadlock, though of course we pay in memory.

jnthn: definitely, probably fix precomp deadlocks too

And if Gabor's plan is to both bring Baildor up to speed and write a book, the December deadline seems awfully optimistic

I gave up #perl6 long time ago, though I see today it's pretty dead :)

I don't think there's any silver bullets, but I think the improved scalability and lower risk of deadlocks from pool exhaustion will massively outweight the very small number of surprises that may occur.

I used that trick in the LibSSH binding to make sure we didn't get deadlocks or clog up the event processing thread: https://github.com/jnthn/p6-ssh-libssh/blob/master/lib/SSH/LibSSH.pm6#L827

either way - something in that section of code does not handle stdout/stderr properly (nor did it before my commit, which could lock up on OSX due to a open3 deadlock)

that's a deadlock

it's dead, jim

"The unusual syntax is tough to parse, and the language seems dead".... or maybe not :P

Wonder if there's a way to use GitHub's editor to edit more than 1 file for a PR... It makes it dead easy to submit fixes to user's code without forking or cloning anything, but I want to edit the META file too to bump the version :/

could sure use definedness-based defaults right about now :|  https://gist.github.com/zoffixznet/8f52e9f2a2ecdeadd35780decd6ce77b

hmmm.. is Geth dead ?

⭐⭐⭐ Reminder: the deadline to submit your suggestions and corrections to

postponing deadline to 2.04 could help to clarify eventual strange ideas :)

⭐⭐⭐ Reminder: the deadline to submit your suggestions and corrections to

why would it fail to copy that ... is it a dead symlink or something?

yes, it is a dead link

I think it was dead symlinks yes

leaves to devour limbs of warm dead bird

¦ roast: 1f5dead548 | (Zoffix Znet)++ | S02-types/array-shapes.t

¦ roast: �review: https://github.com/perl6/roast/commit/1f5dead548�

¦ rakudo/nom: * Fix a very occasional deadlock when GC occurred exactly at the same

.oO( my dreadlocks deadlocked )

There's no way for us to get into deadlocks with our own processes over this, I presume? :)

Yeah, though if we make it fine-grained then we still need to be really very careful that we don't end up vulnerable to lock acquisition order deadlocks...

arnsholt: Yes, except deadlocks and contention, which you solve by locking less of the things :P

well if you get deadlocks can you not just wait longer :) and it'll eventually undeadlock

i think it barely missed the deadline?

roast: 8dead1cd38 | (Jonathan Worthington)++ | S17-supply/syntax-nonblocking-await.t

roast: �review: https://github.com/perl6/roast/commit/8dead1cd38�

I'm guessing samcv missed the submission deadline for this run

Spoken from the dead!

that seems more plausible.  box was dead but if i wait a few minutes it comes back

IT's a dead-simple puzzle but I'm doing a brute-force state graph just so that I can bum it down later.

is Geth dead?

rakudo/nom: (the original @rakudoperl seems to be a dead account)

Or at least.... I'll be dead by then

dogbert2, it means that most probably there is some threading deadlock

The advent deadline is sooner, so concentrating on that first ;)

And the text and code following "  Several mandates that apply to us have drop-dead dates in 2017.

I was about to say, it seems like that oughtn't to cause deadlock.

nqp: [js] Remove dead code.

Internet dead at home for some reason :( not a good release day start :(

nqp: [js] Delete dead code.

nqp: [js] Remove dead commented out code.

every once in a while I hit up against some kind of deadlock between IO::Socket::Async and sockets that aren't managed by Perl 6

SoC is announced in October. Organizations begin submitting applications in February. Applicants apply in March. Accepted Proposals/Students announced in April. Work runs from May to August with various checkpoints and deadlines. Results of SoC Projects are reported at the end of August

Just a dead method :/

was it dead code?

still, having that as an external dependency, feels like a deadlock situation waiting to happen :-(

hoelzro: No; CATCH handlers are (by design) run on the stack top, so you've got the dynamic scope of the thrower in place and so resumable exceptions are dead easy (you just don't unwind after)

nqp: [js] Delete dead code.

nqp/no-eval: [js] Get rid of dead variable.

nqp/no-eval: [js] Remove dead code.

A big improvement from the 1.69s listed in this article :) https://eev.ee/blog/2011/06/27/perl-5-is-dead-perl-6-is-a-disaster/

rakudo/supply-circular-wait-fix: The approach taken so far is vulnerable to deadlock, since there can

rakudo/supply-circular-wait-fix: a work queue in place instead, which successfully avoids the deadlock

rakudo/nom: The approach taken so far is vulnerable to deadlock, since there can

The branch I merged fixes a nasty circular wait that could occasionally cause deadlocks for programs using the supply/whenever syntax.

Just tracked a deadlock down to it not starting enough threads.

Including figuring out why my branch that gets rid of a deadlock also oddly breaks Supply.throttle.

rakudo/nom: This could lead to deadlocks, such as a hang in S17-supply/syntax.t

rakudo/supply-circular-wait-fix: The approach taken so far is vulnerable to deadlock, since there can

rakudo/supply-circular-wait-fix: a work queue in place instead, which successfully avoids the deadlock

oh man, I saw the word hanging and thought "oh crap, another deadlock to find" ;P

dead code is a liability, IME

nqp/noparrot: Kill a dead line in Configure.pm

nqp: [js] Remove dead code.

lizmat: I'm dead tired, will have to take a look tomorrow. Harrass me if I forget. :-)

bisect: good 2015.10 my $p1 = start die "I’m dead"; my $p2 = start ~"I’m alive"; try await Promise.allof($p1, $p2); say .result for grep { .status ~~ ‘Kept’}, $p1, $p2;

Also, it's just 4 days till YAPC::Europe call submission deadline. I'd better make up my mind about if I want to give a talk or not soon...

schrödinger's cat is both alive and dead; heisenberg's cat only knows either where it is or where it is going, but not both :p

did you read/hear about the one where our test suite would hang on windows because the test runner was always only grabbing output from one process at a time, and that caused a deadlock situation?

nine: huh. sounds like a misunderstanding, or unintended deadlocking, or something.

Well, I've read the PR and channel log and the post seems to make a huge number of assumptions and invent reasons for deadlocking, so don't take it too personally.

oh, and actually the front page is dead.

nqp: [jvm] Remove dead code.

nqp: 9dead8a | (Pawel Murias)++ | src/vm/js/nqp-runtime/serialization.js:

nqp: review: https://github.com/perl6/nqp/commit/9dead8ab99

rakudo/nom: Remove dead code


## result-#perl6.md

      
    Raw
  

              result-#perl6.md
            
          
    that's actually a godsend for a deadlock (i think) in promises in certain cases

¦ doc: �Eliminates dead code�

is it a dead project?

I still can decide which part of the dist I am going to use, and the rest is just dead code on my hard disk

it'd be very easy to accidentally "suspend" without args and deadlock the thing

¦ whateverable/master: ff5e8784a2 | �The deadline is approximate�

Worse I'm swearing, more fun I'm actually having, but I'm not doing this under any kind of deadline.

moritz: really? I though it was dead for a long time

https://github.com/perl6/perl6.org/blob/master/source/fun/index.html - the troll link is dead and also there's an unmatched </div> at the end and one too many </ul>s in the middle

Is szabgab here? Part 1, 1.5, 2 and 6 are dead. # https://szabgab.com/perl6.html#screencast

zeddy__k: every language that's not dead is under developement

say whatever you want, but without lizmat, the channel is pretty dead :)

comborico1611: I thought it was dead

UML's not dead, it's corporate

http://testers.perl6.org/ also seems dead

the main dev was on hiatus which is ok, but there was a promising spacefm-ng fork… dead now

lookatme: at's a "the programmer created a deadlock"-panic? I have that all the time on all the programming languages with threads :)

if I had no idea about either of the two languages and one person tells me, "Perl 5 is stable and Perl 6 is just this tiny hobby project thingy" and another person tells me, "Perl 6 is awesome and Perl 5 is as good as dead anyway", the only logical conclusion is that I need to take anything I read with a grain of salt or ten

I'd argue that perl was a dead language, but now it isn't

Seems like the website is fairly dead, with the last update coming in 2013

a "moratorium on new features" seems a lot like declaring it "dead and burried"

I will predict the following answers: 1. Perl is dead or should die, 2. Because it's Perl. These are not my opinions, but there does almost seem to be concensus over these things.

you can take the FLAC from my cold dead fingers

nah, don't go naming stuff after me before I'm dead

after I'm dead, I no longer care, and you can do as you want :)

you don't have to be dead to not care

stmuk: and the number of people that think Perl5 is dead because it's stuck to a major version

these days when people say "Oh, you do Perl, isn't Perl dead?" I just say "well, programming languages never die"

managers being told that p5 is dead changes my actual life

lizmat: who's going to spend all the time porting a language that is dead to a new mv?

but without that freedom it is "dead"

jberger: my point is that Perl 5 as a language is *not* dead

Perl 6 is a dead brand, it's never going to happen

I've never had a manager tell me I can't write a project in Perl because of Perl6. I HAVE had then tell me because I should use Jave, or Node, or Python because Perl is dead. But Perl6 is never on their radar.

if had wanted Perl 5 dead, I would have taken a different set of actions

isn't that dead xD

Ven``: it is a common joke in the perl5 community to keep repeating that it's dead ;)

Altreus: A few years ago, I told someone "Perl 5 is so dead is only has a conference somewhere in the world once a *month*"  (this was a year when it actually did have conferences or workshops or whatever for every month :)

as for slow disconnect, it indeed depends on the network. you don't want the server to assume any momentary network blip is a hard disconnect, so it waits a bit before declaring the connection dead.

how many pages are dead weight?

when perl6 is "finished" it is dead

It's not quite the plan any more. The metacpan fork was limping all along and last time I got the update about it it was "stalled but not yet dead", which is why CPAN support was added to mp6o. My crystal ball says mp6o's featureset will slightly develop further for ~2 years, then there'll be move to write proper Rakudo version of the site. Perl 5 version just isn't working out, the way I see it.

Zoffix : :) i will try my hand , though no deadline in sight, all i know is i will work daily at it.

ok, well, let me know if you can't make the deadline anyway... I intend to finish mine tonight or early tomorrow

nine: "ssh niner.name" hangs, and camelia is dead. Please fix at your convenience

moritz: "camelia is dead" RIP

like, that's what xml namespaces are for, yeah?  but xhtml is dead, so?

¦ doc: - Remove dead code

Long story short is "you can use one of your dead (unused) keys to type <windows> '>' '>' to get the guillemot."

It's a "dead key" in Linux because applications don't use it in general.

Zoffix, I'll look at it tomorrow now as I have, er, deadline pressure

I use English (international AltGr dead keys)

you do have to read both streams tho or you risk a deadlock... presumable Proc::Async is smart enough to know that / do it for you

which is even more deadly with some temporary caches, where I don't even know if it won't be just in-memory one or in-sql one

and wanted to keymap a dead key for accents

so I thought I remapped something for dead keys or even hardcode í and ó (spanish)

mac has acceptable dead keys in the US layout

reads his programming books in PDF or on dead trees

mspo: nah, it's good. I'd hate for us to have dates to follow. I rather we Release When It's Ready. 2015's Christmas release was a disaster and I'd argue large part of that was rushing to meat a deadline.

arbitrary deadlines are not cool.

.oO(meat the deadline, fish the spec)

.oO( .beat with $dead-horse )

dalek is dead again!

But there can certainly be "dead zones" where cursors further up the stack may not reflect the new language

deadfall :-)

am i writing the code in perl6 or perl5. i'm just a little in over my head, trying to meet an urgent deadline

i'm up against a deadline

jdv79: Because the forked child will be missing all but one of its threads, and so will usually deadlock in short order (like, the next time it tries to GC and wants to sync the threads up).

ugexe: I personally know several people who don't want to even try the implementation because it's Perl, and they don't want to be a Perl programmer because Perl is dead, sucks, etc.

rpython is also a pretty amazing project, but apart from the pypy devs it's not useful (topaz is kind of dead? was it hiphop that used rpython or was it another one?)

On the perl6 website it has a deadlink to the Metamodel::EnumHOW class (see here: https://docs.perl6.org/language/typesystem#Metaclass)

do someone knows about the project V5 ? that is perl5 implemented in rakudo. Is it dead ? stalled ? of no interest ?

I was in the process of writing  it up on the mailing list.  I am tenacious but I am really only a dead beginner, so I am not sure other than the mailing list how I can be of help.  I share and blab a lot over on the mailing list/

¦ ecosystem: �Remove some dead links�

.o( when i was a kid my dead raised rabbits were scary )

smls: I had a bug in IO::Socket::Async where it deadlocked occasionally because DESTROY ran, tried to take a lock, but another lock was already held by that thread, and it set up a circular wait with another thread.

After each GC run, this queue is walked to see if there are any objects on it that are dead

¦ modules.perl6.org: �Toss dead code�

i think what's happening is that I'm piling (possibly dependant) work on the scheduler before it decides to start enough threads and it deadlocks

¦ rakudo/nom: �Remove dead code for `use v5`�

if some error message was never observed then it's probably dead code

welcome to another week full of ungrateful customers, dyslexic management and unrealistic deadlines

stmuk: I feel I'm not explaining it right. It's not students complaining. It's not the teacher dismissing the language. It's the teacher not wishing to teach the language because their students will be told they're learning a dead, unwanted language, despite them learning a new language with a bad name

So ignore it. No true Scottsman would use reddit. So ignore it. No true Scottsman would claim Perl is dead. So ignore it. So ignore everyone who is confused about the name :/

I think this whole renaming debate (which has been going on for years) is just a total dead end

Heads up for anyone using IO::Socket::Async::SSL: today I some landed fixes, one for it occasionally disordering messages (actually rooted in a bug in Supply.schedule-on in Rakudo; now using something else to avoid that) and another that could very occasionally cause deadlocks under load. Version bumped, uprading suggested.

Although you will have to rip "Perl6" from my cold, dead hands.

.tell AlexDaniel something worng with the bots. They're all dead and if I try to run one, I get "Cannot locate symbol 'SSL_load_error_strings' in native library 'libssl.so'"

Is de bot dead?

15:04Z <Zoffix> AlexDaniel: something worng with the bots. They're all dead and if I try to run one, I get "Cannot locate symbol 'SSL_load_error_strings' in native library 'libssl.so'"

so then things work until something else needs that lock and suddenly you deadlock

student: because the word on the street is "Perl is dead" and "Perl 6" sounds like just another version of it. No one wants to try dead thinga

oh, and when it hangs, it's using 100% cpu. I wonder if it's deadlocked?

oh snap, grant submission deadline is *tomorrow*

Ok, I am a bit struggling trying to do things which are not very useful and should probably be done at another level. So far has been fun but Im afraid I got to a dead end

it looks that we don't have to put much effort in trying to get rakudo to build on Solaris. With the layoff of the tech people, it looks like it's dead

raschipi: it's going to be published by Apress; manuscript submission deadline is Dec 1st

so... he wants to wait until Perl 6 is dead, so it's not a moving target anymore? /s

Zoffix: I don't know, that's just how it is. There's always something to improve, so unless you declare the project dead and reject all tickets you just won't get there

Oh... is 6.c.errata dead now?

They both seem to talk about testing the Perl 6 modules in a bit redundant way and one of them links to http://smoke.perl6.org/ which seems to be dead

decided not to do it himeself because morphing the language into what I want it to be for the book is a sure way to slip deadlines

moritz: i swear i'll actually read my dead tree p6 fundamentals :)

the dead tree is really pretty looking. :)

stmuk: I only know the PDF and the dead tree version, not the kindle version, so I can't comment

manuscript submission deadline is Dec. 1 for me :-)

andrzejku: but the dead trees doesn't execute :)

zengargoyle: Apropos serialization and remoting data. As I wrote yesterday  the biggest issue is re-creating objects on the receiving side, it's dead slow. I may be doing something wrong though. Another issue is that once serialized the data can be over the limit of a one packet size, so we also need a system to split packets, send them, and  put them together in the right order. I think there's nothing for that, so it must be build from

however, on 6.c, it seems that when i hit the threadpool size, instead of take them in "slices", it enter in a dead lock

Anyway, the deadlock is because you fill up all of the pool with threads awaiting Promise.in

i would say stalled but not dead yet

Nooo my vm is dead

the disk file is dead I think

¦ modules.perl6.org: �Toss dead SASS�

it's pretty nice looking for a dead-tree (it's been a while since i've actually seen a dead-tree technical thing)

but for some reason if you use Proc somewhere it'll seemingly deadlock the scheduler if your task count is > the max thread count

if it weren't 5am for me and i wasn't dead tired i'd ask for the script and have a look myself

4 Aug 2017 23:00Z <zengargoyle> moritz: clicky clicky purchased dead tree.

IRC isn't dead by a long shot.

.tell moritz clicky clicky purchased dead tree.

probably not the one you are seeing, it usually is prone to deadlocks

moritz: someone linked this to me earlier: https://beta.undeadly.org/cgi?action=article&sid=20170304230520

'cus it can see the result is dead

nemo: that's what i mean, that's very dead

so the whole page is dead

geekosaur: kdbus is long dead

(actually looking at the code it already does that so it might be dead code anyway?)

yes, looks like dead code

has just tried to sneak a talk submission into the YAPC::EU queue past the deadline

syscall(169, 0xfee1dead, 537993216, 0x4321fedc);

anyone looking for a fairly cross-platform way to slurp an http request body into a var - https://github.com/ugexe/Perl6-App--ecogen/blob/master/lib/App/ecogen.pm6#L9-L28 + `return powershell-webrequest($uri) // curl($uri) // wget($uri)` - this works now (would deadlock prior to proc rework)

bioduds_: i'd also humbly ask that you think about treating IP as IP and not as IPv4.  v4 is the dotted-quad thingy, but there's v6 which is 128bits usually in a crazy dead:beaf::dead:beaf format.

well, so the 'deadly slow' points are pretty much obvious by now

zengargoyle: oh, no, any comment that might help improve the book is welcome. (Even though it is too late now for the printed version, since the dead tree version is out by now. I can still improve the e-version.)

araraloren: panda isn't relevant; it's dead. And yes, zef supports it. E.g.:   zef install https://github.com/zoffixznet/perl6-IRC-Client/archive/2.001002.zip

El_Che: and I considered whether to go through the hassle of creating a dead tree book when apress contacted me

no, the deadline we gave was Sunday 14 May

m: try { die("dead") }

m: try { CATCH { .say } die("dead") }

rakudo-moar 096bc1: OUTPUT: «�5===�SORRY!�5===� Error while compiling <tmp>␤Strange text after block (missing semicolon or comma?)␤at <tmp>:1␤------> �3try { CATCH { .say }�7⏏�5 die("dead") }�␤»

m: try { CATCH { .say }; die("dead") }

rakudo-moar 096bc1: OUTPUT: «dead␤  in block <unit> at <tmp> line 1␤␤dead␤  in block <unit> at <tmp> line 1␤␤Actually thrown at:␤  in block <unit> at <tmp> line 1␤␤»

m: try { CATCH { .throw }; die("dead") }

rakudo-moar 096bc1: OUTPUT: «dead␤  in block  at <tmp> line 1␤  in block <unit> at <tmp> line 1␤␤»

m: try { CATCH { when X::AdHoc { say "caught die $_"; } }; die("dead") }

rakudo-moar 096bc1: OUTPUT: «caught die dead␤»

Perl is dead, eh?

is dead but for actually doing tombstone testing to see if the function is ever called and delete it otherwise

maybe it..deadlocked?

AlexDaniel, bisect log: https://gist.github.com/6a0efd5cdeadd3b98ad8d034d463e4cf

bisectable is dead :(

no surprise, Opa is dead

but I have the odd feeling the project is dead

[15 08:16:06] <Sequell> travis[2/2]: <Grunt> Travis can't be bargained with. Travis can't be reasoned with. Travis doesn't feel pity, or remorse, or fear. And Travis absolutely will not stop, ever, until your project is dead.

he had a blog on use.perl.org, but the link is dead

Skarsnik: language definitely grew. New faces on IRC. 4 or 5 new books being published (some finished!). People outside the community no longer go "lulzwat Perl is dead" and mostly know Perl 6 is a new language. However, I did notice ecosystem growth slowed down quite a bit, which I suspect has a lot to do with Inline::Perl5 and Inline::Python being improved greatly. There's little reason for people to write

DrForr: Effectively, the stuff to the right of the and is dead code

they came to see if perl6 is alive and it was clear to see that perl6 is actually dead

but Lisp is dead?

raschipi: I don't need a container. It just makes it dead easy and clean

samcv: I want the manuscript to be complete in May, but I don't have any hard deadlines

looks like some dead code

why do you say dead code?

$prev-word=$word; # dead code...

. o ( I see dead code );

ZzZombo: i have no idea what you mean by "dead code" there

[21:21:59] <ZzZombo> $prev-word=$word; # dead code...

Thing is, in Perl 6 it's dead easy to say

If it is in C, I am dead

The community seems to be deadlocked to me about what the proper release should look like, so I'm doing my own thing. If people wanna use it, great, if not fine with me.

there is also a project called "puredarwin" but it's fairly dead

darthdeus_: if you like dead-tree version, the first one in that list is already complete

IOninja: awesome! I love dead trees :P

moritz: any plans for a dead-tree version in the future?

and he replied 'Those days are dead and gone and the eulogy was delivered by Perl.'

Those days are dead and gone and the eulogy was delivered by Perl.

Oh, I'm already done with tests: https://github.com/perl6/roast/commit/1f5dead548

I got a dead sha! https://github.com/perl6/roast/commit/1f5dead548

that's one step down from deadbeef :)

m: "1f5dead548842b9f26516adb6df995d9108d7ef3".comb.grep({!/\d/}).squish.join.say

rakudo-moar 164e39: OUTPUT: «fdeadbfadbdfdef␤»

darthdeus: from the perl5the narrative coming out of the perl6 community was "we're the replacement when we get there, perl5 is already dead" for some years

m: my $x; my $y; my @a = ($x notandthen $y notandthen 'all systems are reset and ready to go'); my @b = ($x orelse $y orelse 'all systems are dead, using backup value'); dd [@a, @b]

rakudo-moar 1811b8: OUTPUT: «[["all systems are reset and ready to go"], ["all systems are dead, using backup value"]]␤»

m: my $x = 42; my $y = 72; my @a = ($x notandthen $y notandthen 'all systems are reset and ready to go'); my @b = ($x orelse $y orelse 'all systems are dead, using backup value'); dd [@a, @b]

but I can't archive.org from where I am, and the original link is dead

timotimo: yes, the deadline was 9th of February iirc

stop beating that dead horse

m: say categorize { $_ %% 2 ?? ‘alive’ !! ‘dead’ }, (1, 7, 6, 3, 2);

rakudo-moar aac9ef: OUTPUT«{alive => [6 2], dead => [1 7 3]}␤»

[Coke]: do people ever blow the deadline of the grant delivery they promised and is it a big deal?

IOninja: are you already planning to miss your deadline?

IOninja: also, IANAGM but I would guess that since it's paid on completion, it's not that big a deal if you miss a deadline, but communication with your GM is paramount to keeping the grant active until it is complete.

pyrimidine: I can remember at least 2 grants that extended well past their deadlines.  I don't know if they ever paid out or were simply dropped.

If TPF or the like haven't applied, they missed the deadline.  Org application deadline was Feb 9

also for the undead

vktec: for me, I like how expressive it is (a lot of common functions/methods are built so code can be short), modern (unique OO system, gradual typing, concurrent) and dead easy C-binding. The community is very accessible. Downsize is age (needs more libs) and speed for sometype of applications (although it's getting a lot faster).

"Bug report: Car didn't apply break. Driver dead."  "Oh shit, off-by-one error right there!"

dead link on his website

i'd like to review your code, but i'm afraid i'm dead tired. i've already made a major mistake today that requires a bit of intervention from someone with more permission bits set …

cale2, to rebuild from scratch docs you'll need a workers squad. :) Not so long ago I've reviewed all the docs for an example output style subject. It is "easy", but there is a damn huge load of work and I felt myself like dead when I finished it.

we also handle "actually, the original author is dead"

Does that even work? It'll prolly just deadlock.

weird, I had deadlocks in roast when max threads was too low

it's for defining when local variables can be considered dead

And the README starts with "This repository is retained only for archival purposes.  The project is currently considered dead..."

kenietz, that situation is typically called a deadlock

(pull dead modules from the ecosystem) do we have a way to mark them as "invalid" or something?

AlexDaniel, Full output: https://gist.github.com/a77f658bedead8bbc2d09759b459fbf5

and even getting a full report of all the GC object stats, live and dead, all those not yet collected: https://github.com/openresty/stapxx#lj-gc-objs

www.p6c.org seems ... kind of dead

I guess 32 bits is dead, right guys?

So in effect the data in the first sublist beyond the first item is dead

samcv: After the submission deadline, the grants are posted for public commentary for some amount of time (1-2 weeks I think), then they committee votes.  I'd figure they'd award by sometime in early Feb  (but I'm just guessing;  Coke would know truer things since he's on the committee)

because, google won't help. Traffic to the language is pretty low, (because of perl is dead doctrine)

printing like on dead trees (and yes, there may be bugs)

Seems a waste to use a dead language if you have to explain it so verbosely :)

Leont was active on github 3 weeks ago, so he aint no dead

well, I was short in time before the deadline and according to the proposal it was between 2 and 4 people (jj + his 3 daughters). He's often around here, so you could more info. It looked a fun idea to me

I added the docker talk because there was a sudden deadline :)

Sudden deadline is sudden.

RandalSchwartz: I was just wondering if you were dead. Last I recall you were in the hospital and your account hacked or something?

I'm over on the oter side of te spectrum, nearing infra-dead :)

but the bot is dead so… :P

US battlecruiser dead in the water due to div-by-zero error

ok it's not dead

how hard is the deadline of getting an advent post in before midnight of the publishing day?

Actually, I am back to using a Mac now, and I have forgotten how to type the Unicode symbols, or I would be using the right quotes and things like diaereses ... I was used to dead keys with X' compose.

ugh. all my ssh keys are on dead mactop.

I find that in my concurrent code, the biggest problem I have during development is figuring out what exactly happened in some dead subtask.

you might be deadlocking there

r/perl6 looks so dead. Mostly the posts are weekly summaries and for now the advent stuff

m: CONTROL { .gist.say }; emit; say "haha, no one is deadied";

rakudo-moar a980eb: OUTPUT«�5===�SORRY!�5===� Error while compiling <tmp>␤Calling emit() will never work with declared signature (\value --> Nil)␤at <tmp>:1␤------> �3CONTROL { .gist.say }; �7⏏�5emit; say "haha, no one is deadied";�␤»

m: CONTROL { .gist.say }; emit 42; say "haha, no one is deadied";

is there a way to pass a variable key name in that form? i may have gone brain dead too.

FWIW I'm all for the book, and I want to see it out in people's hands. But the lack of community interaction worries me. As it does most everyone here, so I'm not going to flog that dead horse.

AlexDaniel: One little mistake (e.g. not normalizing urls in your caching mechanism) and you end up with a dead server.

there's also --shared if you're not making any modifications (but if the original repo loses that branch, your copy goes dead)

sena_kun: it's three weeks before the end of the semester here, I'm going to be dead by the end of it, that's for sure

MadcapJake: for a minute I thought that you were dead

well, dead keys too, but I don't think these ones can help with emojis

Cool.  Nothing like a deadline to light a fire under my ass.

https://docs.perl6.org/type/$AMPERSAND$QUESTION_MARKBLOCK is dead link on https://docs.perl6.org/type/CallFrame

there is a dead link

efficient and deadly

that feel when rakudo.org is dead

... and in return, just hit dead stop traffic. *angry hand wave*

andrzejku: besides, wasn't RoR dying or dead because they designed themselves into a corner?

But on the topic of '0' being true. It makes sense in Perl 6 because Perl 6 has types. 0 is an Int and '0' is a Str. BUT, if you're dead bent on it being false, you can make it false.

hmm, only one dead tree reward and already taken :( I guess I'll have to buy it afterwards then, and back it anyway for now :)

AlexDaniel: FWIW, I didn't mean that you open too many tickets or anything here: https://irclog.perlgeek.de/perl6/2016-11-15#i_13573265  it was just general frustration at dead-end tickets :)

. o O( don't dead-end tickets just mean that people with notable insight don't write enough patches..? )

I was worried HTTP::UserAgent would also be a dead end, but I think I can salvage it.

But you can do stuff like "see bit pattern 0xdeadbeefdeadbeefdeadbeefdeadbeef on the data bus -> change a CPU instruction to not do some of the usual protected-mode tests"

Any idead why rad_number in rakudo actually works when the bug workaround is after the :my?

or maybe it's the fact that $proc.started is returning true even when the process is already dead?

viki: i think i see the logic, and i'm beating a dead horse again:  the system throws if we try to write to a file open read only, that's the the way system open works and i don't see any way to add any useful info--case closed, Watson!

fwiw the p5 advent calendar had submission deadline yesterday

Yes and no. If it were dead easy to put all our business logic in plain old classes and have simple (or even better, free) ways to convert DBIC results to such classes, people would just do that.

nine: what's making it not-dead-easy?

"it could break stuff" I mean, I found bugs. Turns out -- they didn't matter because most of this is dead code anyway...

<Grunt> Travis can't be bargained with. Travis can't be reasoned with. Travis doesn't feel pity, or remorse, or fear. And Travis absolutely will not stop, ever, until your project is dead.

m: sub dies() { die "dead meat" }; dies orelse say "oh no! $_"

m: sub dies() { die "dead meat" }; dies() orelse say "oh no! $_"

rakudo-moar 74d0e3: OUTPUT«dead meat␤  in sub dies at <tmp> line 1␤  in block <unit> at <tmp> line 1␤␤»

m: sub dies() { die "dead meat" }; (try dies()) orelse say "oh no! $_"

m: sub dies() { die "dead meat" }; (try dies()) orelse say "oh no! $!"

rakudo-moar 74d0e3: OUTPUT«oh no! dead meat␤»

m: sub dies() { die "dead meat" }; (try dies()) or say "oh no! $!"

rakudo-moar 74d0e3: OUTPUT«oh no! dead meat␤»

well  sub dies() { die "dead meat" }; (try dies()) �or� say "oh no! $!"

The news occasionally shows the story but no one gave a shit. After a couple of weeks it was clear the crew is dead and that was the end of it.

it will depend on where the sub was, and how deep. there really are situations where any rescue mission will only get near its goal after everyone is dead anyway

flags		: fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm pbe syscall nx pdpe1gb rdtscp lm constant_tsc art arch_perfmon pebs bts rep_good nopl xtopology nonstop_tsc aperfmperf eagerfpu pni pclmulqdq dtes64 monitor ds_cpl vmx smx est tm2 ssse3 sdbg fma cx16 xtpr pdcm pcid sse4_1 sse4_2 x2apic movbe popcnt tsc_deadline_timer aes xsave avx f16c rdrand lahf_lm abm 3dnowprefetch ep

bioduds_: and aren't bitcoins minded with purpose-made hardware these days anyway? And isn't bitcoin dead 'cause they reached the limit or whatever the hell happened last year there? :)

seems like mining is dead for mere mortals

like, usually after "die" the code assumes the rest of the routine is dead code

I don't suppose anyone has a clone of HTTP::Server::Tiny handy?  I'm struggling to work out the reason for the deadlock in t/12-supply.t

anyhow, to repeat my earlier question, does anyone have a local clone of HTTP::Server::Tiny and want to offer any suggestions as to why the deadlock in t/12-supply.t?

so ... compiz and compiz fusion are kind of dead; what project would supercede those?

Oh, seems like gogs&notabug are less dead nowadays

last time I checked not only it was very … useless… but these projects were also a bit dead. Good to see them alive again

don't know that I have the time to get that deep into it, this is only a small part of a much larger project with a way-too-soon deadline

huh, it can apparently deadlock?!

I might be a bit braindead right now, but wouldn't that change the semantics of indirect method calls when the argument is such an access?

Oh yeah, if you just want something dead simple like "everything that matches this pattern", you probably want comb

crap, backup ext usb disk dead after 4 years.

elohmrow: url is dead

TestNinja: it's only murder if the dead one is of the same species as you. So you're a bot? :-)

it took python 9 years to become useful, so we are well within the deadline :)

nine: you're extraordinary. I got an headache looking at the opensuse build system docs (and the zillion dead links)

resurrection may be the wrong word. i don't think cthulhu is actually dead?

timotimo: there is even a debian  request for the possibility to switch elision on-off at run time, but it seems to be dead in the water

jnthn: To avoid calling dir() twice, I have to re-implement its :test handing though: https://gist.github.com/smls/e4adead89c3aa8dcefd945725d2cd803

About the issues number... There are many pragma-related issues, many of "document this and that" issues, etc. There are not so many big and important issues like dead links and such, so we should be okay with it somehow.

"@zoffix Pearl 6 has been an ongoing development since 2000. Yet after 14 years it is not officially done.. Its not dead its dead end"

if i start 30 netcats per sec it seems that my code deadlocks. at least nothing is happening anymore

then the only thing thats happening is the "deadlock" when i use 20 or more connections in parallel

doc: This change completely solves the problem of dead links in a 'From ' field on generated routine/ pages.

Also, I think, https://github.com/perl6/doc/pull/632 can be merged to try how actual output of checklink changes. Today I've elimitated pretty much of dead links from routines page, the output should be quite smaller.

AlexDaniel, this PR somewhat changed the pod. And I used Pod this evening in the code to check a type of every "From" link. And we have now: empty links + all "From" links - they're all dead.

Currently, if we resolve webchat/examples links, then almost all output will be gone. It would be actually useful to search for dead links, not just staring at huge output.

s34n_: Is it? my impression was that panda was dead, and zef was its successor

And -release seems to be dead entirely

excellent. I am, once again, going to be trying something I don't understand, that none of the people who do understand it have tried before, on a deadline, for no particularly sane reason

notice it has to distinguish :16<deadbeef> from :16deadbeef

m: say(:16<deadbeef>)

rupert160: ^^^ please note that Promise provides a wide range of methods to say exactly how long (the implict) await should block. If you use more then one await, you can introduce a deadlock quite easyly.

even the radix form :16<deadbeef> is a variant of it

m: my $foo:16<deadbeef> = 42; say $foo:16<deadbeef>

rakudo-moar 32c08b: OUTPUT«�5===�SORRY!�5===� Error while compiling <tmp>␤Confused␤at <tmp>:1␤------> �3my $foo:�7⏏�0516<deadbeef> = 42; say $foo:16<deadbeef>�␤    expecting any of:␤        colon pair␤»

doc: Fix dead links on the glossary page

It's not telling you it isn't useful, it's telling you there's nothing to do and you wrote dead code.

holyghost: no, parrot is dead

I.I code deadpool.

Kinda weird to read previous comments from a person that's now dead :|

there are about 100 billion dead humans on this planet (starting to count about 170ky ago). Most of them never wrote anything. In a few decades most words on record will be written by a now dead person.

Long time. I was starting to think you were dead :)

localstorage, silverlight (luckily mostly dead), ip tracking, ...

sorry for beating a how-so-dead horse at this point. but the solution feels a bit icky

progress in everything has made huge leaps and strides, but it is still dead easy to trigger segfaults and other random/weird errors in async/concurrent code

bisect: good=2015.10 my $p1 = start die "I’m dead"; my $p2 = start ~"I’m alive"; try await Promise.allof($p1, $p2); say .result for grep { .status ~~ ‘Kept’}, $p1, $p2;

bisect: my $p1 = start die "I’m dead"; my $p2 = start ~"I’m alive"; try await Promise.allof($p1, $p2); say .result for grep { .status ~~ ‘Kept’}, $p1, $p2;

doc: Remove dead CSS

is http://irclog.perlgeek.de/perl6-dev/today dead only for me, or are there more people not getting it ?

dead here too

because the number 4 pronunciation is quite similar to the pronunciation of dead

Do any toxic deadly chemicals smell like manure? I just rode the bus through several blocks and it reeked. Still stinks at $workplace. I wonder if I should evacuate :|

*sigh* reddit and similar really aren't good for programming langs. I have wondered whether perl6 needs something like undeadly.org (for the OpenBSD community)

masak: Snake isn't dead, but it's not super-alive either

is the perl 6 project for .net dead?

and not to beat a dead horse, but um... dead meat

guess the bot is dead?

evalbot: Remove some dead channels

AlexDaniel: dead code is best code

removed dead code is best code

.oO( r̶e̶m̶o̶v̶e̶d̶ exterminated dead code is the best code )

And just because something is "dead" doesn't mean that there aren't lingering organs still in use! =)

so deadlocks?

I hope perl will be supported more soon. I always see 'perl is dead, perl is ugly, perl is this perl is that', even looking for tutorial :(. And a web dev told me to not use Perl.

Well Perl is most definitely not dead, it's just not quite as fashionable as some languages

"Its not just C. I fully expect at some point, companies will cry out for maintainers in numerous "dead" languages that still pay the bills somewhere. So don't forget your Perl!"

nah, it's just that I am over energized right now. Had a dead line 5 minutes ago

ostensibly Perl 6 day today, though I might need to leech some of it to deadline-related $work :/

if you have a direct-ish connection from start to finish, you'll be fine. if you have to move 1km away from start as well as end, and then 2km towards the goal, you'll be looking at a big amount of dead ends first

thus, ack for non-braindead escaping  :-P

(until it's a dead language)

so funny that #p6dev is amok and #perl6 is dead right now xD

but to beat a dead horse: words are tools for understanding, "transpile" was created to inform (perhaps less competent, perhaps not) programmers of a specific type of compilation that is taking place and it serves that purpose well, I think.

caw caw bang f**k you're dead

with years... we have all to switch to perl6 ? or perl5 will still continue to exist  ? i mean.. .for example with python... they suggest to switch and use always python3 now since in 2020 the support for python 2.x will be dead... how about perl ?

Perl 5 != Perl 6, so I guess Perl 5 won't be dead before a long

Bot dead :) I'm just updating Perl 6 and then I realized I need to recompile Perl 5. So I did that and now I'm installing a gazillion of modules :)

in Git::Version::Compare (perl 5), I'm dropping the gdeadbeef bit

not to beat a dead horse, but I think subscripts should be allowed in ident because x₁ is a very common compsci/math concept/syntax

http://www.billboard.com/articles/news/7341522/prince-dead

http://www.tmz.com/2016/04/21/prince-dead-at-57/

maybe im stucked to an dead cluster

tadzik: yeah ... on the good side our gov is pretty specifically designed to deadlock on error

masak: adventurer.... more returning from the dead

"dead batteries included"? :)

http://www.thewalkingdead.com/wp-content/uploads/2014/08/hawkward.jpg

http://www.thewalkingdead.com/readme.html

You've never herad of thewalkingdead.com ? You just linked it...

also "Perl 6 is dead" is just so 2006

It's not autopsy of a dead language, is it?!

Too bad I'll be dead by then :(

i can't laugh at myself when i'm dead

Now if the corpse was �in fact� a dead parrot. Then it �would� be funny!

its almost the definition of navel gazing around "why is Perl dead" despite the obvious reality of everyone there using it every day

so, braindead as I expected :)

http://doc.perl6.org/type/Metamodel::C3MRO got dead links to nextsame and friends. I'm unsure where to put them.

is it possible that it is failing to close the client connections in a timely fashion and is getting deadlocked before it is able to do when it reaches the max number of threads

Its behavior *after* trying to handle 16 threads is also reminiscent of a deadlock.

I'd guess if I had to that it's assuming that the thread pool is infinite so it simply spawns what it needs, and when resources run out it deadlocks trying to allocate the new threads rather than puts requests in a queue.

“<dead_diaeresis> <acute> : "̈́"   U0344 # COMBINING GREEK DIALYTIKA TONOS”  ← omg, X11/X.org, why did you have to put lines like this in the files I need to parse.

Is there a parseInt() or similar that could xform 'deadbeef' ₁₆→ Int,  '0755' ₈→ Int  ?

ooo, m: say :16('deadbeef')

m: say :16('deadbeef')

many of those are not currently functional: parrot backend is essentially dead, jvm is broken (they're working on it), std (basically a parse tester working against the spec) bitrotted when rakudo-moar started using a parser based on the spec instead of the original ad hoc one

Guest58846: nope, I'm undead

And they said Perl was dead.

uhm, I fear ufo is rather dead

-∞ on meeting arbitrary dead lines

it's not arbitrary. It's what people will get for the next few years. Very important deadline to keep in mind

CurtisOvidPoe: as long as we're not all dead by the end of Perl 6, I'm fine with the title

I want a claky keyboard that is so heavy it could be considered a deadly weapon.

moritz: Dude, I am a purist. If I can't type a character using only the Shift key, it's dead to me.

Xliff: hmm, so dead keys are dead for you too?

Xliff: you have dead keys somewhere on the first layers? Huh?

no rim or deadnote sample in the kit?

i mean, low velocity on the deadnotes can work i guess, but...

jnthn: Ok. - So I guess there's no way to use a native C function which writes to a file descriptor and use that with Async::Proc? I tried to use it with plain run but I get deadlocks when the programs writes to stdout and stderr and reads from stdin.

But as a I said, I can't get it to work with just run because of deadlocks and Proc::Async has no way to get the native file descriptor.

jnthn: Yeah. Any idea how I could get it to work with run without the deadlock?

well, in this case it'd be dead code elimination, really

johnP: parrot was a dead end half a decade ago

.oO( monthly reminder? “this project is still dead. Thanks for reading this email” )

http://rakudo.org is dead for me

I do that in JavaScript too, because the dialects that are actually available where I need to run are broken and braindead in various ways.

In this page, the link to Module::Skeleton is dead : http://doc.perl6.org/language/modules-extra

doc: Replace a dead link

if you're curious, I'm trying to figure out how to properly assign <dead_greek> to e.g. AltGr+g

tweakism: <dead_greek> ? is that like dead sea scrolls?

a lot of non-US keyboards use deadkeys for diacritics... like, pressing ' follows by a does á, and if you want a normal ' you have to type '' or something.

TEttinger: yup, they're dead keys :)

which, Compose is also a dead key

a dead key is a key that you press and release, and it doesn't do anything immediately; it modifies whatever you press later

.tell AlexDaniel Google told me you may figured this out: I'm trying to add <dead_greek> to AltGr+g; maybe we can chat about it later.

07:06Z <tweakism> AlexDaniel: Google told me you may figured this out: I'm trying to add <dead_greek> to AltGr+g; maybe we can chat about it later.

tweakism: So, there are several ways to do that. I use custom keyboard layouts so I usually just change the layout, but even then there are different approaches. Let's try the fastest one first: if you're using e.g. “us” layout, then open /usr/share/X11/xkb/symbols/us, find the right key and change it to something like key <AC05> { [ g, G, dead_greek, dead_greek ] }; and that's it

_nadim, you can't trust a living dead language. It may eat your brain. :)

not a big dead

RabidGravy, Pushed now, but dalek was dead, I'm waiting for travis-ci results. :)

moritz: is the submission deadline already over?

saw deadpool now

see https://dzone.com/articles/learning-es6-using-let-const-and-temporal-dead-zon

Hopefully I didn't leave any hanging pod tags because I'm dead tired and heading to bed.

nope. it was an artifact of the last minute work required for the christmas release. An unfortunate result of the hard christmas deadline imposed on us.

going to finally see deadpool tonight

I was more thinking allowing something like a 0xdeadbeef initialization option

MadcapJake: Feb 19 1900 UTC was the mentoring org application deadline

Herby_: not sure if you are actually following me but what I was trying to say is that this solution is dead simple if you just take my word that these two lines return writable diagonal slices :)

I think IO::Spec is a dead end, I've seen mumurs about it getting killed off.

Hm. I'm getting deadlocks when I try to capture stdout and stderr.

s/deadlocks/weird hangs/

it's indead not a symlink on the dev package

And then it'll fall to dead code elimination

I have an issue where my program seems to deadlock if you go above a sufficience number of promises relative to threadpool size

so with sufficient promises being awaited, a deadlock situation is possible

jnthn, without that I'm guessing you could reach deadlock until an external process finsihes?

Peter_WR: You'd end up blocking an OS thread from the thread pool, and if you do that to the whole pool then yeah, you can deadlock

you aren't to expect that from a deadpoolmovie

7 -> 8 was dead easy

sadly, deadpool was sold out and we didn't get any ticket ;(

so, technically, would you be able to force a deadock if you would have sufficient awaits at the moment?

afk for some deadpool, then work on P6W &

By that time, it was kind of obvious for any insider that parrot was a dead-end, and the TPF is a better umbrella really, but I can imagine how the outside world wouldn't have known

timotimo: it's been dead for months, we can do whatever we want with it.

star: Start to bring back R* Mac dmg binary build from dead

nqp: [js] Remove a piece of dead code.

http://blog.acolyer.org/2016/02/05/is-sound-gradual-typing-dead/

oops, dead link

I would hope the SIG hack is dead

the world's already too big to keep up with everything related to some topic, unless that topic is already effectively dead (and sometimes not even then)

ZoffixW: huggable is dead!

sena_kun: my problem is: I'm writing an article for a print magazine, and I need to include easy instructions for getting rakudo star 2016.01 installed. I'm not confident that the package managers will catch up until the article submission deadline

jdv79: some spectest is probably deadlocked.

pmurias: it was running "node" something. it's dead now, I have no idea, sorry.

i'm a deadpool fan, too

's threadpools are dead pools

Like names of dead Roman gods make any more sense.

the Imlib module was dead and I am trying to revive it

The home page of rt.perl.org is almost a dead-end. How to navigate to the list of bugs is very non-obvious.

Having deadlines nearly always *reduces* software quality. We've done the Christmas thing now. We don't need to force ourselves to meet any further artificial deadlines again, just deliver gradually increasing value to our userbase at regular intervals, as we've become well practiced at doing.

(deadlocks and all!)

stupid deadlocks

zavolaj is "dead"

if it rejects a program because a dead part of it is ill-typed, it rejects a valid program

ely-se: dialyzer assumes that dead code is bad and should be detected

ely-se: in regards to stuff breaking due to newly discovered crap dead code, just not aborting  legacy production code solves that issue

given some of us hope to be dead by the time we reach .z, it's someone else's problem :)

If we do switch to 6.0 someday, I hope to be dead before we hit v6.6.6...

rakudo/nom: Rip out remaining dead code from newio branch

roast: Remove references to dead code of newio branch

sergot: well, atm it is pretty dead…

masak: If this happens, Perl 5 is dead.

rakudo/nom: 57deadf | RabidGravy++ | / (3 files):

rakudo/nom: review: https://github.com/rakudo/rakudo/commit/57deadf39e

Well, at some point I started to realize that if the repo is owned by tadzik then it is potentially dead or just unusable… nvm, don't mind this cryout, I just want to serve a goddamn binary file…

https://github.com/mourner/dead-simple-grid

is the "old enough to not stress anymore" a limit you reach where you might die at any moment, so the normal deadlines don't have any power over you anymore? :P

Two locks opened in opposite order can deadlock, and it's easy to do that inside a highly composed codebase.

But, the recent concurrent-only Promise changes has its own deadlock hazards, if you have any feedback loops.

hoelzro: everything would be dead simple if we only supported Unix. Then I'd just open a pipe and pass the file descriptor to the child process.

you're right; the only process for a new user to get 2015.12 right now is via rakudobrew. Everything else via that domain is a dead end

goes off to fix up a few now-dead SSL certs on my LAN because I'm really lazy with specifying dates...

but i'm dead tired right now ;)

that's a really tight CFP deadline right there

S02: "For identifiers that take a non-negative integer argument, it is allowed to abbreviate, for example, :sweet(16) to :16sweet. (This is distinguishable from the :16<deadbeef> form, which never has an alphabetic character following the number.) Only literal non-negative integers numbers may be swapped this way. Please note that this abbreviation allows:"

oh, WOW... first company ThinkPad (the only one with Win10) didn't wanted to boot (but was unplugged from power (and battery is dead anyway) :) ) THEN it displayed that some update is ready to install... but after installing Win10 month ago and seeing packets int tcpdump EVERY second I firewalled it from inet... you just can't air gap that new beasts! ;)

awwaiid: that discussion has a long pedigree. it's currently at a kind of dead point where TimToady has said "it should work with Inf fitting inside both Int and Num", but there's no implementation in sight, and Architect jnthn has said he won't go near the thing.

on a long enough timeline, everybody who remembers either language will be dead, after all

yep, dead

a3r0: deadlines do not work

tablets: review: https://github.com/perl6/tablets/commit/78a2c9dead

so basically precomp is dead on the JVM atm

krshn: I have a dead key for that though

flussence: sorry, but we'll likely be dead when that becomes a reality

all my vmbox save are dead ><

I'm disallowing myself to participate in #perl6 for the next few days because of dayjob deadlines.

or any other way to revive it, right now I have a piece of dead wood

ab6tract, brrt: "1.5d to deadline... everybody wanted to fix everything and things was breaking as they was fixed. Then Management called: guys, we need to sink things before they go to into void... Luckily Overlord had idea how to do this. Actually, we can't whine on our Managers as they are lastly barely sleeping and Head Engeener can consult with them what things actually should be doing. Then management c

pmurias: yeah. Well, my problem with Bailador is that it seems to look a bit like a half-dead project

It's just because I fail repeatedly at implementing a first grader's example, i.e. a dead simple linked list

"CPAN6 is under heavy development"... That's like the 3rd project this week I see that's "under heavy development" and seems to have been dead for a number of years

aghr. I need to stop programming perl6 and get other stuff with deadlines doen. Fun to play with the presents before christmas

ie it's a dead language etc.

Both would probably have not made it into nom if we had 1) reviews, 2) no deadline

nqp/js-cps: [js] Remove dead code.

camelia in mono looks dead

[Coke]: ulimit would not help with a deadlock

nine: (deadlock, ulimit) that'd avoid the ulimit time check also?

jnthn: with enough values in the source, hyper can deadlock ...

but it's pointless to beat a dead horse like that, so I'll just stop talking about flattening etc. That ship sailed some decades ago

what I've just discovered is that there's <dead_greek> key

niecza is dead :(

has anyone experience problems with the react syntax and channels? sometime there seem to be a deadlock (the react block just prints $_, nothing fancy

about 15% of the time, this code get something like a deadlock

those insiders are all dead, no?

RabidGravy: you're just like Hitles <--- see what I dead there? :)

after a nuked install, spectest is still mostly dead :-(

but i have no good way to figure out which lines are "dead"

in the meantime, I've been trying to run `panda smoke`: a handful of modules deadlock on precomp after hitting some error or other during normal compilation, and when it gets to v5 panda itself just gets stuck in a busy loop.

what does 'deadly parasitic' mean in https://raw.githubusercontent.com/perl6/mu/master/docs/Perl6/Cheatsheet/cheatsheet.txt

well, it replace organs instead of merely augmenting the host. I don't think it is supposed to be deadly.

who knew the comma was so deadly

lol is dead isn't it?

is KeyHash dead?

mu: I cannot make the deadline for the 6th.

found while doing `panda smoke`: Hinges causes a deadlock on the precomp lockfile

http://www.radiotimes.com/news/2014-07-14/giant-dead-parrot-unveiled-in-london-to-pay-tribute-to-monty-python

is panda still dead?

I think purl is dead. 'been ages since I've seen her.

honestly a bit of leeway with the deadline would be appreciated. i would feel better about it if i could give it a morning read over rather than posting while drinkcoding (<-- only smashcase whenyouhidingsumtin ;) )

any thoughts on trying to get Šuppa to sort near Sośnierz instead of dead last?

nqp: Bump MOAR_REVISION for deadlock fixes

rakudo/nom: Bump NQP revision to get MoarVM deadlock fixes

the link to Advent calendars in http://perl6.org/documentation/ is dead

hankache: the links do not seem dead

json: @*INC is dead, long live CURLI

m: say KeyReducer; # isn't this dead?

chimps are dead

Not to mention dead/unreachable code elimination

Tonight, though, it seems I've run up against my fair share of dead-ends

(half-dead-ends? wilted-ends? sprouting-ends?)

scopesoft: start doing some while loops with native ints and you can see that the performance "bottom" for perl 6 can really beat perl 5 significantly. the core devs just can't finalize the interior decorating *and* rewire the engine at the same time when there is a deadline looming

m: my $p1 = start die "I'm dead"; my $p2 = start "I'm alive"; try eager await $p1, $p2; say .result for grep { .status ~~ 'Kept'}, $p1, $p2;

Hi folks. Writing up an OSCON proposal and was curious about the deadline for the Perl 6 release?

MS actually sold a Unix for a long time. Think it's dead now, though

Should the second one not deadlock?

_sri_ - I think that argument is pretty much dead at this point.

diakopter___, I doubt TimToady wishes to make a statement that Perl 5 is dead amd no one should use it because Perl 6 is better.

yay Zoffix is not dead in the weird dark alley

there's a condition where we can deadlock when trying to start a gc run

i wanted to talk with someone about that blog post that talked about the threadpool exhaustion and deadlock

the one @ http://blogs.perl.org/users/pawel_bbkr_pabian/2015/09/asynchronous-parallel-and-dead-my-perl-6-daily-bread.html

if perl 6 is going to be made of composable concurrency primitives, and ask that you not worry about things like threads and locks, then it is wrong for you to be able to deadlock a perl 6 program based on the size of the threadpool

cxreg: The reason the thing in that blog post deadlocks is 'cus await is blocking at the moment

it's just dead code elimination, no?

brrt: dead code elimination

just to give myself a deadline, when does the advent start up? :)

could be deadlock too i suppose

Hotkeys: it doesn't look like there should be something wonky - except if it does deadlock for some reason or other, which you could probably figure out with perl6-gdm-m

guess it's dead...

I've got about six in flight with various deadlocks and blockers

7 Sep 2015 06:58Z <jnthn> bbkr: Saw your post; I think the deadlock will go away once I implement the smarter version of await that makes thread pool threads available to do other work while they're awaiting.

livescript is pretty much dead (and I don't want to keep on being the only one trying to make stuff change)

so i should something else indead of WhatEver?

nqp: [js] Remove some dead and/or commented out code.

I wanted to use Padre, two birds with one stone, but it's a dead project

rakudo-moar cd7766: OUTPUT«1) f has been entered␤3) here be dragons␤6) no, I'm dead␤»

jnthn, also funny deadlock thing in require tickled by creating URI objects in a thread

Hmm, grammars have deadlocks?

psch: newio is dead in the water after GLR

if the dragon's weak spot is someone telling him "Hello, Perl 6 World!"... then consider him dead.

so, it's a deadlock

itz_stmuk, yeah I have a large bottle of Leffe, three different types of deadly Imperial Stout, a rather toxic Brewdog IPA and a "chocolate lager"

chrisseaton: There are lots of online resources for learning things about Perl 6.  Is there a reason you want a dead-tree version?

I've reached a dead end here: https://github.com/tadzik/panda/blob/master/lib/Panda/Tester.pm#L24 :) Seems it's not picking up the "-e /Users/curtispoe/.rakudobrew/bin/../moar-nom/install/bin/perl6" bit and runs p5 instead. But I don't have an OSX to test on :P ¯\_(ツ)_/¯

I've been thinking about http://blogs.perl.org/users/pawel_bbkr_pabian/2015/09/asynchronous-parallel-and-dead-my-perl-6-daily-bread.html.  Maybe you've already moved on from this issue, but might it not be possible to simply stop parallelizing and do work in serial when the threadpool is (nearly) exhausted?

by live objects, i imply the opposite of dead objects, like in c++ and ada.

oh, wait, moar jit is working, moar-nonjit is dead.

we've already had that discussion. and it's dead simple to add it in your code.

There is no right pronounciation of Latin, it's a dead language…

R41g0rX, it's OK. It's common misconception that Perl is dead. The reason is in the 90s it was pretty much the ONLY way to do web and now we have many ways, but people have a perception that Perl disappeared.

"This Mocha project is dead!"    "No it's not, it's pining for the fjords."

is it dead now?

m: :16<deadbeef>

m: :16<deadbeef>.say

m: :16<deadbeef>.perl.say

m: :16<deadbeefdeadbeefdeadbeefdeadbeef>.perl.say

m: :16<deadbeefdeadbeefdeadbeefdeadbeef>.WHAT.say

m: :16{deadbeef}.say

rakudo-moar 68f233: OUTPUT«�5===�SORRY!�5===� Error while compiling /tmp/Bhjh0UAGl4␤Malformed radix number␤at /tmp/Bhjh0UAGl4:1␤------> �3:16�7⏏�5{deadbeef}.say�␤    expecting any of:␤        number in radix notation␤»

oh right. dead slots.

nqp: [js] remove dead commented out code

but just talking *about* p6 will be deadly, so gotta show some nifty code, both deep and every-day

FROGGS eiro : that's what I meant with up-to-date: EnumMap is dead  :-(

m: sub f { my &b = { return 5 }; sub g { &b() }; g(); say "dead code" }; f()

m: sub f { my &b = { return 5 }; sub g { &b() }; g(); say "dead code" }; say f()

Yeah, now that Isaac Newton's dead, we all need to pitch in.

Running out of threads from the pool should cause a deadlock, no?

I offered to show rakudo off to some people here at StrangeLoop (all of you should be here, btw), but haven't had takers. I might start tackling people. I REALLY wish I had hit the deadline and had a chance of presenting here... this is definitely a prime target audience

ShimmerFairy: i'm not into guessing, i want to fix CURLI.  If i need to fix CURLF too then i will.  I've been digging around in CURL{I|F} and asking a lot of questions about it for more than a year and a project i was working on is now dead until CURLI is fixed.  I'm willing to contribute to fix the issue but we're under the consensus that CURLs need to change and we're trying to hammer out how.  CURLF is useful on a bigger s

Well, in biology stable often equates to 'dead' :)

nqp: Remove dead code.

its a lot more dead than I had hoped for ;___;

I'll be doing that again soon now parrot is actually dead and I can do it properly

lizmat: so newio is dead in the water?

[Coke]: they don't fear people because they know they wouldn't eat them. a possum's defense of playing possum also involves smelling like a dead rotting carcass

is sorry for beating a half-dead horse.

well, it might be a half-dead unicorn...

some bugs will make a satisfying "crunch!" sound when you step on them, but they're really fine and just play dead for a while, then escape to re-emerge somewhere else

well, there's 2 releases - one is the spec, one is the compiler, sure. Anyway, I'm just doing a braindead compiler release this week.

.tell bbkr Saw your post; I think the deadlock will go away once I implement the smarter version of await that makes thread pool threads available to do other work while they're awaiting.

Hi. I've published new blog post of how to deal with asynchronous parallel nested documents processing (and don't get crazy). Enjoy: http://blogs.perl.org/users/pawel_bbkr_pabian/2015/09/asynchronous-parallel-and-dead-my-perl-6-daily-bread.html !

Many people think that perl is dead, and this people go across Python instead....

people thing every language is dead

.oO(every language thinks people are dead)

911, perl6 thinks im dead

I did not know I belonged to a dead community. Mongueurs are moribund, maybe.

I msg-ed him that #perlfr on freenode is dead and gave him correct pointers.

has gotten three of his previously failing modules to work under GLR.  two of them were dead easy.

cdc: https://github.com/rakudo/rakudo/commit/ab73b0ade1f4c80de6deade33ee76c6a68a77f0b

I pinged the mailing list in case IRC is dead while people go from SPW to YAPC::EU, but: anyone object if we merge glr back to nom by the end of the day?

ShimmerFairy: well, purging it once we know for sure it's dead is fine; but purging and then later reverting the commit would be bad

tadzik: my design goal is to have it be dead simple and work.  :)

why can i start typing into ssh, notice the connection is dead, kill the connection and reconnect and in the mean time the characters have actually been sent ?!?

Tho connection wasn't dead.

timotimo, tadzik: I’m deadly serous that I’ve started emmentaler with “./smoker projects.json”, get a weird error message, and then projects.json is just gone.

is LoL officially dead?

masak: An interesting idea, if it weren't for the fact that the traffic jam is also in an almost-dead-zone for cell traffic (and thus bus wifi)  :-/

timotimo: IIRC that's pretty much dead already, no?

we don't give you a way to stop a running piece of code dead in its tracks; you'll still have to have some sort of stop switch that you can flip

cdn dead?

nine: though I'll never be caught dead using P5 modules in P6 code :D

I was processing nested data structures in parallel and I encountered interesting deadlock. Here is the gist: https://gist.github.com/bbkr/78e048b94f9fb622e3a6 . Basically it is recursive "do await for { start { } }" construct. It works fine for small data structures, but if it wants to spawn more Promises at the same time than available threads this code never ends. Is my approach faulty or is it Rakudo bug?

smls: I think I understand this Promise deadlock now. Promises are created for first and second level of recursion in parallel. And when first level manage to create 16 of them there is no free thread to process promises on second level required by first level.

doc: dead7d2 | (David H. Adler)++ | lib/Language/5to6-perl (4 files):

doc: review: https://github.com/perl6/doc/commit/dead7d2627

:T in signatures is dead right, and :U refers to a type object (not undefined) now?

*deadlocker

they're buffered, but not infinitely so, you may deadlock your program

p6list is dead

is "gimme" dead in GLR?

.gimme is dead anyway

This structure is partly because >6 months ago, the Rakudo concurrency code could deadlock when there was no user-level reason for it.  That may well be fixed now, but ... I'm just dusting this code off after having it unchanged for quite a while.

Oh, I mean, could deadlock if the threadpool was smaller than the task count.

anyway @a = @b, @c # 2 elems is deadly logical :)

now i need to figure out which ones of my modules are dead or dying

augment: benign parasitic. supersede: deadly parasitic

I have no idea what parasitic means nor why PErl6 has something called deadly parasitic

the benign/deadly parasitic are referring to scopes though. so i guess maybe its scope is dependent on the parasites host, but doesnt do much to explain benign/deadly

No, benign/deadly is surely a description of what the keywords do ("augment" changes, "supersede" replaces)

we were discussing the descriptions "benign parasitic" and "deadly parasitic" as related to what augment and supercede do

well, in "benign parasitic", the host survives, in "deadly parasitic", it doesn't

Is Scala dead? Haskell?

Both python and ruby have had builtin arbitrary sized integers. In the Debian language shootout, this was the one tests where perl5 was a dead duck in the water (I think they got rid of it though).

On 'for $supply.list { }': it's an anti-pattern to do this most of the time. It's occasionally useful. I would say it's useful in demos, but last time I did the .Net equivalent in a live demo my code deadlocked on itself. :P

skids: Yeah, that's true, though since I always use shift and caps lock sits there dead that doesn't apply to me. (I remember one night translating a grammar to P6 grammar that had uppercase rule names, and having a sore pinky from holding shift by the end :P)

Well, once I get next week's 3 days of teaching done, I've no $otherjob deadlines until September. So August is looking very good for me having lots of time to break Perl 6 things. :)

which also comes into tombstone testing to identify dead code too

Bob was dead

Then it's adding dead code? :)

if consensus wants slurp-rest dead, and a :close parameter added to .slurp, I can also live with that

Well, and any code after it is dead

(1) you're in good company. there are lots of dead Medieval logicians who would agree with you in a heartbeat. (they also had serious foundational problems because of this belief.)

well, hasn't been much need for docs since they're drop-dead simple; it just calls the same method name that just got reduced

anyway, select as a global concept is dead

.tell FROGGS may be of interest: pipe deadlock (dihwidt?): https://news.ycombinator.com/item?id=9753279

04:09Z <raiph> FROGGS: may be of interest: pipe deadlock (dihwidt?): https://news.ycombinator.com/item?id=9753279

sue: the other end is somewhere in the US. Although I think that the UK is similarly brain dead in some of these things.

rakudo/nom: Remove dead line of code.

Please tell me formats are dead?

.oO( is Hitler still a threat? I thought he was dead. )

I'm 100% sure that Hitler's public double is dead

I'm 5% sure that the original Hitler is dead

hoelzro: did you manage to create a deadlock?

storing only derivative data is a deadly sin in science

nqp: review: https://github.com/perl6/nqp/commit/6da0dead91

otherwise, you could create a run-pipe (for lack of a better name) construction that deadlocks

hoelzro: why should it deadlock?

don't stay up on my account; I can create a deadlocking example and you'll see it tomorrow

er, deadlock

the idea was that if the parent is blocking on $p.out, and the child writes enough to $*ERR to fill the pipe, that should cause a deadlock.

i found doc.perl6.org has lots of dead links and wrong links

HuStmpHrrr: doc.perl6.org is actively maintained so we'd be interested to know here there are dead links.

what is 0xa0.deadbeefmethod?

But even my rudimentary, braindead debug output from that loop {} is not outputting

Never have any dead code, even if it's just declarations.

"comments = dead code" :P

m: say :16("0xdeadbeef")

pretty brain-dead simple in this case, actually...leaving a ping to my server running every 5 seconds in the background

m: sub r:hidden-from-backtrace { die 'dead'; }; r;

m: sub r :hidden-from-backtrace { die 'dead'; }; r;

m: sub r is hidden-from-backtrace { die 'dead'; }; r;

rakudo-moar e1cc78: OUTPUT«dead␤  in block <unit> at /tmp/Z7pqCwDLNO:1␤  in any <unit-outer> at /tmp/Z7pqCwDLNO:1␤␤»

m: { sub is hidden-from-backtrace { die 'dead'; } }.()

rakudo-moar e1cc78: OUTPUT«�5===�SORRY!�5===� Error while compiling /tmp/xk9S35ZnSy␤Missing block␤at /tmp/xk9S35ZnSy:1␤------> �3{ sub is�7⏏�5 hidden-from-backtrace { die 'dead'; } }�␤    expecting any of:␤        new name to be defined␤»

m: { return sub is hidden-from-backtrace { die 'dead'; } }.()

rakudo-moar e1cc78: OUTPUT«�5===�SORRY!�5===� Error while compiling /tmp/Di4nxHxy0v␤Missing block␤at /tmp/Di4nxHxy0v:1␤------> �3{ return sub is�7⏏�5 hidden-from-backtrace { die 'dead'; } }�␤    expecting any of:␤        new name to be defined␤»

m:  (sub is hidden-from-backtrace { die 'dead'; }).()

rakudo-moar e1cc78: OUTPUT«�5===�SORRY!�5===� Error while compiling /tmp/zhuP2ZJSI6␤Missing block␤at /tmp/zhuP2ZJSI6:1␤------> �3(sub is�7⏏�5 hidden-from-backtrace { die 'dead'; }).�␤    expecting any of:␤        new name to be defined␤»

m: my $r = sub { die 'dead'; }; $r:hidden-from-backtrace.();

rakudo-moar e1cc78: OUTPUT«dead␤  in sub  at /tmp/Vm4DXWeysW:1␤  in block <unit> at /tmp/Vm4DXWeysW:1␤  in any <unit-outer> at /tmp/Vm4DXWeysW:1␤␤»

m: my $r = sub { die 'dead'; }; ($r is hidden-from-backtrace)();

rakudo-moar e1cc78: OUTPUT«�5===�SORRY!�5===� Error while compiling /tmp/sHbOmPtQef␤Two terms in a row␤at /tmp/sHbOmPtQef:1␤------> �3my $r = sub { die 'dead'; }; ($r�7⏏�5 is hidden-from-backtrace)();�␤    expecting any of:␤        infix␤        infix stopper␤       …»

m: my $r = sub { die 'dead'; }; ($r is hidden-from-backtrace).();

rakudo-moar e1cc78: OUTPUT«�5===�SORRY!�5===� Error while compiling /tmp/A7VvLD_DPZ␤Two terms in a row␤at /tmp/A7VvLD_DPZ:1␤------> �3my $r = sub { die 'dead'; }; ($r�7⏏�5 is hidden-from-backtrace).();�␤    expecting any of:␤        infix␤        infix stopper␤      …»

m: my $r = sub :: is hidden-from-backtrace { die 'dead'; }; $r()

rakudo-moar e1cc78: OUTPUT«dead␤  in block <unit> at /tmp/vcDCYrkIoq:1␤  in any <unit-outer> at /tmp/vcDCYrkIoq:1␤␤»

m: try { fail "dead"; };

p is dead, long live m

m: class A { has $.x; has $.y; submethod BUILD (Int :$!x, Int :$!y) { die 'dead' if ($!x + $!y) % 2 != 0; }; }; A.new(x => 1, y => 1); A.new(x => 2, y => 1);

rakudo-moar 8e8936: OUTPUT«dead␤  in submethod BUILD at /tmp/tDicHu31ii:1␤  in block <unit> at /tmp/tDicHu31ii:1␤␤»

m: class A { has $.x; has $.y; submethod BUILD (Int :$!x, Int :$!y) { die 'dead' if ($!x + $!y) % 2 != 0; }; }; A.new(x => 1, y => 2); A.new(x => 2, y => 2);

rakudo-moar 8e8936: OUTPUT«dead␤  in submethod BUILD at /tmp/cQTgujUxGu:1␤  in block <unit> at /tmp/cQTgujUxGu:1␤␤»

ethod BUILDALL(|c) { POST { die "dead" if ($!x + $!y) % 2 != 0; }; callsame; };}; A.new(:x(1), :y(2));

m: class A { has $.x; has $.y; ethod BUILDALL(|c) { POST { die "dead" if ($!x + $!y) % 2 != 0; }; callsame; };}; A.new(:x(1), :y(2));

rakudo-moar 8e8936: OUTPUT«�5===�SORRY!�5===� Error while compiling /tmp/UHuLb8FWk3␤Unexpected block in infix position (missing statement control word before the expression?)␤at /tmp/UHuLb8FWk3:1␤------> �3A { has $.x; has $.y; ethod BUILDALL(|c)�7⏏�5 { POST { die "dead" if …»

m: class A { has $.x; has $.y; method BUILDALL(|c) { POST { die "dead" if ($!x + $!y) % 2 != 0; }; callsame; };}; A.new(:x(1), :y(2));

rakudo-moar 8e8936: OUTPUT«dead␤  in method BUILDALL at /tmp/O9ufiAydAf:1␤  in block <unit> at /tmp/O9ufiAydAf:1␤␤»

m: class A { has $.x; has $.y; method BUILDALL(|c) { POST { die "dead" if ($!x + $!y) % 2 != 0; }; callsame; };}; A.new(:x(1), :y(1));

rakudo-moar 8e8936: OUTPUT«Postcondition '{ die "dead" if ($!x + $!y) % 2 != 0; }' failed␤  in method BUILDALL at /tmp/rbgEXwVyTU:1␤  in block <unit> at /tmp/rbgEXwVyTU:1␤␤»

Whoops, back.  Hit a dead zone there.  (I'm on PA Route 309!)

masak: When's the deadline? :)

jnthn: the deadline is Su-Shee is gonna badger you until you do! :D

so. I will remind you all about the deadline once or twice. ;) SUBMIT.

Cellular dead spots, I shake my fist at theee

m: try { CATCH { $_.bracktrace.nice; } ; die 'dead'; };

m: try { CATCH { default {  $_.bracktrace.nice; }; } ; die 'dead'; };

m: try { CATCH { default {  $_.backtrace.nice; }; } ; die 'dead'; };

it's two calls indead of one

almost as much as deadlines

if this is the freedesktop stuff then it's braindead and you won;t be able to use quoting to make it behave

Sysaxed: I think it's one of *these* talks. (a dead talk)

rakudo/nom: Toss dead code.

Is the people who own the channel "dead?

old and dead code

m: say 0.deadbeefp2;

rakudo-moar 5a38b2: OUTPUT«No such method 'deadbeefp2' for invocant of type 'Int'␤  in block <unit> at /tmp/2GIiY2QMD0:1␤␤»

doc: Fixed dead link

ecosystem: it requires rakudo-parrot, which is dead; instead, we have native threads!

so, it's now rakudo-parrot being dead, not just Star being frozen? :)

raydiak: depends whether you consider the deads grumpy or not, I guess

the touchpad and stick mouse on my laptop are dead :(

I wish...this car would be dead by now if that were the case :)

already dead

Everyone, OSDC.no (including Nordic Perl Workshop, Oslo, 8-10. may) talk submission deadline is this friday! Please submit your talks ASAP.

m: say 0xdeadbeef * 16 ** -1

m: say :16<deadbeef> * 16 ** -1

but the AltGr + * combinations are just completely dead, they do not even produce a wrong character

DrForr: On your actions question earlier: the idea is that you use "make" to attach the AST node you made for a certain grammar rule to Match object, and the action methods higher up retrieve it with .made. That way, if a path turns out to be a dead end and a Match is thrown away, the AST node just goes away with it, nicely handling the backtracking case.

=iknowadeadparrotwheniseeone

zavolaj is dead, long live rakudo

TPF current grant submission deadline extended: http://news.perlfoundation.org/2015/03/extended-calling-for-grant-pro.html

Sorry, entered dead zone.  Laaaag!

I dunno quite how it works with the code Rakudo generates, but I've seen spesh toss dead initializations in NQP code.

.oO(dead man's switch)

but it was quite the event, people pretending to be dead on the bridge and such

Is the above idiom dead? ^^^

masak: it's been dead to companies for a while now... at least the one I've worked in/talked with :p

...also occurs to me that rw open of a pipe without putting each end in a separate thread is a deadlock condition waiting to happen, perhaps this should be warned about

yeah, deadlines tend to do that :)

huh? that link seems dead?

I'm meant to be doing like 2 other things with deadlines at the moment, mind... :/

jnthn: hangon, so NQP native-ref branch is now dead (no lnger needed)?

Anyone with both Windows and Linux access interested in fixing it to work on both?  I can make guesses, but they'd probably be dead wrong ...

nqp/native-ref: Remove dead code.

bartolin: with the exception of now-dead backends, I don't see how more queues would help us organize the tickets better

rakudo/native-ref: Remove dead code.

.oO( bury dead code )

lol_: no, it is not dead yet :o)

oh right camelia is dead

of course, dialects of Perl 6 can restrict the programmer in various ways, but we mustn't put the mother language on such an evolutionary dead end

I thought it had to create a False when returning False, but I was dead wrong.

If there's code inside it's harder to determine certainly that it's dead code

rakudo/nom: Also removed dead URL about same. Keep remaining advice for now.

I'm having trouble finding an actual description for META.info (if one even exists). Following links from modules.perl6.org gets me to S11, which only has a dead link for "META6.json" (which I haven't heard of before). Up until now I've been cargo-culting other people's stuff...

dead link for that on http://doc.perl6.org/language/about

link for graphviz is also dead - s/com/org/

masak: I have a solution, but it's kinda brain-dead and utilizes not only your hint of 10 answers, but also an arbitrarily-chosen upper bound of 100 for each var

but we're trying to avoid the "batteries included but some of them are dead batteries"

masak: I used to be *no dead trees*. mostly because I couldn't afford (programming) books, though

masak: can't as that it's already dead or that we need to keep it alive?

lizmat: https://registry.hub.docker.com/u/mj41/perl6-star/ ... still 20 minutes to p6weekly deadline?

An implementation detail without dependencies can be deleted since it's dead code.

if we stop supporting parrot, parrot will be dead.

star: it seems not to be in use, and I see no benefit in keeping dead code around.

pmichaud: too bad, but quality comes before the deadline in my book  :-)

nqp-js: Remove dead code.

I have no clue where this term "official compiler" came from, but it needs to be killed dead Dead DEAD.

nqp-js: Remove dead code.

but perl is dead!?

asdf12z_: hopefully after I'd dead, and can't contradict 'em :)

hah! we've had our deadline for *years*, and it's always been "around 18 months from now" :P

in September we can expect beta probably. but look what Perl6 did to spec and developmen time! imagine what could happen to the deadline date! ;)

you'd almost thing this language weren't dead after all

yoleaux is dead

I feel like http://rakudo.org/ is dead, and http://downforeveryoneorjustme.com/http://rakudo.org/ agrees

nwc10: the pony's dead, you know that.

notices that "the pony's dead" is a wonderful text for this tune: http://de.wikipedia.org/wiki/Der_Hahn_ist_tot_%28Kanon%29

If spesh sees it already is a Foo, then it turns the branch into a goto and the coercion becomes dead code and vanishes.

Perl is "dead" but everybody still wants to be like Perl.

masak: I'd say that's factually accurate, for at least some definitons of "wrong"...just not a position that's going to do much for most debates, other than stop them dead on both sides :)

rurban: it becomes shit when Perl-people start believing that they are working in a dead or dying language, and start iterating it to other Perl-people, utterly de-motivating developers on the way...

El_Che: When it the actual deadline for that?

rakudo/nom: Remove dead code.

(sorry if I’m beating a dead horse and being annoying)

I think there were some transitional 32/64 RISC architectures, all of course pretty much dead

dead code would be of the latter kind.

lizmat: No, it's dead and burried. :)

FROGGS_: project management fail? I mean - payment tied either to deliverables, deadlines, or some other progress

ah, but the protocol I'm implementing (XMPP) expects a write at the beginning before sending any more data from the server, so that would deadlock, I think

Old feather feels so dead. Only I'm online...

but my point is, many one-liners are dead simple. and I still enjoy Perl 6 over AWK even for dead simple things.

nim (formerly nimrod) is very agressive at dead code elimination

xfix: in Perl 5, -use- is dead simple

m: start { sleep 1; die 'dead'; }; sleep 2;

I like R* and also that official bit :)  but I thinked it was: let's show the World we are here, we have something working and we are damn you forum-X NOT dead!"

I'd like to recommend https://skillsmatter.com/skillscasts/6088-the-worst-programming-language-ever to people who enjoy deadpan reverse psychology crossed with language design.

The slow is because the scheduler isn't especially smart yet, and it mostly worries about avoding deadlock rather than optimizing throughput.

keeps hoping someone will say "you've been able to do that for years, here's how you say it..." even though we're in the #perl6 dead time :)

actually it might be more transparent for the observer if they see the events unfolding like you described, instead of a big BAMM, people dead, morale low

and the *really* cool ones were too cool for breathing, and stopped dead after about three minutes

masak: drop dead

They're dead, not recognised by any of the three systems I tried them in.

b2gills: it seems like these twit coding people aren't up to date. didn't anybody tell them perl is dead?

is that the one where a person believes they are already dead?

so parrot is dead, yes?

parrot: say "Hi, I'm dead."

p: say "Hi, I'm dead."

rakudo-parrot cd9001: OUTPUT«Hi, I'm dead.␤»

then it'll say "it's dead, jim"

so unfortunately every dependency on my "dead simple" advent calendar scraper requires manual intervention

Will perl have any sort of deadlock detection?

I've only had stretches of incredibly-busy time and brain-dead-recovering time recently.

mu: Remove some dead projects from dalek-conf.json

mu: remove more dead URLs

m: my $p = start { die 'dead'; }; await $p; $p.kept.say;

rakudo-moar f8f6fe: OUTPUT«===SORRY!===␤dead␤»

m: my $p = start { die 'dead'; }; await $p; $p.result.say;

rakudo-moar f8f6fe: OUTPUT«===SORRY!===␤dead␤»

moritz: Note that the end of the year is not a hard deadline

Juerd: and it's good that it's not a hard deadline, 'cause it might take some time

timotimo: if you want to add some humour, you might want to add a footnote after the GLR, NSA and NFG acronyms something like "Any resemblance to real TLAs, living or dead, is purely coincidental."

timotimo: detects deadlocks...

Is perlito also a "dead end"?

FROGGS_: I may be wrong but I believe that symbian has officially been dead for some years now hasn't it?

Oh, you poor, half-dead thing!

lizmat: damn it, the video recordings are up now that planetaria is dead and your talk references that; maybe we can get the yapceu channel owner to put an annotation up or something?

Sparc64 qemu will probably dead

lizmat: I'm so used to #perl being dead on here relative to irc.perl.org :P

the project is dead at this point.

n: say "are you dead?"

is "Using Perl 6" dead?

perl6.org: Replace dead http://planetsix.perl.org/ link with http://pl6anet.org/

Is Blizkost (mentioned on perl6.org/compilers) dead now we have Inline::Perl5?

timbunce__: I'd say Blizkost is pretty dead

timbunce__: OK. But given I don't think it even works against current Rakudo, it's probably dead. There's no reason to resurect it because Inline::Perl5 works, and does more.

.oO( the king is dead, long live the king ) # want array

Third row, dead center.  :-)

.oO( Why would anyone bring the corpse of a dead comedian into the house?!? )

Carlin has been dead a bit longer than Bernie was at the time  :)

do they stack dead comedians in a house in that movie?

almost? they arn't actually dead?

isn't actually dead

pesky little deadlines

moritz: FWIW (after you made the spec change): 1. I've actually used the multiple -e with perl5 before.  2. IIRC this was to get around some confusing bit of shell parsing.  3. The benefit gained over just breaking down and writing my code to a file was not, on balance, worth the ugliness in the default option parsing.  So in other words, as someone who has used the feature you are declaring dead, I think you made the right decision.

anyway, I'd better get my other tasks done or I will miss a deadline here.

I'm scared of this one. I know that a lot of people think this is what "killed" CL, because reader macros encouraged a "dead island programming": only you can use stuff you've done, because there's so much other syntaxes going on

computer dead

Volunteer organized conference: lots of work, getting more and more stressful the closer the conference is, followed by a couple of extremely intense days with even more work and stress. Then it's finally over. You need some time to relax. Then some time to follow up on lots of stuff you pushed out because you were busy with the conference. Good that the conference is over. Oh I forgot, there's some videos to upload. Not much motivation because there's no deadlin

How is Perl 6 going? The Blogs link on Perl 6 page is dead.

modules.perl6.org: do not try to copy now-dead medals

to me, these perlmonks visitors, are dead people (in the Walking Dead sense)

http://flavorwire.files.wordpress.com/2013/10/2013-05-23-the_walking_dead.jpg

don't dead, open inside

is firmly of the opinion that sometime in the 1990s a group of perl5 hackers traded their humanity for a deep internal understanding of perl5, and this led to perlmonks *and* to the general perception that perl5 is "dead". something is deeply rotten in that community

host08 (camelia's host) is pretty dead; I can't login to kill anything.

I was just wondering i went to this page http://www.perlfoundation.org/perl6/index.cgi?state_of_the_onion and there are dead links. Isthat normal?

question is if we can heal the dead links.

maybe they're just "mostly dead".

nqp-js: Remove dead code.

that's one that doesn't show up often ... was thinking of making a multi-key dead-key combo for inserting 「 and 」  but they won't show up in a terminal

(the machine was nearly dead after I tried to run just the jvm tests, and when I could finally get back in, the tests had failed). Assuming there's some nasty spectest.

sees that 08 is back for 42 minutes and has what looks like dead cron jobs on it. Coke re-runs today's runs.

we'd probably not be able to completely dead-code-remove, say, float handling if our format string has only %d in it ...

PerlJam: when do you suppose the deadline for that would be?

one of them was about a blog post from 2009 being hyped by trolls - the post was about how mod_perl_perl6 is dead oh no!

so it feels like some kind of deadlock

the lck_mtx_sleep feels like we're deadlocking

deadlock city, it appears ?

It's not clear it's deadlock, in that there's no other thread seemingly holding a lock

And if the perl5-porters manage any nice performance increases, the line won't be dead flat anymore.  :-)

rakudo/nom: Fix deadlock reported in RT#122709.

rakudo/nom: started and so deadlocked.

5 Sep 2014 21:57Z <lizmat> jnthn: re "my $p; $p = start { await $p }; await $p" deadlock, maybe we should force waiting for a start promise to only be allowed in the originating thread ?

..rakudo-parrot 4a7429: OUTPUT«1␤Cannot resume dead coroutine.␤  in method reify at gen/parrot/CORE.setting:8094␤  in method reify at gen/parrot/CORE.setting:7804␤  in method reify at gen/parrot/CORE.setting:7804␤  in method gimme at gen/parrot/CORE.setting:8273␤  in metho…»

..rakudo-parrot 4a7429: OUTPUT«1␤Cannot resume dead coroutine.␤  in method reify at gen/parrot/CORE.setting:8094␤  in method reify at gen/parrot/CORE.setting:7804␤  in method reify at gen/parrot/CORE.setting:7804␤  in method gimme at gen/parrot/CORE.setting:8273␤  in metho…»

also, Parrot probably should avoid using the word "dead" in its error messages :P

gtodd: aren't you thinking of R&G are dead?

otherwise we have found a new way of deadlocking...

forcing this would be simple and a simple way to avoid this type of deadlock

.tell jnthn re "my $p; $p = start { await $p }; await $p" deadlock, maybe we should force waiting for a start promise to only be allowed in the originating thread ?

well, I think that's a recipe for trivial deadlocks

trivial deadlocks like that are trivial to spot

from letting a waiting thread take on the work of another task to giving a helpful error message on trivial deadlocks is only a short step

as far as I am concerned, "Using Perl 6" is dead, and new doc efforts should go to doc.perl6.org

so otter i believe that it would be an nice mascot https://speakerdeck.com/stevan_little/perl-is-not-dead-it-is-a-dead-end

that's why it sucks to be dead after one :)

PerlJam: "fully done" for a programming language would mean "dead", so it's good it's not the case for both Perls ;)

my brother-in-law told me when I was going into sysadmin that it was a dead-end job :)

it's not so apparent there, but what about :16(deadbeef)?

(backscroll) I think if any sixers start saying that five is dead, we will look back to our existing marketing with nostalgia.

.oO( why must it be so hard to just peacefully co-exist and kill Perl 5 dead? ) :P

Rounin_: Java has always had a thing about dead code.

.oO(perl.org is a dead end...)

I think the (at least temporary) decision was that we don't try to detect infinite loops or deadlock in other parts of the language, so why here?

is now re-enjoying https://speakerdeck.com/stevan_little/perl-is-not-dead-it-is-a-dead-end

pugs was pretty much dead in 2012

Reload seemed to work, so it's not like the endpoint is dead.

I typically have to then "chmod a+x ./perl6", and things can continue; but if you're doing it as part of a bigger process, it kills you dead.

we already missed the deadline for igniting jupiter.

And you get the WHICH for, say, a Set by combination of the ObjAt values for the pieces (through some wise algorithm we get from the appropriate lump of dead tree)

Yes, it's making that situation work out without ending up with deadlock...

oh, I kill dalek dead

mostly dead

Perl is not dead

masak: it's probably too late when you're dead  ;>

So, effectively dead code.

it was unusably slow before. had to emit debug output so I knew it was not dead. now runs in under 2s. whee.

spectesting some removal of dead code in ModuleLoader.nqp

rakudo/nom: Remove dead code

is there a good pattern for delegating to a member object? right now I'm futzing with add_fallback, but it feels a bit like a dead end

jnthn: after you fix it, we can all sing "ding dong, the wicked .WHICH bug is dead!"

beating a dead horse, even

carlin: puts is dead. niecza is in a coma. rakudo.parrot was just hit by a bus today.

rakudo/nom: Specify that many are pure, so spesh's dead code elimination can take

strange how a guy dead for nearly 2,500 years is dictating our PL paradigms...

Arc is kinda dead, though :(

hey looking at profiling, and coming from some recent node.js, it would be *super awesome* if there was a brain-dead-simple way to get the compiler to tell you when you've pessimised some code

cxreg: we have logs for things that MoarVM does, but it's far from brain-dead-simple

in designing connection games, the big challenge is to design the game such that "deadlocks" (both players unable to get past the other) don't occur.

Hex solves it by making the topology hexagonal, eliminating deadlocks completely.

Druid solves it by allowing the players to build upwards, into the third dimension. it's more exhilirating, but I've seen Druid games deadlock sometimes.

.oO( For a dead language, Latin sure has a lot of encodings... )

I don't know why people insist on calling Latin "dead". there are lots of languages with less life in them than Latin.

i'm idly clicking through the perl6.org website and looking at outdated/dead links and/or information here and there

now that's what I call a dead parrot: http://c.fastcompany.net/multisite_files/fastcompany/imagecache/1280/poster/2014/07/3033103-poster-1280-parrot-sketch-art.jpg

vendethiel, people do stats about activities on well know places and conclude that Perl is dead.  But most perl activity is secluded on  perl.org irc  servers.

is back from the dead.

well, in other times I'd've been dead by now several ways :)

(given that rakudo doesn't have them, and anyone else is dead, dying, or hasn't started yet?)

[Coke] : we saw the dead parrot sketch done live, flawlessly going over into the cheese shop sketch!  And of course the sperm song, the pen*s song, Professor Gumby doing a flower arrangement course, and much more.

my point is, if you're dead sure all the time, your glass is full and you can't take new stuff in.

That'd be too boring if we are dead sure all the time.

I'm hoping to block reinstalling File::Find, because that seems to kill panda dead on moar

reminds that YAPC::EU talk submission deadline is July 1st (today)

in the cases where they aren't, probably most of the time a function, inlining, and dead code elimination would do just fine.

btyler: not feather having trouble in general, just the web service behind :3000 being dead

feather seems to be ipv6-dead

you are right, just perl 5 helps more with deadlines :-/

knows deadline stress only too well]

segemos_: hm, I keep seeing a deadlock running ab.pl6 under r-j

goes back to building the high sleeper (deadline is tomorrowish)

Who said perl was dead ? I'm surprised (or impressed)

m: try { 'hi'.say; die "dead"; CATCH { default { 'caught'.say; } }; }; '/try'.say;

m: try { 'try'.say; die "dead"; 'after life'.say CATCH { default { 'caught'.say; } }; }; '/try'.say;

rakudo-moar 87333c: OUTPUTÂ«�[31m===�[0mSORRY!�[31m===�[0m Error while compiling /tmp/JuenfUKe2sâ�¤Two terms in a rowâ�¤at /tmp/JuenfUKe2s:1â�¤------> �[32m'try'.say; die "dead"; 'after life'.say �[33mâ���[31mCATCH { default { 'caught'.say; } }; }; �[0mâ�¤    expecting any of:â�¤    â€¦Â»

m: try { 'try'.say; die "dead"; 'after life'.say; CATCH { default { 'caught'.say; } }; }; '/try'.say;

jnthn: if Promise.vow uses $lock.protect, it deadlocks some spectests, does that make sense?

hmmm... but then we would deadlock quite easily in the class A { use B }; class B { use A } case

sounds like deadlock to me.

for preventing deadlocks

Mouq, yoleaux is pronounced the same as 'YOLO', and acronym meaning 'You Only Live Once', which means "you should do stupid things now, since you won't get to do stupid things when you're dead"

Saw the patches sometime in the last week that made $*USER and $*GROUP work.  They are objects that .Numeric and .Str appropriately.  Is the 'true dualvar' concept -- single values that ~~ Int and ~~ Str at the same time -- now dead?

It's hard to spot dead-pan or sarcasm on IRC sometimes  :)

sunlight, falling on your spear, deadly life is your ideal, life is like a wheel

I'm getting a race condition / deadlock in async IO on both JVM and Moar: https://gist.github.com/donaldh/090b39bb1f4732ad4b82

If you don't keep coming up with material for journalists to speculate about, they'll start asking "Is X dead?"

muraiki: it's really dead simple at the moment, but I'm using it almost every day.  (Have a copy running right now, as a matter of fact.  My son is happy playing with his Legos at the moment, so I'm sneaking in a little practice.)

it's not a dead language, so it's still developing, yes

it looks dead though

.oO( unexpectedly undead )

probably hoping he'll drop dead appropriately right after to enhance the irony

and spesh now does a fixed-point-iteration instead of one pass for eliminating dead code in specialization

retupmoca: +1 for pointing things to perl6-community-modules/foo repo and getting deadish modules out of the ecosystem

Pauekn: which makes it very hard to joke about Parrot being dead... because everyone's already done that, like, always.

(parrot dead) that joke was how the name itself was picked.

also usually don't worry about race conditions unless there's real risk for data loss or deadlocks

parrot's not dead yet

colomon: yes, I saw. I still have a rakudo buildbot which should have caught it, but it was dead.

lizmat: figure out how to do dead code elimination in NQP. At which point, Rakudo will be faster :-)

I can't remember if there was an actual usable tool, or just a paper about hacking clang to figure out what code is "dead" due to optimisations, but changes behaviour

I was trying to write a glue script thingy yesterday that checked some dead links using HTTP::Client, but that seems to... flat out not work. Is there something newer I should be using instead?

rakudo/async: that may lead to deadlocks.

perl6.org: Delete dead link. Add perl6 video channel link.

suspects deadlock of some sort

I'd've thought    parallelyzed (adj) : A multi-threaded application that is deadlocked  :)

but if Perl is dead but apparently is still moving so it must be a zombie or vampire and they are hard to kill...

but I guess that just carries the danger of deadlocks again  :-(

btw; deadline for submitting talks to JavaZone is April 28th (in a week or so)

also it's not so much that you are presumed to have been there, but because "everyone knows it's dead already" and why are you wasting time on what is obviously dead?

and hence whilst the implementation is "supported" for a while yet, criticisms such as http://programming.oreilly.com/2013/10/dead-batteries-included.html will become more accurate

rakudo/nom: Remove dead code from HashIter.reify

tbh, from an outsider point of view, perl is dead. I did a lot of web before coming here (~ 6 months ago), php, then mostly ruby and js, and nobody even considers perl (in its global state) a threat or anything. It just doesnt exist anymore

significant whitespace is just not cool... you can pry my curly brackets from my cold, dead hands!

Ven: you can have my parentless function calls after you pry them from my cold, dead hands. :P

is dalek dead?

hating a (supposedly) dead language, what for?

manages not to joke about dead horses and dead parrots

r: FROGGS "“Isn’t Pearl dead?” - What do you answer to that?" erm :(

rakudo-parrot 358582, rakudo-jvm 358582, rakudo-moar 358582: OUTPUTÂ«�[31m===�[0mSORRY!�[31m===�[0m Error while compiling /tmp/tmpfileâ�¤Two terms in a rowâ�¤at /tmp/tmpfile:1â�¤------> �[32ml dead?â€� - What do you answer to that?" �[33mâ���[31merm :(�[0mâ�¤    expecting any of:â�¤ â€¦Â»

20% for an implementation that's been dead since 2009 seems good ;o)

lizmat: a shared array would have to be protected by locks (afaict), and that implies a risk of deadlocks

and tracking down the deadlock if everything looks like a standard, non-concurrent variable might be much trickier

jnthn: possibly a deadlock or something?

jnthn: Normally the children's autoput would be captured by a qx.  But with that process dead ... they talk to the terminal.  I should think they should get a SIGPIPE instead, which indicates something isn't set up right during spawn.

punter: tadzik has started a game development contest; deadline is this sunday :P

TimToady: So, when is my deadline for fixing this pesky work-passing bug... :)

deadline was on friday

now the only step left to fixing it before the deadline today is "a miracle occurs".

I was planning to do it for myself anyway, but I usually work a lot better when under pressure and deadlines

there are a lot of branches in the NQP repository. How many are dead?

it's more like a violent action movie villain death where you know he's probably not really dead

how frequently does the magazine come out? and what are its publication deadline dates?

as cann have been observed on perlmonks, whenever you talk about MoarVM, people go "meh, yet another dead end" or something.  So I think you really need to have something spectacular to show off before bothering them.

grondilu: about the "yet another dead end": when you state what improvements moarvm brought us, then nobody can still think it is a dead end :o)

pmichaud, #perl6ers: I see what look like dead repos in the perl6 account on gh (https://github.com/perl6/misc, https://github.com/perl6/modules, etc.); should I try delete them and if not can I help clean them up? are there other accounts to clean up?

in good/bad news, this project's deadline has just been pushed out another week.

S17-async are dead tests...  I think they can go

where is the GSOC channel? irssi seems to think it's dead, and isn't telling me the name of the channel it used to be.

ah. -all- my irc.perl.org connections were dead.

I don't even remeber its name, so hopefully it's dead :P

gconf is dead

is this a dead project?

what is dead?

r: sub explode() is pure { die "dead" }; eval q{ say "beginning"; explode(); say "end" }

rakudo-moar 44a466: OUTPUT«WARNINGS:␤Useless use of "explode()" in expression "explode()" in sink context (line 1)␤beginning␤dead␤  in sub explode at /tmp/tmpfile:1␤  in block  at eval_0:1␤  in any  at eval_0:1␤  in sub eval at src/gen/m-CORE.setting:703␤  in sub eva…»

..rakudo-jvm 44a466: OUTPUT«WARNINGS:␤Useless use of "explode()" in expression "explode()" in sink context (line 1)␤beginning␤dead␤  in sub explode at /tmp/tmpfile:1␤  in block  at eval_0:1␤  in any  at eval_0:1␤  in sub eval at gen/jvm/CORE.setting:703␤  in sub eval a…»

..rakudo-parrot 44a466: OUTPUT«WARNINGS:␤Useless use of "explode()" in expression "explode()" in sink context (line 1)␤beginning␤dead␤  in sub explode at /tmp/tmpfile:1␤  in block  at eval_0:1␤  in any  at eval_0:1␤  in sub eval at gen/parrot/CORE.setting:705␤  in sub …»

if no one is committed to working on it, it's dead.

Postmodernism is dead.  Perl is postmodern.  Ergo...? -- http://www.prospectmagazine.co.uk/magazine/postmodernism-is-dead-va-exhibition-age-of-authenticism

If a cat can be both dead and alive, why can't it be on both sides of the door at once?

You can have my vi when you pry it from my cold, dead hands, but more tools sounds good to me =)

daily runs dead until further notice.

So that if one thread is sat in a tight loop and another triggers GC, the looping thread will come and join in, rather than deadlocking the VM.

but i don't think we have "dead code elimination" of any sort yet

unless hoelzro just wished us all dead... in German.

if I had wished you dead in German, I would have used proper capitalization =)

opensolaris /per se/ is dead, illumos is still at least twitching (see also omnios, smartos)

I'm afraid of finished software. It's dead. :-)

geekosaur: NASA doing dangerous science experimenting with deadly arsenic bacteria - could prove fatal to humans.

and very dead. Unlike the (former) members of Abba

http://www.yapcna.org/yn2014/talks/tag/perl6 # just gonna mention the deadline is tomorrow at midnight EST

is reminded of woolfy shouting "I can hear you!" at FOSDEM, when the Python people in the next booth were claiming Perl was dead   :-)

some STDs are deadlier than others...

ranging from "simply shouting around" over "Perl 6 is dead" over "I'll use Perl 6... but only if you implement $esoteric_feature; otherwise it's useless" to "I'll help you with your project, but you have spoon-feed me every step of the way"

since dalek is dead...

rakudo-moar 1ec4c9: OUTPUT«SetHash.new(There, were, three, men, came, out, of, the, West, Their, fortunes, for, to, try, And, these, made, a, solemn, vow, John, Barleycorn, must, die, They've, ploughed,, they've, sewn,, harrowed, him, in, Threw, clouds, upon, his, head, was, dead, l…»

rakudo-moar 1ec4c9: OUTPUT«SetHash.new(were, three, men, came, out, of, the, West, Their, fortunes, for, to, try, And, these, made, a, solemn, vow, John, Barleycorn, must, die, They've, ploughed,, they've, sewn,, harrowed, him, in, Threw, clouds, upon, his, head, was, dead, let, lie…»

All I want to know is ... what did John Barleycorn do to those 3 guys that made them want him dead?  ;)

who/whom didn't, so it's dead. less/fewer doesn't really, so it's probably also dying. :)

Albany.pm is coming back from the dead. (yay)

the book is dead anyway.

FROGGS: it's dead.

I mean, it would be dead wood if it was printed

diakopter: So...C is dead? :)

r: try { sub dead (-->Int) {"oh my!"}; dead}; say $!.WHAT # Namely

jnthn: I believe OSCON has a submission deadline coming up soonish, if you want to consider that

hoelzro: moar-support is dead

whcih I guess with dead code elimination means it'd throw away the extra code you're suggesting at specialization point...

unfortunately, the Qt Jambi project is apparently dead

all other obsoletion problems are deadly

I did the divisors_sum in a less braindead manner.

psch: Are you considering the code starting "if +%!deadly {"?

(and my phone was dead) :(

That nqp::null is dead code as you have it.

right now it just stops dead in its tracks once it reaches compunit

moritz: okay, so for this case that would mean building the correct exception in report_inevitable_dispatch_failure in the optimizer and adapt the loops over %worrying and %deadly to handle exceptions as well?

there's a dead link to your http-server-simple fork in that last post

I always envision some very angry dead Greek philosopher going "it's called *universe* because it holds *everything*, you dorks!"

That said, tomorrow is garbage day...  I have to bring out the garbage.  (bring out your dead, bring out your dead)

mu: update dead github links

try setting the ulimit for core dump files up and attach gdb to the already-dead process?

lue: I have no idead about "supposed to". You just have to get the damn thing working :-)

I know it can also deadlock threads that way, which is why the dining philosophers on RC serializes output to a channel

timotimo: perhaps. The "regex" part of Perl 6 regexes is dead simple; the "grammar" aspect is the interesting part :)

Now I can't tell if that's deadpan or an honest question. :)

it is dead :o(

it's dead, Jim

hoelzro: on steam, you are "Rob"? last online 3 days ago, played defcon, sir you are being hunted and left 4 dead 2?

because it's already dead?

block, hash, "${foo}bar", \x{dead}, /x{1,2}/, q{}, and I think something in formats

anyway, unoverloading {} is why we get things like "\x[dead] {$foo}" instead

we have deadlocking issues?

using a metaphorical waiter who refuses to serve a philosopher that might cause deadlock

suspects the Pike solution can still deadlock, if we take its description at face value: this solution avoids deadlocks by adding a 20% chance that a philosopher drops the fork if he can't pick up both.

well, you can block on backpressure, and have a cyle of that, which is a kind of deadlock

but all the the approaches I've seen to composing transactions involve either the possibility of deadlock/livelock, or the ability to just keep hammering on it till you get a commit to go through, à la STM

phenny is dead, long live preflex+yoleaux

where yoleaux appears to be dead now too

.oO(10 years after S30 freezes with the rest of 6.0.0: "Don't use the spec-issued DBIish, it's been dead for years. Use DBIlike")

standard libraries which some are already less than enamoured with: http://programming.oreilly.com/2013/10/dead-batteries-included.html

lizmat: unless... r-j was already dead when I run "say (^20_000).join(',').split(',')[*-1];"

lizmat: unless... Camelia's r-j was already dead when I run "say (^20_000).join(',').split(',')[*-1];"

lizmat: It *will* deadlock

Unfortunately, we were all dead wrong.

should perl6 get an ordering for locks automatically, so that you can lock multiple locks "at the same time" without having the order matter for deadlocking?

diakopter: there is also a large part defensism going on, people battling the idea "perl is dead" so hard that they don't realize it could be more alive

it's dead, jim

hmm, Parrot is quite dead, NQP (Not Quite Parrot ;) is new middleware for v6. Forget a code/design/years_of problems for a while. But maybe some Parrot part is still good for something ? Maybe some Parrot idea still looks promising for civilization ?

TimToady: The talk had a slightly tighter deadline :P

where is http://try.rakudo.org/ ? is it dead?

kivutar: it's dead, yes :(

(I know a dead rakudo when I see one)

nqp: Toss dead code.

Why no yoleaux of late?  Is the bot dead, or have we decided not to use it anymore, or is it just that we lost it and can't seem to get it back?

we must conclude that Windows is deadlier.

aristotle pointed me at http://programming.oreilly.com/2013/10/dead-batteries-included.html (which links to http://www.leancrew.com/all-this/2012/04/python-doesnt-play-nicely-with-others/ ) and possibly related is also http://www.python.org/dev/peps/pep-0439/

google: "How to write left for dead mods in Perl 6"

.g "How to write left for dead mods in Perl 6"

that new test is braindead, but an ok start. (many opcodes are untested)

now y'all're just beating a dead duck.

Oh, my blog...  well, yes, that blog was both about the main room (for which the deadline is passed) and our devroom (for which the deadline lays far into the future).

I didnt miss deadline did I? :)

<dead_circumflex> <U2212>    	: "⁻"   U207B # SUPERSCRIPT MINUS

<dead_circumflex> <minus> 	      : "⁻"   U207B               # SUPERSCRIPT MINUS

TimToady is undead.

dukeleto++ is doing an admirable job pretending that Parrot isn't, at this point, well and truly, beyond-any-parrot-joke dead.

cxreg: a crime against humanity? I needs a bit of code cleanup... (which I have putting of to squeeze in features for the GSoC deadline)

Someday, I'll be dead.

nqp: removed dead code

hopes that Perl does not evolve into a religion after he is dead, or that if it does, he is not held responsible for it...  :)

I'm guessing those mostly are throwing away dead things...

. o O ( dead people don't laugh )

because that openid's dead

TurboPascal is dead

if it doesn't, I'm willing to bring it back from the dead in the next 24 hours :)

I was just curious because on #programming they said it was "dead jim"

If you're not learning, you're probably dead.

incoming gsoc deadline is surley speeding up the progress ;)

the "perl6 is dead, long live perl5" talk just landed on youtube

"Perl 6 isn't dead, but its developers are zombies!"

but dead releases are awful

rakudo-js: review: https://github.com/pmurias/rakudo-js/commit/fc41b4dead

I read this headline and thought "well that's a job for moritz" http://www.cnn.com/2013/09/05/world/asia/china-river-dead-fish/index.html

r: multi infix:<==>('Perl 5', 'dead') { True }; say 'Perl 5' == 'dead'

that doesn't tell me much :) But that reminded me of a forum post when someone posted a picture of crystals and said "here's how you do it", followed by a recipe for some deadly toxine

"pugs is dead. Get over it."?

is spreading the "perl is not dead" meme

star: review: https://github.com/rakudo/star/commit/0ce8b0dead

could be dead simple, but I'm not seeing it yet

No, it's not dead simple.

moritz: $work deadline.

rakudo/scalar-from-desc: Remove dead code

Interesting... for the sake of comparing performance, I used explicit async blocks, and now I got to a deadlock in the scheduler

it kind of deadlocks :|

there's also niecza (p6 on mono - getting a little crufty), and pugs (p6 on haskell - pretty much dead, but still passing a huge chunk of spec tests)

honestly, I've reached the jaded opinion that anybody stating goals for open source projects that they're not *directly* funded for with solid deadlines ... is ultimately a form of dreaming

perigrin: I've reach the jaded opinion that anybody stating goals and deadlines for non-trivial software projects is ultimately a form of dreaming.

finally got on again; room 2 is kind of dead...

padre seems like a dead project

(I hope Niecza isn't dead, I haven't seen updates in it for a long time)

masak: we're a late-week deadliner

dead code indeed...

removing the dead code fixed it

"He is dead Jim"

or ... Perl is dead; haven't you heard?  ;>

Perl is dead, but Parrot is alive and well?

search for dead on http://act.yapc.eu/ye2013/schedule

runtime macros + continuations -> you too can write code that's dead slow -and- impossible to debug

Hmm. Apparently the is rw trait is dead

perl is undead so we are undead

nono, I was just looking for dead weed to be removed

roast: deadbef | coke++ | S32-io/slurp.t:

roast: review: https://github.com/perl6/roast/commit/deadbef167

colomon, jnthn: categorize is *dead* simple.  The only optimization I can think of there is to use postfix for

lizmat: I understand it's dead simple.  That doesn't mean it's fast.

I'll see if I can come up with something more clever, but that's the dead easy way. Just make it prove --exec '$(NQP_EXE) --vmlibs=nqp_dyncall_ops' ...

these kids have never heard the "perl is dead" meme and don't know that node is cooler than ruby now

Perhaps perl is: is~a, ~numeric, ~number, ~dead, ~directory, ~array, ~defined, is~_deeply, ~hash, ~integer

Perhaps perl6 is: is~-prime, perl 6 is dead, is perl 6 dead, perl 6 is a joke, perl 6 isa, perl 6 is export, is perl 6 release, where is perl 6, perl 6 release, is perl 6 ready

dalek also dead. whoops.

though it seems like it's playing dead, so maybe it's just a die

r: say "0x" X~ <dead beef>

rakudo c52f24: OUTPUT«0xdead 0xbeef␤»

rakudo-js: Remove dead code.

"Perl6 is dead, long live Perl5"

because knowing dead sections of the compiler code is a pretty cool thing

though obviously constructing 308 digits of precision is braindead too.

diakopter: woohoo the videoproject is not dead

oh, because it's dead code

how to immunize yourself from "is dead" jokes: name your project "Parrot".

sorear: so, i'll have to write my "module" in nqp; last time i tried to build something in nqp to be used from perl6 i ran into all sorts of trouble; is there a dead-simple way to make that work?

so... sixparrot is dead

well, that was the dead pan part of my joke: it's 31 celsius in the shade outside now

I do COBOL nearly every day... it's alive^Wundead.

jnthn: I was SHOCKED to see that auto-close is not only not dead, it's infected JNQP

sorear: maybe the others have already filled the deadpan-snarky quota, but it is my belief that what you're doing is *calling* a non-existent method.

Or I'm just braindead...

the point where the Parrot team realized that that perl6 was a dead end was the point where they recruited pmichaud as the lead Perl 6 dev.

no, the dead-end perl6.

I get the feeling that the humor is dead at this point, though. :)

flogging a dead beefburger?

he's calling perl dead!

tadzik: if you are rolling (?) the r in parrot like in "that parrot is dead" then it will be good :p

is very dead from lack of oxygen

(today is deadline, but they usually take about two weeks to send a demand note, and the first one is free :-)

GlitchMr: forget all that Perl 5 internals knowledge; Perl 5 is a dead end!  (Stevan told me so)  Learn about Perl 6 internals or moe internals.

But that doesn't change that Pugs.hs is mostly dead

I bet if the sky weren't night-black, it'd have the color of television, tuned to a dead channel.

almost deadpans an explanation in sorear's direction about teeth

just %h{any <a b c>} by itself is just another junction.  The unobserved state of a maybe-dead/maybe-live cat.

timotimo, PerlJam: ok, you're right.  I was just thinking boolean context.  In any other context I guess you cannot tell whether the cat is alive or dead  :-)

right, since the deadness/aliveness is actually a boolean value ;)

at least definite deadness/aliveness is

nqp/rak-jvm-support: Toss more dead code.

moritz: also, looks like the cute graphlets are all deadbeef: http://irclog.perlgeek.de/ :/

rakudo/jvm-support: Remove dead code.

rakudo/jvm-support: Remove a currently dead code-path.

tadzik: lizmat suspects some dead code in docs related stuff

rakudo/jvm-support: Remove dead code.

is in the enviable? position of having followed this parser rabbit hole a few times before while braindead fuzzing, but unfortunately doesn't remember where it leads still

ohh, I deadlocked my rakudo :/

still a deadlock on my box

releasing once a year feels like working for a dead project somehow

wtf? sqlite2 is, like, decades dead, isn't it?

masak's was closer to "You'll pry RT from my cold dead hands".

there are too many ways for creating deadlocks

server is dead

while we're flogging dead memes, lunch today had tentacles. Chance of contamination with horsemeat - pretty much zilch :-)

Just need to get past this article deadline that's coming up soon

forgot about the JavaZone deadline

ah, conf deadlines...

Oredev has a deadline way before the conf too. My $dayjob are like "submit?" and I'm like "ah, a November conf" and then always miss the (I think April-ish) deadline.

geekosaur: yes, standard pascal is long dead... object pascal is alive and well though ( http://freepascal.org/ )

got sick of all the "$project is dead" FUD : https://twitter.com/dukeleto/status/323116597575307264

nqp/jvm-support: Toss dead code.

jnthn: yeah, it seems pretty barren/dead ATM

I just read https://speakerdeck.com/stevan_little/perl-is-not-dead-it-is-a-dead-end  As I'm in the process of porting core modules, I couldn't agree more about the whole perl 5 is "supporting too much old buggy code" thing.

nqp-jvm-prep/asm_port: Cleanup some dead code.

Read more: http://artists.letssingit.com/monty-python-lyrics-dead-parrot-sketch-mkqd4zc#ixzz2Pd1WhZHU

moritz: really? our mailing list indicates we're mostly dead!

gtodd: yes, unfortunately it has an dead upstream author

tadzik: what's the deadline for submitting talks to PLPW?

japhb: Perl 6 is dead, Perl 5 will be the new upcoming Perl 7 :P

sorear: it... just seems to me they'd *obviously* sell more Kindle versions if it were cheaper than paper. and that it shouldn't be so hard, since the production cost has to be lower than for a dead-tree book.

I wonder if we'll eventually stabilize on expensive dead-tree versions and cheap kindle versions.

well, one option to win is to slowly accumulate points, and have all the others dead-lock each other so that they can't reach an agreement to stop you

oh, and one more thing (not quite related to winning): there needs to be a deadline for patch proposal too

and the quote is from Spamalot, "I am not dead yet"!

rakudo-js: Remove dead code.

has no clue about the significance of that threshold, and I'm too braindead to imagination anything

It'd be cool, but with teaching duties and article deadline in late April, I don't think it'd be prudent =)

pugs is dead?

Friendly reminder: YAPC::NA 2013: "The deadline for talk submissions is March 15th"

jnthn, moritz, masak, timtoady, pmichaud: Do we still just have only one P6 talk submitted for YAPC::NA? Today is the submission deadline...

for this yapcna "The first deadline is with the full length talks.  The second deadline is one week before the conference starts and many proposals will be accepted.  At least two speaking spots on days 2 and 3 will be held open until the day before the talks to give you a chance to see something at the conference and put together a Lightning Talk response.  However if you wait for the later deadlines note that there are fewer spots

toddr_: last year's summit in europe was a long exercise in bringing most of the people up to speed with the fact that it's not dead, we're making progress, and stop being so flipping emo

swings a dead cat in #perl6 to satisfy PerlJam's request.

Just dead code I think

pmichaud: I interpreted that as meaning we're not setting deadlines, etc.

colomon: deadlines for what, though?

Will submit talks...deadline isn't for a couple of weeks yet, no? :)

you don't *have* to push the deadline

try for 1..10 { .say; die "dead" when 5 }

r: try for 1..10 { .say; die "dead" when 5 }

rakudo f4e96b: OUTPUT«1␤2␤3␤4␤5␤dead␤current instr.: 'throw' pc 333455 (src/gen/CORE.setting.pir:149679) (src/gen/CORE.setting:9303)␤called from Sub 'die' pc 35346 (src/gen/CORE.setting.pir:14008) (src/gen/CORE.setting:578)␤called from Sub '' pc 260 ((file unknown):189751590) (/tmp/jMUs…

r: try eager for 1..10 { .say; die "dead" when 5 }

rakudo f4e96b: OUTPUTÂ«�[31m===�[0mSORRY!�[31m===�[0mâ�¤Two terms in a rowâ�¤at /tmp/JX1Z2IrRkO:1â�¤------> �[32mtry eager for 1..10 �[33mâ���[31m{ .say; die "dead" when 5 }�[0mâ�¤    expecting any of:â�¤        postfixâ�¤        infix or meta-infixâ�¤        infix stopperâ�¤        statement endâ�¤        â€¦

r: try eager do for 1..10 { .say; die "dead" when 5 }

nqp: Remove some dead code.

FROGGS: Oh, I have rakudo, I've been sleeping badly last three days from trying it out dead tired :)

.oO("The robber shouts 'Worse answer!', pulls out a gun, and shoots you.  You are now deader.")

naturally. it was a robber. if you want plain dead, talk to rob.

FROGGS: Oh, it's Swedish for "dead good!" :)

dead code?

nah, if it's stable, it's dead

too many dead-looking trees this time o' year...

rakudo-js: Remove *loads* of dead code from before the serialization refactor.

Yes, I was totally brain-dead in my initial discussion and I regret it, but I'm happy to see that there might be a positive takeaway for the issue.

floging a dead meme

all VMs' implementations of buffers are going to be dead simple...

Also: Woo! GSoC was announced.  Org deadline 3/18 1900 UTC

nqp: Toss dead code-path.

Is submission deadline soon?

I can't seem to find any sort of talk deadline, no.  Maybe I'll suggest that there be one.  :-)

Look, matey, I know a dead parrot when I see one, and I'm looking at one right now.

oh dear, I had forgotten about the dead Parrot jokes.

pmichaud: I've been surprised how little dead parrot quotes have been going around

Howdy Parrot/Perl 6 folks: A general question from me as the Perlbuzz guy (and also Gabor as Perl Weekly guy by proxy).  Is there anything I can help you with amidst all this turmoil about dead(?) projects and the future and blah blah blah?  Messaging?  Blog posts?  Tweets?  Is there something people should know about How Things Are Going that isn't getting out there?

Oddly, declaring it dead has brought more life to it than I've seen in ages.

XS? No, it's dead and buried

diakopter: was probably a dead end from earlier development.

nqp/rx-portability: Kill dead code.

just deleted some more things and is now building stuff to make sure it's as dead code as he thinks it is.

you all said Parrot's dead

what's the deadline for getting that organized?  it seems like we ought to be able to find things for people to do...

Last year it was announced 2/4 and org deadline was 3/9

and Ruby must be dead too, as it's still on version 1

nqp: Toss a mass of now-unused C code and dead ops.

And the deadline is April 15

in conclusion, idea not dead yet! :)

no, not dead at all

Is it dead?

perl6 is not dead

Did you guys see Ovid's comment on his own post?  ``I just got back from FOSDEM and heard, again, for the umpteenth time, that since Perl had 4 "major" releases (1,2,3,4) in its first few years and hasn't had a major release since Perl 5 about 20 years ago, it's clearly "dead".''

Ruby is dead too?

uvtc: https://speakerdeck.com/stevan_little/perl-is-not-dead-it-is-a-dead-end

Because it's not dead.

http://stackoverflow.com/questions/4035538/is-gnus-java-compiler-gcj-dead says it doesn't do the nio stuff

nqp/dyncall-sized-num: Remove dead code from CArray.

i havent really heard anything about perl6 until a few days i thought it was dead years ago O_o

deadline is Feb 4, my executive secretary informs me

jnthn: I just had hilarious mental image of you as a newscaster, reporting in a deadpan voice that 4, as of this morning, is prime.

I had to wait for beer to kick in before Warsaw.pm stopped doing "Perl is dead" jokes :P

"Perl is dead" jokes are so dead.

Segfaults are generally easier to fix than braindead typos =)

unless it's the result of a braindead typo :-)

http://www.reddit.com/r/perl/comments/17fkn3/another_perl_is_dead_article_this_one_uses_tiobe/

Maybe the "perl is dead" story is just what people publish when they've got nothing else.

or “I don’t see blog posts about perl so it must be dead”

Why does everyone feel the need to keep restating that Perl is dead, when TCL is dead too, and no-one needs to be reminded about that. Truthiness?

(chill out, we're dead)

"... In the long run we are all dead" -- John Maynard Keynes

clearly very dead.

moritz: depends how those interact with dead code.

Deleting dead code isn't cheating :)

sees dead unicorns

lue: Popen("perl6", stdin=PIPE, stdout=PIPE). what exactly happens after that i'm not sure. actually this process should have been dead by now!

I've accepted/rejected all solutions I got before the deadline.

moritz: Is any mention of LazyScalar dead code?

both Rakudo and STD are dead wrong here, if you ask me.

hint: to add a deadlock to rakudo just use perl 5's ternary syntax

will probably also run out of time before deadline

Slightly OT: This made news on reddit - http://www.reddit.com/r/perl/comments/16h8cc/perl_is_not_dead_it_is_a_dead_end_forking_perl_5/

"I had the feeling that in the long run (...) Perl 5 was a dead end". -- moritz++ august this year

of course Perl 5's a dead end. What is Perl 6 all about? :-)

or they think that Perl 6 is an even deader end than Perl 5 :-)

to be honest, I didn't recognize Perl 5 as a dead end before I got involved with Perl 6

well there is "dead end" in technical terms and "dead end" in terms of usage..

nwc10: I have no idea how dead-endish cobol is in technical terms..

Su-Shee: though in the (very) long run, technical dead-end implies usage dead-end too

nqp: Toss some dead code.

wishes TimToady would return to perl5 for a bit and turn things around before everything goes up in flames https://speakerdeck.com/stevan_little/perl-is-not-dead-it-is-a-dead-end

watches the presentation "perl is a dead end"

everybody seen the nice "perl is a dead end" talk already? :) that was funny.

Su-Shee: so, not dead but not impressively alive either.

rakudo-js: remove a dead method

r: use Test;    is 0xdeaddead0000deaddead0000dead +& 0xbeef0000beef0000beef0000beef, 0x9ead0000000000009ead00009ead,     'numeric bitwise +& of bigint';

n: use Test;    is 0xdeaddead0000deaddead0000dead +& 0xbeef0000beef0000beef0000beef, 0x9ead0000000000009ead00009ead,     'numeric bitwise +& of bigint';

p: use Test; is 0xdeaddead0000deaddead0000dead +& 0xbeef0000beef0000beef0000beef, 0x9ead0000000000009ead00009ead, 'numeric bitwise +& of bigint'

p: say 0xdeaddead0000deaddead0000dead +& 0xbeef0000beef0000beef0000beef

p: say sprintf '%x', 0xdeaddead0000deaddead0000dead +& 0xbeef0000beef0000beef0000beef

p: say sprintf '%x', 0xdeaddead0000deaddead0000dead

p: say sprintf '%x', 0xdead

p: printf "%x\n", 0xdead

p: printf "%d\n", 0xdead

as at least one bit of perl 4 code survived, dead, for IIRC 10 years until it was purged

wants a list of solitaire games he can search by how you play it, so he can figure out the name of this braindead time killer.

r: say 0xdeaddead0000deaddead0000dead +< 4

long live IRC -- http://royal.pingdom.com/2012/04/24/irc-is-dead-long-live-irc/

tadzik: if you have the time, the link to "masak's Pls" is dead by now and i'm not sure where it's meant to lead.

and outside of THAT chamber, people say, "Perl? Isn't that dead?" ;)

how true is the statement that parrot is almost dead?

"dropping some context" doesn't work for puns, it kills them stone dead

felher: the more I program, the more I realize that we're all Dr Frankenstein. we're putting behavior into dead matter. and we're slowly getting increasingly good at it.

masak: did I read the p6cc announcement correctly, that there's no separate sign-up deadline this year?

notably that hop returns an ICMP unreachable for feather3, but just dead air for feather.

pugs: use lib 'lib'; say "dead"

i'm trying to raise a project from the dead

ecosystem: Remove dead modules from the SHELTER

if we're in dead point, we should try TDD maybe :)

(always learning) I had an old boss who told me once you stop learning, you're dead. (and that's from when I stocked shelves at the grocery store!)

Say for instance :auth<github:supernovus> or :auth<http://github.com/supernovus/>  If we want to go with dead simple, we could say, encode both : and / to _, collapsing to a single _ character in a row, and stripping trailing _ characters, making the folders for the previous examples 'github_supernovus' and 'http_huri.net'  respectively.

damnit, I'm thirty! the ppl in medieval were already dead at that age

I feel dead these dyas

sir, I assure you, being dead is worse than this.

I've heard that the IRC can be quite deadly to the MSN-lubbers.

masak: is yapsi dead?

dead language, eh? :)

contemporary Latin isn't dead.

what's the worst that could happen? people will declare it dead before they know anything about it? :)

was overjoyed to discover there has been a new release of Factor!  Thought the project was dead....

in the general case, detecting a dead file handle requires a major collection

Semispace copying is nice because dead things are basically free

that is a bit wasteful when you have a large live set compared to the dead set

rakudo/Q: Delete dead code.

sweet listen dead in june

even johnny cash is goth at halloween, especially since he's dead

fyi http://www.parrot.org/languages lists 3 languages: "winxed"  -- deadlink for me;  "lua" -- last commit 5 months ago

tadzik: it has a dead link to Pls

japhb_: new evil dead movie coming soon.

will also get back to paying his taxes, as that is on a deadline of sorts.

And my FastCGI library is now dead in the water. I may finish the Protocol class, but it's no use going any further.

incidentally, the thread is about *Python* not being dead

it is a nice contrast to the constant flow of "perl is dead"/"perl is not dead" articles from a couple years ago

doy: it's Python's turn not to be dead. :P

don't beat a dead hor... oh wait

Tene: "experienced users tend to take priority". Agreed, but that's why we end up with PHP. People growing with a brain dead language for fear of learning what is there.

goes to fix the pick so it's not braindead inefficient

.oO( I see dead nicks )

better than being lumped with the dead white males...

wonders how much longer yarp wants to beat a dead horse

Sometimes the killed code needs to live on long enough to know it really is OK being dead :)

jnthn: yeah, I popped up.  We met our robotics deadline last night, so I have a little bit of breathing space again.  :-)

niecza: fix excessive replace, remove dead code

niecza: Remove now-dead code generation for static field access

Su-Shee: *shrug* i had to restart chrome about 10 times yesterday because its inspector suddenly fell over and refused to function. i'm not aware of a sane way to force a complete refresh of all the assets of a website in chrome; it sometimes works, sometimes doesnt. firefox is dead slow. all of them are incompatible with each other in hilarious ways.

FROGGS: the link is dead, did you merge the branch?

calling all undead programmers

yarp: now if you want to assume memory is a flat array of bytes possibly with holes... go for it.  every processor made in the last ~20 years has supported that, true segmentation is dead, word-addressed architectures are dead, split I/D architectures are dead (for non-embedded systems)

is it about undead code?

"...inside the box is a vial of poison and no cat.  So, the no cat is simultaneously dead and alive."

that's a dead phone joke

tadzik: hope things work out with your dead phone.

ooh: https://github.com/aanand/deadweight -- pcawley suggested that something like this be a killer app for Perl 6. that was two years ago, I believe.

Teach a man to burn a fish, and, er, it'll stay burnt after it's dead.

It'll stay burnt after he's dead too...

The delek is dead!  Long live the dalek!

sergot: uvtc did much of the wiki stuff. The perl 6 book is dead, I'm afraid

tadzik: maybe they are waiting for you, in an unfortunate kind of deadlock situation...? :)

stable = dead, just as in biology

current instr.: 'add_deadly' pc 9181 (src/gen/perl6-optimizer.pir:3416) (src/Perl6/Optimizer.pm:536)

nqp: Toss a bunch of now-dead code (replaced by a combination of QAST::WVal, bs and some of the logic moving into QAST::Compiler itself).

nqp: Toss some now-dead code in P6Regex.

loopback swap is a Bad Idea for the reason you just mentioned, deadlocks

"if they're dead, how can I steal their ideas?" -- mst

nqp/toqast: Toss some now dead code.

i18n libs probably become one of those things where you use <10% of the provided functionality, and the rest is dead weight.

only other perl6 stuff I'm aware of is the mailing lists (dead), the bug trackers (summarized in changelogs), twitter, and planet perl6 blog aggregator

Unfortunately I've an article deadline coming up, so it'll probably be a few weeks at least before I get it done

Wait, Silverlight is dead?

_moonlight_ is dead, but silverlight may be hanging on

doc/htmlify-refactor: kill some dead code

worst case scenario is I can just wire it up manually for this deadline and integrate with a DBI later.

is phasers dead?

don't call it dead call it "a tradition worthy of a comeback" ;)

there are people joining #phasers all the time ... It can't be dead  ;)

I'm trying to work to a deadline at work; what's the best way to get some help with getting DBIish or miniDBI working?

and I'd submit that someone who doesn't know Perl 6 would immediately figure out what :16<deadbeef> means

That's because deadbeef is a culturally unambiguous hexadecimal number.

:16<deadbeef> could be written as 0xdeadbeef

managed to send in both proceedings articles before the deadline

this year I decided to take that chance. the deadline is tomorrow.

I can't wait for rakudo deadbeef

huf: half baked code can be a dead end no matter how much you put it online. jnthn++: the trick with flying is to miss the ground when you are about to hit it

akshually it was just a mostly dead ssh connection where I didn't see what I typed

r: $_ = "mostly dead ssh connection"; s[ea] = "rea"; .say

sorry to hear about non-bootstrap running into a dead end. it seemed like an interesting direction.

sorear: why did non-bootstrap run into a dead end? tuit starvation? or technical problems? or both?

I can still update it and make it more solid or concrete; but things got a little hectic here as the talk deadline approached.

when the dust settles and all other programming languages are all long dead, JavaScript will still be there.

masak: btw, naming the game "crypt" may start a myth about Perl 6 being dead  ;)

the headlines seem to lack <a name=...> tags, offhand.  But I certainly will give more feedback later. Today's tuits go to my yapceu talk.  There is a deadline looming...

seen schrödingers cat, dead

schrödingers cat, dead was last seen in  15546 days 17 hours ago .

roast: "I know a dead function when I see one"

Yeah, 1 is dead simple

"Hey, has anyone considered just letting dead objects fill up memory until we run out of it?"

partly because sprintf encodes a sublanguage as a dead string.

there are several forces in play here. one the one hand, sprintf suffers from its first argument being a dead string.

I don't know what you mean by dead string.

[Coke]: dead string as opposed to a sublanguage, which is syntax-checked with the rest of the program. even Perl 5 regexes are syntax-checked. not so sprintf format strings.

YAPC::EU talk submission deadline is today. just so y'all know.

(yes, deadline is this weekend, I know)

I thought pugs was dead.

So it's only 60% dead?

irked? worried? idk. its deader than a zen rock garden

Timbus: The Rakudo website last got updated just over a week ago. That doesn't feel so dead. What kind of aliveness are you wanting? :)

flussence: that's possible, but rather hard to do without getting into a deadlock

rakudo/toqast: nsentry is dead

Sounds deadly.

irc.per.org seems to be on the dead side of living

the dead jacc guitarist?

(yapc)  TPF extended the deadline this year for yapc submissions

Don't have one handy, but basically, resurrection means that the DESTROY could bring dead objects back to life.

jnthn: the sign-up deadline is hard. I *have to* send a complete list of attendees to the hotel, and can't add any new names after the cut-off date

the finality of this final deadline is *very* final, deadly and line-shaped! :)

It's an actual deadline!  The line will be dead!

How does one distinguish a dead line from a live one ?

sends it a deadly SIGKILL

pmichaud: I've received an email from somebody who found dead links on rakudo.org, and couldn't find any webmaster email address to notify

I've also got one analysing stored proc usage transitively, which has dredged up 900 in theory dead SPs. Need to analyze that bunch of stuff some more next time...

[Coke]: yeah, I know, most of those links are dead

"most are dead". please keep the hyperbole to a minimum. ;)

phenny: tell masak use.perl.org seems to be dead, the two links on http://rakudo.org/how-to-help/ to your journal are dead

masak: 19:41Z <moritz> tell masak use.perl.org seems to be dead, the two links on http://rakudo.org/how-to-help/ to your journal are dead

I know about the june 25 deadline so will definitely get as much known as I can this week.

so is perl5 dead? why did he leave perl5?

perl5 is used by zillions of websites, it's not dead

or will the perl5 be dead when all will use perl6 instead of perl5?

people you kill today are dead in 40 years still

project deadlines?

deadlines in general?

not even a warning that continue is dead code

oh, all three S05 regressions have the same underlying cause and it looks dead easy to fix...

well I have to get back to writing for a conference deadline, thanks for answering my questions

niecza: Add Mu.take.  (Not 100% convinced it is a good idea, but it is in spec and roast and was dead easy to do.)

I re-implemented .trans back in 2010 when I realized it was dead slow for long inputs.

or one can do something like deadlock detection to note lack of progress

hmm, binary search in NQP is dead again with fea45a0b23e994634d7148af65521faa7555fcef

I tend to think SMOP should stay dead; diakopter et al's 6model/c is the new SMOP

little punchy from dayjob deadlines. pay me no mind

Hopefully hurd, because a programming langauge being "done" means it's dead and over with. :)

masak: do you mean OT = operational transform? the kind used in the now dead Google Wave (r.i.p)?

so it's dead?

users mostly think perl6 is dead in the water :/ so messing with that is a good thing

r: say :16<deadface>

deadline to submit presentations to Strange Loop is today. https://thestrangeloop.com/sessions-page/call-for-presentations

that was dead before I started on steme, I believe.

otoh, I hope we're all dead before this is done too, in the 100-year-language sense :)

This is exactly how Agile works only Perl 6 doesn't have the pressure of deadlines and budgets.

I'm all for some dead-simple format here, something along Module::Name\nfile\nfile\n\nAnother::Module... and so on

jnthn: Chuck will probably say "huh, it's dead already" and move on ;)

Combination of two errors. One brain-dead copy-pasta, and one line I forgot to update in Makefile.in

But the actual bug isn't dead yet, even if the valgrind complaints are :/

Seq is dead.

there has to be some deadline even for spoiler warnings.

imagine this. A forest, a swamp, a small hut. A smoke coming out of pistol silencer, Fiona crying over Shrek dead body, and the guy in a mask saying "I'm terribly sorry, my lady, but it had to be done. It will make millions of people feel better"

If we're going to track /dead/ projects, that's fine, but keep them hidden by default.

Dead ends that add useful features aren't dead ends?

both are dead easy to pronounce.

so easy that you drop dead if you try? :-)

sorear: no, it was just dead in the water.

that's why it's considered dead/unused

brrt: and do it quick, because the student application deadline is Friday

TimToady: can i have official approve that $*OS and $*OSNAME are dead?

Teratogen: Perhaps a dead horse, but have you used Lisp macros?

But i'd like to know if there is a special name for the kind of map perl6 has, describing its feature to take arguments by the arity of the function supplied? dynamic-arity-map probably is dead wrong... :)

the only good parametrization of the 2-manifold of genus 2 is a dead parametrization of the 2-manifold of genus 2...

oh wait, the PC police will be after me for using the only good X is a dead X

TimToady: the only good PC police is a dead PC police. ;)

it's a dead store, $from = $/.pos ; $from = $/.pos ;

moritz: I think the decree "the spec as of revision deadbeef" is Perl 6.0.0 might shake up that, when it comes =)

emulate that, and then enable various "refactorings", or finding dead bits of CSS, etc.

inspects a dead rakudo

(it helps stave off the "perl is dead" meme just a little bit more)

at least now I don't have to worry about y'all thinking I'm dead ;)

if you want us to think you're dead, just let us know :)

Then it'll be dead easy to render the error however we want it.

macros2 is dead -- long live macros3.

it seems he has missed the submission deadline for documentation

isn't dead yet, but does now have a cough

assuming that I'm not dead, or faking death convincingly

is trying to figure out if he is looking at dead code which can be deleted for his $work, too

rakudo/bs: Toss dead line of code.

sorear: when is the deadline for the annocement?

people on twitter thinks that perl 6 is dead, because the activity on the mailing lists dropped

tell them that the mailing lists are dead, and development is done on IRC now

"mailing list is dead, love live twitter"? j/k

mathw: i'm terribly sorry but that can only mean you are undead

I don't know what the successor to pinyin will be called, but Wade-Giles still won't be dead then either.

just a quick reminder, the day after tomorrow is the deadline for the prisoner's dilemma mini challenge

Whitney Houston is dead!

well, I won't publish any submissions before the deadline, and my own strategies are already written and their SHA1 published

We're always "too slow" (if we thought otherwise, we'd stop making improvments and Perl would be dead :)

then you'll get lots of... comments of how Perl 6 is dead, and besides that irrelevant and slow.

compared to that, Perl 6 is practically dead today :)

was spew ever dead?

fasad: if I call something bold and then display it as italics, will the universe stop dead?

(sorry for the delay -- there was an incident of potty training and then I realized I'd never deleted the dead code for smoke-niecza)

there is a wiki for perl 6: http://www.perlfoundation.org/perl6/index.cgi?perl_6 . Looks dead !

oh crap, I missed the p6cc deadline...

less than 24 hours till p6cc deadline!

6-peeps, only four days remain until the final p6cc deadline!

(4 days left until p6cc deadline). Guess I'm losing! ;)

determines that partcl is still mostly dead. Ah well.

unless we explicitly mark such filehandles as "dead", or so

masak: ... when's the deadline? ;)

dead here too

"DUDE, this cat's, like, nine kinds of alive and dead!"

Allowing only ., \xdeadbeef and friends, and ranges of same at a first approximation

oh, interesting... I just changed it to be properly infinite, and niecza stops dead at digit 100 or so.

today is the last day before the deadline to sign up for p6cc!

hates dead keys

thou: on the parsing natural languages topic... you do know that besides some very limited cases, this is a dead end, right?

I hope to extend the deadline for a week, but not sure it'll work

rouso: 07 May 19:24Z <BrowserUk> tell rouso please no with the cooroutines! They are cooperative. One uncooperative collaborator and everything hangs. The do not scale; cannot make use of multiple cores; require endless tuning for every small change. The are a dead technology--if you experienced Windows3 you know what I mean.

the latter two also exist as dead-tree books.

perl6: say :16<dead.face>

niecza: Fix error on :16<dead.face>

is(:16<dead_beef> * 16**8, :16<dead_beef*16**8>,

my interpretation is that :16<dead_beef*16**8> is a Num because 2958942e8 is a Num

Perl 6 is dead, nothing good will ever come here

sorear: done, and I still get the error.  and I just realized it's because I'm not waving the "no return value" dead chicken at my CgOp call

cedric: hmm... your immediate problem is the '"no return value" dead chicken', your less-immediate problem is that rxsetpos only works in regexes

Accidentally did /join #perl5, was shocked to learn that it *is* dead!

not sure if there's any point in trying to debug it; it's an evolutionary dead end.  but it certainly sucks that it's happening.

mhmm what do you mean evolutionary dead end?

donri: 185b3293@gateway/web/freenode/ip.24.91.50.147 is a dead giveaway

oh wait, isn't today a deadline for new projects?

the deadline is december 18th, I think

niecza: remove dead spectest file, skip broken one

djanatyn: deadline extended by 24h

djanatyn: do you need a deadline extension for http://www.google-melange.com/gci/task/view/google/gci2011/7177376 ?

nom: say :16<dead_beef.face>

nom: say ":16<dead_beef.face>

nom: say ":16<dead_beef.face>"

nom 17a235: OUTPUT«:16<dead_beef.face>␤»

nom: say +":16<dead_beef.face>"

nom: say +":16<dead_beef>"

"It's the reliability of single-threaded message-based designs that I like. An avionics software designer told me they never use multi-threading just for that reason. A single thread is absolutely guaranteed to have zero race conditions and deadlocks. No multi-threaded software can provide that sort of guarantee." from http://c2.com/cgi/wiki?MessagingAsAlternativeToMultiThreading

Tomorrow is the deadline for getting perl6 tasks into GCI. Hurry Hurry. ;)

how are your GCI efforts coming along? are you all set with the tasks you want to do? it's just two more days til the next publication deadline.

as we didn't add any before the first deadline.

http://blogs.perl.org/users/alberto_simoes/2011/11/the-perl-foundation-grants.html -- normal (NON hague) grant deadline extended.

nope. not slushy. deadline has passed, per rafl on #gci

we just got mail about a deadline extension

deadline until next Monday, November 28th at 8:00 UTC.  So please feel free

nom: .say for :16<dead_beef> * 16**8, :16<dead_beef*16**8>

> .say for :16<dead_beef> * 16**8, :16<dead_beef*16**8>

nom: .say for +^0xdead +& 0xbeef, 0x2042

> +^0xdead +& 0xbeef, 0x2042

nom: say +^0xdead

> say +^0xdead

$ ./perl6 -e '.say for :16<dead_beef> * 16**8, :16<dead_beef*16**8>'

nom: say +^0xdead +& 0xbeef

> say +^0xdead +& 0xbeef

rakudo/bigint: make :16<dead_beef*16**8> return an Int

I've been doing the Str.Numeric() work because I wanted to kill that top block of TODO items dead.  ;-)

unless maybe when you're dead

perl6: say +^0xdead

as a bonus, explaining on the way why certain special variables are dead and gone, and what we use instead, and why it's better. :)

6model: edeaddb | sorear++ | lua/runtime/Runtime/Signatures/SignatureBinder.lua:

6model: review: https://github.com/diakopter/6model/commit/edeaddb8c6

nqp: say(0xdead)

nqplua: say(0xdead)

I'll probably be dead when there is an official Perl 6 interpreter

oh, we have the day of the dead now, it's a good enough reason to shut down most of the roads

tadzik: Day of the dead?

#google is dead

sorear: google is also dead :p

should check in his stupid "check_explode" script that makes sure unrun test files are still exploding in the same way. (since it's at home behind a dead wifi hub)

sorta like defining substraction as "deadding"

cognominal: bareword literals need to stay dead, tyvm.

Woodi: sure, all current build tools suck dead gerbils through a garden hose

nom's just completely braindead when it comes to things that overflow int64.  (maybe int32 on some machines)

the parrot is dead, man

wow, dennis ritchie is dead

far be it from me to criticize another (dead) man's cult

resist the urge to write a "Steve Jobs is dead. Now get over it" post

bah, stupid router's gone dead and I can't ssh in :(

dead ants?

is sitting at $dayjob watching my 6-core workstation deadlock 6 threads in crap software over and over :)

yay, more dead mailing lists </sarcasm>

and more dead IRC channels...

flussence: 'as' is dead.

is p6eval deaded?

schiesse! I think I missed the deadline to sign up for the mandarin intro at continuing ed.

COBOL *is not* dead...

oh so yaml is dead?

still it's dead code, and should be removed...

japhb: wantarray is long dead.

we'll need a different verb to put things into the unhandled list instead of the undead list

maybe undead is misnamed, since it's really the old exception that is undead when it comes back :)

my guess is that the NewType($value) syntax is dead, and that the thing you found in the spec is a fossil.

rakudo/nom: Toss dead code.

I say we convince everyone that Perl 6 is dead and failed and over budget... and THEN we take over the world.

what would be truly ironic is if we weren't able to convince people that Perl 6 is dead  :-P

it also probably makes decontainerization dead simple, just don't change the owner upstream

Constant folding isn't quite the right term…  There's no folding, just changing code gen based on the presence of a literal.  It's the difference between recognizing :16<deadbeef> as a literal and :16<$const> as a literal

So long as we don't get ourselves into deadlock issues.

ecosystem: Removed my old dead projects, and added WWW::App.

masak: This castle is called "Wawel". I did some impossible magic once and managed to get a pass to spent one night there. That was creepy, sleeping among ghosts of dead kings :)

"Soft" deadline for student code sample submission

or the deadline's for year 2011 + 2**32...

donri: gsoc is over, python on parrot will be dead by Christmas, 90-95% certain.

TimToady tells me it's only dormant, not dead

[Trying to remap results in a dead Caps Lock key that does nothing]

meth: Perl 6 does not have a "reference" type at all.  That is dead and buried. \o/

the NoSQL movement seems to be good at understanding what applications require, and structuring solutions appropriately.  In that sense the SQL standard has been a dead hand at the wheel (tool:hammer :: problem:nail).

At least two of those projects are dead, deprecated, disused, discouraged, or some other word which starts with d.

which ones would be dead?

well, they all don't look dead to me

nom: say (:16{dead_beef}).perl

nom: OUTPUT«===SORRY!===␤Malformed radix number at line 1, near "{dead_beef"␤»

nom: say (:16{0xdead_beef}).perl

nom: OUTPUT«===SORRY!===␤Malformed radix number at line 1, near "{0xdead_be"␤»

nom: say (:16(0xdead_beef)).perl

nom: say (:16<0xdead_beef>).perl

nom: say :16<deadbeef>

nom: say +":16<deadbeef>"

Shouldn't :16<deadbeef> be a Pair, as in, `"16" => "deadbeef"`?

nom: say :16<dead_beef.face>  # From S02

nom: (16 => "dead_beef.face").perl.say

nom: OUTPUT«16 => "dead_beef.face"␤»

NQP doesn't appear to handle sym['$<'] the way Rakudo's grammar expects.  The generated PIR seems to try to match "Capture[0xdeadbeef]" instead of '$<'.  I'll look into it in a bit if nobody else gets a chance.

moritz: we didn't kill it all the way dead. :/

wait, I don't think that does dead keys...

no, they're trying to get me used to the notion of being a dead white male

read that as 'dead white whale'

masak: seing your gist https://gist.github.com/1139458  if you like pentominoes and obfuscation, you should visit http://paris.mongueurs.net/assombri/opc3/Stephane_Payrard.tar.gz   TPJ is dead, but a copy mentionning the winner of that contest if here http://www.foo.be/docs/tpj/issues/vol3_3/tpj0303-0015.html

risou: re the tweet, neutro is long dead, you probably want to use panda instead

TimToady: what do you think of adding deader implementations (Rakudo-Alpha, Pugs, Mildew/SMOP)?

roast: Get rid of a lot of dead weight from the trig test harness.

I read it from http://transfixedbutnotdead.com/2010/01/14/anyone-for-perl-6-metaprogramming/

moritz: [bless( {}, 'main' )]DESTROY created new reference to dead object 'main' during global destruction.

Sorry, beating a dead horse...

more specifically, it's idempotency of the dead horse

2. the correct (deadlock-free) way to handle asynchronous signals isn't control exceptions, it's starting a thread to handle them

I mean the advantage I see is that I can choose my language as long as I can fix stuff when I hit a dead end ... wouldn't have this choice for a company project I guess :)

CBro2007: so what would be needed would be someone to think long and hard how to make Set and Bag et al. dead easy to use -- such that they are on par with arrays and hashes. that's a challenvge, I think, but one that would pay off big time.

if a software project is finished, it's dead :-)

oh.  I thought E2 development was essentially dead

rakudo/nom: Toss some dead code.

rakudo/nom: Toss dead code.

though in this case it's been taken out and shot repeatedly, and stayed undead

"undead memes" is probably redundant

masak: That's how we feel about: from "Perl 5 is dead" to "Perl 5 is meandering"

I still prefer "Perl is undead"

november is dead methinks

hi, anyone up for looking at a rakudo problem? I'm not sure why i'm getting "Cannot resume dead coroutine"; i tried with rakudo * 2011.04 and current git master.  http://paste2.org/p/1500332

thou was last seen in #perl6 3 hours 9 mins ago saying "hi, anyone up for looking at a rakudo problem? I'm not sure why i'm getting "Cannot resume dead coroutine"; i tried with rakudo * 2011.04 and current git master.  http://paste2.org/p/1500332".

rakudo 72d158: OUTPUT«Cannot resume dead coroutine.␤  in <anon> at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'Any::join' at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'List::perl' at line 2868:src/gen/core.pm␤  in main program body at line 22:/tmp/nEWs1EbFB4␤»…

rakudo 72d158: OUTPUT«Cannot resume dead coroutine.␤  in <anon> at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'Any::join' at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'List::perl' at line 2868:src/gen/core.pm␤  in main program body at line 22:/tmp/oiuC05H09N␤»…

rakudo 72d158: OUTPUT«Cannot resume dead coroutine.␤  in <anon> at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'Any::join' at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'List::perl' at line 2868:src/gen/core.pm␤  in main program body at line 22:/tmp/iqwWixCws0␤»…

rakudo 72d158: OUTPUT«Cannot resume dead coroutine.␤  in <anon> at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'Any::join' at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'List::perl' at line 2868:src/gen/core.pm␤  in main program body at line 22:/tmp/8QGFB8fj1v␤»…

rakudo 72d158: OUTPUT«Cannot resume dead coroutine.␤  in <anon> at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'Any::join' at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'List::perl' at line 2868:src/gen/core.pm␤  in main program body at line 22:/tmp/stVq9uhXS1␤»…

rakudo 72d158: OUTPUT«Cannot resume dead coroutine.␤  in 'Iterable::Numeric' at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'infix:<==>' at line 1:src/gen/core.pm␤  in 'ACCEPTS' at line 3536:src/gen/core.pm␤  in <anon> at line 1567:src/gen/core.pm␤  in <anon> at line 1:src/metam…

more opinion: http://me.veekun.com/blog/2011/06/27/perl-5-is-dead,-perl-6-is-a-disaster/

masak, have you seen an error like this before: http://paste2.org/p/1500332  # "Cannot resume dead coroutine"

rakudo 72d158: OUTPUT«Cannot resume dead coroutine.␤  in <anon> at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'Any::join' at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'List::perl' at line 2868:src/gen/core.pm␤  in main program body at line 22:/tmp/h4QIKp4KYt␤»…

rakudo 72d158: OUTPUT«Cannot resume dead coroutine.␤  in <anon> at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'Any::join' at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'List::perl' at line 2868:src/gen/core.pm␤  in main program body at line 22:/tmp/9RH76vqCP_␤»…

rakudo 72d158: OUTPUT«Cannot resume dead coroutine.␤  in <anon> at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'Any::join' at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'List::perl' at line 2868:src/gen/core.pm␤  in main program body at line 22:/tmp/RXwzWQ5X9b␤»…

rakudo 72d158: OUTPUT«Cannot resume dead coroutine.␤  in <anon> at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'Any::join' at line 1:src/metamodel/RoleToInstanceApplier.nqp␤  in 'List::perl' at line 2868:src/gen/core.pm␤  in main program body at line 22:/tmp/vzVuEJqIQ9␤»…

'course, maybe that's just because everyone over there is dead now

colomon: is projects.list dead? How do I properly get a module on modules.perl6.org ?

then now it is dead

antony_: prefix:<=> is dead, long live .get and .lines

dalek is dead!!!

he wasn't dead, he was just resting

»That people don’t think Perl6 is dead confounds me; we’ll get to that later, though.«  -  first, make sure 'e's dead. - *bang* OK, what now?

<a dead language joke>

<a meta joke about dead language jokes>

nom: say "dead"

nom: OUTPUT«dead␤»

and .pretty is dead?

g'ah. not even deadlines instill the right kind of industrious fear in me anymore... :)

what kind of deadlines?

is "pugs" essentially dead?

there's the old-old NQP. It's dead

sorear: no SIGPIPE, no deadlocks

if it is i'll be dead by then

still dead code

(dead code)  the reason for the dead .return there is that we have to do some fakery in the first sub in order to get "main" to work properly and still have :load :init subs take place in the proper sequence.   the end result of that fakery is that the PAST compiler gets a little confused and we get two returns

I thought GIMME was dead

I searched the #perl6 logs for "gimme" and didn't see anything that indicated it was dead.

Oh wow, rakudo gives "Cannot resume dead coroutine." for [Z+] @a, @b, @c

tadzik: could you please nopaste your local dead-coroutine error? along with your local rakudo version?

tadzik: don't wait past the deadline :)

masak: oh, I'll do it anyway if it will get implemented after the deadline ;)

It won't be deadly slow, but I'm not interested in making it a 6model primitive.

and as a side note, in the Irish Traditional Music community, seeing someone spell "air" with an "e" on the end is almost always a dead giveaway that they have no clue what they are talking about.

1. "sorting lists of pairs" - discussion deadlocked on how cmp should work.  This is bad...

4 exams on friday, 2 of them deadly

there's handwaving verbiage in "Mostly Lazy" about that, but I'm not sure how we detect circular definition without deadlock...

if we drive cmp in that direction, then we need to make it drop-dead easy to get at the natural ordering differently

colomon: or, put another way ... if we get rid of cmp, then we'll have to provide some standard comparators that are drop-dead easy to use (so that our users don't go crazy) and one of them will contain the comparison that we're talking about for cmp

and a Java project little deadline

I'm worried we may get caught in a deadlock (more)

(and the list implementation was done on a time deadline, too :)

rakudo: say "I'm ", <alive dead undead undecided>.roll, "!"

rakudo be887a: OUTPUT«I'm dead!␤»

rakudo: say "I'm ", <alive dead undead undecided a-carrot>.roll, "!"

moritz, ok, i have been reading that, too. so Per6::Doc is dead at the moment?

slavik: it's approximately dead compared to rakudo

rakudo/nom: ddeadfd | jnthn++ | src/CORE.setting/BOOTSTRAP.pm:

rakudo/nom: review: https://github.com/rakudo/rakudo/commit/ddeadfd281

jnthn: The TPJ link at the bottom of that page is dead

it turns out that you can't put a deadline on that kind of work. it just makes no sense.

niecza: [hoopl] added a dead register store elimination pass

no, it's dead

no. use.perl.org is dead-ish.

last call for GSOC proposals: about 4 hours left until submission deadline

heh, somebody submitted a GSoC proposal 150 seconds before the deadline

and that goes for any piece of software. regardless of what deadlines or rules mere mortals come up with.

yep, 8th is the deadline

tadzik: seems like it's dead :(

@schoolwork is good. Switching between tasks costs time, so indeed, it is better to reduce the number of different tasks competing for attention. It often helps to briefly step back to overview, quantify and prioritize them all. In this case, I would suggest leaving S32 until some other time. As for GSOC, let's discuss that more until April 8, the student proposal deadline. http://www.google-melange.com/gsoc/events/google/gsoc2011

(that one's probably dead due to feather downtimes)

I don't see that either approach is a dead end

I'm mulling about what can be done about declaring Ponie "undead", five years later.

pmurias: I think type inference for numerics is a dead end, but I can't explain why well enough to convince anyone else

Python is dead-simple to deploy. :P

jnthn: is Rakudo represented by Perl foundation? I think today's the deadline for GSoC organizations application

true, but then it's also fixed to a filepath and dead if you move the source, not that it might be a big issue

what's the deadline?

afaict there's no real deadline for ideas

he's dead. And so is everybody from his time. D'oh.

yapsi: was a variable used to be tricky business. With FUTURE it's dead simple.

and that's the most difficult part of our release process. the rest is dead simple.

perl6 is dead

no, it's undead

That is not dead which can eternal lie

is logged in from a livecd while copying files off an undead disk drive...

So I have a binding to a lazy @primes, '.say for @primes' dies with "Cannot resume dead coroutine."

geocities is dead my friend :(

Error for project Net-IRC : could not get http://github.com/TiMBuS/Net-IRC/ (project probably dead)

is it safe to assume gitorious support is dead and cold? :)

that doesn't mean the support for it isn't dead and cold, of course...

I had a look at OpenSolaris just a week ago for BSD compatibility testing - it is very dead, not worth supporting unless someone asks for support in 2011. For BSD testing I opted for this one because its LiveDVD was the most up to date and functional one I could find. http://www.rofreesbie.org/

[Coke]: IO. Data manipulation is also _dead_ slow.

Tene: yes, deadpan humor often misses on IRC because it's hard to tell that's what it is sometimes

rakudo: sub brain-damage-o-meter(Str $i) { $i.chars / 'criminally-braindead'.chars }; say brain-damage-o-meter('htmlspecialchars');

rakudo: sub brain-damage-o-meter(Str $i) { [/] ($i, 'criminally-braindead')».chars }; say brain-damage-o-meter 'htmlspecialchars'

rakudo: sub brain-damage-o-meter(Str $i) { [/] ($i, 'criminally-braindead')».chars }; say brain-damage-o-meter 'htmlspecialchars()'

rakudo: sub brain-damage-o-meter(Str $i) { [/] ($i, 'criminally-braindead')».chars }; say brain-damage-o-meter 'masak'

rakudo: sub brain-damage-o-meter(Str $i) { [/] ($i, 'criminally-braindead')».chars }; say brain-damage-o-meter 'jnthn'

rakudo: sub brain-damage-o-meter(Str $i) { [/] ($i, 'criminally-braindead')».chars }; say brain-damage-o-meter 'Tadeusz'

rakudo: sub brain-damage-o-meter(Str $i) { [/] ($i, 'criminally-braindead')».chars }; say brain-damage-o-meter '兎用心棒'

colomon: in some sense working code is what counts here. recall that the *only* contestant who got p4 right got so involved in it that he (1) missed the deadline, and (2) didn't complete all of the other tasks.

ooh, is there a deadline?

I see there's Term::ANSIColor, Term::ExtendedColor shouldn't be too hard... Are there any plans for a cpan for perl6? The cpan6.org site seemed a bit ... dead. The cpan source is available, so it should be pretty easy setting that up?

perl6 was started at a point in time when perl5 looked dead

mberends: be not constrained by the limitations of dead trees!

Last I checked, e.g. speed wasn't even a concern yet and rakudo was mad slow on random dead-simple things

I'm not dead yet, zebras!

you're asking for deadlocks if you do that because of buffering semantics

ok. Just build parrot without optimize. It will be dead slow. But help to catch GC errors early.

but I'm not dead set on adopting .values as the name. just not .reals, please.

So after $dayjob gave me a CGI.pm thing and then a PHP thing I come home to find my desktop's video card is broken and all my spares are dead. Happy Fun Time Week!

where's everyone? this chat looks dead

tadzik: not dead at all... look at http://irclog.perlgeek.de/perl6/today to get an idea for the activity level here

moritz_: have you submitted a talk to LinuxTag Berlin? if not yet, the dead line is today!

masak: maybe you can review arnsholt's code for p4 too (and just mention it's post deadline)

note that even if arnsholt had made the deadline, which he deplorably didn't, he'd still have sent in only four solutions.

I assign 80% odds that perl 5 will reach "dead language" status before Perl 6

shortcircuit: nobody understands it well enough to improve it, except audrey, who [clarification: is not dead but] hasn't touched it in 3+ years

niecza used to do the same thing, until I realized that the option was dead code

needs storage size for numerator and denominator, but the basic notion is dead on.

the talk dead-line is in a few days

masak: moritz_ dead-line is 8 Feb

I thought that project was dead so thanks for showing interest in finishing it

IMO that doesn't just _violate_ the priciple of least surprise, it violates it, beats it up, stabs it a few times and leaves it for dead in a drainage ditch.

that's a teasingly short deadline... I'm at $work! :)

is everybody gonna wait till the deadline?

when's the deadline?

the deadline is in March

frettled: everyone blew p4, exept arnsholt (who blew the deadline instead).

braindead

It's still dead slow in nqp-rx though.

I have a dead trans-ikeet, and I was wondering if you could help me fix him.

No, 'e's definitely dead

what i meant is that it should be possible to combine type-inference, constant folding and dead branch elimination and other stuff together

reanimates a dead lock

Good thing I blew the deadline then, since three out of four of my solutions had a lib/ with a module file in it =)

.oO(Monty's Parrot: The parrot (is&!is) dead)

masak: Oh, the deadline was friday not saturday. My bad =)

colomon: BTW, I messed up on the p6cc deadline, so if you want to look at my p4 code, I'll have to put it somewhere =)

arnsholt: now I'm even more sorry you didn't make the deadline! :-|

moritz_: don't worry, everyone did. you all blew p4, except arnsholt who blew the deadline... :)

But yay. My dead-stupid p3 solution works =D

unless we set some deadline

my brother-in-law once told me that my sysadmin job was a dead end, but that's how we got Perl :)

your solutions have already brightened my life in unexpected ways. I hope there will be mamy more as we approach the deadline.

rindolf: nothing. someone mentioned it, I looked into it, didn't think much of it but "oh yet another language with nice features and no ecosystem" and played a little with it like with a dead mouse. ;)

Is it dead AGAIN?

diakopter: gimme5 is dead, but the essential problem - platonic ideal perl 6 doesn't exist - remains

so what we'd like to do is dead easy.  :)

and drama is straightened up... time to work on Java Kitty... my JVM+Android dead cat thing.

submissions after the deadline will be considered to be after the deadline! :)

arnsholt: ok. you realize that the deadline is in 10 days, right?

I'm very unsentimental about dead code.

hans is dead?

apt-cache show indicates pkg-parrot-devel@lists.alioth.debian.org for the Maintainer of the Parrot package. *checks mailing list archives for undead behavior*

http://wklej.org/id/444886/ -- why is it so dead silent? It could at least crash, or something

is very dead

someone pointed to *BSD libmp but that's pretty much dead and known to be buggy.  and points to *BSD libcrypto

masak: what's the deadline for the contest, again?

in any event, it doesn't correlate with "dead [and uninteresting]"

heh, that's also a submission deadline for a conference I might attend :-)

the link to the perl bcrypt thing is dead

well, it just so happens that I seem to get a lot done when I'm not setting myself deadlines...

szabgab: haven't seen jnthn since you asked last time. is there a deadline involved?

it's as if they'd paid money and were promised a deadline

.oO( I'd volunteer, but I'm absolutely hopeless at sticking to deadlines... )

flussence: if you know by how much you usually overshoot, you could pretend that the deadline is that much earlier than it actually is :P

I retroactively appreciated it when I noticed how much of a win dead code elimination was :-)

dead ones, I hope

masak: http://research.swtch.com/2010/12/yacc-is-not-dead.html

actuallly, speaking of dead channels, I don't think I've seen someone even post a message in #perlnewbies for a few months

But even that's dead now.

Yacc is dead: http://arxiv.org/abs/1010.5023

by the way, am I the first person to notice the totally brain-dead API of Test.pm? 'multi sub todo($reason, $count)' but 'multi sub skip($count, $reason)'. wtf?

Test.pm is pretty brain dead in general

Nobody is to let RMS learn that! THE SECRET STAY HERE. Anybody who tries to tell him, is dead!

ah--yeah... that is a dead horse to beat. As we have run() already capable of doing eval stuff in this program.

I just finished cleaning up some dead code from one of my $work projects: 1200 lines of code deleted!

but it is a dead end, and all those jits and trace based compiler efforts prove that

muixirt: your statement is dead wrong, see what I wrote above

if jnthn is dead we're all screwed

my battery's getting dead

I look at the deadline soon

mu: 4adeadd | sorear++ | misc/dalek-conf.json:

mu: review: https://github.com/perl6/mu/commit/4adeadd1a7554feb8ae804f1298be9f973afa7f2

nice post by draegtun++ that I hadn't seen before: http://transfixedbutnotdead.com/2010/10/31/perl6-metaprogramming-update/

please do it ASAP as the dead-line is oevr 2 weeks ago

it's a dead end

It's dead and gone now but the site still up

6model: review: http://github.com/jnthn/6model/commit/fd172283279114dead7fb60ec09634e1643375d8

"Imagine you're landing on an aeroplane and the automatic pilot's working," he suggests. "If it divides by zero and the computer stops working - you're in big trouble. If your heart pacemaker divides by zero, you're dead." Isn't that why IEEE has it equal Inf instead of an error?

it may be a bad assumption -- could be the GC isn't doing a good job of deleting dead variables

masak: Seven years between X11R5 and X11R6 was pretty bad, people started claiming that X/X11 «is dead», that the concept itself was dated, that a new and perhaps incompatible release would not work out, etc.  People also seem to agree that the X11 model is fundamentally flawed, but at a loss when asked to provide a functional alternative.  :)

but "Out of the box" no, you're dead wrong

deadly slow so far.  :(

it's a lot faster because it is easy to knock out dead ends

I need to find a place for my perl blog, though. I see "use perl;" is dead :(

shortcircuit: please tell us he's not dead

Juerd: afaict blazar is dead

http://transfixedbutnotdead.com/2010/08/30/givenwhen-the-perl-switch-statement/ i think i read it wrong, let me re-read that article

ash_: try.rakudo.org is dead :(

a finalized parrot would be a dead parrot. would still have lovely plumage though.

Now I feel the need to write the Parrot/P6 version of the dead parrot sketch...

well the "viv" STD-based reference parser used by various other compilers link is dead

rakudo: [build] release should not rely on dead pugs svn. Quick and ugly Unix-only hack.

Reading from dead slave at persist.pl line 82

Reading from dead slave at persist.pl line 35

phenny, tell sorear "wonders if a non-executing class hierarchy extractor would be useful"... Sounds good for documentation. Also anything that moves us closer to being able to do static code analysis and dead code detection would be useful. Notes Alias' blog post on "Why Perl6 scares the hell out of me" (http://use.perl.org/~Alias/journal/35508)

sorear: 13:37Z <ggoebel> tell sorear "wonders if a non-executing class hierarchy extractor would be useful"... Sounds good for documentation. Also anything that moves us closer to being able to do static code analysis and dead code detection would be useful. Notes Alias' blog post on "Why Perl6 scares the hell out of me" (http://use.perl.org/~Alias/journal/35508)

niecza: Simplify NewBoundVar now that Bind is dead

TimToady: linguistically, I'd say "choose" implies "choose one" rather than "choose until you drop dead"

But it's not dead yet.

if not, it still tracks the dead pugs svn

rakudo 9993bb: OUTPUT«Cannot resume dead coroutine.␤  in 'Any::join' at line 1␤  in 'List::Str' at line 2558:CORE.setting␤  in 'infix:<~>' at line 7033:CORE.setting␤  in <anon> at line 154:CORE.setting␤  in <anon> at line 1␤  in 'List::Bool' at line 1␤  in 'prefix:<?>' at line 416:CORE.setting␤  in

mberends: 10 Sep 12:11Z <masak> tell mberends that if he plans to submit OSDC.fr talks: deadline falls today.

.oO( when you execute an autopun with a deadpan expression, is it called an "autopan"? or a "deadpun expression"? )

phenny: tell mberends that if he plans to submit OSDC.fr talks: deadline falls today.

rakudo: Remove dead check_invokable() code from perl6multisub.pmc .

unfortunately, I have no windows anywhere and my virtualbox is dead for some time

"[perl #76438] peephole optimiser could prune more dead code"

Anyway, going with C blindly is also bad, there's a lot of stuff that's undefined in C that was done to appease certain platforms back in the 80s, those platforms are now dead and nobody cares.

it should make the end case dead easy.  :)

am I dead?

"Cannot resume dead coroutine"

I am innocent! It was dead when I walked in!

but Mu isn't dead

is u4x dead or just moved?

I hear there's perlmongers in sfbay, but I ran into a few dead ends when looking, iirc.

in the event i detect a dead subprocess, i am adding a message

rakudo: say :16<deadbeefcafef00dbabe>

point is :10($anything) works if $anything is :16<deadbeefcafef00dbabe>

multi sub base(0, $b) { '' }; multi sub base($n, $b) { base($n div $b, $b) ~ substr("0123456789abcdefghijklmnopqrstuvwxyz", $n % $b, 1); }; say base(:16<deadbeef>, 8);

rakudo: multi sub base(0, $b) { '' }; multi sub base($n, $b) { base($n div $b, $b) ~ substr("0123456789abcdefghijklmnopqrstuvwxyz", $n % $b, 1); }; say base(:16<deadbeef>, 8);

moritz_: i now have the server using the rakudo repls working now, i only have 1 last thing to finish up, cleaning up dead sessions, then i'll be ready to update try.rakudo.org

Cannot resume dead coroutine.

a red-handed "Cannot resume dead coroutine" would be great.

===SORRY!===␤Cannot resume dead coroutine.

so far it's deadly slow

is perl6-examples dead? ;f

seems dead

(my connection to feather is still dead)

all the dead brain cells make room for more concrete

sorear: it's already been declared dead, at least on #perl6

(yes, this reference is older than Perl itself and uses examples in a language which is beyond dead...)

Tene: try it. it's dead simple.

svk is dead, iirc

jnthn: well, I plan to do the operators and then lay it down. I won't even need tomorrow, despite the deadline being 19:00 UTC.

what is: Cannot resume dead coroutine.

anyone (jnthn) seen this: Cannot resume dead coroutine.

barewords are dead, yes?

I'm alive, but dead tired :) good night! :)

it is afeter the dead line already

is the bot dead?

rakudo: my $a = "Boo FAA"; if $a !~~ / (Boo)\s(FA) { say $1 } / { say "I'm dead!"; };

we had an 'each' for quite a while, but it was a junction-y affair. moritz_++ killed it almost completely dead.

kthakore: not recently, it was sometime back. I was amazed at how you brought back a (nearly) dead project. :)

isBEKaml_: nothing is dead when it has code publicly available

pmichaud: right -- the schedule for this is really outside TPF's deadline tomorrow, I guess.

tpf deadline?

so there's no "deadline"

.notdef isn't dead yet?

isn't that list dead dead dead? =-)

Is Perl 6 dead yet?

rakudo 7f5c22: OUTPUT«Cannot resume dead coroutine.␤  in 'Any::join' at line 1␤  in 'List::perl' at line 2557:CORE.setting␤  in <anon> at line 22:/tmp/36DxD8nLx7␤  in <anon> at line 1␤  in 'Any::join' at line 1␤  in 'List::perl' at line 2557:CORE.setting␤  in main program body at line

rakudo 7f5c22: OUTPUT«Cannot resume dead coroutine.␤  in 'Any::join' at line 1␤  in 'List::perl' at line 2557:CORE.setting␤  in <anon> at line 22:/tmp/PC_EjQyHIL␤  in <anon> at line 1␤  in 'Any::join' at line 1␤  in 'List::perl' at line 2557:CORE.setting␤  in main program body at line

rakudo 7f5c22: OUTPUT«Cannot resume dead coroutine.␤  in 'Any::join' at line 1␤  in 'List::perl' at line 2557:CORE.setting␤  in <anon> at line 22:/tmp/LwpyMvBLAj␤  in <anon> at line 1␤  in 'Any::join' at line 1␤  in 'List::perl' at line 2557:CORE.setting␤  in main program body at line

but yeah, I'm not sure why we'd get the dead coroutine issue there.

PerlJam: sure, the naysayers are more broadly distributed than just p5, but there's a point to be made that perl 5 isn't dead either.

cons is dead

ponie is not dead

sorear: who would want to hack on a dead-end branch of rakudo?

masak: if you just want a tree, rather than deparsed output, viv is entirely dead weight

no, it's based on File::Find, without the brain-dead interface

moritz_: I got the invitation, but the link for setting the password seems dead

parrot --hash-seed=deadbeef /path/to/perl6.pbc program.pl

rakudo 278366: OUTPUT«Cannot resume dead coroutine.␤  in 'Any::join' at line 1␤  in 'List::perl' at line 2528:CORE.setting␤  in main program body at line 22:/tmp/eJhgHd3XUU␤»

rakudo 278366: OUTPUT«Cannot resume dead coroutine.␤  in 'Any::join' at line 1␤  in 'List::perl' at line 2528:CORE.setting␤  in main program body at line 22:/tmp/ap4qCsJ32q␤»

Yes, but there's this weird and wrong idea that Perl is dead.

perl5 wont be dead for atleast 100 years. but Im afraid perl6 will.

Is PGE dead yet?

so is <foo> picking up lexicals now officially dead?

beats a dead horse

PerlJam: that is also probably dead for now

ingy: maybe that's "deadly"?  :>

rakudo 3370f0: OUTPUT«Cannot resume dead coroutine.␤  in 'Any::join' at line 1␤  in 'List::perl' at line 2528:CORE.setting␤  in main program body at line 22:/tmp/tP945QDNyS␤»

the only way Rakudo Star fails is if Perl 6 becomes a dead language.

tylercurtis: I would, but I have deadlines on my own... I can offer my assistance as far as proofing goes, but I think I need actual tuits for things like enums in Rakudo, the GSoC work, and the book.

pmichaud: I think the Q2 2010 cards were before y'all set the July 29th date ... if you'd like I can revert back to Q2 but it looks reasonably like you'll hit your deadline :)

There's some nasty deadlock in the kernel, something with mdraid and dm.

"cannot resume dead coroutine"

I dimly recall that macos x preserves decomposed normal form of umlauts entered with dead keys

STD-dist is dead

the crickets around here are all dead.

rakudo d51e99: OUTPUT«Cannot resume dead coroutine.␤  in 'Any::join' at line 1␤  in 'List::perl' at line 2522:CORE.setting␤  in main program body at line 20:/tmp/d9x_Y7gxGI␤»

I thought explicit refs were dead?

===SORRY!=== Cannot resume dead coroutine. here

locally gives "Cannot resume dead coroutine."

"cannot resume dead parrot"

notdef is dead for a month or so now

Cannot resume dead coroutine.

I should also mention EBCDIC, IBM's ASCII competitor, which was origenally intended to be a compatible extension of the old (pre-1900) punch card formats, but they managed to invent six versions of it that weren't even compatible with *each other*... luckily this is dead now

javascript does, but a brain-dead browser does not

is := dead yet

Cannot resume dead coroutine.

it should really say, "cannot resume dead parrot coroutine"  :)

"cannot resurrect dead norweigan blue parrot coroutine"

it's boxes with (dead|alive) cats, all the way down.

"Perl is dead."

but they can be dead code

alright, I won't beat the dead horse, then

Nietzsche declared that God is dead. Perhaps Niecza will declare Perl5 to be dead ;-)

FakeDBI is dead. Long live MiniDBI ! (well, not too long ;)

phenny: tell hmmm pugs has been effectively dead for >1 year.  There are more recent releases, but only to track incompatible changes in GHC Haskell

the only reason i have tried using rakudo with cgi is cgi is dead simple

pmurias: CORE.lex is dead and gone, you can't obtain it

std: 0xdeadbeef;

backtracking is braindead easy when it just involves throwing away a cursor from the front of the list

mberends: no, I'm trying to keep a deadline today. ;)

BinGOs: Maybe that's the acceptance deadline. :-)

gimme5 is dead and gone

std: 0xdead_beef_1337_cafe

rakudo: my Str $s = "0xdeadbeef"; say $s.sin;

feels like he's stepped through the looking glass, where his simple attempt to eliminate what should be dead code has lead to nightmares...

std: 0x_dead_beef

std 31325: OUTPUT«�[31m===�[0mSORRY!�[31m===�[0m␤Whitespace is required between alphanumeric tokens at /tmp/RJjIcwt5A6 line 1:␤------> �[32m0�[33m⏏�[31mx_dead_beef�[0m␤Whitespace is required between alphanumeric tokens at /tmp/RJjIcwt5A6 line 1:␤------> �[32m0x�[33m⏏�[31m_dead_beef�[0m␤Undeclared

Yeah, I see that, but AFAICT it's a dead store.

is ponie not-dead now?

Tene: One ponie is dead

EvanCarroll: ponie is long dead, and I don't know of anybody working on it in recent history.  The current work is embedding perl5, which is working to some degree now.

so I plan to kill dead most of the preferences proto has.

but it's not a hard deadline.  we'd rather be right than on-time.

a hard deadline would be end-of-july.  I can't see any reason for us going beyond then.

TimToady: I've read that some commercial static analyziers (coverity, iirc) removed some concurrency related checks (like dead locks, race conditions) simply becasue they were too hard to explain to the casual programmer

but you know how version releases just .. tend to stretch over deadlinse :>

I suppose that's a good thing though. To be a saint, you'd have to be dead for 5 years...

csmeta: [perlesque] a known working state, I think.  still lots of dead/wip C#

that's okay, I'll probably keep making appearances after I'm dead too...

it's providing me with something to look at that isn't a brain-meltingly strange deadlock

but renaming Perl 6 to something else might make it clearer to uninitiated that Perl 5 isn't a dead-end.

after gimme5 is dead I'm looking forward to doing a proper refactor of RE_ast

the ESR quote at http://en.wikipedia.org/wiki/Plan_9_from_Bell_Labs#Impact is interesting from a Perl 6 perspective as well. Perl 5 may ultimately be a 'dead end', but it's a quite successful one. :)

Copyright (2054) Larry Wall, you may use this if I'm still alive, or if you're dead...

It's an awesome license, and it smells faintly of dead parrots and silly frenchmen :)

rakudo 10a321: OUTPUT«Cannot resume dead coroutine.␤current instr.: 'perl6;GatherIterator;get' pc 582331 (src/gen/core.pir:102521)␤»

but on average, Parrot is much less dead nowadays than a year or two ago.

slavik: prefix:<=> is dead, long live .get

http://dev.pugscode.org/wiki/ seems to be dead. (linked to from perlcabal.org)

is planet dead?

moritz_: do you think that patch is worthwhile, or a dead end?

as usual, I make some hidden assumption that is dead wrong and blinds me :(

Oh, I think $() is dead anyway - is it still mentioned in S05?

is getting really annoyed that whenever he comes to #perl6 lately, it's dead silent.

masak: he hoping for the same reasons that perl 6 will hopefully be a dead born child. ;)

mutablevar.pmc appears to be entirely dead code in rakudo

isn't SVK dead?

It isn't dead if people are using it.  (I have no idea if people are using it)

what if only dead people are using it?

[Coke]: Just make sure to publish it in dead-tree format, to satisfy wikipedia's fetish with wood and ink.

hates the fact that it's always dead when he can get online :/

rakudo 3d3893: OUTPUT«Cannot resume dead coroutine.␤current instr.: 'perl6;GatherIterator;get' pc 563264 (src/gen/core.pir:97964)␤»

rakudo 3d3893: OUTPUT«Cannot resume dead coroutine.␤current instr.: 'perl6;GatherIterator;get' pc 563264 (src/gen/core.pir:97964)␤»

rakudo: Add dead simple preliminary implementation of Sop, and turn on the only test we were able to find for it.

slavik: there are two projects to support "perl5" as a Parrot language.  PONIE, a port of the P5 compiler to generate Parrot code (is dead, needs >5 man-years to revive), and blizkost (autothunks Parrot calls into libperl.so, mostly works)

TimToady: The other nice thing is that you don't hold the lock. Just manipulate the copy and then the briefest of locks to sync it back. No possibility of deadlocks.

Irc on my phone... I wonder what this does when I go through a dead spot.

somehow that reminds me of "Perl is dead" - "Perl is alive and kicking" :-)

p6eval being dead-ish

sorear: I seem to be going senile in my advanced age </deadpan>

IllvilJa: in a channel where development, newbie questions and frivolous OT conversation is signal, one person's persistent beating of one dead horse is noise.

Whoever this Rolf (LanX) is, that discussion subthread is counter-productive.  Kudos to pmichaud++ for trying to keep up, but I think it's a dead end.

moritz_: when's the hard deadline on the book?

well, once the nerves are all dead, you don't feel it anymore

but the contextual implementation is so brain-dead easy (because of the multi-stage compilation in csmeta) that it could be done just as easily in perlesque.

diakopter: the reason Perl 6 isn't 6.0.0 yet is not because we haven't set enough deadlines.

IETF, by the way, does accept April Fools RFCs (with a deadline and all that)

can the proposals be changed after the submission deadline?

Ponie is a Parrot/Perl5 bridge.  Ponie is dead.

UTC is the dead-simple time zone to use when doing datetime arith.

jnthn: pinging dukeleto is important given how close to the deadline for student apps we are.

deadline is  the 9th, so 2 days from now

ingy: I didn't pay attention to any of the YAPCs this year, but the last couple of years I recall that the deadline for CFP was extended because the timeline was originally quite short.

it's dead simple date-only arithmetics

hello everyone! I learnt about GSoC deadline just today. Is it too late to try to apply?

twigil: it's only too late when the deadline closes :-)

rakudo: my @x = 1..Inf; say "dead"

Oh, sorry. I've not been following the channel much today, so I didn't realize it was that dead a horse

rakudo e50ff8: OUTPUT«Cannot resume dead coroutine.␤current instr.: 'perl6;GatherIterator;get' pc 465380 (src/gen/core.pir:74369)␤»

'dead coroutine'!

rakudo e50ff8: OUTPUT«Cannot resume dead coroutine.␤current instr.: 'perl6;GatherIterator;get' pc 465380 (src/gen/core.pir:74369)␤»

rakudo e50ff8: OUTPUT«Cannot resume dead coroutine.␤current instr.: 'perl6;GatherIterator;get' pc 465380 (src/gen/core.pir:74369)␤»

should stringifying that really result in a 'Cannot resume dead coroutine'?

rakudo e50ff8: OUTPUT«Cannot resume dead coroutine.␤current instr.: 'perl6;GatherIterator;get' pc 465380 (src/gen/core.pir:74369)␤»

rakudo e50ff8: OUTPUT«Cannot resume dead coroutine.␤current instr.: 'perl6;GatherIterator;get' pc 465380 (src/gen/core.pir:74369)␤»

rakudo e50ff8: OUTPUT«Cannot resume dead coroutine.␤current instr.: 'perl6;GatherIterator;get' pc 465380 (src/gen/core.pir:74369)␤»

rakudo: say "dead or alive?"

Opera removed the postings for the internships I wanted to apply for on the day of the deadline

lichtkind: Though I didn't submit yet. Guess deadline isn't for a little bit?

with an AST you can do some constant folding, you could do dead code elimination, you could do some type inference too

Is cabal dead?

rakudo: say :16<dead_beef.face>;

Oh zarking, I'm in the year 3095. Better leave... (good thing I have pandimensional wireless, or else I'd be messaging a dead Freenode server :))

for compilers (be it as they may) there is rakudo and pugs which i undestand is dead

sorear: it's not very active, but it's not yet dead

cron is definitely dead though, so it won't make backups

feather2 and 3 are dead. That means I'm not going to wait the 60 minutes after all.

[OFF] we're discussing parrot's stone-deadedness :)

Robin Milner is dead :(

then chuck norris extended the deadline to infinity

So basically it's a necromeme that just became undead?

jnthn: infradead. :)

awakes after 2 hours of sleeping like dead

rakudo 0bb373: OUTPUT«Cannot resume dead coroutine.␤current instr.: 'perl6;GatherIterator;get' pc 427377 (src/gen/core.pir:67628)␤»

rakudo 0bb373: OUTPUT«Cannot resume dead coroutine.␤current instr.: 'perl6;GatherIterator;get' pc 427377 (src/gen/core.pir:67628)␤»

the dead coroutine seems to be a new failure mode

rakudo 7ccf14: OUTPUT«Cannot resume dead coroutine.␤current instr.: 'perl6;GatherIterator;get' pc 421734 (src/gen/core.pir:65403)␤»

or maybe the list is dead

> say :16<dead_beef*16**8>

> :16<dead_beef*16**8>

I'll take a stab at it right now, because it's a dead cinch I'm not getting a big project done today.

I missed the Iron Man deadline, though, but right now I don't care too much.  ;)

Teratogen: yeah, it's not ready for production use yet, and there is no set deadline

masak: deadline was today :)

not just deadlines

the concept of deadlines is quite alien in #perl6, unfortunately. Idealism rules here :/

spinclad: you were remembering polyglotbot that supported perl6-parse: and friends.  polyglotbot is sadly dead.

Tene: polyglotbot dead:  :,(  *snf*  let me lift a cup of ... well, tea ... to its memory.  i'll miss that feature, rarely used tho it was.

I suppose "next week" is also the deadline for R* stuff

i got stopped dead in my tracks writing an ebnf front end for pge years ago

wallberg: no, I didn't leave! my wifi got dead... :/

#= is already dead, as far as I'm concerned

that would be undead then

is qw// dead and replaced by <>?

Perl 6 isn't dead??

pugs is dead.

why not? open source developers aren't machines churning out projects on a deadline.

TimToady: see above re bound/unbound lists, and let us know if you think it's a promising avenue to pursue or a likely dead end.

I guess that's dead code (but for junctions, it's a not found method, so we try to auto-thread it...)

pmichaud: Yay. Ripping out that dead code seems to have had no effects, as you'd hope. :-)

...this is the dead?

k. just wondering if you were referring to the old parrot wiki on the TPF, which should be dead.

ruoso: but it will definitily be done till 26th (deadline on a university project i'm going it as a part of)

dead people have the best stuff

hey look, PURAMU is a social media manager from Arizona and he says in his article that Perl is dead http://it.toolbox.com/blogs/puramu/perl-is-dead-12264

i.e. dead :)

the 'perl is dead' meme is dead.

jnthn, colomon; glad to help. cutting a release is now pretty braindead.

found a pesky deadlock!

locks the OT topic dead

timtoady deader: ( no output )

masak: you never see the Monty Python dead parrot sketch, have you?

lue: no, some are dead simple.  :)

diakopter: yeah, that too. :) but I was referring to features. the one I just submitted, with prefix:<?>, ought to be dead simple. g'morning.

which reminds me, we should put a deadbeef method into Num :)

ng: say 0xdeadbeef;

ng: say 0xdeadbeef.deadbeef

ng c11b42: OUTPUT«Method 'deadbeef' not found for invocant of class 'Int'␤current instr.: '_block14' pc 29 (EVAL_1:0)␤»

what would the deadbeef method do?

ng: say 0xdeadbeef.?deadbeef

ng: my $result = 0xdeadbeef.?deadbeef; say $result

rakudo: my $result = 0xdeadbeef.?deadbeef; say $result

rakudo: my $result = 0xdeadbeef.*deadbeef; say $result

r29684 | jnthn++ | [t/spec] p5=> is dead.

or the sound deadlines make when they woosh by. :D

speaking of docs and deadlines, I've recently felt an urge to become really productive with the u4x contents.

but hopefully dead easy to fix

SF: no, $ARGS prompts('Search? ') is definitely dead. note that there is an implicit 'is' there, and that implicitness is also dead. TimToady conjectures in E02 that it'd be $ARGS.prompt or something like that. but I don't think that's in the spec.

Perl 6: The Perl is dead, long live the Perl

might just have fallen in love with git... that was dead easy.

# is that correct according to the spec? I feel like i am beating a dead horse but i am still confused by list context a bit

ash_: no, I just made a dead simple test file.

jnthn: the good news is the grep code itself is dead simple.  :)

Morning all.  Has promised I posted my perl6 followup (last night):  http://transfixedbutnotdead.com/2010/01/14/anyone-for-perl-6-metaprogramming/

isn't this something where a rakudo example blogged would nicely fit in? http://transfixedbutnotdead.com/2010/01/13/anyone_for_metaprogramming/

draegtun: then you're encouraged to reply to http://transfixedbutnotdead.com/2010/01/13/anyone_for_metaprogramming/ :-)

btw:  draegtun == transfixedbutnotdead :)

moritz_: http://transfixedbutnotdead.com/2010/01/13/anyone_for_metaprogramming/

I think I've missed to 10 days deadline for the ironman anyway

Actually, I'll know I'm old when I'm like my grandfather just before he died (at age 89).   All of his friends were dead and the people he tended to have conversations with were the sons or daughters of the people he knew)

But my client logged me into #perl6 twice just now, then lost one of the connections, then when I tried to close the connection that was dead, closed the live connection instead.  :(

deadlines have a wonderful effect of focusing the mind on what's important.

it is a pity that the Perl 6 development process has few deadlines. I'm glad the April deadline for Rakudo * is focusing some minds.

oh, I like deadlines. I just don't like starting with the project when the deadline is already in sight :)

no, the procrastinators have deadlines very far way.

for me, the spec's were a bit more technical than i could easily comprehend, the perl 6 book helped me with perl 6's regex's the most, now i sound like i am beating a dead horse or something

businesses like dependable timescales, Perl 6 regards completeness as more important than deadlines, so that is less good for business

to be more clear, I meant "who regards completeness as more important than deadlines"?

perl5 certainly not, no. it's noth dead, but it doesn't seem to be on the rise again either. at least not here.

now, notes.txt brings up the possible risks of keeping the spec in flux. notably that there's no hard deadline, and what takadonet brings up, that people perceive Perl 6 as "not stable".

masak's dead right in terms of speed and stability, I think.

colomon_: I'd be interested to hear more about your doubts about Rakudo Star. myself, I'm worried about ng, but I'm not yet ready to doubt the Rakudo Star deadline.

rjbs: dead to rights

I still believe we can make it for the Rakudo Star deadline.

how cumbersome it was to express things that are dead simple today, before the invention of the zero, or the x^2 notation, or the equals sign.

I noticed a python bot that just drops dead on one channel when this happens

http://lastofthecarelessmen.blogspot.com/2009/12/good-thing-perl-is-dead.html something along these lines might also work (much humour)

mberends: I meant "channelling". I thought of writing "channelling the dead ghost of APL", but that felt like going a bit too far.

yes because then the deadline arrives

mathw: I think it's on the hard drive of my dead laptop.

in parrot, is there an easier way to print a hash in a way to see its contents? using say just did: Hash[0xdeadbeef]

I've been landed with another deadline for some stuff I actually get paid for, so...

Anything that iterates is dead dog slow in Rakudo.

Hey, maybe Win32 is dead when Rakudo * is released?  :D

like, car batteries citizens think are dead, but just need a recharge and could be sold 2nd hand

"we must be in the dead sea, b/c rocks float"

cries, as the machine that he had unicode all setup on is now dead, so he's stuck with ?'s again. =-)

moritz_: eh. I'll focus energies on resurrecting the dead machine.

actually, problem would be that @a would kill ng dead.

in any case, battery dead and 0210 local -> bed

deadbeefcafef00dbabe

phenny: tell Wolfman2000 that November isn't on Web.pm yet. plan to migrate it in the next few months, though. whether Squerl, Astaire et al can be used effectively at this point remains an open question. my hunch is that they will shrink the codebase of November (by removing insane hacks), and not make it deadly slow or unreliable in the process.

Wolfman2000: 02:14Z <masak> tell Wolfman2000 that November isn't on Web.pm yet. plan to migrate it in the next few months, though. whether Squerl, Astaire et al can be used effectively at this point remains an open question. my hunch is that they will shrink the codebase of November (by removing insane hacks), and not make it deadly slow or unreliable in the process.

jnthn: yes, but I'm dead tired. it's past my bedtime.

TimToady: try running the code indead :)

Well, maybe I'd know enough people to hold me over water ... but having to race from one to the other, with all having the same year-end-deadlines build a bit of stress, I think

the fact that someone even feels the need to say "Python’s not dead people." feels comforting in some way. so it's not just the Perl community which goes around doing that.

One of these days, I tell you, one of these days, one of them is going to try to do something other than study dead languages.

not many people know it, but Ruby started dying the day DHH released Rails, and it has been successively dying since. Python was dead already in 2002, but no-one noticed.

masak: I'd be careful with that comment about Python already dead...

Wolfman2000: just to be clear, I wasn't 1% serious about Python/Ruby being dead.

Write a post called "Perl 6 isn't dead, but Ruby/Python are Mü"

mathw: start a "PHP is dead" meme  or "Java is dead" see how long you can keep them going.

But plz not undead.

good morning :) as a fellow long term NIH sufferer, it was comforting to read what diakopter++ wrote about his experience of the affliction. #perl6 does seem to be a kind of safe haven for such people. NIH is infectious for the same reason as gambling addiction: it sometimes works, and then it pays BIG. There is also a treatment, but those in denial about the disorder refuse to take it: strict deadlines.

reimplementing perl 5 on parrot is a *hard* task.  years ago, there was an effort called 'ponie'.  it's dead.  now, we're looking at integrating perl 5 with parrot, in a project called 'blizkost' (if i've spelled that correctly)

missed the midnight deadline. bah.

(one that's not dead)

qp_pq, you should get some sleep before you drop dead

there is also the off chance that I'll hit that combination of deadly-tiread and can't-sleep...

PerlJam: bad p6 name will make p6 dead, good name will make p5 unhappy...

and   dead.beef  into   0xdeadbeef / 65536  :-)

(assuming base 16 on "dead.beef")

pushing it back behind a technical deadline isn't a good plan

personally, I think there's just far too much Perl 6 activity taking place for a dead language.

Perl is dead.  Long live Perl!  (oh wait, we've already been there)

I thought it wasn't dead after all :-)

r29057 | colomon++ | [t/spec] Delete dead trig.t tests.

book: review: http://github.com/perl6/book/commit/43015deadd20808b41e864d362303be15bc188df

In other news...I've been given a deadline for the Perl 6 Pastebin website I've been working on with others in here.

I think dcantrell wanted to get a VMS CPAN smoking machine and I told him "Over my dead body."

We almost nailed mst last week, I see.  He was only about 16 hours from falling short of the absolute 10-day deadline, muahaha.

frettled: I have a feeling (based on what he's written in some blog posts) that he is very well aware of such deadlines.

is there an easy way to see when I last missed some deadline for the ironman thing?

moritz_: it should change to a Paper Man if you miss a deadline.

and it also doesn't tell me when I last missed a deadline

Juerd: oZ] is my unofficial coach when the main catalyst room is either dead or dumbfounded by my questions.

or "Perl 6 is dead!"

I was dead tired yesterday, after playing with sleep a bit.

"Perl 6 is dead."

"Perl 6 is dead."  :-)

i.e. future Perl, dead Perl

if someone believes that Perl 6 is an evolutionary dead end, then they'd be perfectly correct that Perl 6 is a branch and that Perl 5 represents the mainline

I'm sorry to inform you that Perl 6 is dead.

Really, it's dead. #perl on magnet says so.

You, my friends, are working on a dead language.

masak, Juerd: you guys both realize I don't think Perl 6 is dead, right?

Wolfman2000: I don't think many people in this channel think it is dead.

...then who thinks Perl 6 is dead?

Besides: normal support channels went dead awhile ago.

http://transfixedbutnotdead.com/2009/11/08/best-things-in-life-come-in-threes/ lovely

This layout has dead keys in the right alt, and now esperanto letters too.

PerlJam: I want industrial-strength perfection, without all the intermediate steps of bugs and dead ends.

frettled: the old joke is ultimately a dead end too.

masak: you mean all of the dead ones? ;)

In case you're wondering why feather's unreachable: our fiber uplink is dead :(

what they got right was making it dropdead easy to get started

And if we end up passing the spec tests with some stuff still left in there, well, we found dead code. ;-)

nqp-rx: review: http://github.com/perl6/nqp-rx/commit/a669f199e640a1e631249cb30ca59d14dead6c95

if it belongs to another project, we should probably stop dead in our tracks...

and requires that you have "healthy" sleeping habits, not dropping dead into bed at the end of the day

Is feather dead?

diakopter, do you have any (non working) code to show? I'm dead curious how it looks...

I don't commit crud willingly, or by default. things such as deadlines or a wish to release early might change that default.

Well, the type rules are dead easy for the most part.

but pmichaud++ has never, as far as I know, been vastly wrong about deadlines before, so I trust him.

does anyone know: is pugs dead?

that was my [probably dead wrong] thought, yeah

sjohnson: just myopic.  The web is the biggest new platform in the last 15 years.  If you're not dominating the most recent platform, you're dying or dead.

"ooo Perl; it's so dead it's *ghostly*"

moving stuff out of the pugs repository is not a bad idea.  People thinks pugs is dead so don't look in that repository

r28344 |     :by is deemed Too Ugly and is now dead, David Green++

makes closures braindead easy

so you'd end up with -> $b { say SOMEMAGICdeadbeef::<$a>, $b } for the lexical $a

if you see that deadbeef isn't hte same as deadface

So, for example, ~ could have '5' and .perl could have deadface::

my twitter account is um... dead, it gets update from an iphone app that records how long my jogs are and thats all thats on my twitter account right now

http://yaml.org/ says JsYaml, but it's a dead link

hm. I could blog about it. I'll just need to clean up a bit and get rid of the deadline cruft. :)

We should asymptotically approach 100%, never quite reaching it until the language is dead.

SWMBO is requiring me to go take a walk so I don't drop dead

i was under the impression that "finished" only applies to languages in the sense "dead"

rakudo: say "I'm not dead yet!"

rakudo 09b954: OUTPUT«I'm not dead yet!␤»

masak, indead many of these games are representable by a graph and it is probably some interesting challenge to generate such graphs

we're working on a deadline nowadays.

perl6: say :16<dead.beef>

perl6: say :16<dead_beef>/:16<10000>

rakudo: say :16<dead_beef>

Do you have deadline until the release?

COBOL and fortran is "almost" dead, many people prefer to learn other languages instead of COBOL and fortran

does windows support compose key?  I'm vaguely aware it supports dead keys

I am deadly serious

oh dead...

rakudo: say :16<dead_beef.face>;

rakudo: say :16<dead_beef>;

r28162 | colomon++ | [t/spec] Fixed dead_beef.face, prior version relied on div of two integers producing a fractional number.

isn't he dead?

the ponie effort was premature and was declared dead at one point

Tene: That's one of those business decisions I have trouble understanding sometimes.  If they have something that works in perl, why change?   (unless they honestly believe perl is dead)

If they're having trouble finding perl programmers, then perl is dead in their area.

there are a few ways to troll - using a dragnet, using bare hooks hoping to snag/gore a fish, or using non-trolling fishing techniques such as lures (prey replicas) with hidden hooks or bait (dead actual prey) with hidden hooks. and i'm sure others.  Great analogies to online troll patterns.

er, yeah, if you have reason to believe the connection might be dead

I think it'll be a bit hectic before April. some of my projects have April as an implicit deadline too, now.

sjohnson: it's been dead for a while

_why isn't dead to my knowledge :)

ins is dead

So I was under the impression that pugs was dead?

as a perl 6 compiler, it's dead.

rakudo: class A { has @.array; method postcircumfix:<[ ]>($n) { "15 $n on a dead man's chest" } ; }; my $a = A.new(a => 1..5); say $a[0];

rakudo 0d4fe0: OUTPUT«15 0 on a dead man's chest␤»

jaffa8, The only way improvement ends is when a project is dead.  Live projects change.  In fact, on computer projects of all forms, "Maintenance" is where the *vast* majority of changes happen.

Really! I thought it was dead. This is interesting news :)

i think pugs is easier to recognize, but.. is it dead currently?

Would you think that I should start now in Perl6, or that this will be a dead end?

(for those missing the joke, the biologists word for stable is "dead")

stable = dead... he he he

frettled: and the horses are dead, yes?

Flogging dead horses: http://www.sucs.swan.ac.uk/~cmckenna/humour/work/horse.html

the deadline (and it is really a deadline of sorts for Rakudo *) is january 2010 for protoregexes/ltm

extend the deadline to xmas

masak, will do.  It will probably have to wait until August is over; immovable $work deadlines.

rakudo: my @zombies = 1..666; say "I see "~+@zombies~" dead people!";

rakudo a5dfe9: OUTPUT«I see 666 dead people!␤»

rakudo: my @zombies = 1..666; say "I see {@zombies.elems} dead people!"; # ;)

rakudo: my @zombies = 1..666; say "I see "~@zombies.elems~" dead people!"; # ;)

rakudo: my @zombies = 1..666; say "I see "~ +@zombies ~ " dead people!"; # ;)

rakudo: my @zombies = 1..666; say "I see "~ +@zombies ~ " dead people!";

rakudo: my @zombies = 1..666; say "I see" ~+@zombies ~"dead people!";

rakudo: my @zombies = 1..666; say "I see" ~ +@zombies~ "dead people!";

rakudo: my @zombies = 1..666; say "I see" ~ +@zombies~"dead people!";

rakudo: my @zombies = 1..2; say "I see "~ +@zombies ~ " dead people!"; # ;)

rakudo a5dfe9: OUTPUT«I see666dead people!␤»

rakudo a5dfe9: OUTPUT«I see 2 dead people!␤»

rakudo: my @zombies = 1..666; say "I see {@zombies.elems} dead people!"; # ;)

rakudo a5dfe9: OUTPUT«I see 666 dead people!␤»

rakudo: my @zombies = 1..666; say "I see @zombies.elems dead people!"; # ;)

rakudo a5dfe9: OUTPUT«I see @zombies.elems dead people!␤»

rakudo: my @x = 1..6; say "I see " ~ +@x~" dead people!"; say "I see " ~ +@x ~ " living people!";

rakudo a5dfe9: OUTPUT«I see 6 dead people!␤I see 6 living people!␤»

rakudo: my @zombies = 1..666; say "I see" ~+@zombies ~"dead people!";

rakudo: my @zombies = 1..666; say "I see" ~+@zombies~"dead people!";

rakudo: my @x = 1..6; say "I see" ~ +@x ~ "dead people!"; say "I see " ~ +@x ~ " living people!";

rakudo a5dfe9: OUTPUT«I see6dead people!␤I see 6 living people!␤»

rakudo: my @zombies = 1..666; say "I see "~+@zombies~" dead people!";

rakudo: my @x = 1..6; say "I see "~+@x~" dead people!"; say "I see " ~ +@x ~ " living people!";

rakudo a5dfe9: OUTPUT«I see 6 dead people!␤I see 6 living people!␤»

rakudo: my @x = 1..666; say "I see "~+@x~" dead people!"; say "I see " ~ +@x ~ " living people!";

rakudo: my @x = 1..6; say "I see "~+@x~" dead people!"; say "I see " ~ +@x ~ " living people!";

rakudo a5dfe9: OUTPUT«I see 6 dead people!␤I see 6 living people!␤»

rakudo: my @x = 1..100; say "I see "~+@x~" dead people!"; say "I see " ~ +@x ~ " living people!";

rakudo a5dfe9: OUTPUT«I see 100 dead people!␤I see 100 living people!␤»

rakudo: my @zombies = 1..6666; say "I see @zombies.elems dead people!"; # ;)

rakudo: my @x = 1..499; say "I see "~+@x~" dead people!"; say "I see " ~ +@x ~ " living people!";

rakudo a5dfe9: OUTPUT«I see 499 dead people!␤I see 499 living people!␤»

rakudo: my @x = 1..500; say "I see "~+@x~" dead people!";

rakudo a5dfe9: OUTPUT«I see 500 dead people!␤»

pmichaud: you're just used to the brain-dead merging of other SCMs.

Seems dead right now.

drops dead

JimmyZ:I know about the tutorials. I just think it is bad pr if you google for perl6 and tutorial and end up with dead links...

Ooh, the dead lives again!  (#perl6 revives)

Both my grammas are dead :)

From an Australian point of view, the problem is that it's dead in the middle of the day, not that there's too much traffic :)

Yes, but being here once doesn't solve the "dead in the middle of the day" problem :)

moritz_: right, but this time there's a deadline. and, quoting pmichaud, "when there's a deadline, things tend to get done."

people requested it today when I told them want() was dead.

the long-dead Roman empire can be incremented, but the still-alive Sinitic peoples have to remain at 一.

rakudo: review: http://github.com/rakudo/rakudo/commit/b6f792c47eadead06a889002b5a3918df3b153f3

I wanted to learn French because it wasn't dead, but was still good for the classics.  2 birds with one stone :)

A bot that isn't braindead.

PerlJam: I'm not going to compromise for dead implementations.

having multiple implementations will make it harder to say 'perl 6 is dead'

and using pugs to argue against the "perl 6 is dead" meme is dead wrong, too

moritz_: actually I was supporting your "not compromise dead implementations".. :)

What, does that mean that we're dead, and as the water cools, we come back to live?

.oO( Now where am I going to find a box that I know will be dead idle for a sufficient block of time each day ...? )

earlier it seemed to be dead and now it took a long time - though eventually answered

but immutable cursors plus lazy lists is a brain-dead easy way to do backtracking

at any rate, that looks dead-simple to implement in rakudo, and resolves several of the binding issues I had asked about at NPW

yes, i know they are dead

trait_auxiliary is dead. :-)

then realized how dead simple it was

pugs is pretty much dead, but you try to follow the steps described in the INSTALL file

it's dead?

I use US-International with no-dead-keys for norwegian. AltGr-[ZLW] is [ÆØÅ]. That also has «» and some other snacks.

is braindead

which, in the mind of most people, is a dead animal

I think I've explained about 20 times within the last 12 weeks that perl isn't dead and perl 6 no vaporware.

clug, the old CGI system is dead then ? (not a bad news)

sial.org dead?

lichtkind: yes, I have a November account. you're right, Synopsis links would not be able to point to the exact paragraph, the reader would have to do some searching. I'm mainly worried that the appendix is a 'dead end' when searching for info.

in effect, proto is the dead end you get if you just implement a package manager without caring about the known requirements. :)

pmichaud: Yeah, in the dispatcher changes !DEREF is dead.

Or dead keys, rather

( DanielC -- are you unfamiliar with the term "dead keys"?)

But if I were to learn them (especially Hebrew, which is living, whereas Koine Greek is dead), I'd do it properly and learn to speak it

unhandled and dead exceptions are thrown

sadly not, really bummed, work deadline is blocking it

( sjohnson: If there were people wanting to talk perl6 here at the moment, I'd say to take this conversation elsewhere (#perl?), but since it's fairly dead trafficwise, I won't complain :) )

wayland76: this is simply a way to expose the current projects, making it dead simple for people to annote the code.

I prioritise the tune for my sister, and my own recorder practise, because they both have quite tight deadlines at the moment

and also the cooking of dinner, because there's a deadline on eating too :)

so I think the Ruby notation is a dead end

(I was thinking of dead fish)

Anyway, it survived our mistreatment (and a couple of heavy droughts), so when it was time for a new tree in our front yard to replace the (largely dead) oak it was an easy pick.

Why do my lambdabot messages keep returning from the dead?

r26901 | masak++ | [u4x/TODO] 'is also'/'is instead' are dead, long live 'augment'/'supersede'!

still brain dead after a fight with IIS

just because somebody hasn't been exposed to a different technology doesn't mean he's stupid or brain-dead or whatever

Whee! Found the deadlock

Matt-W: but if all threads claim all locks in the same order, there can be no such deadlocks

ruoso: the test you commited seems to show a use of a dead value not a leak

Well if it makes you feel any better, I'm trying to figure out a three-way deadlock

but it wasn't a dead parrot yet

a Match is basically a "dead" Cursor

it resonates well with me though, because it reminds me of Dawkins' "There are a lot more ways of being dead than of being alive."

std: sub prefix:<un>($what) { }; un $dead;

std 26807: OUTPUT«Potential difficulties:␤  Variable $dead is not predeclared at /tmp/sE01VKpLHp line 1:␤------> �[32msub prefix:<un>($what) { }; un $dead�[31m;�[0m␤ok 00:03 41m␤»

std: sub prefix:<un>($what) { }; sub un { }; un $dead;

std 26807: OUTPUT«Potential difficulties:␤  Variable $dead is not predeclared at /tmp/EcXJKiSSOQ line 1:␤------> �[32mix:<un>($what) { }; sub un { }; un $dead�[31m;�[0m␤ok 00:03 41m␤»

std: sub un { }; un $dead;

std 26807: OUTPUT«Potential difficulties:␤  Variable $dead is not predeclared at /tmp/nmppEfp2tK line 1:␤------> �[32msub un { }; un $dead�[31m;�[0m␤ok 00:02 36m␤»

moritz_: I think the 22nd was some kind of deadline.

Well, it's probably dead anyways...

rakudo is dead. long live pugs!

ok, it's 17:00 here now. final deadline for the project is 18:30.

aw, there goes my deadline. :(

Or implement Prolog on Parrot, but Prolog seems to be nearly dead, very few users

anyway, the first attempt was a dead end.

cbk: the '=' prefix operator is dead, use $*IN.get

cool, so now Web.pm has a deadline, of sorts.

But we'd just have to get it past the "type IDs are dead" mentality.

Matt-W: are they brain-dead ?

one of the criticisms I've heard about rakudo is that it's tied to parrot and that parrot is somehow broken.  (I've heard this a few times, but never with any specifics)   I wonder if this is another "perl is dead" meme on the rise.

maybe we need to start a "perl is undead" meme

so having a method call as a parameter is brain dead

(seriously, any more stable, and it should be considered dead...)

jnthn: ... 'is that the prefix: operator is now dead' I HAZ EATED TEH <=>

while re-generating the proto database requirements, came to the 'PERL6LIB is deperecated' dead end a few times. why is it considered to be just a temporary workaround?

seems my deadline can still be May 23, given that schedule.

prefix:<=> is dead dead dead

prefix:<=> is dead dead dead

r26292 | lwall++ | Kill prefix:<=> very, very dead.

r26293 | lwall++ | [STD] Kill prefix:<=> even deader.

best thing to do.  The IRC channels are relatively dead with NPW on

the tuits do get rounder as deadlines approach :)

Oh, I regularly think "dead chicken" as I'm eating it :)

masak, i prefer to learn dead langages as latin or ancient greek vs esperanto: it helps to lean other langages

ok, so I need to fiddle with the status report.  sigh.  it's so easy when you don't have external deadlines to put things off until tomorrow, rather than just ripping at things and going with "good enough" crud.

wayland76: s1n: thanks for the comments anyway.  :)  I feared #perl6 dead air.

the haskell implemention itself is dead

pugs: say "I'm not dead!";

pugs: OUTPUT«I'm not dead!␤»

then our whole idea for using adverb-based testing is also dead, I think

got his out of the way in January. Then, his deadline was end of Jan...

No you're dead on.  Good.  One less open issue.

jnthn: do you have any ideas why socket API is dead in Parrot?

yeah, i've got a deadline, and it doesn't match with yours :)

deadline?  hmm?

r25884 | lwall++ | [viv] clean out deadwood from older implementation

only 4 hours left to the deadline and about 30 (of 100) points left to finish :(

no, i'm not dead!

yes, calling qx() has been poisoned in Rakudo, so it's dead code.

I must be sick. Yesterday night I dreamed that TPF missed the application deadline for gsoc :)

because that seems a little dead

runtime/parrot/library/HTTP/Daemon.pir is dead... It even can't be parsed by imcc.

in a "Microsoft broke the web a decade ago but we're finally digging out from that by piling up the dead bodies high enough" kind of way.

in the category of a random idea, any interest in defining a "minimal core perl" set of features?  pugs is dead, but all other impls could aim for / only be declared usable once they do the minimal core.  then we could at least say "if you write X, it will run everywere".  p6 is such a big language, without that...

I guess my problem is that, for 50% of my day, #perl6 is dead :)

Not suggesting we do all the time (in fact, I think we shouldn't) but for stories/pages that are a big deadl, I think rakudo.org/notable-release-whatever is better than rakudo.org/node/48

Ariens_Hyperion: He's only 4 books into a 7 book set.  He'll be dead before he gets to 7 at this rate, *especially* if he keeps updating the existing books.

Well, whatever is done in that respect, surely what we have now is dead wrong.

So 'is also' is dead then?

wayland76: no, bless isn't dead. see S12.

(intermittently reproduceable deadlocks)--

it's dead-simple by design.

initially we can detect and avoid manually, such a feature can be retrofitted like deadlock detection in a database server.

rakudo: say "undead"

so, '+' twigil is dead?

and Codd is dead, unfortunately

A bit like one of my colleagues trying to calm me down yesterday saying it doesn't matter, we're always going to go down dead ends in development, you're not the first person who had to throw away a week of incredibly fiddly code, we've learned loads from it...

I can't try it in trunk as it is still dead for me :-(

sure, p6eval also caught up with the deadness of trunk

Which is my drop dead on my book.

I've just submitted a post-deadline talk proposal and wondered what the chances were of being accepted. It would be about Pod 6.

mberends: kudos. I hope it gets accepted. I know they've had to extend their initial deadline, so hopefully they'll be lenient.

yes, it's a dead alley for a Perl programmer

are they supposed to or is that "dead spec"

parrot has a pretty firm deadline to be moved by Feb 6.

whom is dead.

r24925 | putter++ | [elfparse] Started sketching in category handling.  Also tweaked README, removed some dead code, and added Makefile targets.

since infrastructure issues also include "how does one build Rakudo...", that's a bit of an imposing deadline.

you know, every time I see the "Perl is dead" or "Perl 6 is vapor" I think: If perl were dead and perl 6 irrelevant we wouldn't see so much fuz about it... it would simply disappear...

ruoso: I wish it worked like that. people calling a thing dead can help kill that thing.

Is Perl dead and Phyton reborn?

Would like to hear what he thinks of this: http://www.web-app.net/?Is_Perl_dead_and_Phyton_reborn_/&action=viewnews&id=60

lumi_: pugs is sleeping/dead. Rakudo (Perl 6 on parrot) makes the most progress

Pugs isn't dead, it's just sleeping.

yeah, almost. is the deadline close yet?

i understand that it's pretty hard to give a 100% correct deadline

as you wish regarding not asking about deadlines. hmmm testing, will see if i get free enough

Call for Papers deadline is getting close

masak++ # very nice use case for the "use deadlock"

mtnviewmark: depends on what you mean by 'alive' I guess. it isn't dead.

Ponie has been dead for years

yes, pugs is written in haskell and dead atm

Where would I find recent win32 builds these days? Links tend to be dead and google isn't helping...

r24643 | ruoso++ | [mildew] support for CALLER pseudo-package using a "flattened lexical scope" that turns postcircumfix:{ } into lookup (Implementing MY:: should be dead-easy now).

exceptions often have some kind of a smartmatch against the context, so that has to be something like :WHICH(0xdeadbeef) where that matches the .WHICH of the routine's context

and smop_mem_mark_phase(additional root objects);smop_mem_print_dead_objects prints out dead object on the list of references

would put a readme in the pugs examples pointing off to the new repo, my understanding is that pugs is pretty dead though ;)

eric256: not dead, it's resting!

r24361 | moritz++ |  * Str.pos is dead, long live

interesting idead

have you tried a nodeadkeys variant?

is dead tired... spent the whole day painting his new house...

spx2: Well, I keep hearing reports of a Christmas deadline (for the basic language, not the libraries); assuming that's true, a number of the basic libraries should be implemented towards the end of January

DumpMatch.pm is dead, long live DumpMatch.pm!

[particle]: Then say fork until dead

ruoso: other implemenation = parrot,elf,pugs? pugs is dead untill audreyt resurrects it, elf could be easily influenced to use whatever we want by implementing it and parrot will likely do the metamodel in pir/C

pretty dead in there

as a dead SLIME Frame is accessed at native_capture

could we catch using an undead object?

not who is accessing the undead object

masak: sm0p is dead

well, that's how we'll make the deadline of Christmas This Year :)

I personally doubt the Christmas deadline that people have been talking about, but I think it'll be close

#perl6de is dead, to the best of my knowledge

@tell ruoso it turned out rootnamespace was an undead objects (it got DESTROYALLED) just after creation and "lived" on with a counter near 999

for some reason I am reminded of The Princess Bride and the hero being "mostly" dead.

kp6 is dead

Ontolog: Pugs isn't dead

pmurias: i didn't say it's ... dead... i say its not being actively developed

how to get to X-mass.  kp6 you know.  pugs until resurrection is dead, and even then will be mostly hs rather than p6 - migrating the prelude from hs to p6 was a work (struggle) in progress back when pugs wound down.  elf is better than redsix.  and rakudo you know.

it's not dead, it's sleeping!

you mean create a deadlock...

my mobile basic phone is dead but I am tighed six more month with my providers. I don't know if I want to jump on the iphone bandwagon riht now.

pmc_ext = 0xdeadbeef

it might be doable in rakudo, or NQP -- at the time I was going for what would get it implemented for me the quickest, since I had a tight deadline :-)

in http://svn.pugscode.org/pugs/t/README the link http://rakudo.org/perl6/index.cgi?smart_linking is dead

how are we planing to avoid deadlocks?

hate dead keys

there's a dead link http://rakudo.org/perl6/index.cgi?download_perl_6 from http://www.pugscode.org/

Grrrr: what is the deadline for abstract editing (if i change it today will the changes be reflected in the paper conference schedule?)

i have completly no idead why and when it happens, but i encoutered it before and it went away when i rewrote the p6 block

Else you find at summer's end, you've spent a great deal of time wandering a maze of deadend passages, and debugging rakudo, rather than writing tests.

pmurias: IMAP on my server is dead right now, if you were using that you can use imap.gmail.com. mail *delivery* is not affected

Yep. -> is dead.

r21202 | ruoso++ | [smop] yet more work on the p6opaque implementation... Some nasty bug is causing a deadlock (yes... I know the reasons for locks to exist is to cause dead-locks, but that is what I got so far)

r21042 | lwall++ | [STD] list and chain operators also want deadwood removed

although "np6" would indead be a good name.

There is a dead link on pugscode.org :   wiki  ->  http://rakudo.org/perl6/

ie, dead

backticks are dead, correct?

is apparently braindead

drop dead. Moritz was faster

Is printf() dead?

I am kind of worried that the project is named after the dead parrot skit

dominiko: Pugs is mostly dead.

() compiler.  pugs - non p6, mature, dead.  rakudo - non p6, active.  elf - p6, low-bus-number active, currently less wizzy than pugs and rakudo, more than kp6.  being implemented in p6 perhaps provides greater leverage for wizziness than rakudo's pir, but less than pugs's haskell.  kp6 - sort of p6, inactive.

S03-operators seems to be a fairly braindead name since all of S03 is about operators

Auzon: but since pugs is as dead as a open source dog can be I wouldn't pay the smokes too much attention

perl6: die "dead";

but the deadline didn't expire...

diakopter: svnbot still dead :(

it's not a very nice attitude, but it's not nice to be blocked on a possibly dead project either

and if you need to distinguish, use [] insteaqd of {}, as in \x[dead]beef

whether that should be deadly or no.

Muixirt: pugs development is as good as dead, and ghc 6.8.2 broke pugs build

pmichaud: re "go on a mailing list somewhere?" and "not as nice as", that seems a really big barrier.  even just requiring logging in and account creation is can be deadly, albeit unavoidable until the community is large enough for 24x7 spam watch.  hmm, except for "a few writers are collaborating here on a project" use, vs "the community is maintaining this".

mncharity: I don't know yet, that's why I said "sort of".  There is no article yet.  If something comes together before the deadline for TPR, I'm going with it

i think kp6 is frozen/dead right now so i don't suppose the bug will be fixed

Then again, hashrefs are dead and captures should be used instead, which I don't know yet

re 'why not write in OCaml or something', the "yet another dead p6 implementation" problem.

re dagger, wouldn't help.  the passages are full of the detritus of dead projects.  corpses, broken tools, etc.  even if it's a memorable dagger, well, everything gets covered in bit rot too.

logo also has the "yet another dead p6 implementation problem".

TimToady: The "story of longest token matching" strikes me as something that would make a good article for one of the perl mags (bits or dead trees both), if ever you have a hankering to write about it  :)

a golem is one of those undead things that wanders around cemeteries...

some ideas from it went into a ruby kp6 backend, best characterized as abandoned and dead.

perhaps the two characteristics a parser project needs to have is to be usable now, and to be clearly converging towards "realness / spec-ness / this is really on the mainline development path leading to P6 and not just another dead end".

re wx, it will be fun to start adding gui support to p6.  can wake up some of the old amulet-like constraint propagation stuff.  NeXT DPS, etc.  lots of deadish projects to scavenge nice ideas from :).

in case anybody wonders... the server on which exp_evalbot runs has ghc 6.6.1 installed (debian etch + a few backports), so pugs will stop dead at its current revision

hmm, the challenge is to attract developers.  else we just end up with yet another dead p6 implementation.

horrid has two impacts.  it raises the effort and motivation required.  and it reduces clarity.  "clarity" being the obviousness of "this isn't just another dead-end subset".

but a primary issue is becoming that there is someone else who cares about it, will work on it an pursue development.  both because I'm finding myself increasingly spending coding time on non-p6 work, where I actually get to work with others, and because end of March approaches, my default pumpkin deadline.

kp6 is annoying it its restricted dialect, but then deadly in it's slow speed.

basically our versioning systems don't have things like "put the set of files named frob-with-dead-code-removed-and-api-diddle-13 down over there, and call it frob2".  you have to go up to the repo level to get it.

but unfortunately there is no place to meet in the middle (see the dead Ponie over there in the corner)

"not to beat a dead horse, but.."

How about you sit there like a dead log if your IQ is less than 75.

katie_d: there's also some dead-tree info in the book "Parrot and Perl 6 Essentials"

but dead-trees are quickly outdated.

[deadpan] hooray...

ok, food.  bbiab.  re  http://www.perlfoundation.org/perl5/index.cgi?gsoc2008_projects , perhaps highlight the deadlines and what is needed for them?

() it was interesting the difficulty of characterizing what i've come to view as the critical importance of a fast edit-test cycle.  given a _work_ p6 snatched from the future, however slow, we would be all set.  but given existing buggy and incomplete implementations, slow is deadly.

it seems to do longest token right on 0xdeadbeef and then fail the match

but "java didn't get continuations because at one meeting it got put off due to deadline pressure, and was never gotten back to"(my fuzzy recollection), seems a cautionary tale for us all.  though less so given p6's nature. :)

As this stuff goes, it doesn't look too deadly.

r19614 | ruoso++ | [smop] the native capture have a new important method called "may_recurse". This is only true when there are non-constant-identifiers in the capture. Some low-level classes (like slime) cannot recurse, and therefore it is a deadly error to try to create a new slime object with

but I'd really like to allow people to say 0xdeadbeef where a decimal is expected on input

it's just the literal forms that don't make sense with :10<0xdeadbeef>

i suppose :8(<0xdeadbeef>) is workable

dduncan: it's kinda dead in the water if it doesn't ...

ferreira: accept my hd drive died.  I need -just- one file from it, I'm hoping that someone can restore it.  I think the logical sectors 0-7? are dead.

i guess it's really a dead langauge :/

akreal: to the computer or from the dead :)

kicks a dead ponie

I never planned joining the development.. then I wanted to test pugs, and reported a dead link here

yes.  There was an article on Perl buzz, saying that perl wasn't really that dead, and that it appeared popularly in many job offers.

dead onion ;)

hmm, I wonder if the whole "sections" thing is dead

was tracking the pugs repository via git-svn for a while... that's on my currently-dead laptop, though.

see p5's CODE(0xdeadbeef) for instance

I also have a version of most of the lojban grammar in Perl 6 rules on my dead laptop with no convenient way to recover it or other copies.

i prefer stuff in dead trees form, but printing the report is an option

r18315 | Aankhen++ | * pruned a lot of dead code from EmitLisp.pm

bot is dead

generally speaking, what is the elegant Perl 6 solution for a weak-referenced collection of objects that auto-removes dead wood?

why is the evalbot dead?

is @#array = $new_size; dead in p6? @array.elems is not an lvalue or anything like that?

Audrey must take good care of herself.  I'd much rather have Audrey alive and Perl dead than the other way around.

"p6 is bloatware and dead" is something we hear too often to think it's still fun ;)

for starters, how can it be bloatware if it's dead? :)

ignore the dead link in that site at the bottom, i emailed the webmaster

michaelkohwj: which dead link?

how much time till one of these becomes official though? when's the deadline?

there's no deadline, and every implementation that passes the test suite will be "official"

and the as2 link on http://www.perlfoundation.org/legal/ is a dead link

In the end, 3 months after OSCON, we hit a dead end

And that ended with a DIFFERENT legal dead end

no state of the onion would be a sure sign to the perl naysayers that they are right about perl being dead  (IMHO)

PerlJam: perl isn't dead, and never die.

those are officially dead, though Captures have some of the same multitype capabilities

no it isn't. yesterday was just excising dead code

: * Pugs.Eval: Eliminate all dead code paths discovered by the

dead-ends are very time-consuming, and actual development has been quite fast

So if you are inside a transaction, and you try to pull a sequence value, it deadlocks

bloonix: cool but its now cold and gone, (third deadline :))

I thought the old 0x syntax was dead, bereft of all life, pushing up the daisies

the source browser is dead

when I use PHP, I feel dead; when I use Perl, I feel alive :)

I'm not so worried about the dead code problem; memory is getting cheap, but yes, distribution can be a pain if ambiguous.

found a ukelele made out of an armadillo the other day (talking of unexpected things which shouldn't be made of dead animal :/)

You are so dead, buu.

lambdabot is dead. :(

this weekend may be a no-sleep all-nighter before deadline special.  if not, this weekend.  else, early next week?

ok so not to beat a dead horse, but checkout source, configure,make,make test, make smoke, add smartlinks, checkout

deadwood's a good show.

I can't think of a right associative operator right now (brain-dead after a feast)

svnbot6 rose from the dead

moritz: Lambdabot is dead, you can use lambdabot2 for now.

why are they both acting dead?

djeez, my wifis practically dead out here

evalbot has been dead for sometime

Especially if brain dead regexes are used

So is the whole coerce:<as> syntax dead?

dead, apparently

any ideas for a status faq? I currently have "is perl 6 dead?", "what about perl 6 implementations?", "when will it be released?" and "why pugs? why haskell?"

Ah!  So my code depended on now-dead syntax?

not dead, just means something other than $.add_baz

well, we missed the SoC deadline for this year IIRC?

moritz: sorry, lack the tuits right now. have a big deadline for my AI exam.

So yeah, it's not dead, just slow :(

drops dead

somehow deadrat and python just seem to go together....

Limbic_Region: berlios.de is dead.

offby1 - see http://en.wikipedia.org/wiki/Day_of_the_dead for applicability in Brazil

*shrug* - not like I have a deadline or anything

for some mysterious reason, the old TV card's BT878 chip messes with NIC chipsets like DEC41113 and RTL80129. after some time of watching TV the NICs go dead

"Man found dead; sharp end of feed operator suspected"

moritz said 22h 23m 44s ago: on http://perlcabal.org/~nothingmuch/harrorth/doc/02.kwid there is a dead link, the one to the forth tutorial (moved to somewhere under http://www.jforth.org/ but I can'

@tell nothingmuch on http://perlcabal.org/~nothingmuch/harrorth/doc/02.kwid there is a dead link, the one to the forth tutorial (moved to somewhere under http://www.jforth.org/ but I can't reach that page)

perlmonkey2: no, not dead ;)

or it is true perl6 is really dead :)

Pugs doesn't do any form of dead code elimination at the moment, does it?

larry's not dead, he's just reached his recursion limit

laptop still dead/gone, so on a relatively slow box ATM

#svn seems dead; can someone help me check out pugs?  here's the problem: http://nopaste.snit.ch:8001/9696

@tell aunt_rhodie the old gray goose is dead

r15683 | audreyt++ |   lexical pad, so eliminate dead code concerning disappearing

btw, a while back you "complained" about ticket bot spam.  not sure if you were serious.  I actually thought it was kind of cute.  showed tracker actually being used (which in so many foss projects they're dead)

err, ticket system is dead.  got started, never caught on, accumulated drift of unmanaged cruft.

and how to remove dead bodies from one

but 1,2,3 were also dead

great, five and six are dead too

PadEntryMulti is dead, yay.

it's just the surface semantic is borderline braindead

:16<dead_beef> might require brackets, and :16.42 could be version

other kp6 backends (C, C++) seem to be dead ends, though some code could be reusable by parrot

diakopter, ok, so the project is dead?

Welcome to #perl6, where you can't swing a dead cat without hitting a commit bit.

is http://pugs.kwiki.org/?ConvertingPerl5ToPerl6 dead?

paying for afternoon nap.  grrrh.  braindead but can't sleep

but i think it comes down to what samb said somewhat. I mean unicode does everything, including dead languages.

dmq: Does it matter that it includes dead languages?

tot is dead

feeling dead was mostly just a joke

I'm sure I don't feel nearly as dead as Audrey does right now... :/

well, he's dead now

(I think undeads were there for a while too)

hm. <1.5hr till OSCON proposal deadline

rafl: yay, is jabber.org dead for you too? well.. whatever, i wanted to send the patch for Net::SSLeay with the test

gour: it's been dead in here for some hours

so it's dead

he's dead--I asked Umberto Eco instead...

for one, mono is officially dead now, isn't it?

mono dead? thats interesting..

unfortunately, I have to run off and make it to the post office to meet a mailing deadline

the p5 backend is dead I think.  yes?

well, PIL-Run is dead.  do we have anything else which actually... right, but do those take pugs ast's?

thus while there have been p5 and pbc backends in the past, the pbc was always a "look, neat!" rather than passing lots of tests, and the p5 is dead.

hmm, was this channel really dead for more than 9 hours?

deadish, yes. kolibrie said something three hours ago.

he's been dead for 1900 years, I don't think Paul is the least offended. :)

maybe it was thread deadlock of some sort

ah, yes.  that's something we intentionally killed very dead.

allbery_b, that can get deadly though:   my @x = (sqrt(1), sqrt(2), sqrt(3))

... leaves you in a half-dead, unreaped state.

not bad for a "dead language" though

~ he was quick on the draw - i  thought i'd be dead / he put the gun to my head and this is what he said ~

grep is dead, long live grep?

mx is dead

This lead me to thoughts about out-of-order execution, and parallel execution.  Both of these looked like dead-ends to me; threading in an interpreter at that level is slow and stupid isn't it...

we only did ten flips, but I flipped all heads.  thought I was in R+G are dead...

dead now?

hm, that was a pretty braindead thinko.  but I think I might have it now.

AIX was dead 15 years ago

ingy: that makes it a long-lived undead

ungratefaul undead operating systems...

IP over dead avian carriers?

gotta vamÃ¸Ã¸se, alas.  knock 'em dead.

r14532 | putter++ | regexp_engine_cruft/regexp_engine_factory.pl - removed some very dead code to make file more readable.

should stringify as CODE0xdeadbeef or something.

perl5 on parrot is currently dead

known dead-ends could be just rejected by the wrapper

ok,.. I hate to go, but I have a deadline,.. but fglock lets talk about this again, very soon

ingy: The logic goes something like "people are stupid, ergo you're going to screw up or someone around you is going to screw up and you're dead"  :-)

another example of braindead makery...

goes back meetng $deadline...

r14221 | putter++ | Makefile.PL - revert r14215.  -B PERL5 does v6.  PIL-Run is dead, long live v6.

it will be dead useful

problem is failing regex tests produce matches on which hash access is deadly.

re hash access is deadly - this is fixable

svnbot seems dead.

it uses words like "EuroSign", "dead_ogonek", etc

dead_ogonek are keyboard symbols

r13519 | lwall++ | Tweaks to character types.  Ling and Graf are dead.

or rendering an embedded language (tex example - texemacs did this, but google doesnt find good pointers... project dead?),

on monday i have a $work deadline

I thought the parrot was dead...

might already be dead or hung.

There's no ponnie, and ponie is dead, but there's punie, which is partially Perl 1

Ah, so that's a dead horse.  What's Perl 6 running on parrot called?  Any distinct name for p5 on parrot?

undead things tend to take the long view...

TimToady: I'm all for the longnow, but not if means I'm dead when a useable perl6 compiler is finally released.

leo: yes, I read that.  But I take it to mean that the current ponie effort is door-nail dead and not to preclude any resurrection and transmogrification into some new ponie incarnation.

only thing I could think of was dispatch into a method, but that means an 'asSig' which is dead weight in most cases, and looks unclean roo

indead, but it's not tested beyond compiling hello.pasm to hello.o{,bj} and linking that

in dead :)

it explains let-reduction, lambda-lifting, constant folding, dead code elimination, type-inferencing

but that was a dead end

but that's probably dead end too.

it's dead

(I know it's dead, just havn't seen the obituary)

CPAN Testers is a problem, it's dead largely

r12447 | agentz++ | * implemented the todo function which marks the next one test as TODO according to a given deadline.

.deadbeef

well, nuking that list seems to be enough.. maybe do both to "ensure" everything will be dead..

real-life deadlines caught me up

I don't want to get beaten by the Google deadline too, though

audreyt: since you mention SoC.. deadline is 21 (or 20?), any suggestion on how I spent this last few days (I see you liked CollectionsM)?

all ${...} notations are now dead.

dead by the same criterion.

r12265 | audreyt++ | * Pugs.Lexer: "\0123" is now as dead as "\123" -- both fatal parsefails.

but that's pretty dead, as the interest seems to have declined

hm, is it dead? :)

dead unless you use self './' or some such.

is long dot dead?

has hit a dead end with php and decides to go to sleep to dream about perl

audreyt: anymoose, to more important matters. the coersion from str to num is kinda braindead -- there's a ByteString.readInt there so it's not very polymorphic

braindead is fine...

That's dead.

alias deadchicken find . -name \*.hi | perl -n00le '@a = split /\n/, $_; print $a[rand@a]' | xargs rm

that's good.  you would need it even more if you were here.  the sun is dead asleep.

When is the deadline?

What? The steamroller operator is dead? Awww :-(

TimToady: I'm not dead yet. I still have lots of voom!

maybe, I have a cell phone, but may be in a dead spot.

why would i be dead?

nope - dead end

the internet is dead.  you'd think it was friday night or something...

I'm confused. I thought (according to S06) that the semi was dead, and we were relying strictly on * and ? for optionality in prototypes...

the inability to skip deadly tests is a pain when doing a new pugs backend, or complete pugs alternative.  the tests grew up with pugs, using evals, and commenting out, to deal with problematic ones.  but we dont have a more general mechanism to easily say "skip/eval this test when running under X".

if someone could take a look at http://sial.org/pbot/18254 ... I'm trying to figure out why prove drops dead after the first :todo test and doesn't even attempt the rest

r11181 | audreyt++ |   (Python on Parrot) is not dead; the list is active as

fglock: are the t-old things dead?

the pugs is dead, long live the pugs

unfortunately still has to think about $work today, and deadline

actually my $deadline is post-YAPC,.. which is even more of a PITA

Brian Ingerson is dead

Big deadline

spec change _after_ the deadline. revised deadline coming monday.

"NCI is dead. Long live {Perl,Polyglot}CI"

"what you thought you had to learn last week that is dead this week"

PerlJam: By tomorrow I'll be dead.

Juerd: implicitly computed keys are now dead, yay

r10317 | audreyt++ | * implicitly computed keys in named arguments are now dead:

I hope Sunday schools aren't as deadly.

Juerd: excellent! perl6 is the 50 or 100 year language, so those older people will be dead for the majority of its lifetime.

::8<020><deadbeef>  # hex

re deadbeef: didn't think so, really

i'd be inclined to insist on :16<dead_beef> * 16**8, as well, and keep a bare number inside the < >s

It's becoming dead to Perl

well, I wouldn't say "dead"

hey, just a quick update to any SoC folks:  the deadline for student apps has been extended to 1100 Pacific Daylight Time, 5/9/2006.

there is a deadline some 26 hours from now for all this to work on win32 :)

hen is the SoC submission deadline?

I believe dduncan thinks the cleanest SQL is a dead SQL.

it's just kind of dead in here right now

Â¨ might work, but I suspect is often hard to type || display (that's dead diaresis as a character on it's own).

yeah, I think the microphone went dead in it.  not a big deal, but still.

did they move the deadline yesterday?

(which is now dead. yay)

Of course, that doesn't have the same brain-dead ease of clicking a URL.

it's a set deadline :)

saying how sexy ruby on rails is, and perl is effectively dead

Pugs is dead.  Long live Pugs.

"God is dead." --Nietzsce. "Nietzsce is dead." --God.

Nitzsce is God. --dead

audreyt: is ** and * dead?

fine, it's dead

distinct deadness in here today

containing dead code

${} is dead in favor of $()

PerlJam - IRC is already dead easy to write a client for.  Knowing Emacs just lets you target that platform and save on UI the way you'd normally save by targetting a terminal in unix.

21:07 < ayrnieu> PerlJam - IRC is already dead easy to write a client for.

best footnote ever: "[1] DOM means brain dead in Dutch."

senses deadlock

but ninjas are so cool because they're silent and deadly and stuff

no, that's dead python ;-)

But yes, the net tends to go dead Friday nights.  some people have lives, it seems...

mugwump: I'm not sure if I'll be in euroscon (havn't heard anything yet, submitted past deadline)

you could get grant money to work on things you're already working on (though there will be the extra added benefit of a deadline and a progress report or an end-of-project report)

Is there any timeplan or roadmap for parrot? i can't find any deadlines with date.

i thought the tree stuff was dead

gugod: jabbot is dead, long live jabbot!

(when his DSL isn't dead, that i)

ingy: no... big deadline

Scalar of is not a problem when we've already said it's dead unless explicitly declared in a lexical scope, and then it's the compiler's problem.

Limbic_Region: the weekly meetings are still taking place, although I missed a bunch of them because of paying-job-deadlines (and scope creep on that job)

is kwid dead or part of damian's plan?

it'd be dead easy to skip from audio clip to audio clip as navigation buttons on the swf snippet were pressed

it's dead easy if you have the flash authoring app to hand

If I were dead today, I would not like that.

so he can't be dead today...

fire at will (rogers? he's safely dead)

Trying to debug Spork, a Spiffy client, is absolutely deadly.

__DATA__ is dead

It won't impact perl, because it's dead DNA anyway

So if you try to pull a sequence value inside a transaction, you hit a deadlock

drats, svnbot was dead, so...

I hate managing projects and deadlines :'(

*shrug*, perl5 does not seem undead to me.

its not undead, but it is less lively than it used to be

deadpan sarcasm is horrible online

except that I don't remember my password, and that the email address I registred with is dead

deadlock=bad

kane-xs: jabbot is dead

it's just that if it's not cought then it's not a deadly catch

despite the fact that it's considered to be an almost dead project lately

PIL is dead?! dang. I only learned of it uh... last night.

PIL is dead,.. long live PIL!

i thought PIL is dead because it didn't map objects well enough and that's why PILN was born

I'm kinda annoyed that YAML isn't coming with Python by default (got certain serious deployment constraints at $work, and I'd *love* to have a non-braindead configuration language)

r9312 | audreyt++ |   So for now, bring it back from dead.

pilX is dead,.. long live pilX

but this should give us constant propagation, dead code elimination, and other niceties

Is he dead?

I hope the defaults will be less brain-dead than in Data::Dumper. :) I should yet find a usage for default $Terse = 1; $Indent = 2;

is not so quick to mark it off as a dead thing

lypanov: http://www.mtholyoke.edu/~ebarnes/python/dead-parrot.htm

http://people.csail.mit.edu/jrb/goo/ 's http://people.csail.mit.edu/jrb/goo/goo-imp.pdf and http://people.csail.mit.edu/jrb/goo/goo-boot.pdf are quick skims.  but goo is dead (jrb has too many other interesting things to do).  and it's not clear the fast subtype/dispatch stuff was ever actually implemented?

r9204 | gaal++ |  * Updates recovered from dead laptop

50 uses for a dead cat: pretty printing

wrt scrhodinger's cat: between hitting it and removing the blood from your eyes you don't know if it's alive or dead

Juerd: the latter; it's now dead.

hmm, I'm debating whether I should apply for an OSS summer project - like google's summer of code. deadline for the applications is today..

fyi, the deadline is tonight, pst ... in under 6 hours ... so if you want to propose something and haven't, that's how much time you have ... remember, acceptance means free admission

if its anything really bad, I have 5 hours in which I can submit edits, though hopefully they'll let me after the deadline too

nice life's work.  we should talk semantic net sometime.  re lol, the thought of doing a paper deadline crunch to get into oscon.  not sure why it was lol, but was.

hmm... so is that the final cut of the body that goes in the catalog, or is there a later deadline for that...

ok.  I just note that if there is a printed version, the deadlines to get things off to the printer are sometimes surprisingly early.  so one wants to avoid something there that in restrospect on might regret.  random thought.

Alias_, it seems to happen as a result of a dead host 

so I wont bother you much since I know you have a deadline,.. but it occurred to me that we will be writing Perl 6 not in Perl 5, but in CPAN which fits quite nicely with your "CPAN is my programming language" idea :) 

(from analog dead trees)

r8965 | putter++ | pX is dead, long live pX:

r8965 | putter++ | Yesterday's strawman project proposal for "write a p6 implementation in full p6, and then boostrap it by transcoding" is dead.

deadline is in 48 hours :)

(and then just go ahead and let deadlines fall where they may)

re the latter, deadline for proposals is less than 2 weeks away

You lock, dead

which is dead, per usual :-(

"Adverbial number forms: :16<deadbeef>  and :16[14,15]" and "New \x[abcd]  and \x[1,2,3,]  forms instead of \x{abcd}" are redundant.

I copied it out of a dead tree book by hand.

audreyt: btw, re "triage", my understanding is that's "focused on assessment, quick look at everything".  tag the dead, tell the mobile to move, briefly touch the critical, and the key "and move on".  so when it comes down do debugging individual files with known issues, I don't think that's "triage" any more.  random thought. :)

nice to know NextStep wasn't a complete deadend.  nice system.

perhaps I'm being too negative.  perhaps posix has improved things.  but this corner of the world, terminal control and configuration, and the inability to get del and backspace reliably working, has been a problem for more than a human generation.  it gets a bit irritating after a while.  smells like dead fish. ;)

it looks like the pil2run backend is completely dead at this point.  but it had a similar repl.  no cruft on secondary lines, and input terminated by a blank line.  easy enough to write your own repl in p6.

a dead language only used by stuffy academics??

this may be beating a dead horse, but is there any estimate for when 6.2.11 will go out?

audreyt's journal suggests $job for atleast another day, plus post-deadline recovery ;), plus whatever life stuff is associated with Lunar New Years.  sounds like very late Jan or early Feb.

i just want to know whether they are dead or alive

it's deadline

push @children, { pid => $pid, cmd => $cmd, deadline => $timestamp }; 

struct task { whatever pid; size_t deadline; char * cmd }

the earliest deadline

but our feet were dead

r8770 | audreyt++ | * Adverbial number forms eg. :16<deadbeef> works, as does :16[14,15].

lol.  putter pictures "night of the living dead" zombie hackathon...

Anything that uses Scalar::Util is dead atm

So you have the current situation where PPI is at 0.990 in the PPM lib, and dead

is there any type of deadline or such for that kind of stuff?

but type inference is pretty much dead...

(dead tree cost bucks standards)--

basically the chain goes something vaguely like; clockspeed/voltage too high, bad cpu/heatsink bond, heat sink too small, insufficient airflow over sink (eg, sink fan dead, or a temp->speed control not doing the right thing), case hot. ;)

wants complete control of his namespace.  the ability to correct for CPAN modules with brain-dead apis.

(evalbot's dead?)

I try to engineer schedules so that work slows down as I move closer towards the deadline, launches are much less stressful that way

one serious issue with yaml is that it serializes badly to dead trees

did you think med-to-dead? or med-to-galilee?

once you can get it to parse, compiling it is dead simple

and if I can statically determine context later, that's just dead code elimination.

or die "Error " ~ int rand 0xdeadbeef;

ooh. has it been dead all this time?

hmm... i think it's dead

life's kind of crazy right now. too much bloody seasonal crap, plus i'm kind of braindead with hayfever at this time of year.

it died and stayed dead

that was implied in one of the pages I saw... apparently at some point you try out a number and see where it goes, and sometimes you hit a dead end etc.

My max is 100 a day. And then I'm dead.

I don't think regexp will be dead even we have got rule. :-)

is back but sees that the conversation is dead

brisbane.pm is one of those sometimes alive, sometimes dead groups :)

busy. too many forgotten previously arranged meetings and deadlines

Juerd: and is still dead? that's a problem all right :)

I'll write up more about what aevil/jhi and me tlaked about in journal... I've jotted things in analog dead trees

I was thinking that'd be pretty well dead last -- is it needed for simple stuff?

nothingmuch: Be careful to avoid deadlocks

and that makes it easier, since the DBI API is dead simple

my $name = =$IN; # is strange indead

no, more accurately: "dead"

so i should check for ->dead after i set?

stevan, well, hmm.  Depends on when the deadline is, and whether it pays at all.  Right now I've got a lot of stuff on my plate (witness the fact that I haven't even been reading #perl6 for about half a week)

needs to kill this $contract dead

eval: "I'm not dead yet!"

buu: Return: I'm not dead yet! 

PerlJam: to quote the article "A hard real-time system is one in which one or more activities must never miss a deadline or timing constraint, otherwise the system fails. Failure includes damage to the equipment, major loss in revenues, or even injury or death to users of the system."

has had a big deadline and has been giving his spare time to catalyst lately

misc: Since I typed something like "My connection is dead again :(", but I reckon that's something you never saw

PIL-Run is dead.  long live Perl6::Run::OnPerl5::X1 !  ;)  not really.

Of course, I'm out of the loop, so I could be dead wrong.

is irc.perl.org dead?

for a channel with 188 users #irssi is pretty dead

theorbtwo: plus publication could mean "published in book form on the web" instead of "published in dead tree form"

Ah.  To me "book" and "published" implied dead-tree pretty strongly.

wonders if that dead horse is anything more than bones and little bits of rotted flesh

lvl 1, cantrip: "dead horse reanimation"

autrijus: remember that laptop I bought on my way to Taipei? I resurrected it with the disk from a dead ipod

mmm lightning talk submission deadline for euroscon is today.

Fair enough.  But I'm feeling partial deadlock in the P6 aether, and that's disturbing the force . . . to mix several metaphors

eric256, the circular discussions are part of the partial deadlock I referred to

It's not perfect, but it's also not deadly, or entire-disk-spamming

nothingmuch: it's made of dead trees

Yesterday, P5 embed was dead.  After this build, I'll try again

"geoffb" at 69.110.115.185 pasted "p5 embed dead again" (215 lines, 14.3K) at http://sial.org/pbot/13532

yeah, /me didn't notice hops 19-37 were all dead

Alias_: I think dead code elimination during INIT time is viable, but likely to be runtime dependent. parrot does have facility for it

dead code elmineation at link time is a basic idea

Been working on a contest entry, and ended up possibly missing the entry deadline by 40 minutes because the terms weren't clearly written.

r7217 | iblech++ | * Config::Tiny: Removed dead code (a pugsbug was fixed).

deadlocking is least fun of all

autrijus, when you said pugs dev is bus-error free, you were referring to deadlocking (or lack thereof), right?

kgftr|konobi - theorbtwo is working on a vector search engine for a contest with a Monday deadline - I would expect him to be less visible then normal

The article points out one networking problem -- dead hyperlinks.  Good thing there's an internet archive now; of course, that doesn't help anything that's not linked into the publicly accessible internet

nothingmuch, actually using more than one language in the game.   In particular, one very high level one (like Perl, say), and one dead fast one for core optimization (C or even assembly)

also dead easy to install for X terminals

hmm. is p6l dead, or is my mail setup fuxored?

"the only good indian is a dead indian?"

Is harrorth on the back burner or pretty much dead?

as can the limit interface (sends a deadly signal)

slurpy array is dead dead not working dead.

i think 3000 or so are dead

lol, "dead"

Mmm, TBH, it's not something which I'm dead set on.  I can do without it.  I'm just trying to give you suggestions. :-)

but Larry seemed so dead set on the Class being a thin candy shell for the MetaClass

Is p6l dead, by the way?

Juerd: He is dead. 

Besides, it would be a dead channel

and my brain is dead so I won't bother trying

svnbot seems to be dead again. :-(

Is !! dead, then?

!! was never alive -- it was at best undead

and my *work* computer is dead!

btw, what state is the parrot target in?  dead for now?  (passing 2/3)  last i heard it was waiting on the new calling convention

"typeglobs are dead, dead, dead, dead, and dead, not necessariy in

the dead seed is in the grain of the void

not that it's that important, if the mega inferrencer detects that *baz is assigned at runtime in code which is not eliminated by the dead code eliminator, then baz should never be inlined

It'd be dead easy if you're generating the code. But it'd still be a filthy hack ;)

hmm... svnbot is dead...  as of a few minutes ago, yes :)

anyway... that's pretty insane then? you can't keep track of when things are actually DONE, you can end up with crazy race conditions and deadlocks and not understand where/why

deadline, etc.

Yep, he has deadlines etc. as far as I know

iblech: could you please reveal some information about the deadline?

xinming: I dunno, all I know is from autrijus' journal (http://use.perl.org/~autrijus/journal): "It is tomorrow now and I'm still neck deep in this $work deadline thing"

r6390 | scook0++ | * Removed some dead code (killed by refactoring)

Devel::TypeCheck looked interesting.  I only briefly skimmed the paper, but was left wondering why only three programs(?) were used for Experimental results.  Oh, duh.  Paper deadline of course. ;-)

i dont use that much bw anyway, i think my project is near dead :P

and then he can't make folding deadlines, because the code is too bugyg

How to access the first $x? or It's dead.

is, sadly, deep in $job $deadline foo

ick, deadlines

I work better without deadlines

$deadlines--

has several $deadlines all one after the other

0xFF.dead;

Aankhen``: lots of dead trees ;)

nothingmuch: your smoke is dead :(  *tear*   and if it supported parrot/rules, we could just point pm at it to find out what is/isnt working...

jdv79: available as dead trees

r6148 | iblech++ | * PIL: Removed dead code (&PIL::generic_catch).

using more than 2 chars for an 'i' is braindead.. i've seen some people actually do counter and kounter

If just thinking about it is that deadly, immaginin what fate will befell you if you accully spam.

r6028 | rafl++ | * Changed maintainer address (mookooh.org is dead).

Larry's onion was last night, and Damian's dead languages

r5928 | autrijus++ | * remove dead code juncTypeIs from Junc.hs.

Pretty sure.  There's supposedly a deadline and stuff.

There is one bit of sad news, though, everyone here I've spoken with about Perl, thinks that Perl is practically dead.

Something like that.  It would probably be turned off by default, but it'd be dead useful for debugging.  (Especially if it also recorded mutations.)

He did post to p6c today, so he's not dead, at least.

someone doesn't irc for 3 days and people assume they're dead?  COME ON PEOPLE!  :-)

then it hit 2000 or so and I was like "oh man, now I'll need a whole 2 hours to sort through all this", so i pushed the deadline a bit more

I'd like a feature where if i delete a thread, children of that thread are automatically deleted for me, until the thread has been dead for a week

anyway, i get a lot of "army of frogs is attacking you. what will you do?" followed by "the army of frogs is dead!" all the time

greetings. I'm about to sleep now; this is just a heads-up to say I'm not dead. I have merely been caught up in $work for a couple days; after that I've stumbled upon this horrible thing called the Sims. :-/

hopes that lwall will decree that $::foo is dead, or actually a way of deferencing a type-space object, or just equivalent to $::('foo')

it seems that some details changed; previously the deadline was the 26th, and now its the 22nd; the submission email address is now also osc-lt-2005-submit-perl@plover.com

use vars is dead in p6, though, right?

so, has the stuff in S02 about $:: being the default namespace which is "searched from inner lexical scopes to outer, then from inner packages to outer" all dead now?

escapes the deadly clutches of the $conference_call 

sadly, we still have plenty of undead horses to beat around.

I'd suggest njs but njs seems unmaintained and dead

changes to the grateful dead

 currently it's dead code, but if anyone sees the use of it i can make it optional.

and the in denial refers to people like Juerd and myself, who keep beating dead horses which are dead for the wrong reasons

oh. I didn't follow the control flow.  so the oddity is the inits look like dead code.

nothingmuch: dead project has infinite inertia

nothingmuch: Inertia is a measure of how hard it is to get something to move...and dead projects don't move. :)

nothingmuch: you can't move a dead project, hence it has the most intertia

r5464, autrijus++ | * remove dead code in Bind.hs.

r5472, autrijus++ | * remove dead code.

DALnet isn't dead?

gaal: knobs, please knobs.  (backloging)  5 min is deadly in a development cycle.  way too much for "does it work _now_?".  but precompiled speed great for "ok, think so, run make test".  knobs.

There has got to be some bit of magic source filtering that will allow you to write relatively simplistic perl 6 code and have it run under both perl6 and perl5.  Just the brain dead simple stuff like . reverting to -> and ~ reverting to .

instead I will feed on the dead remains of some tofu

i'm brain dead (went bicycling for 2.5 hrs) so i'll stop pretending like I can help anyone

he was dead?

thanks for keep working on it while I'm semidead :)

clkao: I suck, I was totally dead

*.bbc.co.uk is comically dead

nudges theorbtwo (why is the IM window dead?)

long dead

knowing that I am dreaming shocks some of the other actors though - I don't fall down and play dead when shot

Limbic_Region: recently those genres have been practically dead on the PC, which sucks

?eval "Am I still dead?"

'Am I still dead?' 

?eval my $a = 10; $a +|= 0xdead

Oh evalbots still deadd.

is he dead?

coke__: can you look at README and hack Makefile.PL to print out a deadly warning so nobody gets bite by this again?

and then print out a deadly warning and die

But, that still doesn't help when your programmer explicitly wants to walk all the existing objects in a class without having links that keep objects alive that should be dead.

evalbot still dead?

Darren_Duncan: the laptop is completely dead

no photos that Ive noticed at all (I would, but my camera didnt get brought, its dead)

Eval bot is dead kelan 

or, in words of J. Joyce, that dead people rushes to capture my tongue

Hm, a google hit for "dead perl people" on my site, juerd.nl

he'll be writing the last page and then suddenly notice he's dead

sighs and wishes he didn't have unrealistic project deadlines to meet

Admittedly, it won't be quick, but it'll be dead easy to write :)

sorry I didn't get a review of your document back to you before your deadline -- I was out of town (in the middle of nowhere in New Mexico) and didn't get it until late on the 9th

so, at worst one transaction would block until the other completes ... thats not a deadlock

deadlock

Leaving S aside, because the S problem is tractable if it were all we had to worry about, P is deadly.

but anyway. today's the hard deadline of hw2005

autrijus: is there anything we can do to help you meet deadline?

but deadline is in 90 minutes :)

autrijus: when is the deadline?

happily we beat the deadline

the deadline for submission is tomorrow :-/

we're not dead, we're just resting!

Ok the bot isn't dead.

When's the deadline on it?

cool. but in implementation it's actually dead simple. I'll try to nopaste something before I sleep :)

i'd like to try xen, but its not drop-dead easy yet

I thought that project is dead?

might mean that it's stable rather than dead :)

I think its more stable than dead, meself

and then it's dead simple to get to pugs

cool.  That gives me a deadline of 20 days to convert as much as S29 and Prim.hs to Perl-MetaModel classes as possible :)

if the smoke loop isn't dead, that is

                say "The $enemy.name() is dead!" ;

dead in here?  juerd still around?

will perl6 have to run on all the platforms that perl5 runs on? some of them look pretty dead

the queen is dead

Funnily, this single screenful of text contains as much information as those 16 dead tree pages.

Hm, I just started my laptop, but I see the battery's already dead

method dead ()  { $.life <= 0 } 

#haskell people is dead, I'll ask here, it's not completely OT, I think.  Why if I do "type Id a = a; data IntM m = IntM (m Int)", then :type 2 :: IntM Id does give this error: "Type synonym `Id' should have 1 argument, but has been given 0" ?

then it's at least grateful dead

I thought the icu dep was dead now?

Side note on colons: S29 as it stands still relies on colon delimeters for optional parameters. As I understand it, that's now dead, correct? I'm working up a huge diff to change it, but don't want to finalize that until I'm clear.

Faith without works is dead

is huffman dead?

Net::IRC seems to be dead.

Atleast, the SF project is dead.

and look where they are... dead!

i must say, debian makes chroots drop-dead simple

unfortunately the regular perlnomic is meeting the same fate as all other nomics.  stagnancy leading to a dead game

(localized sites with automatic, unoverrideable selection)--  # fuck you, drop dead, and more like that.

svn dead

Oh, the server is dead entirely?

and I would say "but p6 wouldn't exist without Parrot" - but I would be dead wrong wouldn't I 

waves. SVN dead?

might be waving a dead chicken, but worth a try...

Rotterdam.pm has been dead for years

I see dead people

i just kill till it's dead

is having a braindead moment:

going from svn to svk is dead simple

falls over dead

I hear HP-UX is even deader than AIX

So this is an odd form of "dead"

undead then

the undead OS that roams the earth

i thought irix was the undead OS that roams the earth..

even dead inlines

err - tornado, I wanted to say, obviously. Like flogging a dead donkey.

I for a change bought the dead tree version

has spent next to no money on books or DVDs in the last year but typically always gets dead tree versions

i think it wants more dead chickens.

blames a dead screen and a living web irc log

blames a dead screen and praises a living web irc log

It implies that in it's existing form it's a dead end.

he's fighting with a dead filesystem, autrijus 

theorb: of course not, he's dead.

PerlJam: Huh?  Who is dead and why do I care?

(I know, spoon is dead, but spoon the person and Spoon the module are different things.)

noooo! I'm in this "deadline approaching, must write perl5 code for a living" mode

how longs kwiki.org been dead?

if i say keep-inline-functions the used ones stay, but i want the dead code too

Silly is great if you don't have a deadline.

IIRC, 6.2.0's deadline is in about -6 hours.

yes, that's true. but it's not like i'm dead set on jail :) if they offer me another task, i'll take it

the loop is also dead

i'm not dead set to go to jail, so if something else works out (eg if they offer me a task i agree to do), i'll be gone just a few weeks

Nope, mjh.  The wierd behavior of the comma operator is dead dead dead.

braindead colloquy

gaal: I'd want a pure Perl SQL DB, so Perl always has a SQL DB, even if it's dead slow :)

seems dead

It's also dead easy to implement.

"Decided RE syntax was a dead end, replaced it with rules, which are better in just about every concivable way."

hhhmmm... everyone dead? or is it just me?

not dead... just don't know enough Subversion to answer your question :)

And Perl6-Bible is a dead simple module.

As long as it works for the brain dead, I don't care

Darren_Duncan: I read that.  I'm just concerned that the concensus in the Perl5 world seems to be MakeMaker is dead, long live Module::Build.  But it sounds more as though this is to be a stopgap?

I agree, makemaker is dead

it's great to have a deadtree version :D

autrijus: Take a job translating it, and get paid to have a deadtree version!

uh, I already have a dead tree version as a gift :)

can you confirm that the codingmonkeys subetha test thingy is dead?

theorbtwo: Forking implies a new name, unless the old fork is dead, in which case it's a change of management

chip: I consider "both" old systems dead, except that EU::MM is the better variant of dead, as it is a clean skeleton instead of a rotting carcass

2) a reference IMC implementatino will free us from the dreaded deadlock situation with PIR bugs and shortcomings

pugs - 1279 - Remove dead code corresponding to the ol

https server still dead

perl6 is dead

it seems so close, and so dead serious

luqui: is development of Math::LOgic::Predicate dead?

From S02: "A bare closure also interpolates in double-quotish context. It may not be followed by any dereferencers, since you can always put them inside the closure." Later: "The old disambiguation syntax: ${foo[$bar]} ${foo}[$bar] is dead. Use closure curlies instead: {$foo[$bar]} {$foo}[$bar]."

S02.pod:The C<$#foo> notation is dead.  Use C<@foo.end> or C<[-1]> instead.

seems dead, but been a fair bit of cvs activity recently

o/~ latin is a dead language / as dead as it can be / first it killed the Romans / now it's killing me o/~

thats the beauty of it,.. most of it is brain dead translation

stevan: i don't want to do braindead translation

a deadjournal.

is too dead to even think he can try

because i just noticed i'm dropping dead

Isn't it a similar, if less deadly, error to have a leading comma?

This is an important mile stone without which you'd be dead.

I knew an American who teaches in Japan. He simply quit responding to his creditors, including student loans. He said they assume you are dead after 3 years

and not cause deadlock

mmm ICFP deadline is 13th april

nothingmuch: "Be consistent. Be nice" vs. "Be consistent. Or be dead"

No, assigning to each-other isn't automatically dead...

all... dead...

Nov 4.  I think that counts as pretty well dead.

it's not dead

"it's not dead yet."

"i'm not dead yet" "you'll be stone dead in a moment"

mumbles something else about deadlocking :)

and has no chance of deadlocking :)

cause any code accessing them (read, write) to deadlock

You dead yet?

that's the origin of the dead fish operating

deadlocking bad, makeshifting good (I think)

Hm, I think I need a dead-tree version of YAHT.

But I get partway and get distracted; that ha[[ens to me a lot less with dead-tree.

I'll probably be dead this time tommorrow

luqui: I talked steve fink into writing  http://0xdeadbeef.net/wiki/wiki.pl?FinkBlog/CodeTour

the pod is dead!  long live the kwid!

rises from the dead