一小段 MBAlib 文本節錄︰

彼得原理

管理學家勞倫斯·彼得（Laurence．J．Peter），1919年生於加拿大的溫哥華，1957年獲美國華盛頓州立大學學士學位，6年後又獲得該校教育哲學博士學位，他閱歷豐富，博學多才，著述頗豐，他的名字還被收入了《美國名人榜》、《美國科學界名人錄》和《國際名人傳記辭典》等辭書中。

彼得原理（The Peter Principle）正是彼得根據千百個有關組織中不能勝任的失敗實例的分析而歸納出來的。其具體內容是：“在一個等級制度中， 每個職工趨向於上升到他所不能勝任的地位”。彼得指出，每一個職工由於在原有職位上工作成績表現好（勝任），就將被提升到更高一級職位；其後，如果繼續勝任則將進一步被提升，直至到達他所不能勝任的職位。由此導出的推論是：“每一個職位最終都將被一個不能勝任其工作的職工所占據。層級組織的工作任務多半是由尚未達到勝任階層的員工完成的。”每一個職工最終都將達到彼得高地，在該處他的提升商數（PQ）為零。至於如何加速提升到這個高地，有兩種方法。其一， 是上面的“拉動”，即依靠裙帶關係和熟人等從上面拉；其二，是自我的“推動”，即自我訓練和進步等，而前者是被普遍採用的。

彼得認為，由於彼得原理的推出，使他“無意間”創設了一門新的科學——層級組織學（Hierarchiolgy）。該科學是解開所有階層制度之謎的鑰匙，因此也是瞭解整個文明結構的關鍵所在。凡是置身於商業、工業、政治、行政、軍事、宗教、教育各界的每個人都和層級組織息息相關，亦都受彼得原理的控制。當然，原理的假設條件是：時間足夠長，層級組織里有足夠的階層。彼得原理被認為是同帕金森定律有聯繫的。

 

在對層級組織的研究中，彼得還分析歸納出彼德反轉原理：

一個員工的勝任與否，是由層級組織中的上司判定，而不是外界人士。如果上司已到達不勝任的階層，他或許會以制度的價值來 評判部屬。例如，他會註重員工是否遵守規範、儀式、表格之類的事；他將特別贊賞工作迅速、整潔有禮的員工。總之，類似上司是以輸入（input）評斷部 屬。於是對於那些把手段和目的的關係弄反了，方法重於目標、文書作業重於預定的目的、缺乏獨立判斷的自主權、只是服從而不作決定的職業性機械行為者而言， 他們會被組織認為是能勝任的工作者，因此有資格獲得晉升，一直升到必須作決策的職務時，組織才會發現他們已到達不勝任的階層。而以顧客、客戶或受害者的觀點來看，他們本來就是不勝任的。

 

諾斯古德·帕金森（C．N．Parkinson）是著名的社會理論家，他曾仔細觀察並有趣地描述層級組織中冗員累積的現象。他假設，組織中的高級主管採用分化和征服的策略，故意使組織效率降低，藉以提升自己的權勢，這種現象即帕金森所 說的“爬升金字塔”。彼得認為這種理論設計是有缺陷的，他給出的解釋員工累增現象的原因是層級組織的高級主管真誠追求效率（雖然徒勞無功）。正如彼得原理 顯示的，許多或大多數主管必已到達他們的不勝任階層。這些人無法改進現有的狀況，因為所有的員工已經竭盡全力了，於是為了再增進效率，他們只好雇用更多的 員工。員工的增加或許可以使效率暫時提升，但是這些新進的人員最後將因晉升過程而到達不勝任階層，於是唯一改善的方法就是再次增雇員工，再次獲得暫時的高效率，然後是另一次逐漸歸於無效率。這樣就使組織中的人數超過了工作的實際需要。

彼得原理首次公開發表於1960年9月美國聯邦出資的一次研習會上，聽眾是一群負責教育研究計劃、並剛獲晉升的項目主管，彼得認為他們多數人“只是拼命地想複製一些老掉牙了的統計習題”，於是引入彼得原理說明他們的困境。演說召來了敵意與嘲笑，但是彼得仍然決定以獨特的諷刺手法編寫彼得原理，儘管所有案例研究都 經過精確編纂，且引用的資料也都符合事實，最後定稿於1965年春完成，然後總計有16家之多的出版社無情地拒絕了該書的手稿。1966年，作者零星地在 報紙上發表了幾篇述論同一主題的文章，讀者的反應異常熱烈，引得各個出版社趨之若騖。正如彼得在自傳中提到的，人偶爾會在鏡中瞥見自己的身影而不能立即自 我辨認，於是在不自知前就加以嘲笑一番，這樣的片刻里正好可以使人進一步認識自己，“彼得原理”扮演的正是那樣一面鏡子。

