The Experts below are selected from a list of 3240 Experts worldwide ranked by ideXlab platform

Elena Zucca - One of the best experts on this subject based on the ideXlab platform.

  • Jam---designing a Java extension with mixins
    ACM Transactions on Programming Languages and Systems, 2003
    Co-Authors: Davide Ancona, Giovanni Lagorio, Elena Zucca
    Abstract:

    In this paper we present Jam, an extension of the Java language supporting mixins, that is, parametric heir Classes. A mixin Declaration in Jam is similar to a Java heir Class Declaration, except that it does not extend a fixed parent Class, but simply specifies the set of fields and methods a generic parent should provide. In this way, the same mixin can be instantiated on many parent Classes, producing different heirs, thus avoiding code duplication and largely improving modularity and reuse. Moreover, as happens for Classes and interfaces, mixin names are reference types, and all the Classes obtained by instantiating the same mixin are considered subtypes of the corresponding type, and hence can be handled in a uniform way through the common interface. This possibility allows a programming style where different ingredients are "mixed" together in defining a Class; this paradigm is somewhat similar to that based on multiple inheritance, but avoids its complication.The language has been designed with the main objective in mind to obtain, rather than a new theoretical language, a working and smooth extension of Java. That means, on the design side, that we have faced the challenging problem of integrating the Java overall principles and complex type system with this new notion; on the implementation side, it means that we have developed a Jam-to-Java translator which makes Jam sources executable on every Java Virtual Machine.

  • PPDP - True separate compilation of Java Classes
    Proceedings of the 4th ACM SIGPLAN international conference on Principles and practice of declarative programming - PPDP '02, 2002
    Co-Authors: Davide Ancona, Giovanni Lagorio, Elena Zucca
    Abstract:

    We define a type system modeling true separate compilation for a small but significant Java subset, in the sense that a single Class Declaration can be intra-checked (following the Cardelli's terminology) and compiled providing a minimal set of type requirements on missing Classes. These requirements are specified by a local type environment associated with each single Class, while in the existing formal definitions of the Java type system Classes are typed in a global type environment containing all the type information on a closed program. We also provide formal rules for static inter-checking and relate our approach with compilation of closed programs, by proving that we get the same results.

  • ECOOP - Jam - A Smooth Extension of Java with Mixins
    Lecture Notes in Computer Science, 2000
    Co-Authors: Davide Ancona, Giovanni Lagorio, Elena Zucca
    Abstract:

    In this paper we present Jam, an extension of the Java language supporting mixins, that is, parametric heir Classes. A mixin Declaration in Jam is similar to a Java heir Class Declaration, except that it does not extend a fixed parent Class, but simply specifies the set of fields and methods a generic parent should provide. In this way, the same mixin can be instantiated on many parent Classes, producing different heirs, thus avoiding code duplication and largely improving modularity and reuse. Moreover, as happens for Classes and interfaces, mixin names are reference types, and all the Classes obtained instantiating the same mixin are considered subtypes of the corresponding type, hence can be handled in a uniform way through the common interface. This possibility allows a programming style where different ingredients are "mixed" together in defining a Class; this paradigm is somehow similar to that based on multiple inheritance, but avoids the associated complications. The language has been designed with the main objective in mind to obtain, rather than a new theoretical language, a working and smooth extension of Java. That means, on the design side, that we have faced the challenging problem of integrating the Java overall principles and complex type system with this new notion; on the implementation side, that we have developed a Jam to Java translator which makes Jam sources executable on every Java Virtual Machine.

  • Jam : A smooth extension of Java with mixins
    Lecture Notes in Computer Science, 2000
    Co-Authors: Davide Ancona, Giovanni Lagorio, Elena Zucca
    Abstract:

    In this paper we present Jam, an extension of the Java language supporting mixins, that is, parametric heir Classes. A mixin Declaration in Jam is similar to a Java heir Class Declaration, except that it does not extend a fixed parent Class, but simply specifies the set of fields and methods a generic parent should provide. In this way, the same mixin can be instantiated on many parent Classes, producing different heirs, thus avoiding code duplication and largely improving modularity and reuse. Moreover, as happens for Classes and interfaces, mixin names are reference types, and all the Classes obtained instantiating the same mixin are considered subtypes of the corresponding type, hence can be handled in a uniform way through the common interface. This possibility allows a programming style where different ingredients are mixed together in defining a Class; this paradigm is somehow similar to that based on multiple inheritance, but avoids the associated complications. The language has been designed with the main objective in mind to obtain, rather than a new theoretical language, a working and smooth extension of Java. That means, on the design side, that we have faced the challenging problem of integrating the Java overall principles and complex type system with this new notion; on the implementation side, that we have developed a Jam to Java translator which makes Jam sources executable on every Java Virtual Machine.

Davide Ancona - One of the best experts on this subject based on the ideXlab platform.

  • Jam---designing a Java extension with mixins
    ACM Transactions on Programming Languages and Systems, 2003
    Co-Authors: Davide Ancona, Giovanni Lagorio, Elena Zucca
    Abstract:

    In this paper we present Jam, an extension of the Java language supporting mixins, that is, parametric heir Classes. A mixin Declaration in Jam is similar to a Java heir Class Declaration, except that it does not extend a fixed parent Class, but simply specifies the set of fields and methods a generic parent should provide. In this way, the same mixin can be instantiated on many parent Classes, producing different heirs, thus avoiding code duplication and largely improving modularity and reuse. Moreover, as happens for Classes and interfaces, mixin names are reference types, and all the Classes obtained by instantiating the same mixin are considered subtypes of the corresponding type, and hence can be handled in a uniform way through the common interface. This possibility allows a programming style where different ingredients are "mixed" together in defining a Class; this paradigm is somewhat similar to that based on multiple inheritance, but avoids its complication.The language has been designed with the main objective in mind to obtain, rather than a new theoretical language, a working and smooth extension of Java. That means, on the design side, that we have faced the challenging problem of integrating the Java overall principles and complex type system with this new notion; on the implementation side, it means that we have developed a Jam-to-Java translator which makes Jam sources executable on every Java Virtual Machine.

  • PPDP - True separate compilation of Java Classes
    Proceedings of the 4th ACM SIGPLAN international conference on Principles and practice of declarative programming - PPDP '02, 2002
    Co-Authors: Davide Ancona, Giovanni Lagorio, Elena Zucca
    Abstract:

    We define a type system modeling true separate compilation for a small but significant Java subset, in the sense that a single Class Declaration can be intra-checked (following the Cardelli's terminology) and compiled providing a minimal set of type requirements on missing Classes. These requirements are specified by a local type environment associated with each single Class, while in the existing formal definitions of the Java type system Classes are typed in a global type environment containing all the type information on a closed program. We also provide formal rules for static inter-checking and relate our approach with compilation of closed programs, by proving that we get the same results.

  • ECOOP - Jam - A Smooth Extension of Java with Mixins
    Lecture Notes in Computer Science, 2000
    Co-Authors: Davide Ancona, Giovanni Lagorio, Elena Zucca
    Abstract:

    In this paper we present Jam, an extension of the Java language supporting mixins, that is, parametric heir Classes. A mixin Declaration in Jam is similar to a Java heir Class Declaration, except that it does not extend a fixed parent Class, but simply specifies the set of fields and methods a generic parent should provide. In this way, the same mixin can be instantiated on many parent Classes, producing different heirs, thus avoiding code duplication and largely improving modularity and reuse. Moreover, as happens for Classes and interfaces, mixin names are reference types, and all the Classes obtained instantiating the same mixin are considered subtypes of the corresponding type, hence can be handled in a uniform way through the common interface. This possibility allows a programming style where different ingredients are "mixed" together in defining a Class; this paradigm is somehow similar to that based on multiple inheritance, but avoids the associated complications. The language has been designed with the main objective in mind to obtain, rather than a new theoretical language, a working and smooth extension of Java. That means, on the design side, that we have faced the challenging problem of integrating the Java overall principles and complex type system with this new notion; on the implementation side, that we have developed a Jam to Java translator which makes Jam sources executable on every Java Virtual Machine.

  • Jam : A smooth extension of Java with mixins
    Lecture Notes in Computer Science, 2000
    Co-Authors: Davide Ancona, Giovanni Lagorio, Elena Zucca
    Abstract:

    In this paper we present Jam, an extension of the Java language supporting mixins, that is, parametric heir Classes. A mixin Declaration in Jam is similar to a Java heir Class Declaration, except that it does not extend a fixed parent Class, but simply specifies the set of fields and methods a generic parent should provide. In this way, the same mixin can be instantiated on many parent Classes, producing different heirs, thus avoiding code duplication and largely improving modularity and reuse. Moreover, as happens for Classes and interfaces, mixin names are reference types, and all the Classes obtained instantiating the same mixin are considered subtypes of the corresponding type, hence can be handled in a uniform way through the common interface. This possibility allows a programming style where different ingredients are mixed together in defining a Class; this paradigm is somehow similar to that based on multiple inheritance, but avoids the associated complications. The language has been designed with the main objective in mind to obtain, rather than a new theoretical language, a working and smooth extension of Java. That means, on the design side, that we have faced the challenging problem of integrating the Java overall principles and complex type system with this new notion; on the implementation side, that we have developed a Jam to Java translator which makes Jam sources executable on every Java Virtual Machine.

Giovanni Lagorio - One of the best experts on this subject based on the ideXlab platform.

  • Jam---designing a Java extension with mixins
    ACM Transactions on Programming Languages and Systems, 2003
    Co-Authors: Davide Ancona, Giovanni Lagorio, Elena Zucca
    Abstract:

    In this paper we present Jam, an extension of the Java language supporting mixins, that is, parametric heir Classes. A mixin Declaration in Jam is similar to a Java heir Class Declaration, except that it does not extend a fixed parent Class, but simply specifies the set of fields and methods a generic parent should provide. In this way, the same mixin can be instantiated on many parent Classes, producing different heirs, thus avoiding code duplication and largely improving modularity and reuse. Moreover, as happens for Classes and interfaces, mixin names are reference types, and all the Classes obtained by instantiating the same mixin are considered subtypes of the corresponding type, and hence can be handled in a uniform way through the common interface. This possibility allows a programming style where different ingredients are "mixed" together in defining a Class; this paradigm is somewhat similar to that based on multiple inheritance, but avoids its complication.The language has been designed with the main objective in mind to obtain, rather than a new theoretical language, a working and smooth extension of Java. That means, on the design side, that we have faced the challenging problem of integrating the Java overall principles and complex type system with this new notion; on the implementation side, it means that we have developed a Jam-to-Java translator which makes Jam sources executable on every Java Virtual Machine.

  • PPDP - True separate compilation of Java Classes
    Proceedings of the 4th ACM SIGPLAN international conference on Principles and practice of declarative programming - PPDP '02, 2002
    Co-Authors: Davide Ancona, Giovanni Lagorio, Elena Zucca
    Abstract:

    We define a type system modeling true separate compilation for a small but significant Java subset, in the sense that a single Class Declaration can be intra-checked (following the Cardelli's terminology) and compiled providing a minimal set of type requirements on missing Classes. These requirements are specified by a local type environment associated with each single Class, while in the existing formal definitions of the Java type system Classes are typed in a global type environment containing all the type information on a closed program. We also provide formal rules for static inter-checking and relate our approach with compilation of closed programs, by proving that we get the same results.

  • ECOOP - Jam - A Smooth Extension of Java with Mixins
    Lecture Notes in Computer Science, 2000
    Co-Authors: Davide Ancona, Giovanni Lagorio, Elena Zucca
    Abstract:

    In this paper we present Jam, an extension of the Java language supporting mixins, that is, parametric heir Classes. A mixin Declaration in Jam is similar to a Java heir Class Declaration, except that it does not extend a fixed parent Class, but simply specifies the set of fields and methods a generic parent should provide. In this way, the same mixin can be instantiated on many parent Classes, producing different heirs, thus avoiding code duplication and largely improving modularity and reuse. Moreover, as happens for Classes and interfaces, mixin names are reference types, and all the Classes obtained instantiating the same mixin are considered subtypes of the corresponding type, hence can be handled in a uniform way through the common interface. This possibility allows a programming style where different ingredients are "mixed" together in defining a Class; this paradigm is somehow similar to that based on multiple inheritance, but avoids the associated complications. The language has been designed with the main objective in mind to obtain, rather than a new theoretical language, a working and smooth extension of Java. That means, on the design side, that we have faced the challenging problem of integrating the Java overall principles and complex type system with this new notion; on the implementation side, that we have developed a Jam to Java translator which makes Jam sources executable on every Java Virtual Machine.

  • Jam : A smooth extension of Java with mixins
    Lecture Notes in Computer Science, 2000
    Co-Authors: Davide Ancona, Giovanni Lagorio, Elena Zucca
    Abstract:

    In this paper we present Jam, an extension of the Java language supporting mixins, that is, parametric heir Classes. A mixin Declaration in Jam is similar to a Java heir Class Declaration, except that it does not extend a fixed parent Class, but simply specifies the set of fields and methods a generic parent should provide. In this way, the same mixin can be instantiated on many parent Classes, producing different heirs, thus avoiding code duplication and largely improving modularity and reuse. Moreover, as happens for Classes and interfaces, mixin names are reference types, and all the Classes obtained instantiating the same mixin are considered subtypes of the corresponding type, hence can be handled in a uniform way through the common interface. This possibility allows a programming style where different ingredients are mixed together in defining a Class; this paradigm is somehow similar to that based on multiple inheritance, but avoids the associated complications. The language has been designed with the main objective in mind to obtain, rather than a new theoretical language, a working and smooth extension of Java. That means, on the design side, that we have faced the challenging problem of integrating the Java overall principles and complex type system with this new notion; on the implementation side, that we have developed a Jam to Java translator which makes Jam sources executable on every Java Virtual Machine.

Ferruccio Damiani - One of the best experts on this subject based on the ideXlab platform.

  • On flexible dynamic trait replacement for Java-like languages
    Science of Computer Programming, 2013
    Co-Authors: Lorenzo Bettini, Sara Capecchi, Ferruccio Damiani
    Abstract:

    Dynamic trait replacement is a programming language feature for changing the objects' behavior at runtime by replacing some of the objects' methods. In previous work on dynamic trait replacement for Java-like languages, the objects' methods that may be replaced must correspond exactly to a named trait used in the object's Class definition. In this paper we propose the notion of replaceable: a programming language feature that decouples the trait replacement operation code and the Class Declaration code, thus making it possible to refactor Classes and to perform unanticipated trait replacement operations without invalidating existing code. We give a formal account of our proposal through a core calculus, FDTJ (Featherweight Dynamic Trait Java), equipped with a static type system guaranteeing that in a well-typed program no runtime type error will take place.

  • FTfJP@ECOOP - A mechanism for flexible dynamic trait replacement
    Proceedings of the 11th International Workshop on Formal Techniques for Java-like Programs - FTfJP '09, 2009
    Co-Authors: Lorenzo Bettini, Sara Capecchi, Ferruccio Damiani
    Abstract:

    Dynamic trait replacement is a programming language feature for changing the objects' behavior at runtime by replacing some of the objects' methods. In previous work on dynamic trait replacement for JAVA-like languages, the object's methods that may be replaced must correspond exactly to a named trait used in the object's Class definition. In this paper we propose the notion of replaceable: a programming language feature that decouples trait replacement operation code and Class Declaration code, thus making it possible refactoring Classes and/or performing unanticipated trait replacement operations without invalidating existing code.

Lorenzo Bettini - One of the best experts on this subject based on the ideXlab platform.

  • On flexible dynamic trait replacement for Java-like languages
    Science of Computer Programming, 2013
    Co-Authors: Lorenzo Bettini, Sara Capecchi, Ferruccio Damiani
    Abstract:

    Dynamic trait replacement is a programming language feature for changing the objects' behavior at runtime by replacing some of the objects' methods. In previous work on dynamic trait replacement for Java-like languages, the objects' methods that may be replaced must correspond exactly to a named trait used in the object's Class definition. In this paper we propose the notion of replaceable: a programming language feature that decouples the trait replacement operation code and the Class Declaration code, thus making it possible to refactor Classes and to perform unanticipated trait replacement operations without invalidating existing code. We give a formal account of our proposal through a core calculus, FDTJ (Featherweight Dynamic Trait Java), equipped with a static type system guaranteeing that in a well-typed program no runtime type error will take place.

  • FTfJP@ECOOP - A mechanism for flexible dynamic trait replacement
    Proceedings of the 11th International Workshop on Formal Techniques for Java-like Programs - FTfJP '09, 2009
    Co-Authors: Lorenzo Bettini, Sara Capecchi, Ferruccio Damiani
    Abstract:

    Dynamic trait replacement is a programming language feature for changing the objects' behavior at runtime by replacing some of the objects' methods. In previous work on dynamic trait replacement for JAVA-like languages, the object's methods that may be replaced must correspond exactly to a named trait used in the object's Class definition. In this paper we propose the notion of replaceable: a programming language feature that decouples trait replacement operation code and Class Declaration code, thus making it possible refactoring Classes and/or performing unanticipated trait replacement operations without invalidating existing code.