@book{Blac07a, Title = {Squeak by Example}, Author = {Andrew Black and St\'ephane Ducasse and Oscar Nierstrasz and Damien Pollet and Damien Cassou and Marcus Denker}, Note = {http://SqueakByExample.org/}, Publisher = {Square Bracket Associates}, Year = {2007}, Abstract = {Squeak by Example, intended for both students and developers, will guide you gently through the Squeak language and environment by means of a series of examples and exercises. This book is made available under the Creative Commons Attribution-ShareAlike 3.0 license.}, ISBN = {978-3-9523341-0-2}, Url = {http://SqueakByExample.org/index.html}, Keywords = {scg07 olit scg-pub jb08 snf08 skipdoi} } @book{Meye88b, Author = {Bertrand Meyer}, Keywords = {olit-oopl eiffel oobib(oopl) scglib}, Publisher = {Prentice-Hall}, Title = {Object-oriented Software Construction}, Year = {1988} } @manual{ANSI98a, Address = {New York}, Organization = {ANSI}, Title = {{A}merican {N}ational {S}tandard for {I}nformation {S}ystems - {P}rogramming {L}anguages - {S}malltalk, ANSI/INCITS 319-1998}, Note = {http://wiki.squeak.org/squeak/uploads/172/standard\_v1\_9-indexed.pdf}, Year = {1998} } @inproceedings{Cass07a, title = {Redesigning with Traits: the Nile Stream trait-based Library}, booktitle = {Proceedings of the 2007 International Conference on Dynamic Languages (ICDL 2007)}, isbn = {978-1-60558-084-5}, pages = {50-75}, year = {2007}, Publisher = {ACM Digital Library}, annote = {internationalconference cook}, abstract = {Recently, traits have been proposed as a single inheritance backward compatible solution in which the composing entity has the control over the trait composition. Traits are fine-grained units used to compose classes, while avoiding many of the problems of multiple inheritance and mixin-based approaches. To evaluate the expressiveness of traits, some hierarchies were refactored, showing code reuse. However, such large refactorings, while valuable, may not be facing all the problems, since the hierarchies were previously expressed within single inheritance and following certain patterns. We wanted to evaluate how traits enable reuse, and what problems could be encountered when building a library using traits from scratch, taking into account that traits are units of reuse. This paper presents our work on designing a new stream library named Nile. We present the reuse that we attained using traits, and the problems we encountered.}, author = {Damien Cassou and St\'ephane Ducasse and Roel Wuyts}, url = {http://www.iam.unibe.ch/~scg/Archive/Papers/Cass07aTraitsStreamRedesign.pdf}, doi ={10.1145/1352678.1352682} } @book{LaLo90a, Author = {Wilf LaLonde and John Pugh}, Isbn = {0-13-468414-1}, Keywords = {olit-smalltalk oobib(smalltalk) book scglib}, Publisher = {Prentice Hall}, Title = {Inside {Smalltalk}: Volume 1}, Year = {1990} } @inproceedings{Cook87a, Author = {Steve Cook}, Booktitle = {OOPSLA '87 Addendum To The Proceedings}, Month = oct, Pages = {35-40}, Publisher = {ACM Press}, Title = {{OOPSLA} '87 {Panel} {P2}: Varieties of Inheritance}, Year = {1987} } @misc{Squeak, Key = {Squeak}, Note = {http://www.squeak.org/}, Title = {Squeak Home Page} } @misc{DDispatch, Key = {DDispatch}, Note = {http://en.wikipedia.org/wiki/Double\_dispatch}, Title = {The Double Dispatch Mechanism} } @inproceedings{Blac03a, Abstract = {Traits are a programming language technology that promote the reuse of methods between unrelated classes. This paper reports on a refactoring of the Smalltalk collections classes using traits. The original collection classes contained much duplication of code; traits let us remove all of it. We also found places where the protocols of the collections lacked uniformity; traits allowed us to correct these non-uniformities without code duplication. Traits also make it possible to reuse fragments of collection code outside of the existing hierarchy; for example, they make it easy to convert other collection-like things into true collections. Our refactoring reduced the number of methods in the collection classes by approximately 10 per cent. More importantly, understandability maintainability and reusability of the code were significantly improved.}, Annote = {internationalconference topconference}, Author = {Andrew P. Black and Nathanael Sch\"arli and St\'ephane Ducasse}, Booktitle = {Proceedings of 17th International Conference on Object-Oriented Programming Systems, Languages and Applications (OOPSLA'03)}, Cvs = {TraitsRefactoringOOPSLA2003}, Doi = {10.1145/949305.949311}, Keywords = {snf04 scg-pub jb02 scg-traits stefPub schaerli}, Misc = {acceptance rate: 26/142 = 18\%}, Month = oct, Pages = {47-64}, Title = {Applying Traits to the {Smalltalk} Collection Hierarchy}, Url = {http://www.iam.unibe.ch/~scg/Archive/Papers/Blac03aTraitsHierarchy.pdf}, Volume = {38}, Year = {2003} } @inproceedings{Cook92a, Author = {William R. Cook}, Booktitle = {Proceedings of OOPSLA '92 (7th Conference on Object-Oriented Programming Systems, Languages and Applications)}, Keywords = {olit oopsla92}, Location = {Vancouver, Canada}, Month = oct, Pages = {1-15}, Publisher = {ACM Press}, Title = {Interfaces and {Specifications} for the {Smalltalk}-80 {Collection} {Classes}}, Volume = {27}, Year = {1992} } @article{Carr96a, Author = {M. Carrillo and J. Garcia Molina and E. Pimentel and I. Repiso}, Institution = {ACM}, Journal = {Journal of Object-Oriented Programming}, Number = {7}, Title = {Design by Contract in Smalltalk}, Volume = {9}, Year = {1996} } @inproceedings{Duca07b, Address = {New York, NY, USA}, Annote = {internationalconference topconference}, Author = {St\'ephane Ducasse and Roel Wuyts and Alexandre Bergel and Oscar Nierstrasz}, Booktitle = {Proceedings of 22nd International Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA'07)}, Abstract = {A trait is a unit of behaviour that can be composed with other traits and used by classes. Traits offer an alternative to multiple inheritance. Conflict resolution of traits, while flexible, does not completely handle accidental method name conflicts: if a trait with method m is composed with another trait defining a different method m then resolving the conflict may prove delicate or infeasible in cases where both versions of m are still needed. In this paper we present freezeable traits, which provide an expressive composition mechanism to support unanticipated method composition conflicts. Our solution introduces private trait methods and lets the class composer change method visibility at composition time (from public to private and vice versa). Moreover two class composers may use different composition policies for the same trait, something which is not possible in mainstream languages. This approach respects the two main design principles of traits: the class composer is empowered and traits can be flattened away. We present an implementation of freezable traits in Smalltalk. As a side-effect of this implementation we introduced private (early-bound and invisible) methods to Smalltalk by distinguishing object-sends from self-sends. Our implementation uses compile-time bytecode manipulation and, as such, introduces no run-time penalties.}, peer = {yes}, Keywords = {scg07 snf08 stefPub alexPub jb08 scg-pub}, Publisher = {ACM Press}, Url = {http://www.iam.unibe.ch/~scg/Archive/Papers/Duca07b-FreezableTrait.pdf}, Title = {User-Changeable Visibility: Resolving Unanticipated Name Clashes in Traits}, isbn = {978-1-59593-786-5}, pages = {171--190}, misc = {Acceptance rate: 33/156:21\%}, rate={21%}, aeres = {ACT}, aeresstatus = {2008}, selectif = {oui}, inria={hors}, location = {Montreal, Quebec, Canada}, doi = {10.1145/1297027.1297040}, month = oct, Year = {2007}} @book{Stro86b, Address = {Reading, Mass.}, Author = {Bjarne Stroustrup}, Isbn = {0-201-53992-6}, Keywords = {olit-oopl c++ oobib(oopl) book scglib}, Publisher = {Addison Wesley}, Title = {The {C}++ Programming Language}, Year = {1986} } @book{Keen89a, Author = {Sonia E. Keene}, Publisher = {Addison Wesley}, Title = {Object-Oriented Programming in Common-Lisp}, Year = {1989} } @article{Berg07e, Annote = {internationaljournal}, Author = {Alexandre Bergel and St\'ephane Ducasse and Oscar Nierstrasz and Roel Wuyts}, Journal = {Journal of Computer Languages, Systems and Structures}, peer = {yes}, Keywords = {scg07 stefPub scg-pub jb08 snf06}, Publisher = {Elsevier}, Title = {Stateful Traits and their Formalization}, Doi = {10.1016/j.cl.2007.05.003}, Year = {2008}, impactfactor={0.467, SCI}, aeres = {ACL}, aeresstatus = {2008}, selectif = {non}, inria={hors}, Volume = {34}, Number = {2-3}, Pages = {83-108}, Url = {http://www.iam.unibe.ch/~scg/Archive/Papers/Berg07eStatefulTraits.pdf}, Abstract = {Traits offer a fine-grained mechanism to compose classes from reusable components while avoiding problems of fragility brought by multiple inheritance and mixins. Traits as originally proposed are stateless, that is, they contain only methods, but no instance variables. State can only be accessed within stateless traits by accessors, which become required methods of the trait. Although this approach works reasonably well in practice, it means that many traits, viewed as software components, are artificially \emph{incomplete}, and classes that use such traits may contain significant amounts of boilerplate glue code. We present an approach to stateful traits that is faithful to the guiding principle of stateless traits: the client retains control of the composition. Stateful traits consist of a minimal extension to stateless traits in which instance variables are purely local to the scope of a trait, unless they are explicitly made accessible by the composing client of a trait. We demonstrate by means of a formal object calculus that adding state to traits preserves the flattening property: traits contained in a program can be compiled away. We discuss and compare two implementation strategies, and briefly present a case study in which stateful traits have been used to refactor the trait-based version of the Smalltalk collection hierarchy.} } @misc{Benjie, Key = {Benjie}, Keywords = {laptop OLPC}, Note = {http://en.wikipedia.org/wiki/\$100\_laptop}, Title = {100 {Dollar} {Laptop}}, Url = {http://en.wikipedia.org/wiki/$100_laptop} } @inproceedings{Scha03a, Abstract = {Despite the undisputed prominence of inheritance as the fundamental reuse mechanism in object-oriented programming languages, the main variants --- single inheritance, multiple inheritance, and mixin inheritance --- all suffer from conceptual and practical problems. In the first part of this paper, we identify and illustrate these problems. We then present traits, a simple compositional model for structuring object-oriented programs. A trait is essentially a group of pure methods that serves as a building block for classes and is a primitive unit of code reuse. In this model, classes are composed from a set of traits by specifying glue code that connects the traits together and accesses the necessary state. We demonstrate how traits overcome the problems arising from the different variants of inheritance, we discuss how traits can be implemented effectively, and we summarize our experience applying traits to refactor an existing class hierarchy.}, Annote = {internationalconference topconference}, Author = {Nathanael Sch\"arli and St\'ephane Ducasse and Oscar Nierstrasz and Andrew Black}, Booktitle = {Proceedings of European Conference on Object-Oriented Programming (ECOOP'03)}, Cvs = {TraitsECOOP2003}, Doi = {10.1007/b11832}, Keywords = {snf03 scg-pub jb03 scg-traits stefPub schaerli}, Misc = {acceptance rate: 18/88 = 20\%}, Month = jul, Pages = {248-274}, Publisher = {Springer Verlag}, Series = {LNCS}, ISBN = {978-3-540-40531-3}, Title = {Traits: Composable Units of Behavior}, Url = {http://www.iam.unibe.ch/~scg/Archive/Papers/Scha03aTraits.pdf}, Volume = {2743}, Year = {2003} }