************************************************************************ Jacob Meushaw OOPL Cecil University of Washington http://www.cs.washington.edu/research/projects/cecil/ www/Refman/wmwork/www/cecil-spec_1.html Cecil is an object oriented research language designed at the University of Washington in Seatle, Washington by Craig Chambers. It is based heavily on the language SELF. SELF has a classless object model and data access through methods. The Cecil langauage makes everything an object including data. These objects are manipulated via messages. The objects are classless as in the language SELF, which cecil is based on. Cecil also incorporates multi-methods, statically checkable declarations and assertions, and modules. A single object declaration can double as the definition for an entire data type. ************************************************************************ ************************************************************************ Arron Watson Cecil : http://www.cs.washington.edu/research/projects/cecil/cecil/ www/cecil-home.html The earliest paper I could find dealing with Cecil was from 1992. In this paper, Cecil was referred to as a new programming language (1). So, it would be reasonable to assume that Cecil appeared around this time. Created at the University of Washington, Cecil uses a classless object model that is based on a pure object model: all data are objects, and objects are manipulated solely by passing messages. Its authors felt that a classless object model was simpler and more powerful than traditional class-based object models. While maintaining its expressive power, Cecil is simplified with its classless structure. Since message passing is the cornerstone of the power of object-oriented systems, Cecil includes a fairly general form of dynamic binding. Inheritance is utilized in Cecil to organize software and factor out commonalties. Cecil extends traditional inheritance mechanisms with predicate objects to support an automatic form of classification of objects into specialized subclasses based on their run-time state. (1) Papers/cecil-oo-mm.html some sample code ... (i had trouble finding a simple 'hello world' example!) ----------------------------------------------------------------------- object polygon; var field vertices(@polygon); method draw(p@polygon, d@output_device) { (-- draw the polygon on an output device, accessing vertices --) } object rectangle isa polygon; var field top(@rectangle); var field bottom(@rectangle); var field left(@rectangle); var field right(@rectangle); method vectices(r@rectangle) { -- ++ is a binary operator, here creating a new point object [r.top ++ r.left, r.top ++ r.right, r.bottom ++ r.right, r.bottom ++ r.left] } method set_vertices(r@rectangle, vs) { (-- set corners of rectangle from vs list, if possible --) } ************************************************************************ ************************************************************************ Andrew Glover CSCI 379-01 1/16/99 Oberon Synopsis The Object-Oriented Programming Language "Oberon" was originally developed at ETH Zuric beginning in 1985. The designers of Oberon were Niklaus Wirth and Jurg Gutknecht. Originally, Oberon was meant for the development of in-house software at ETH Zuric. The goal of developing Oberon was to create a working operating system based on the language Cedar. Since the original designers did not have much to work with in terms of disk space and memory, Oberon was built to be very small and efficient. It has since been ported to many platforms, including Windows, Macintosh, and Linux and is currently being ported to Solaris and HPUX. The Oberon system can also be installed as an autonomous operating system on top of Windows compatible hardware. This version is known as PC Native Oberon. As a language, Oberon supports many standard language practices. It supports information hiding, late binding, object-orientation, polymorphism, separately compiled modules, and strong type checking. The environment that Oberon runs on supports both garbage collection and dynamic module loading. Oberon also supports information hiding for entire collections of types, not just with single objects, allowing the programmer to add another level of security to their code. It was designed in such a way as to facilitate object-oriented programming education and is currently used by many colleges and universities in introductory programming courses. Here is a code sample wich appends a character to a string: PROCEDURE Append*(VAR to(** in/out *): ARRAY OF CHAR; this: ARRAY OF CHAR); VAR i, j, l: LONGINT; BEGIN i := 0; WHILE to[i] # 0X DO INC(i) END; l := LEN(to)-1; j := 0; WHILE (i < l) & (this[j] # 0X) DO to[i] := this[j]; INC(i); INC(j) END; to[i] := 0X END Append; language list Ada95 - lglwww.epfl.ch/Ada/Tutorials/Lovelace/lovelace.html BETA - www.daimi.au.dk/~beta/ Blue - www.sd.monash.edu.au/blue/ C++ - www.csci.csusb.edu/dick/c++std/ Cecil - www.cs.washington.edu/research/projects/cecil/cecil/www/cecil-home.html CLIPS - www.ghg.net/clips/CLIPS.html CLOS - www.franz.com Dylan - (links from www.well.com/user/ritchie/oo.html but they're old) Eiffel - www.cm.cf.ac.uk/CLE Java - www.javasoft.com/ LENS - progwww.vub.ac.be/pools/lens/ Modula-3 - www.research.digital.com/SRC/modula-3/html/home.html Oberon - oberon.ssw.uni-linz.ac.at/Oberon.html Object Oriented Turing - www.holtsoft.com/turing/home.html Object Rex - www2.hursley.ibm.com/orexx/ Objective C - www.santafe.edu/projects/swarm/ObjC/objective-c.html OO-Cobol - www.well.com/user/ritchie/oo.html Oz - www.ps.uni-sb.de/oz/ python - www.python.org Sather - www.icsi.berkeley.edu/~sather/ Self - self.smli.com/ Sina - wwwtrese.cs.utwente.nl/sina/ Smalltalk - st-www.cs.uiuc.edu/ Theta - clef.lcs.mit.edu/Theta.html TOM - www.gerbil.org/tom/ ************************************************************************ ************************************************************************ Nathan Orr http://www.well.com/user/ritchie/oo.html Object Oriented Programming Languages: agora blue dylan lens sina theta http://www.sd.monash.edu.au/blue/ Blue Synopsis: The problem with Pascal today is that it is based on an outdated programming paradigm. The problem with existing OO languages is that they are not made for teaching. Blue tries to bring these two aspects together and aims at being the object-oriented equivalent of Pascal. The problem with existing OO languages lies in their complexity. Languages like C++, Ada, Eiffel, etc have all been developed for real world use in the industry, thus introducing, from the teaching point of view, an undesirable overhead in size, complexity and uglyness. Some of the problems are with the languages themselves, some are with their programming environments. See Requirements for a First Year Object-Oriented Teaching Language for a more detailed examination of the problems of existing languages. Blue is an object-oriented programming language that was developed especially for teaching. It runs in an integrated programming environment that includes a graphical program structure editor, a text editor, a debugger, a library browser, and more. It was developed for teaching obect-oriented concepts to first year students. The Blue language can be briefly characterised by the following key words: Pure object-oriented language Blue supports programming only in classes - classes are the structuring mechanism for all code. It is not a hybrid language that offers both, procedural and object-based programming. Clean, simple, well-defined concepts Emphasis in the language design was on the concepts we want to teach. The important object-oriented concepts are represented in the language in a clean and simple way. Static, "strong" type checking Full static type checking. Single inheritance Genericity (Polymorphism) Blue supports both constrained and unconstrained genericity. Readable syntax: The syntax is based on keywords (rather than symbols) and many programs can be understood by programmers who are not familiar with the details of Blue. Students can easily learn from example programs, or look up keywords in a textbook. Assertions, pre and postconditions Assertions, pre and postconditions are checked by the runtime system. Small Although the features mentioned above are powerful, the language is very small. It can very quickly be learned by programmers familiar with any other OO language, and students can get to a point where they feel comfortable with the whole language (not only a subset). Easy-to-use integrated environment The environment is essential for first year students. It allows teachers to concentrate on the language topics without wasting too much time on operating system problems. It encourages debugging and testing as part of the development process from the very beginning on. Easy transition to C++ and similar languages Blue is similar enough to C++ to make it easy to transfer skills learned with Blue to C++ programming (or any other imperative object-oriented language). Automatic garbage collection Free Blue will be available free of charge to everyone. (This includes the whole environment.) ************************************************************************ ************************************************************************ Tim Evans CS379 Here's my list of object-oriented pl's: Smalltalk Sather C++ Self Eiffel Theta Java Modula-3 Ada95 OO-Cobol Agora Python Beta Sather CLOS Self CLU Theta Simula Object Pascal Flavors Plasma ACT2 Objective-C ObjVlisp ABCL/1 ACT1 Synopsis of the programming language: Cecil Cecil is a pure object-oriented programming language, initially inspired by the languages of Self, CLOS, and Trellis. It is intended to support the rapid construction of high-quality, reusable, extensible software systems. Cecil is unusual in combining a pure, classless object model, multiple dispatching (multi-methods), modules, and mixed static and dynamic type checking. Instance variables in Cecil are accessed solely through messages, allowing instance variables to be replaced or overridden by methods and vice versa. CecilŐs predicate objects mechanism allows an object to be classified automatically based on its run-time state. Type declarations are optional. And objects can be extended externally with additional methods and instance variables, often encapsulated in separate modules, supporting a kind of role-based or subject-oriented programming style. The information from this page came from a research project done on Cecil at the University of Washington. Although I could not find any history of Cecil besides coming from Self, CLOS and Trellis, it must be extremely unused since every search I did on it ended up on the same page from UW. ************************************************************************ ************************************************************************ Missy Biglete OOCOBOL, OOLOGO, ADA95, CLOS, OO in Perl, OOProlog, Beta, Eiffel, dylan Synopsis of Dylan: Dylan is a general purpose programming language invented by Apple Computer. It was developed with Harlequin and other partners. Harlequin developed the first complete, commercial implementation of Dylan. The name Dylan comes from a combination of the words "DYnamic" and "LANguage". It is both object-oriented like C++ and dynamic like Smalltalk. Implementations of Dylan exist on Macintosh, UNIX, DOS, and Windows. Dylan was designed for use in application and systems programming and includes garbage collection, error recovery, and type-safety. The language is good for complex object-oriented programs and programs that need to be changed often and quickly. One advantage is that a programmer can use a single construct to achieve several ends. This multi-method dispatch makes the language more powerful and easier to understand. ˇ Bindings (variables) are resolved at compile time and can be private or shared. ˇ All objects are typed and each is type checked during either compile-time or runtime. ˇ Objects are deallocated automatically when they can no longer be reached by the program. ˇ Functions are active portions of a Dylan program. They accept 0 or more arguments and return 0 or more values. Functions accept arguments of specific types and an error arises when arguments are sent with the wrong types. . The syntax of Dylan is simple and easy to understand. Those who are not familiar with the language can usually understnad it. Example of the "Hello World" program. *****this uses an implementation of Dylan called NOODLE***** (define (hello ) (method () (print "Hello, World"))) The looping version is: (define (hellol ) (method () (print "Hello, World") (hellol) ) ) ***author Richard Morse**** ************************************************************************ ************************************************************************ Greg Colburn Python History Python began to take form in 1990 at CWI in Amsterdam. The development of Python was born out of the need for a language that could function as a scripting language while still capable of accessing a system call interface. Python development began on the Amoeba system. The new language was exclusively used on the Amoeba used with great success until early 1991 when the author posted information about Python on the USENET. At this time, Python is maintained at CNRI in Reston, Va. Language Python is a portable, interpreted, object-oriented programming language. It is designed to work on numerous platforms including most UNIX's, Windows, Mac and IBM's defunct OS/2. Python boasts a clear and simple context that is still very powerful. Major features of Python are support for incorporating modules, exceptions, dynamic typing, very high level dynamic data types, and classes. As mentioned before a major function of Python is its strong interface with systems calls and system libraries. Python can be integrated well with many platforms. Support for numerous windowing systems is built into the libraries. When that isn't enough Python can be expanded with modules written in C or C++. Usage Text manipulation is Python's strongest feature. Its simplicity and speed revil more popular languages such as CGI. Because text manipulation often lends itself to scripting, Python most popular use is scripting. Many programs use Python to integrate many different tools into one cohesive package. This also includes combining graphical interfaces into numerous text based systems. Background Many people wonder where the name Python came from. The title "Python" was inspired by the popular British comedy "Monty Python." The auther is quoted as saying "It occurred to me one day that I needed a name that was short, unique, and slightly mysterious." Apparently the author of Python was a big fan. ************************************************************************ ************************************************************************ Atipon Tantivit OOPL 1/16/99 Professor Mead Source http://www.daimi.aau.dk/~beta/ (BETA Programming Language FAQ) BETA - BETA originates from the Scandinavian school of object-oriented where the first object-oriented language Simula was also developed. - The BETA language development started in 1975 based on the Simula languages. - Kristen Nygaard, one of the two original designers of the Simula languages, was participated in the development of the BETA language. - BETA is a modern object-oriented language with comprehensive facilities for procedural and functional programming. - BETA is a strong typed language (like Simula, Eiffel, and C++), with most type checking carried out at compile-time. - BETA replaces classes, procedures, functions, and types by a single abstraction mechanism called the pattern. - Patterns describe not only all aspects of objects, such as attributes and operations, as seen in traditional object-oriented languages, but also aspects such as parameters and actions, as seen in procedures. - Objects are created from the patterns. - Objects may be traditional objects as found in other languages, or they may also be objects which correspond to procedure or function activations, exception occurrences, or even coroutines or concurrent processes. - Patterns can have hierarchies. - Object may be created statically or dynamically and the objects are automatically garbage collected by the BETA runtime system when no references exist to them any longer. - It has discussed to change the name BETA to something else to avoid the beta-testing jokes. The suggestion for a name is Scala - Scandinavian Language. However, the name has been decided to stick with BETA. ************************************************************************ ************************************************************************ Brian Winant Eiffel (information found at www.eiffel.com) Eiffel is an object-oriented programming language developed by Interactive Software Engineering. The aim of the language is to help specify, design, implement, and modify large software systems. The language specification is platform-independent, like Java, and thus Eiffel programs can be run on any platform. Development environments are currently available for Windows and Linux. The language contains predefined libraries and allows for the easy construction of new libraries. Eiffel code can interact with code developed in another language. The language is compiled and features static typing, assertions, disciplined exception handling, and automatic garbage handling. Objects are described as instances of abstract data types, thus classes are employed. Object methods are broken down into procedures and functions, depending on whether or not the method returns a value. Eiffel is a relatively small language, about the same size of Pascal. Sample code: class ACCOUNT feature balance: INTEGER owner: PERSON minimum_balance: INTEGER is 1000 open (who: PERSON) is -- Assign the account to owner who. do owner := who end deposit (sum: INTEGER) is -- Deposit sum into the account. do add (sum) end withdraw (sum: INTEGER) is -- Withdraw sum from the account. do add (-sum) end may_withdraw (sum: INTEGER): BOOLEAN is -- Is there enough money to withdraw sum? do Result := (balance >= sum + minimum_balance) end feature {NONE} add (sum: INTEGER) is -- Add sum to the balance. do balance := balance + sum end end -- class ACCOUNT ************************************************************************ ************************************************************************ The OBERON Programming Language: A Brief Summary Nicholas L. Stone OOPL - Mead January 17, 1999 Oberon is a general purpose programming language similar to Modula-2. The language was specifically designed for systems programming. More specifically, Oberon was used to create the Oberon System in cooperation with J. Gutknecht. Shortly after its initial conception, a new version of Oberon was developed, Oberson-2, which implemented additional object-oriented features. These features include separate compilation of modules with interface checking across module boundaries, implementation modules, strong type checking, type-safe with no possibility of dangling pointer or memory leaks, run-time type checking, run-time checks to catch overflow and out of range errors, instance and class centered type-extension for object-oriented programming, messages realized as extensible records for programming message forwarding and message delegation, type-bound procedures for implementing methods, I/O operations realized by standardized libraries. Of these characteristics, the most important are those dealing with block structure, modularity, separate compilation, strong type checking, and type-extension. In essence, the type-extension and modularity make Oberon an OOPL. In Oberon a module is a collection of declarations of constants, types, and procedures, together with a series of assignment statements. A module constitutes a text that is compilable as a unit. For example: MODULE Trees; (* exports: tree, Node, Insert, Search, Write, init *) IMPORT Texts, Oberon' (* exports read-only: Node,name *) TYPE Tree * = POINTER TO Node; Node * = RECORD Name-: POINTER TO ARRAY OF CHAR; Left, right: Tree END; VAR w: Texts,.Writer; 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; END Insert; PROCEDURE Init * (VAR t: Tree); VAR t: Tree; BEGIN NEW(t.name, 1); t.name[0] := 0x; t.left := NIL; t.rihgt := NIL; END END Trees.