───

 

能帶給人們多少啟示呢？

論語中雍也篇的一句話︰

子曰：知之者，不如好之者；好之者，不如樂之者。

可否使『學習』者免於墜入『不勝任』之地步？？大概不能的吧！然而『樂在學習』者並不在意『得失』，故使得他與『追求卓越』者不同！！既已出『好惡』之外，或許是『潛龍』的乎？

初九曰：潛龍勿用。何謂也？
子曰： 龍德而隱者也。不易乎世，不成乎名﹔遯世而無悶，不見是而無悶﹔樂則行之，憂則違之﹔確乎其不可拔，乾龍也。

，如是『彼得原理』與其何用哉？？

 

難到『為了娛樂』不正是 Chris Meyers 寫作

Python for Fun

Purpose of this Collection

This collection is a presentation of several small Python programs. They are aimed at intermediate programmers; people who have studied Python and are fairly comfortable with basic recursion and object oriented techniques. Each program is very short, never more than a couple of pages and accompanied with a write-up.

I have found Python to be an excellent language to express algorithms clearly. Some of the ideas here originated in other programs in other languages. But in most cases I developed code from scratch from just an outline of an idea. However Lisp in Python was almost a translation exercise from John McCarthy’s original Evalquote in Lisp.

From many years of programming these are some of my favorite programs. I hope you enjoy them as much as I do. I look forward to hearing from readers, especially folks with suggestions for improvements, ideas for new projects, or people who are doing similar things. You can email me at mailme.html

Many thanks to Paul Carduner and Jeff Elkner for their work on this page, especially for Paul’s graphic of Psyltherin (apologies to Harry Potter) and to the Twisted developement team for their Lore documentation generator to which all the other web pages in this collection have been recently adapted.

Chris Meyers

───

 

的原由嗎？？也使得讀者得以『欣賞』，只用一百多行真可以完成『FORTH』編譯器的耶！！

#!/usr/local/bin/python
#
#   f o r t h . p y
#
import sys, re

ds       = []          # The data stack
cStack   = []          # The control struct stack
heap     = [0]*20      # The data heap
heapNext =  0          # Next avail slot in heap
words    = []          # The input stream of tokens

def main() :
    while 1 :
        pcode = compile()          # compile/run from user
        if pcode == None : print; return
        execute(pcode)

#============================== Lexical Parsing
        
def getWord (prompt="... ") :
    global words
    while not words : 
        try    : lin = raw_input(prompt)+"\n"
        except : return None
        if lin[0:1] == "@" : lin = open(lin[1:-1]).read()
        tokenizeWords(lin)
    word = words[0]
    words = words[1:]
    return word

def tokenizeWords(s) :
    global words                                          # clip comments, split to list of words
    words += re.sub("#.*\n","\n",s+"\n").lower().split()  # Use "#" for comment to end of line

#================================= Runtime operation

def execute (code) :
    p = 0
    while p < len(code) :
        func = code[p]
        p += 1
        newP = func(code,p)
        if newP != None : p = newP

