CECIL(ID:1720/cec001)

Prototyped OOL 

"The Cecil language design began in 1991 as an attempt to combine the advantages of Self, CLOS, and Trellis: a simple, uniform language based on dynamic dispatching, the use of multiple dispatching, and a sound static type system."

Object-oriented language combining multi-methods with a classless object model, object-based encapsulation, and optional static type checking. Distinguishes between subtyping and code inheritance. Includes both explicit and implicit parameterization of objects, types, and methods.


People:
Structures:
Related languages
CLOS => CECIL   Influence
Self => CECIL   Influence
Trellis => CECIL   Influence
References:
  • Chambers, C. "The Cecil Language: Specification and Rationale", TR 93-03- 05, U Wash (Mar 1993). view details
  • Chambers, Craig "Overview of the Cecil/Vortex Project" view details Abstract: The Cecil/Vortex project is aimed at developing techniques for constructing practical programming systems (languages, implementations, and environments) that will help make large applications and systems programs easier to write and extend. The effectiveness of a programming system is determined in large part by the extent to which:
    ? the programming language?s features are available in an orthogonal, unrestricted form,
    ? the language is implemented efficiently enough to encourage programmers to use the important features, and
    ? the language and its intended programming style are supported by a programming environment.
    The Cecil/Vortex project integrates language design, language implementation, and programming environment research. We believe that the synergy of the combined research program leads to more rapid progress and better final results in each individual area. Moreover, the Cecil/Vortex project aims to develop usable artifacts incorporating the research results, both to better evaluate the effectiveness of the research results and to use as a foundation for future research. External link: Online copy
  • Abadi, Martin and Cardelli, Luca "A Theory of Objects" Springer Monographs in Computer Science, 1996 view details
  • Chambers, Craig "Synergies between object-oriented programming language design and implementation research" Invited talk at ISOTAS conference, Japan, March 1996 view details Abstract: By pursuing language design and language implementation research in
    parallel, interactions between the two research areas can be exploited to make faster, better progress in both. We report on our experiences working on the Cecil language design project and the Vortex optimizing compiler project, highlighting how each project has encouraged and challenged the other. External link: Online copy
  • Chambers, Craig "The Cecil Language Specification and Rationale Version 2.0" view details Abstract: Cecil is a purely object-oriented language intended to support rapid
    construction of high-quality, extensible software. Cecil combines multi-methods with a simple classless object model, a kind of dynamic inheritance, modules, and optional static 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 (mutable) state.

    Cecil's static type system distinguishes
    between subtyping and code inheritance, but Cecil enables these two
    graphs to be described with a single set of declarations, streamlining the common case where the two graphs are parallel. Cecil
    includes a fairly flexible form of parameterization, including explicitly parameterized objects, types, and methods, as well as implicitly parameterized methods related to the polymorphic
    functions commonly found in functional languages External link: Online copy
  • Litvinov, Vassily "Constraint-Based Polymorphism in Cecil: Towards a Practical and Static Type System" OOPSLA '98 Conference Proceedings view details Abstract: We present a static type system for object-oriented languages which
    strives to provide static typechecking without resorting to dynamic "type casts," restricting what code the programmer can write, or being too verbose or difficult to use in practice. The type system supports bounded parametric polymorphism where the bounds on type variables can be expressed using general recursive subtype or signature constraints, with F-bounded polymorphism and covariant type parameters being special cases.

    We implemented this type system in the Cecil language and used it to
    successfully typecheck a 100,000-line Cecil program, the Vortex optimizing compiler. Our experience was very good: dynamically-typed code needed very little rewriting. We also observed several common programming situations that presented a challenge for our type system. We discuss these situations and ways to typecheck them statically.
    External link: Online copy
    Resources