ओबेरोन -2

Oberon-2

Paradigms	Imperative, structured, modular, object-oriented
परिवार	Wirth Oberon
द्वारा डिज़ाइन किया गया	Niklaus Wirth Hanspeter Mössenböck
Developer	ETH Zurich
पहली प्रस्तुति	1991 (1991)
टाइपिंग अनुशासन	Strong, hybrid (static and dynamic)
स्कोप	Lexical
प्लेटफॉर्म	Ceres (NS32032), IA-32, x86-64
ओएस	Windows, Linux, Solaris, macOS
वेबसाइट	www.ethoberon.ethz.ch
Influenced by
Oberon, Modula-2, Object Oberon
Influenced
Oberon-07, Zonnon, Active Oberon, Component Pascal, Go, Nim

ओबेरॉन -2 मूल ओबेरॉन (प्रोग्रामिंग लैंग्वेज) प्रोग्रामिंग भाषा का ऐसा विस्तार है जो सीमित प्रतिबिंब (कंप्यूटर विज्ञान) और ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग सुविधाओं को जोड़ता है, पॉइंटर बेस प्रकार के रूप में ऐरे डेटा संरचना को खोलता है, केवल-पढ़ने के लिए फ़ील्ड निर्यात करता है,और मॉड्यूल-2 से फॉर लूप को पुन: प्रस्तुत करता है।

इसे 1991 में ईटीएच (ETH) ज्यूरिख में निक्लौस विर्थ और हैन्सपीटर मौसेनबाॅक द्वारा विकसित किया गया था, जो अब ऑस्ट्रिया के लिंज़ विश्वविद्यालय के इंस्टीट्यूट फाॅर सिस्टम साॅफ्टवेयर (SSW) में हैं। ओबेरॉन -2 ओबेरॉन का सुपरसेट है, इसके साथ पूर्ण रूप से संयोजित है,और ऑब्जेक्ट ओबेरॉन का नवीन स्वरूप था।

ओबेरॉन -2 को ओबेरॉन से इंटरफेस या mixin के बिना सीमित प्रतिबिंब और एकल वंशानुक्रम (वस्तु-उन्मुख प्रोग्रामिंग) से ("टाइप एक्सटेंशन") विरासत में मिला है, किन्तु कुशल आभासी विधियों (कंप्यूटर प्रोग्रामिंग) को ("टाइप बाउंड प्रोसीजर") से जोड़ा गया है। सी ++ - शैली आभासी विधियों के टेबल का उपयोग करके रनटाइम (कार्यक्रम जीवनचक्र चरण) पर विधिवत कॉल करके हल किया गया था।

स्मॉलटाक जैसी पूरी तरह से वस्तु-उन्मुख भाषाओं की तुलना में, ओबेरॉन -2 में, मौलिक डेटा प्रकार और कक्षाएं ऑब्जेक्ट (कंप्यूटर विज्ञान) में नहीं होते हैं,कई ऑपरेशन विधि नहीं होते हैं,और ना कोई संदेश पासिंग होते है (इसे प्रतिबिंब द्वारा और संदेश विस्तार के माध्यम से कुछ हद तक अनुकरण किया जा सकता है) , जैसा कि ईटीएच ओबेरॉन में प्रदर्शित किया गया है,और बहुरूपता (कंप्यूटर विज्ञान) एक सामान्य वर्ग के उप-वर्गों तक सीमित होते है (पायथन (प्रोग्रामिंग भाषा) में कोई बतख टाइपिंग नहीं होती है), और जावा (प्रोग्रामिंग भाषा) के रूप में इंटरफेस को परिभाषित करना संभव नहीं होता है)।ओबेरॉन -2 वस्तु या वर्ग स्तर पर एनकैप्सुलेशन (कंप्यूटर प्रोग्रामिंग) का समर्थन नहीं करता है, किन्तु इस उद्देश्य के लिए मॉड्यूल का उपयोग किया जा सकता है।

