DOCSLIB.ORG

Generics and Reverse Generics for Pharo

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Generics and Reverse Generics for Pharo GENERICS AND REVERSE GENERICS FOR PHARO Alexandre Bergel1∗ and Lorenzo Bettini2† 1Pleiad Lab, Computer Science Department (DCC), University of Chile, Santiago, Chile 2Dipartimento di Informatica, Universita` di Torino, Italy [email protected], [email protected] Keywords: Generic Programming, Pharo, Dynamically Typed Languages. Abstract: Generic programming is a mechanism for re-using code by abstracting specific types used in classes and programs. In this paper, we present a mechanism for adding generic programming in dynamically typed languages, showing how programmers can benefit from generic programming. Furthermore, we enhance the expressiveness of generic programming with reverse generics, a mechanism for automatically deriving new generic code starting from existing non-generic one. We implemented generics and reverse generics in Pharo Smalltalk, and we successfully used them to solve a problem of reusing unit test cases. This helped us to identify a number of bugs and anomalies in the stream class hierarchy. 1 Introduction mechanisms are effective when future extensions are foreseen. They provide little help in a scenario of The notion of generic programming has been orig- unanticipated code evolution in which the program- inally introduced in statically typed programming lan- ming language does provide dedicated evolutionary guages to ease manipulation and reuse of collection construct. This paper is about fixing this issue for dy- classes and algorithms. On the other hand, because of namically typed languages using generics. their flexible type systems, dynamically typed object- As popularized by mainstream statically typed oriented languages have been left out of the scope of programming languages, generic programming pro- generic programming. The need for generic program- vides a mechanism for defining template classes ming in a dynamically typed setting has been less where some types are variables/parameters and then prominent since no restriction applies over the kind for providing arguments for those type variables, thus of elements a collection may contain. instantiating template classes into concrete and com- Furthermore, in a dynamically typed language like plete classes. In the following, we then use the Smalltalk, where types are absent in declarations of term template class to refer to a class where some linguistic entities (like methods, fields, local vari- types are parametrized; accordingly, we refer to a ables), it might look odd to talk about generic pro- concrete/complete class when all the arguments for gramming. However, there is still a crucial context parametrized types are provided. where types (i.e., class names) appear statically: class Reverse generics (Bergel and Bettini, 2011) is the references. When creating an object, the class name is dual mechanism that enables the definition of a tem- hardcoded in the program, and this makes the object plate class from a complete class. We call this mecha- instantiation process hard to abstract from. nism generalization. It allows obtaining a brand new There are well-known patterns to deal with this generic class from an existing class by “removing” problem, such as Factory Method (Gamma et al., hardwired class references, and by replacing them 1995), Dependency Injection (Fowler, 2004), Virtual with parametrized types. For instance, classes (Bracha et al., 2010) and ad-hoc linguistic G<T> = C>C’< constructs (Cohen and Gil, 2007). However, these generates the new generic class G<T> starting from the class C by replacing each reference of a class C’ ∗This author has been partially supported by Program U- INICIA 11/06 VID 2011, grant U-INICIA 11/06, University contained in C with the type parameter T in G. It is the of Chile, and FONDECYT 1120094. dual operation of the instantiation operation offered †This author was partially supported by MIUR (Project by generics. The generic G may be instantiated into PRIN 2008 DISCO). G<U> for a provided class U. Note that, the reverse generics mechanism satisfies the property related work and Section8 concludes the paper and C = (C>T<) <T>. gives some perspectives on future work. Finally, an important point is that the original class C remains unmodified. Indeed, reverse generics are useful under the basic assumptions that (i) the code to 2 Generics in Pharo be reused has to be left intact (it cannot be the subject of refactoring) and (ii) the host programming does not This section presents a mechanism for generic implicitly support for looking up classes dynamically programming for the Pharo/Smalltalk programming (as this is the case in most dynamically languages, ex- language3. The presentation of the mechanism is cept NewSpeak the supports virtual classes (Bracha driven by a test-reuse scenario. We will first define a et al., 2010)). In particular, we aim at providing, test called GCollectionTest. This test will be free from a through our implementation of reverse generics, a particular class of the collection framework. GCollec- generative approach, where new generic code is (au- tionTest will be instantiated twice, for two different fix- tomatically) generated starting from existing one, and tures based on OrderedCollection and SortedCollection4. the latter will not be modified at all; for this reason, Consider the following code snippet containing a reverse generics are not, and they do not aim at, a test that verifies elements addition. refactoring technique (we also refer to Section7). ”Creation of the class T” This paper extends the Pharo Smalltalk program- GenericParameter subclass: #T ming language with generics and reverse generics. We adapted the reverse generics to cope with the ”Creation of the class GCollectionTest with a variable” lack of static type information (in (Bergel and Bettini, TestCase subclass: #GCollectionTest 2011) reverse generics were studied in the context of instanceVariableNames: ’collection’ statically typed languages such as Java and C++). Re- quirements on type parameters can be defined as a ”Definition of the setUp method” ”It instantiates T and add 3 numbers in it” safety net for a sound instantiation; we provide mech- GCollectionTest>> setUp anisms for structural and nominal requirements both collection := T new. for generics and reverse generics in Pharo. collection add: 4; add: 5; add: 10. The generic mechanisms we implemented do not depend on any Pharo facilities suggesting that gener- ”Definition of the test method testAddition” ”It adds an element in the collection defined in setUp” ics and reverse generics are likely to be transpos- GCollectionTest>> testAddition able to other dynamically typed languages. Although j initialSize j it has been realized in a dialect of Smalltalk, noth- initialSize := collection size. ing prevents them from being applied to Ruby and collection add: 20. Python. Even though similar mechanisms have been self assert: (collection includes: 20). proposed in Groovy (Axelsen and Krogdahl, 2009), self assert: (collection size = (initialSize + 1)). to the best of our knowledge, this is the first attempt GCollectionTest is a pretty standard unit test in the to add a generic-like construct to Smalltalk. (The spirit of the xUnit framework (most of the 115 classes Groovy case is discussed in the related work section). that test the Pharo collection library follow a very We employed reverse generics to face a classical similar structure). No reference to a collection class code reuse problem. Unit tests in Pharo are inher- is made by GCollectionTest. The method setUp refers ited from Squeak, a Smalltalk dialect that served as to the empty class T. GCollectionTest may be instanti- a base for Pharo. Those tests have been written in a ated into OrderedCollectionTest and SortedCollectionTest rather disorganized and ad-hoc fashion. This situation as follows: serves as the running example of this paper and was ”Instantiate GCollectionTest and replace encountered when evolving the Pharo runtime. This occurrences of T by OrderedCollection” helped us identify a number of bugs and anomalies in (GCollectionTest @ T-> OrderedCollection) the stream class hierarchy. as: #OrderedCollectionTest The contributions and innovations of this paper are summarized as follows: (i) definition of a mecha- ”Replace T by SortedCollection” (GCollectionTest @ T -> SortedCollection) nism for generics in Pharo (Section2); (ii) description as: #SortedCollectionTest of the reverse generics model in Pharo (Section4); (iii) description of the implementation of both mech- 3http://www.pharo-project.org anisms (Section5); (iv) applicability to a non triv- 4A fixture refers to the fixed state used as a baseline for ial case study (Section6). Section7 summarizes the tests. We consider the setUp method only in our situation. The generic class GCollectionTest has been instan- Structural requirements. In addition to nominal re- tiated twice, each time assigning a different class to quirements, a generic parameter may be also struc- the parameter T. We adopted the convention of defin- turally constrained. A constraint is satisfied based on ing generic parameter as subclasses of GenericParam- the presence of some particular methods. In the ex- eter. This convention has a number of advantages, as ample above, a method check may return discussed in Section5. Since GCollectionTest contains myself includesSelectors: f#add: . #includes: . #sizeg references to T, it is a generic class. There is therefore no syntactic distinction between a class and a generic In that case, only a class that implements the method class.
Load more

Recommended publications
  • New Inheritance Models That Facilitate Source Code Reuse in Object-Oriented Programming
    NEW INHERITANCE MODELS THAT FACILITATE SOURCE CODE REUSE IN OBJECT- ORIENTED PROGRAMMING By HISHAM M. AL-HADDAD Bachelor of Science Yarmouk University lrbid, Jordan 1986 Master of Science Northrop University Los Angeles, California 1988 Submitted to the Faculty of the Graduate College of the Oklahoma State University in partial fulfillment of the requirements for the degree of DOCTOR OF PHILOSOPHY July, 1992 Oklahoma Statt.' Ur1iv. Library NEW INHERITANCE MODELS THAT FACILITATE SOURCE CODE REUSE IN OBJECT- ORIENTED PROGRAMMING C/ wU::r-~ B I A~c;p .... _.-~ Dean of the Graduate CoUege ii PREFACE Code reusability is a primary objective in the development of software systems. The object-oriented programming methodology is one of the areas that facilitate the development of software systems by allowing and promoting code reuse and modular designs. Object-oriented programming languages (OOPLs) provide different facilities to attain efficient reuse and reliable extension of existing software components. Inheritance is an important language feature that is conducive to reusability and extensibility. Various OOPLs provide different inheritance models based on different interpretations of the inheritance notion. Therefore, OOPLs have different characteristics derived from their respective inheritance models. This dissertation is concerned with solutions for three major problems that limit the utilization of inheritance for code reusability. The range of object-oriented applications and thus the usage of object-oriented programming in general is also discussed. The three major problems are: 1) the relationship between inheritance and other related issues such as encapsulation, access techniques, visibility of inheritance, and subtyping; 2) the hierarchical structure imposed by inheritance among classes; and 3) the accessibility of previous versions of the modified methods defmed in classes located at higher levels of the inheritance structure than the parent classes.
    [Show full text]
  • G22.2110-003 Programming Languages - Fall 2012 Week 14 - Part 1
    G22.2110-003 Programming Languages - Fall 2012 Week 14 - Part 1 Thomas Wies New York University Review Last lecture I Exceptions Outline Today: I Generic Programming Sources for today's lecture: I PLP, ch. 8.4 I Programming in Scala, ch. 19, 20.6 Generic programming Subroutines provide a way to abstract over values. Generic programming lets us abstract over types. Examples: I A sorting algorithm has the same structure, regardless of the types being sorted I Stack primitives have the same semantics, regardless of the objects stored on the stack. One common use: I algorithms on containers: updating, iteration, search Language models: I C: macros (textual substitution) or unsafe casts I Ada: generic units and instantiations I C++, Java, C#, Scala: generics (also called templates) I ML: parametric polymorphism, functors Parameterizing software components Construct Parameter(s): array bounds, element type subprogram values (arguments) Ada generic package values, types, packages Ada generic subprogram values, types C++ class template values, types C++ function template values, types Java generic classes Scala generic types (and implicit values) ML function values (including other functions) ML type constructor types ML functor values, types, structures Templates in C++ template <typename T> class Array { public : explicit Array (size_t); // constructor T& operator[] (size_t); // subscript operator ... // other operations private : ... // a size and a pointer to an array }; Array<int> V1(100); // instantiation Array<int> V2; // use default constructor
    [Show full text]
  • Generic Programming
    Generic Programming July 21, 1998 A Dagstuhl Seminar on the topic of Generic Programming was held April 27– May 1, 1998, with forty seven participants from ten countries. During the meeting there were thirty seven lectures, a panel session, and several problem sessions. The outcomes of the meeting include • A collection of abstracts of the lectures, made publicly available via this booklet and a web site at http://www-ca.informatik.uni-tuebingen.de/dagstuhl/gpdag.html. • Plans for a proceedings volume of papers submitted after the seminar that present (possibly extended) discussions of the topics covered in the lectures, problem sessions, and the panel session. • A list of generic programming projects and open problems, which will be maintained publicly on the World Wide Web at http://www-ca.informatik.uni-tuebingen.de/people/musser/gp/pop/index.html http://www.cs.rpi.edu/˜musser/gp/pop/index.html. 1 Contents 1 Motivation 3 2 Standards Panel 4 3 Lectures 4 3.1 Foundations and Methodology Comparisons ........ 4 Fundamentals of Generic Programming.................. 4 Jim Dehnert and Alex Stepanov Automatic Program Specialization by Partial Evaluation........ 4 Robert Gl¨uck Evaluating Generic Programming in Practice............... 6 Mehdi Jazayeri Polytypic Programming........................... 6 Johan Jeuring Recasting Algorithms As Objects: AnAlternativetoIterators . 7 Murali Sitaraman Using Genericity to Improve OO Designs................. 8 Karsten Weihe Inheritance, Genericity, and Class Hierarchies.............. 8 Wolf Zimmermann 3.2 Programming Methodology ................... 9 Hierarchical Iterators and Algorithms................... 9 Matt Austern Generic Programming in C++: Matrix Case Study........... 9 Krzysztof Czarnecki Generative Programming: Beyond Generic Programming........ 10 Ulrich Eisenecker Generic Programming Using Adaptive and Aspect-Oriented Programming .
    [Show full text]
  • Code Reuse and Refactoring: Going Agile on Complex Products
    Code Reuse and Refactoring: Going Agile on Complex Products Using enterprise Software Version Management to coordinate complex products, seamlessly support Git developers, and solve refactoring problems. Table of Contents Component-Based Development __________________________________________________ 1 CBD Product Model ______________________________________________________________ 1 The Repository Model ____________________________________________________________ 2 Managing CBD in Git _____________________________________________________________ 2 Setting Up the CBD Model _____________________________________________________ 2 Incorporating Non-Software Components ____________________________________ 3 Updating Component Baselines ________________________________________________ 3 Submitting Patches to Components _____________________________________________ 4 Developer View _______________________________________________________________ 4 Refactoring: In Practice ________________________________________________________ 4 Refactoring: Developer Impact _________________________________________________ 4 Managing CBD in Perforce Software Version Management and Perforce Git Fusion ______ 5 Setting Up the CBD Model _____________________________________________________ 5 Incorporating Non-Software Components ____________________________________ 5 Updating Component Baselines ________________________________________________ 5 Submitting Patches to Components _____________________________________________ 5 Developer View _______________________________________________________________
    [Show full text]
  • A Model of Inheritance for Declarative Visual Programming Languages
    An Abstract Of The Dissertation Of Rebecca Djang for the degree of Doctor of Philosophy in Computer Science presented on December 17, 1998. Title: Similarity Inheritance: A Model of Inheritance for Declarative Visual Programming Languages. Abstract approved: Margaret M. Burnett Declarative visual programming languages (VPLs), including spreadsheets, make up a large portion of both research and commercial VPLs. Spreadsheets in particular enjoy a wide audience, including end users. Unfortunately, spreadsheets and most other declarative VPLs still suffer from some of the problems that have been solved in other languages, such as ad-hoc (cut-and-paste) reuse of code which has been remedied in object-oriented languages, for example, through the code-reuse mechanism of inheritance. We believe spreadsheets and other declarative VPLs can benefit from the addition of an inheritance-like mechanism for fine-grained code reuse. This dissertation first examines the opportunities for supporting reuse inherent in declarative VPLs, and then introduces similarity inheritance and describes a prototype of this model in the research spreadsheet language Forms/3. Similarity inheritance is very flexible, allowing multiple granularities of code sharing and even mutual inheritance; it includes explicit representations of inherited code and all sharing relationships, and it subsumes the current spreadsheet mechanisms for formula propagation, providing a gradual migration from simple formula reuse to more sophisticated uses of inheritance among objects. Since the inheritance model separates inheritance from types, we investigate what notion of types is appropriate to support reuse of functions on different types (operation polymorphism). Because it is important to us that immediate feedback, which is characteristic of many VPLs, be preserved, including feedback with respect to type errors, we introduce a model of types suitable for static type inference in the presence of operation polymorphism with similarity inheritance.
    [Show full text]
  • Beginning SOLID Principles and Design Patterns for ASP.NET Developers — Bipin Joshi Beginning SOLID Principles and Design Patterns for ASP.NET Developers
    THE EXPERT’S VOICE® IN .NET DEVELOPMENT Beginning SOLID Principles and Design Patterns for ASP.NET Developers — Bipin Joshi Beginning SOLID Principles and Design Patterns for ASP.NET Developers Bipin Joshi Beginning SOLID Principles and Design Patterns for ASP.NET Developers Bipin Joshi 301 Pitruchhaya Thane, India ISBN-13 (pbk): 978-1-4842-1847-1 ISBN-13 (electronic): 978-1-4842-1848-8 DOI 10.1007/978-1-4842-1848-8 Library of Congress Control Number: 2016937316 Copyright © 2016 by Bipin Joshi This work is subject to copyright. All rights are reserved by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed. Exempted from this legal reservation are brief excerpts in connection with reviews or scholarly analysis or material supplied specifically for the purpose of being entered and executed on a computer system, for exclusive use by the purchaser of the work. Duplication of this publication or parts thereof is permitted only under the provisions of the Copyright Law of the Publisher's location, in its current version, and permission for use must always be obtained from Springer. Permissions for use may be obtained through RightsLink at the Copyright Clearance Center. Violations are liable to prosecution under the respective Copyright Law. Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark.
    [Show full text]
  • Advanced-Java.Pdf
    Advanced java i Advanced java Advanced java ii Contents 1 How to create and destroy objects 1 1.1 Introduction......................................................1 1.2 Instance Construction.................................................1 1.2.1 Implicit (Generated) Constructor.......................................1 1.2.2 Constructors without Arguments.......................................1 1.2.3 Constructors with Arguments........................................2 1.2.4 Initialization Blocks.............................................2 1.2.5 Construction guarantee............................................3 1.2.6 Visibility...................................................4 1.2.7 Garbage collection..............................................4 1.2.8 Finalizers...................................................5 1.3 Static initialization..................................................5 1.4 Construction Patterns.................................................5 1.4.1 Singleton...................................................6 1.4.2 Utility/Helper Class.............................................7 1.4.3 Factory....................................................7 1.4.4 Dependency Injection............................................8 1.5 Download the Source Code..............................................9 1.6 What’s next......................................................9 2 Using methods common to all objects 10 2.1 Introduction...................................................... 10 2.2 Methods equals and hashCode...........................................
    [Show full text]
  • Java for Scientific Computing, Pros and Cons
    Journal of Universal Computer Science, vol. 4, no. 1 (1998), 11-15 submitted: 25/9/97, accepted: 1/11/97, appeared: 28/1/98 Springer Pub. Co. Java for Scienti c Computing, Pros and Cons Jurgen Wol v. Gudenb erg Institut fur Informatik, Universitat Wurzburg wol @informatik.uni-wuerzburg.de Abstract: In this article we brie y discuss the advantages and disadvantages of the language Java for scienti c computing. We concentrate on Java's typ e system, investi- gate its supp ort for hierarchical and generic programming and then discuss the features of its oating-p oint arithmetic. Having found the weak p oints of the language we pro- p ose workarounds using Java itself as long as p ossible. 1 Typ e System Java distinguishes b etween primitive and reference typ es. Whereas this distinc- tion seems to b e very natural and helpful { so the primitives which comprise all standard numerical data typ es have the usual value semantics and expression concept, and the reference semantics of the others allows to avoid p ointers at all{ it also causes some problems. For the reference typ es, i.e. arrays, classes and interfaces no op erators are available or may b e de ned and expressions can only b e built by metho d calls. Several variables may simultaneously denote the same ob ject. This is certainly strange in a numerical setting, but not to avoid, since classes have to b e used to intro duce higher data typ es. On the other hand, the simple hierarchy of classes with the ro ot Object clearly b elongs to the advantages of the language.
    [Show full text]
  • Software Reusability: Approaches and Challenges
    International Journal of Research and Innovation in Applied Science (IJRIAS) |Volume VI, Issue V, May 2021|ISSN 2454-6194 Software Reusability: Approaches and Challenges Moko Anasuodei1, Ojekudo, Nathaniel Akpofure2 1Department of Computer Science and Informatics, Faculty of Science, Federal University Otuoke, Nigeria 2Department of Computer Science, Faculty of Natural and Applied Sciences, Ignatius Ajuru University of Education, Nigeria Abstract: Software reuse is used to aid the software phases. Software engineering has been more centered on development process which in recent times can improve the original development which gives an optimal software at a resulting quality and productivity of software development, by faster and less costly price, a design process based on assisting software engineers throughout various software systemic reusable is now recognized. engineering phases to enhance the quality of software, provide quick turnaround time for software development using few Software reuse reduces efforts and cost, because software people, tools, and methods, which creates a good software development costs can be extremely high, but they are quality by enhancing integration of the software system to shared, such that the cost of reuse can be extremely low. provide a competitive advantage. This paper examines the One major advantage of software reuse suggested by concept of software reuse, the approaches to be considered for keswani et al (2014) explains that there is a significant need software reuse, which is broadly shared into three categories: component-based software reuse, domain engineering and for the number of bugs to be reduced during software software product lines, architecture-based software reuse and development process, such that instead of developing an challenges that affect the software reuse development process.
    [Show full text]
  • Java Generics Adoption: How New Features Are Introduced, Championed, Or Ignored
    Java Generics Adoption: How New Features are Introduced, Championed, or Ignored Chris Parnin Christian Bird Emerson Murphy-Hill College of Computing Microsoft Research Dept. of Computer Science Georgia Institute of Redmond, Washington North Carolina State Technology [email protected] University Atlanta, Georgia Raleigh, North Carolina [email protected] [email protected] Far too often, greatly heralded claims and visions of new language features fail to hold or persist in practice. Discus- ABSTRACT sions of the costs and benefits of language features can easily devolve into a religious war with both sides armed with little Support for generic programming was added to the Java more than anecdotes [13]. Empirical evidence about the language in 2004, representing perhaps the most significant adoption and use of past language features should inform change to one of the most widely used programming lan- and encourage a more rational discussion when designing guages today. Researchers and language designers antici- language features and considering how they should be de- pated this addition would relieve many long-standing prob- ployed. Collecting this evidence is not just sensible but a lems plaguing developers, but surprisingly, no one has yet responsibility of our community. measured whether generics actually provide such relief. In In this paper, we examine the adoption and use of generics, this paper, we report on the first empirical investigation into which were introduced into the Java language in 2004. When how Java generics have been integrated into open source Sun introduced generics, they claimed that the language software by automatically mining the history of 20 popular feature was \a long-awaited enhancement to the type system" open source Java programs, traversing more than 500 million that \eliminates the drudgery of casting." Sun recommended lines of code in the process.
    [Show full text]
  • Addressing Common Crosscutting Problems with Arcum∗
    Addressing Common Crosscutting Problems with Arcum∗ Macneil Shonle William G. Griswold Sorin Lerner Computer Science & Engineering, UC San Diego La Jolla, CA 92093-0404 {mshonle, wgg, lerner}@cs.ucsd.edu ABSTRACT 1. INTRODUCTION Crosscutting is an inherent part of software development and can Arcum is a framework for declaring and performing user-defined typically be managed through modularization: A module’s stable program checks and transformations, with the goal of increasing properties are defined in an interface while its likely-to-change automated refactoring opportunities for the user [21]. By using Ar- properties are encapsulated within the module [19]. The cross- cum, a programmer can view the implementation of a crosscutting cutting of the stable properties, such as class and method names, design idiom as a form of module. Arcum uses a declarative lan- can be mitigated with automated refactoring tools that allow, for guage to describe the idiom’s implementation, where descriptions example, the interface’s elements to be renamed [9, 18]. However, are composed of Arcum interface and Arcum option constructs. An often the crosscutting from design idioms (such as design patterns option describes one possible implementation of a crosscutting de- and coding styles) are so specific to the program’s domain that sign idiom, and a set of options are related to each other when they their crosscutting would not likely have been anticipated by the all implement the same Arcum interface. developers of an automated refactoring system. Arcum’s declarative language uses a Java-like syntax for first- The Arcum plug-in for Eclipse enables programmers to describe order logic predicate statements, including a special pattern nota- the implementation of a crosscutting design idiom as a set of syn- tion for expressing Java code.
    [Show full text]
  • Using Recursive Java Generics to Support Code Reuse in the CS2 Course
    Using Recursive Java Generics to Support Code Reuse in the CS2 Course J. Andrew Holey and Lynn R. Ziegler Department of Computer Science Saint John’s University and the College of Saint Benedict Collegeville, Minnesota 56321 [email protected] and [email protected] Abstract Showing students examples of code reuse in early Java programming courses is highly desirable, but one significant class of examples, linked data structures, is difficult to reuse and leads to frequent casting. We show a technique for using recursive generic parameters that significantly simplifies the inheritance of linked data structures, and we discuss the use of this technique in the CS2 course. 1 Introduction Java is well-established as the most frequently-used language in the first two programming courses at colleges and universities (CS1 and CS2). While there is serious and well-founded debate about whether other languages may be more appropriate for an introductory programming sequence at the college level, many computer science faculty members have become comfortable with using Java in these courses and are able to teach programming and problem-solving very effectively using this language. One of the advantages of using object-oriented languages like Java for teaching introductory programming is their support for the construction of abstract data types (ADTs). This support was enhanced in Java 5.0 with the introduction of generics. Libraries like the Java Collection Framework have reduced the emphasis on construction of ADTs in many CS2 courses, but most textbooks and instructors still choose to spend considerable time on the implementation of ADTs. It is now possible to guide students to produce simple and elegant implementations of the standards ADTs, including stacks, queues, various types of lists and trees, maps and even graphs.
    [Show full text]