C+@(ID:1612/c::005)Simplified Cpronounced CAT Jim Vandendorpe Bell Labs 1991 Object-oriented language, uniformly represents all data as a pointer to a self-described object. Provides multiple inheritance with delegation, with control over which methods come from which delegated object. Default methodologies. Simple syntax, with emphasis on graphics. Originally used for prototyping of telecommunication services. Places Structures: Related languages
References: Extract: Introduction Introduction Calico is a new C-based object-oriented language supported by an integrated software-development environment. We designed Calico to provide a rapid development environment for object-oriented systems that would leverage off of the Unix/C environment and provide strengths from several languages and systems, including Smalltalk, CLOS, C++, and Eiffel. None of these languages directly addressed our needs, but each contributed ideas we wanted to develop and use. Calico introduces some unique language features, but its primary contribution is the productivity advantage that this feature integration provided to the Unix/C environment. Calico features + a simple, uniformly applied object model, + a syntax easily mastered by C programmers, + a new multiple inheritance model, + simple method-call semantics with some novel extensions, and + effective support for the team development process. Extract: DEVELOPMENT GOALS DEVELOPMENT GOALS We designed Calico because we wanted to significantly increase the productivity of teams programming in the Unix/C environment. This led to the following design requirements for Calico: It should have a uniformly applied object model, in which all data items are (conceptually, at least) objects whose behavior is defined by a class and whose encapsulation is preserved in all programming aspects. Although we wanted multiple inheritance for design flexibility, we required that it add minimal complexity to the language. We felt that inheritance should maintain strict encapsulation of and paradigms in a way that amplifies the natural strengths of Unix and C. Extract: DEVELOPMENT GOALS DEVELOPMENT GOALS We designed Calico because we wanted to significantly increase the productivity of teams programming in the Unix/C environment. This led to the following design requirements for Calico: + It should have a uniformly applied object model, in which all data items are (conceptually, at least) objects whose behavior is defined by a class and whose encapsulation is preserved in all programming aspects. Although we wanted multiple inheritance for design flexibility, we required that it add minimal complexity to the language. We felt that inheritance should maintain strict encapsulation of classes so large projects would remain manageable even when developrs had to cooperate as suppliers and users of inheritance relationships. + It should have an efficient, unobtrusive, automatic storage-management system (a garbage collector) that, with the uniform object model, would free programmers from all concerns related to explicit use of pointers and release of dynamic storage. + It should provide a very rapid compile/ edit/debug cycle - as fast as that offered by Lisp and Smalltalk environments. + It should provide easy integration with new and existing C code. We wanted programmers to be able to use ordinary Unix tools (like SCCS, Grep, and Sed) at any point in the development process. This ability should apply to source code, binary programs, and, whenever possible, data. + It should support team development by making it easy to share files and to view an application?s source code hierarchically and multidimensionally. (Dimensions include the application?s structure and its multiple versions.) We wanted to provide an environment that combined support for controlling shared source and object code among team members with a highly interactive, tightly integrated environment for individual programmers. We designed and implemented Calico because we knew ofno available languageenvironment combination that met these requirements. Calico?s strength lies in its prudent integration of existing techniques and paradigms in a way that amplifies the natural strengths of Unix and C. Extract: LANGUAGE FEATURES LANGUAGE FEATURES The Calico language is distinguished from its predecessors by seamlessly integrating: + A C calling interface: Calico flexibly interoperates with C by calling C routines in a syntactically simple and natural way + An integrated reflection mechanism: Calico?s flexible method-call options provide a form of reflection. + C syntax: Calico?s statement and expression syntax is very close to C?s, yet it implements all data manipulations as method calls on first-class objects, like Smalltalk + An encapsulation-preserving inheritance model: Calico?s inheritance model uses delegation and is based solely on on 0bject interfaces Extract: Summary Calico offers the C community a powerful programming style that has until now been available only for languages like Lisp and Smalltalk. The ease with which Calico and C code can be integrated lets developers make the necessary trade-offs between productivity and performance. For most large applications, supplementing Calico with C or C++ provides a very effective trade-off between application speed and rapid delivery. To a great extent, the power and responsiveness of the Calico programming environment is due to the nature of the Calico language, which, unlike C and C++, has no source-level interfile dependencies. The design of the Calico environment stemmed born a conscious effort to maintain encapsulation and avoid interclass dependencies in the language?s design and implementation. Fortunately, the same paradigm that encourages good application design also supports a high-productivity development environment. Calico makes it easy for C users to learn object-oriented programming techniques because its expressions and control statements behave in a way that C programmers understand. This lets new Calico users focus on the object paradigm instead of trying to learn a totally new syntax, semantics, and paradigm at the same time. Calico?s close adherence to C syntax makes it easier for users to work concurrently in C and Calico and to combine the two in the same application. in IEEE Software 8(3) May 1991 view details in IEEE Software 8(3) May 1991 view details |