ओबेरॉन -2 में प्रतिबिंब मेटाओब्जेक्ट का उपयोग नहीं करता है, किन्तु केवल टाइप डिस्क्रिप्टर संकलक से निष्पादन योग्य बायनेरिज़ में पढ़ता है,और मॉड्यूल में उजागर होता है जो प्रकार और प्रक्रियाओं को परिभाषित करता है। यदि इन संरचनाओं का प्रारूप भाषा स्तर पर उजागर किया जाता है (उदाहरण के लिए ईटीएच ओबेरॉन के स्थितियों में), पुस्तकालय (कंप्यूटिंग) स्तर पर प्रतिबिंब लागू किया जा सकता है। इस प्रकार भाषा कोड को बदले बिना इसे लगभग पूरी तरह से पुस्तकालय स्तर पर लागू किया जा सकता है। यह मुख्य रूप से, ईटीएच ओबेरॉन भाषा-स्तर और पुस्तकालय-स्तर की प्रतिबिंब क्षमताओं का बड़े पैमाने पर उपयोग करता है।

ओबेरॉन -2 जावा के समान कचरा संग्रह (कंप्यूटर विज्ञान) के लिए अंतर्निहित रनटाइम समर्थन प्रदान करता है सीमा और सरणी सूचकांक जांच आदि करता है, जो संभावित स्टैक और सरणी सीमा ओवरराइटिंग समस्याओं और मैनुअल मेमोरी प्रबंधन विवादों को भाषा सी और सी ++ में निहित करता है। मॉड्यूल आर्किटेक्चर के माध्यम से प्रतीक फ़ाइलों और एड्रेस का उपयोग करके अलग तरह से कंपाइल करके इसका तेजी से पुनर्निर्माण सुनिश्चित करता है क्योंकि परिवर्तन करने के पश्चात इंटरफेस वाले मॉड्यूल को फिर से कंपाइल करने की आवश्यकता होती है।

भाषा घटक पास्कल ओबेरॉन-2 का परिशोधन (सुपरसेट) है।

उदाहरण कोड

निम्नलिखित ओबेरॉन -2 कोड एक साधारण बाइनरी ट्री को लागू करता है:

MODULE Trees;

TYPE
    Tree* = POINTER TO Node;
    Node* = RECORD
        name-: POINTER TO ARRAY OF CHAR;
        left, right: Tree
    END;

PROCEDURE (t: Tree) Insert* (name: ARRAY OF CHAR);
    VAR p, father: Tree;
BEGIN p := t;
    REPEAT father := p;
        IF name = p.name^ THEN RETURN END;
        IF name < p.name^ THEN p := p.left ELSE p := p.right END
    UNTIL p = NIL;
    NEW(p); p.left := NIL; p.right := NIL; NEW(p.name, LEN(name)+1); COPY(name, p.name^);
    IF name < father.name^ THEN father.left := p ELSE father.right := p END
END Insert;

PROCEDURE (t: Tree) Search* (name: ARRAY OF CHAR): Tree;
    VAR p: Tree;
