text_combined: demerphq oryiufjngmailcom 103007 linda w wrote probably long response tried answer points brought sigh focus forests trees demerphq wrote referencing subroutine referencing slot glob symbol table symbol tables hashes therefore behavior expected fact results behavior find suprising reflection misunderstanding subroutine calls method calls work dyanmic language error perls behaviour explanation based perls internals bug perls internals implementation supporting evidence documented oo calling functionality broken bug perl behaving way dont expect bug perl behaving contrary way documented work bug perl case behaving exactly designed work ergo bug isnt reference causing problem though focusing focusing compile time oomethod calling dynamic right thing call made er im dont understand come conclusion execution time situation resolved execution time perl knows whether boom defined locally execution time assert perl look parent methods valid method give priority defined parental method dying fatal error saying method defined shouldnt valid methods perl entries symbol table simple second problem universal method broken well according ooperlconway returnes true object class call method requested local method undefined stated error message return reference function since function method legally callable yes consequence dealing dynamic language dont like use different language conway glossed stickier details quote probably didnt want confuse things perl deal autoload dynamic issues dont think part oo functionality major part method defined local checks parent classes taking reference subroutine involved method dispatch documented take reference parents subroutine therefore isnt bug trying take reference parents subroutine well thats sure code original comments made look like taking reference routine whos location know wanted see reference returned null undefined reference valid wasnt blindly expecting reference work wanted see indication wasnt defined wouldnt call decided taking reference subroutine must return undef subroutine wasnt defined thats things work know ill comment seem really like using nonperl terminology context perl discussion dont seem listen people tell correct makes hard help indicates gaps perl foundation knowledge think add thinking things work ways dont problem perl isnt behaving defined oocalls many times people tell behaving defined believe consider understanding flawed perls behaviour instead go justifying badbehavior based perls internals umm merely explain perl works try rationalize disconnect flawed mental model perls actual behaviour wish going get anywhere understand perl internals wont return null undef value checking result undefined_routine understand currently perl blindly calls referencecreated stub im saying oo rules whose oo rules ces javas smalltalks pythons whichever rules speaking arent perls apriori oo rules defined particular context may general conventions dispatch mechanism expected abide order considered oo general programming public details entirely within remit language designer return true methods undefined says graham bar says otherwise guess one people listen justifying current behavior based perls internals doesnt mean isnt bug well people pointed intentional documented behaviour neither justified perls internals bug said find suprising reflection misunderstanding subroutine calls method calls work dyanmic language error perls behaviour based perl internally implemented realize converse said fact claim nonoo behavior desirable compatible nonoo hash autovivification justifying bug may moroe reflection misunderstanding oo calls give priority parent methods throwing found error wrong error reason reason perl allows methods created fly perl told method supplied later method suppled later sane behaviour die error maybe autoload routine broken way perl cant know whats wrong knows something wrong scenario passing parent method would wrong may parent method something inappropriate maybe even dangerous may expert perl internals domain correct oo behavior supersedes incorrect function based language quirks due implementation sorry thats wrong said earlier behaviours generally considered necessary dispatch mechanism considered oo details necessarily left language designer disagree agree call funkymethodself throwing error desired behavior im saying perl smart enough know difference funkymethodself selffunkymethod follow oo method searching parent methods throws error nonexistent local method wasnt nonexistent created perl way know accidentally didnt mean using methodcall syntax selfmethod look parent classes method throwing undefinederror created subroutine stub symbol table subroutine stub method call subroutine call wouldnt oo lookups func shouldnt take precedence oo call written selfmethod _might_ agree local symbol given preference func isnt valid way many emphasized access method name used reason selfmethod oo call use nonoo reference override valid parent method look perl doesnt work way think either get used dont use repeating incorrect assumptions going get nowhere symbol table perl assume execution time local symbol undefined look valid defined symbol defined local function yes would expect perl override function isnt fully defined body missing stub give 1 way calling empty stub preferable looking parent classes first based perl internals hard get correct autoload assumption subroutine stub expected filled later autoload autoload doesnt error code anything throwing error would make sense method call supposed look entry current package failing finding one supposed look parents classes differ claim method calls look methods stuck perls internals talking entries ooparlance doesnt talk implementationspecific things like entries stuck insisting ideal form oo languages must comply isnt never never created one created nonexistent forwardfunction reference valid method foo oo supported way referencing creating method argh way perl know valid method difference methods functions perl simple albeit unusual route perl found muddying water bringing method dispatch somehow make incorrect autovivification seem less fault autovivification vivifies function stubs oomethods autov perl construct oo construct compiler bogus reference would fail compile time referenced local function would exist perl dynamic binding final check existence isnt done execution time point call made call made oomethod give oomethod lookup preference perls implementation specific _function_ autovivification nonexistent function reference created nonoo reference certainly agree foo supported oo way accessing methods oo gets away implementation specific details using addressof type operators shouldnt assume anything inappropriate die golly gee thats exactly mean computers dont normally ignore things programmers tell generally considered bug cant turn around say case perl know didnt really mean something pretend didnt perl 1 call mechanism func supported proper oo way access methods would agree wasnt im saying func isnt oo oo shouldnt give preference throwing fatal error parent method search sigh saying execution time smethod perl idea oo call different funcs course knows difference one use method dispatch one use direct dispatch im saying doesnt know difference sub method difference finds sub one essentially hash lookup current package recursive depth first search packages listed isa finds package hash lookup returns something looks like subroutine several ooconversant people emphasize even though methods functions similar treated agree makes sense funcs normal function call smethod used oo calls ways perl telling thats internal based perspective perspective oo implementation oo perspective would expect undef_func would override oo baseclass searching oo construct understand believe internal standpoint dont feel internal implementation decider desired correct oo standpoint since oo defined perl ever existed oo changed time doesnt definition seem think generally accepted set requirements far know perl satisfies thats well solution others come one even knew reported bug confusing behaving oolanguage lookup supposed well told several times wrong sorry dont accept wrong faith ive always know case internallyfocus implementation produces incorrect behavior viewed oo perspective viewed perspective oo appears heavily influenced languages implementation however perspective oo least seems take account consequences perl dynamic language therefore sync reality thats nice bad doesnt match actually works given dont seem understand deeper implications working dynamic language dont think really good position determine one work perlinternals expert write oo one experience oo one might preexisting ideas might one read generally acceptedasgood ooperl book point oo reference says inheritedmethods first search undefined function stubs localentry table everything spelled explicity documentation explains exactly perl explains things like autoload etc put together holistically things implicitly explained user rely builtin function determine method safe call tried protect calls returns true reference samename undefined local function cant use definedselfmethod replacement selfcanmethod two issues first shouldnt create function stubs dont intend fill tried explain multiple times stubs filled program classes functions started local slowly conceptuallyfunctional areas broken apart manageable packagesclasses long calls package class worked point referenced functions moved jump table used called tkkeyboardevent handler doesnt matter intentions matters code fact rather unusual mechanism annoying agree wrong excel fitting parts together novel ways second cant generally rely references subroutines see regardless obtained means thing named dispatch would named method dispatch named subroutine dispatch yesand see example str8forward translation reference named something like selfmethodparams obviously wasnt going work fact difference refbased calling namebased calling unfortunately one problems oo examples find seem use examples use strict used something tend always use end examples like selfcanfoo isnt immediately obvious foo effectively treated string see please flag documentation bug say generally reason btw controlled circumstances rely behavior situation wasnt really would consider controlled circumstance well really control considering going complete nonoo case oo case order make easily extensible testing want find bugs cant controlled testing must also things developer know steer around arent sure based implementation whether work programmers find things work stick want find errors things wouldnt normally think try morning coffee acknowledge str8tforward fix one might like believe area hit often bug report numbers represent many perlexperts knew workaround couldnt say failed reams code riddled red flags fact code analysed plain simply wrong method dispatch really nothing yes redflags posted first bit code id gone tons variations didnt expect work since things expected work trying things didnt expect work hoped would generate information point direction wonder one hit exact reason would satisfied listened advice given instead discounting superstitious problem would gone away yeslike wouldnt hit working wouldnt confused thinking incorrect may claim working calling local functions known undefined take precedence searching base classes matches bugs disagree maybe get verification damian conway doesnt work perl verify object oriented framework desirable give calllookup precedence local undefined function valid parent methods desired behavior return true function stubs callable methods er im sure damian conway felt like getting involved disucssion would managed reduce less 10 lines code maybe would hit explanation would satisfied sifting 50 lines code riddled red flags fun especially person trying help argues red flags point someone wants code work doesnt desire understanding something broken im sure wont argue someone giving workaround instead answer eventually got help needed regarding example looking added cases concerned resulting code 70 lines 20 wo debug statements showing error runtime sorry id encountered many different ways type code fail many variations accept workaround wanted know incorrect understanding oo massive braino disruption misreading various ooperl examples references unexpected bug feature threw expected things work vs actually bug people would realized went oh ok doesnt expect instead want must bug doesnt believe using perlimplementation based reason justification behavior dont agree ooimplementation precedence given nonoo reference agree advisable oo fact dont know oo implementations depend method addresses classes breaks oo paradigm agreeing func oo allows oospecific call method rely functions defined way also agree function returning true valid _method_ available function stub current implementation aside really believe current implementation unreliable localundeffuncs supersede parent method calls serves valid reasonable purpose yes put current implementation aside think converse oo experts perlinternal experts functionality suggested functional within object oriented context point view oo experts nondynamic languages opinion irrelevent oo experts dynamic languages opinion probably much explained may quibble various aspects perl works given constraints various language design decisions impose functioning would bet open minded well informed people would come less similar conclusions going lazy loading subroutines going intrinsic type orthagonal class going allow methods subroutines redefined normal program flow various consequences unusual people find certain aspects unexpected undesirable thats situation languages choose sacrifice features use alternate implementations avoid problems impacting oo fine perls heritage language started without support oo added various neat features time end result somewhat loose highly flexible oo framework occasionally surprises people come backgrounds much without designing new language done two separate projects currently btw last im going contribute thread im sorry dont time either get used perls oo warts switch languages alternative frustrate annoy rest us yves perl mredebug e justanotherperlhacker thu 07 aug 2008 084211 0100 perl 46987 oocall failures autovivfunctions testing existence