def rAdd (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(a+b)
def rMul (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(a*b)
def rSub (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(a-b)
def rDiv (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(a/b)
def rEq  (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(int(a==b))
def rGt  (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(int(a>b))
def rLt  (cod,p) : b=ds.pop(); a=ds.pop(); ds.append(int(a<b))
def rSwap(cod,p) : a=ds.pop(); b=ds.pop(); ds.append(a); ds.append(b)
def rDup (cod,p) : ds.append(ds[-1])
def rDrop(cod,p) : ds.pop()
def rOver(cod,p) : ds.append(ds[-2])
def rDump(cod,p) : print "ds = ", ds
def rDot (cod,p) : print ds.pop()
def rJmp (cod,p) : return cod[p]
def rJnz (cod,p) : return (cod[p],p+1)[ds.pop()]
def rJz  (cod,p) : return (p+1,cod[p])[ds.pop()==0]
def rRun (cod,p) : execute(rDict[cod[p]]); return p+1
def rPush(cod,p) : ds.append(cod[p])     ; return p+1

def rCreate (pcode,p) :
    global heapNext, lastCreate
    lastCreate = label = getWord()      # match next word (input) to next heap address
    rDict[label] = [rPush, heapNext]    # when created word is run, pushes its address

def rDoes (cod,p) :
    rDict[lastCreate] += cod[p:]        # rest of words belong to created words runtime
    return len(cod)                     # jump p over these

def rAllot (cod,p) :
    global heapNext
    heapNext += ds.pop()                # reserve n words for last create

def rAt  (cod,p) : ds.append(heap[ds.pop()])       # get heap @ address
def rBang(cod,p) : a=ds.pop(); heap[a] = ds.pop()  # set heap @ address
def rComa(cod,p) :                                 # push tos into heap
    global heapNext
    heap[heapNext]=ds.pop()
    heapNext += 1

rDict = {
  '+'  : rAdd, '-'   : rSub, '/' : rDiv, '*'    : rMul,   'over': rOver,
  'dup': rDup, 'swap': rSwap, '.': rDot, 'dump' : rDump,  'drop': rDrop,
  '='  : rEq,  '>'   : rGt,   '<': rLt,
  ','  : rComa,'@'   : rAt, '!'  : rBang,'allot': rAllot,

  'create': rCreate, 'does>': rDoes,
}
#================================= Compile time 

def compile() :
    pcode = []; prompt = "Forth> "
    while 1 :
        word = getWord(prompt)  # get next word
        if word == None : return None
        cAct = cDict.get(word)  # Is there a compile time action ?
        rAct = rDict.get(word)  # Is there a runtime action ?

        if cAct : cAct(pcode)   # run at compile time
        elif rAct :
            if type(rAct) == type([]) :
                pcode.append(rRun)     # Compiled word.
                pcode.append(word)     # for now do dynamic lookup
            else : pcode.append(rAct)  # push builtin for runtime
        else :
            # Number to be pushed onto ds at runtime
            pcode.append(rPush)
            try : pcode.append(int(word))
            except :
                try: pcode.append(float(word))
                except : 
                    pcode[-1] = rRun     # Change rPush to rRun
                    pcode.append(word)   # Assume word will be defined
        if not cStack : return pcode
        prompt = "...    "
    
def fatal (mesg) : raise mesg

def cColon (pcode) :
    if cStack : fatal(": inside Control stack: %s" % cStack)
    label = getWord()
    cStack.append(("COLON",label))  # flag for following ";"

def cSemi (pcode) :
    if not cStack : fatal("No : for ; to match")
    code,label = cStack.pop()
    if code != "COLON" : fatal(": not balanced with ;")
    rDict[label] = pcode[:]       # Save word definition in rDict
    while pcode : pcode.pop()

def cBegin (pcode) :
    cStack.append(("BEGIN",len(pcode)))  # flag for following UNTIL

def cUntil (pcode) :
    if not cStack : fatal("No BEGIN for UNTIL to match")
    code,slot = cStack.pop()
    if code != "BEGIN" : fatal("UNTIL preceded by %s (not BEGIN)" % code)
    pcode.append(rJz)
    pcode.append(slot)

def cIf (pcode) :
    pcode.append(rJz)
    cStack.append(("IF",len(pcode)))  # flag for following Then or Else
    pcode.append(0)                   # slot to be filled in

def cElse (pcode) :
    if not cStack : fatal("No IF for ELSE to match")
    code,slot = cStack.pop()
    if code != "IF" : fatal("ELSE preceded by %s (not IF)" % code)
    pcode.append(rJmp)
    cStack.append(("ELSE",len(pcode)))  # flag for following THEN
    pcode.append(0)                     # slot to be filled in
    pcode[slot] = len(pcode)            # close JZ for IF

def cThen (pcode) :
    if not cStack : fatal("No IF or ELSE for THEN to match")
    code,slot = cStack.pop()
    if code not in ("IF","ELSE") : fatal("THEN preceded by %s (not IF or ELSE)" % code)
    pcode[slot] = len(pcode)             # close JZ for IF or JMP for ELSE

cDict = {
  ':'    : cColon, ';'    : cSemi, 'if': cIf, 'else': cElse, 'then': cThen,
  'begin': cBegin, 'until': cUntil,
}
  
if __name__ == "__main__" : main()