BEGIN p := t;
    WHILE (p # NIL) & (name # p.name^) DO
        IF name < p.name^ THEN p := p.left ELSE p := p.right END
    END;
    RETURN p
END Search;

PROCEDURE NewTree* (): Tree;
    VAR t: Tree;
BEGIN NEW(t); NEW(t.name, 1); t.name[0] := 0X; t.left := NIL; t.right := NIL; RETURN t
END NewTree;

END Trees.

ओबेरॉन -2 एक्सटेंशन ओबेरॉन के लिए

टाइप-बाउंड प्रक्रियाएं

प्रक्रियाओं को एक रिकॉर्ड (या सूचक) प्रकार के लिए बाध्य किया जा सकता है। वे वस्तु-उन्मुख शब्दावली में उदाहरण के विधियों के बराबर होते हैं।

केवल-पढ़ने के लिए निर्यात

निर्यात किए गए चर और रिकॉर्ड फ़ील्ड का उपयोग केवल-पढ़ने के लिए उपयोग तक सीमित किया जा सकता है। यह - दृश्यता ध्वज के साथ दिखाया गया है।

खुली सरणी

सरणी में जिसे पहले केवल औपचारिक पैरामीटर प्रकार के रूप में घोषित किया जा सकता था,उन्हें अब सूचक आधार प्रकार के रूप में घोषित किया जा सकता है।

कथन के लिए

ओबेरॉन में पास्कल और मोडुला-2 का फॉर स्टेटमेंट में लागू नहीं किया गया था। इसे ओबेरॉन-2 में फिर से सम्मलित किया गया है।

रनटाइम प्रकार की जाँच

पहला, सबसे पारंपरिक, दृष्टिकोण प्रकार बाध्यकारी प्रणाली पर भरोसा करना है। दूसरा दृष्टिकोण विथ स्टेटमेंट का उपयोग करना है, जो इसके वैरिएबल के लिए गतिशील उपप्रकार को सीधे जांचने की अनुमति देता है। दोनों ही स्थितियों में, इस प्रकार की पहचान हो जाने के पश्चात प्रोग्रामर इसके प्रकार के लिए उपयुक्त किसी भी प्रकार की बाध्य प्रक्रियाओं या चर का उपयोग करता है। इन दृष्टिकोणों के उदाहरण नीचे दिखाए गए हैं।

ध्यान दें कि ओबेरॉन-2 में प्रयुक्त विथ स्टेटमेंट का फॉर्म पास्कल और मोडुला-2 विथ स्टेटमेंट से संबंधित नहीं है। रिकॉर्ड फ़ील्ड तक पहुंच को संक्षिप्त करने की यह विधि ओबेरॉन या ओबेरॉन -2 में लागू नहीं किया गया है।

बाइंडिंग टाइप करें

 MODULE Birds;
     TYPE
         Bird* = RECORD
             sound* : ARRAY 10 OF CHAR;
         END;
 END Birds.
 
 MODULE Ducks;
     IMPORT Birds;
 
     TYPE
         Duck* = RECORD (Birds.Bird) END;
 
     PROCEDURE SetSound* (VAR bird : Duck);
     BEGIN
         bird.sound := "Quack!" 
     END SetSound;
 END Ducks.
 
 MODULE Cuckoos;
     IMPORT Birds;
 
     TYPE
         Cuckoo* = RECORD (Birds.Bird) END;
 
     PROCEDURE SetSound* (VAR bird : Cuckoo);
     BEGIN
         bird.sound := "Cuckoo!"
     END SetSound;
END Cuckoos.

WITH कथन

MODULE Test;
     IMPORT Out, Birds, Cuckoos, Ducks;
 
     TYPE
         SomeBird* = RECORD (Birds.Bird) END;
 
     VAR
         sb : SomeBird;
         c  : Cuckoos.Cuckoo;
         d  : Ducks.Duck;
 
     PROCEDURE SetSound* (VAR bird : Birds.Bird);
     BEGIN
         WITH bird : Cuckoos.Cuckoo DO
              bird.sound := "Cuckoo!"
            | bird : Ducks.Duck DO
              bird.sound := "Quack!"
         ELSE
              bird.sound := "Tweet!"
         END
     END SetSound;
 
     PROCEDURE MakeSound* (VAR b : Birds.Bird);
     BEGIN
         Out.Ln;
         Out.String(b.sound);
         Out.Ln
     END MakeSound;
 
 BEGIN
     SetSound(c);
     SetSound(d);
     SetSound(sb);
 
     MakeSound(c);
     MakeSound(d);
     MakeSound(sb)
 END Test.

POINTER

MODULE PointerBirds;
     IMPORT Out;
 
     TYPE
         BirdRec*   = RECORD
             sound* : ARRAY 10 OF CHAR;
         END;
         DuckRec*   = RECORD (BirdRec) END;
         CuckooRec* = RECORD (BirdRec) END;
 
         Bird   = POINTER TO BirdRec;
         Cuckoo = POINTER TO CuckooRec;
         Duck   = POINTER TO DuckRec;
 
    VAR
        pb : Bird;
        pc : Cuckoo;
        pd : Duck;
 
     PROCEDURE SetDuckSound* (bird : Duck);
     BEGIN
         bird.sound := "Quack!"
     END SetDuckSound;
 
     PROCEDURE SetCuckooSound* (bird : Cuckoo);
     BEGIN
         bird.sound := "Cuckoo!"
     END SetCuckooSound;
 
     PROCEDURE SetSound* (bird : Bird);
     BEGIN
         WITH bird : Cuckoo DO
              SetCuckooSound(bird)
            | bird : Duck DO
              SetDuckSound(bird)
         ELSE
              bird.sound := "Tweet!"
         END
     END SetSound;
 
 BEGIN
     NEW(pc);
     NEW(pd);
 
     SetCuckooSound(pc);
     SetDuckSound(pd);
 
     Out.Ln; Out.String(pc^.sound); Out.Ln;
     Out.Ln; Out.String(pd^.sound); Out.Ln;
 
     SetSound(pc);
     SetSound(pd);
 
     Out.Ln; Out.String(pc^.sound); Out.Ln;
     Out.Ln; Out.String(pd^.sound); Out.Ln;
 
 (* -------------------------------------- *)
 (* Pass dynamic type to procedure         *)
 
     pb := pd;
 
     SetDuckSound(pb(Duck));
     Out.Ln; Out.String(pb^.sound); Out.Ln;
 
     pb := pc;
 
     SetCuckooSound(pb(Cuckoo));
     Out.Ln; Out.String(pb^.sound); Out.Ln;
 
 (* -------------------------------------- *)
 
     SetSound(pb);
     Out.Ln; Out.String(pb^.sound); Out.Ln;
 
     pb := pd;
 
     SetSound(pb);
     Out.Ln; Out.String(pb^.sound); Out.Ln;
 
 (* -------------------------------------- *)
 
     NEW(pb);
 
     SetSound(pb);
     Out.Ln; Out.String(pb^.sound); Out.Ln

 END PointerBirds.

IS संचालिका

आईएस ऑपरेटर का उपयोग करके तीसरा दृष्टिकोण संभव है। यह एक रिलेशन ऑपरेटर है जिसकी समान प्राथमिकता यह बराबर (=), बड़ा (>), आदि किन्तु जो गतिशील प्रकार का परीक्षण करता है। दो अन्य दृष्टिकोणों के विपरीत, चूंकि, यह प्रोग्रामर को उस उपप्रकार तक पहुंचने की अनुमति नहीं देता है जिसका पता लगाया गया है।

सिंटेक्स

ALGOL → पास्कल (प्रोग्रामिंग भाषा) → मोडुला-2 → ओबेरॉन → घटक पास्कल भाषा परिवार का विकास सिंटैक्स (प्रोग्रामिंग भाषाओं) की जटिलता में कमी से चिह्नित है। संपूर्ण ओबेरॉन -2 भाषा का वर्णन किया गया है (मोसेनबॉक एंड विर्थ, मार्च 1995) विस्तारित बैकस-नौर रूप में केवल 33 व्याकरणिक प्रस्तुतियों का उपयोग करते हुए, जैसा कि नीचे दिखाया गया है।

Module        = MODULE ident ";" [ImportList] DeclSeq [BEGIN StatementSeq] END ident ".".
ImportList    = IMPORT [ident ":="] ident {"," [ident ":="] ident} ";".
DeclSeq       = { CONST {ConstDecl ";" } | TYPE {TypeDecl ";"} | VAR {VarDecl ";"}} {ProcDecl ";" | ForwardDecl ";"}.
ConstDecl     = IdentDef "=" ConstExpr.
TypeDecl      = IdentDef "=" Type.
VarDecl       = IdentList ":" Type.
ProcDecl      = PROCEDURE [Receiver] IdentDef [FormalPars] ";" DeclSeq [BEGIN StatementSeq] END ident.
ForwardDecl   = PROCEDURE "^" [Receiver] IdentDef [FormalPars].
FormalPars    = "(" [FPSection {";" FPSection}] ")" [":" Qualident].
FPSection     = [VAR] ident {"," ident} ":" Type.
Receiver      = "(" [VAR] ident ":" ident ")".
Type          = Qualident
              | ARRAY [ConstExpr {"," ConstExpr}] OF Type
              | RECORD ["("Qualident")"] FieldList {";" FieldList} END
              | POINTER TO Type
              | PROCEDURE [FormalPars].
FieldList     = [IdentList ":" Type].
StatementSeq  = Statement {";" Statement}.
Statement     = [ Designator ":=" Expr
              | Designator ["(" [ExprList] ")"]
              | IF Expr THEN StatementSeq {ELSIF Expr THEN StatementSeq} [ELSE StatementSeq] END
              | CASE Expr OF Case {"|" Case} [ELSE StatementSeq] END
              | WHILE Expr DO StatementSeq END
              | REPEAT StatementSeq UNTIL Expr
              | FOR ident ":=" Expr TO Expr [BY ConstExpr] DO StatementSeq END
              | LOOP StatementSeq END
              | WITH Guard DO StatementSeq {"|" Guard DO StatementSeq} [ELSE StatementSeq] END
              | EXIT
              | RETURN [Expr]
      ].	
Case          = [CaseLabels {"," CaseLabels} ":" StatementSeq].
CaseLabels    = ConstExpr [".." ConstExpr].
Guard         = Qualident ":" Qualident.
ConstExpr     = Expr.
Expr          = SimpleExpr [Relation SimpleExpr].
SimpleExpr    = ["+" | "-"] Term {AddOp Term}.
Term          = Factor {MulOp Factor}.
Factor        = Designator ["(" [ExprList] ")"] | number | character | string | NIL | Set | "(" Expr ")" | "~" Factor.
Set           = "{" [Element {"," Element}] "}".
Element       = Expr [".." Expr].
Relation      = "=" | "#" | "<" | "<=" | ">" | ">=" | IN | IS.
AddOp         = "+" | "-" | OR.
MulOp         = "*" | "/" | DIV | MOD | "&".
Designator    = Qualident {"." ident | "[" ExprList "]" | "^" | "(" Qualident ")"}.
ExprList      = Expr {"," Expr}.
IdentList     = IdentDef {"," IdentDef}.
Qualident     = [ident "."] ident.

IdentDef      = ident ["*" | "-"].

कार्यान्वयन

ईटीएच द्वारा बनाए गए अनुरक्षित ओबेरॉन-2 कंपाइलर्स में विंडोज, लिनक्स, सोलारिस (ऑपरेटिंग सिस्टम), मैकओएस के संस्करण में सम्मलित होते हैं।

ऑक्सफोर्ड ओबेरॉन-2 कंपाइलर देशी मशीन कोड के लिए संकलित करता है और विंडोज, लिनक्स और मैक ओएस एक्स पर एक जेआईटी का उपयोग कर सकता है। इसे माइकल स्पाइवी द्वारा बनाया जाता है अनुरक्षित और कीको वर्चुअल मशीन का उपयोग करता है।

मोसेनबॉक और विर्थ संदर्भ में एक के आधार पर, मैनचेस्टर विश्वविद्यालय, यूके के स्टीफन जे बेवन द्वारा ओबेरॉन -2 लेक्स (सॉफ्टवेयर) स्कैनर और वाईएसीसी पार्सर है। यह संस्करण 1.4 पर होते है।

देशी ओबेरॉन नामक एक रिलीज़ है जिसमें एक ऑपरेटिंग सिस्टम सम्मलित होते है, और सीधे पीसी क्लास हार्डवेयर पर बूट हो सकता है।

ETHZ में कुछ साधारणतयः .NET-संबंधित एक्सटेंशन के साथ ओबेरॉन का .NET फ्रेमवर्क या .NET का कार्यान्वयन भी विकसित किया गया है।

प्रोग्रामर का खुला कार्यक्षेत्र (पाउ!) एक बहुत ही सरल एकीकृत विकास वातावरण है, जो संपादक, लिंकर और ओबेरॉन -2 संकलक के साथ प्रदान किया जाता है। यह माइक्रोसाॅफ्ट विंडोज निष्पादनयोग्य के लिए संकलित है। पूर्ण स्रोत कोड प्रदान किया गया है, जिसे मुख्य रूप से कंपाइलर ओबेरॉन -2 में लिखा गया है।

जावा से ओबेराॅन के कंपाइलरr (JOB) को रूस के वोलोग्दा विश्वविद्यालय में लिखा गया था। यह जावा क्लास फाइल्स (बाईटकोड) के रूप में ऑब्जेक्ट कोड तैयार करता है। कुछ जॉब-विशिष्ट वर्ग प्रदान किए जाते हैं जो जावा संगत हैं, किन्तु जो अधिक ओबेरॉन-जैसे घटक पदानुक्रम का उपयोग करते हैं।

ऑप्टिमाइज़िंग ओबेरॉन-2 कंपाइलर कार्यक्रम जनरेशन बनाने के लिए जीएनयू संकलक संग्रह (GCC) टूलचेन का उपयोग करके C में संकलित करता है।

ओबेरॉन स्क्रिप्ट एक कंपाइलर है जो संपूर्ण ओबेरॉन भाषा का जावास्क्रिप्ट में अनुवाद करता है। इसका कंपाइलर जावास्क्रिप्ट में लिखा गया है और इस प्रकार ओबेरॉन में लिखी गई स्क्रिप्ट को प्रोसेस करने के लिए वेब पेजों से काॅल किया जा सकता है।

XDS मोडुला2/ओबेरान2 एक्सेलसियर एलएलसी, नोवोसिबिर्स्क, रूस द्वारा एक विकास प्रणाली होती है। इसमें इंटेल पेंटियम के लिए एक ऑप्टिमाइज़िंग कंपाइलर या क्रॉस-प्लेटफ़ॉर्म सॉफ़्टवेयर डेवलपमेंट के लिए वाया-सी ट्रांसलेटर सम्मलित है। विंडोज और लिनक्स के लिए उपलब्ध होते है। कंपाइलर ओबेरॉन -2 में लिखा गया है और खुद को कंपाइल करता है।

ओबेरॉन रिवाइवल ओबेरॉन 2 और कंपोनेंट पास्कल (ब्लैकबॉक्स घटक बिल्डर) को लिनक्स और विन32 में लाने की एक परियोजना होती है। ब्लैकबॉक्स का लिनक्स पोर्ट पहले अनुपलब्ध किया जाता था और यह मूल रूप से केवल माइक्रोसॉफ़्ट विंडोज़ पर चलता था।

Xओबेरान पावर पीसी के लिए एक रीयल-टाइम ऑपरेटिंग सिस्टम है, जिसे ओबेरॉन-2 में लिखा गया है।

पोर्टेबल ओबेरॉन-2 कंपाइलर (ओपी2) को ओबेरॉन सिस्टम को व्यावसायिक रूप से उपलब्ध प्लेटफॉर्म पर पोर्ट करने के लिए विकसित किया गया था।

कीको बायटेकोड

ओबेरॉन-2 कीको वर्चुअल मशीन को निशाना बना सकता है। उदाहरण के लिए, कुछ अन्य भाषा संकलकों की तरह उपयोग में लाया जाता हैं इसके लिए ओ-कोड, पी-कोड, आदि देखें।

ऑक्सफोर्ड ओबेरॉन-2 कंपाइलर पहले मध्यवर्ती बाइटकोड (केइको बाइटकोड) में संकलित करता है जिसे बाइट-कोड दुभाषिया के साथ व्याख्या किया जा सके या केवल -इन-टाइम कंपाइल के लिए उपयोग किया जा सके।

यह भी देखें

• A2 (ऑपरेटिंग सिस्टम)
• ओबेरॉन (ऑपरेटिंग सिस्टम)
• ओबेरॉन (प्रोग्रामिंग भाषा)

संदर्भ

ओबेरॉन और ओबेरॉन -2 का विकास

• ओबेराॅन Language Genealogy Tree ETHZ में अनुरक्षित
• दूसरा अंतर्राष्ट्रीय मोडुला-2 सम्मेलन, सितंबर 1991।

विस्तृत कागजात

• मोडुला से ओबेरॉन तक विर्थ (1990)
• ओबेरॉन में प्रोग्रामिंग - मोडुला-2 में प्रोग्रामिंग का एक व्युत्पन्न विर्थ (1982)
• प्रोग्रामिंग लैंग्वेज ओबेरॉन विर्थ (1990)
• ओबेरॉन 2 रिपोर्ट
• प्रोग्रामिंग लैंग्वेज ओबेरॉन-2 एच. मोसेनबॉक, एन. विर्थ, इंस्टीट्यूट फर कंप्यूटरसिस्टम, ईटीएच ज्यूरिख, जनवरी 1992 और संरचित प्रोग्रामिंग (1991) 12(4): 179-195।

किताबें

• इलेक्ट्रॉनिक ऑनलाइन संस्करणों सहित विभिन्न संदर्भ
• ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग इन ओबेरॉन-2 हंसपीटर मोसेनबॉक (1994)। (Kepler University से पीडीएफ के रूप में स्प्रिंगर-वेरलाग की मित्रवत अनुमति से उपलब्ध)
• ओबेरॉन-2 और कंपोनेंट पास्कल में डिजाइन पैटर्न
• प्रोजेक्ट ओबेरॉन। एक ऑपरेटिंग सिस्टम और कंपाइलर का डिजाइन निकलॉस विर्थ एंड जर्ग गुटक्नेच (2005)
• प्रोजेक्ट ओबेरॉन। एक ऑपरेटिंग सिस्टम और कंपाइलर का डिज़ाइन निकलॉस विर्थ एंड जर्ग गुटक्नेच (2013)

बाहरी संबंध

• Official website, ईटीएच Zürich
• ओबेराॅन Reference page at ईटीएच Zürich
• ओबेराॅन at SSW, Linz
• Pow Tutorial (in Romanian language), by Dan Popa
• ftp://ftp.inf.ethz.ch/pub/ओबेराॅन/
• The ओबेराॅन-2 Reflection Model and its Applications