Metonymic Errors in a Web Development Course

Transcription

1 Metonymic Errors in a Web Development Course Craig S. Miller DePaul University 243 S. Wabash Ave. Chicago, IL USA [email protected] ABSTRACT This paper investigates a class of database access errors that occur in the context of a web development course. While the use of an Object-Relational Mapping (ORM) simplifies database access, students still demonstrate reference errors such as mistakenly referring to the whole object rather than an attribute value that is a part of the object. Metonymy, a rhetorical device used in human communication, offers an interpretation to these errors. A study is presented where student answers are reported and analyzed in this context. Findings indicate the prevalence of reference errors and offer instructional strategies for addressing them. Categories and Subject Descriptors K.3.2 [Computers and Education]: Computer and Information Science Education General Terms Design, Human Factors, Languages Keywords programming errors, web development, metonymy 1. INTRODUCTION The IT program at our university offers a sequence of web development courses whose goals include teaching students the architecture of a web application and the programming fundamentals for connecting the components of the architecture. This emphasis on architecture in IT coursework is supported by findings in previous work. For example, in interviews of IT employers, knowledge of software architecture and the need to integrate existing components to solve a problem were commonly cited as critical competencies for Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. SIGITE 12, October 11 13, 2012, Calgary, Alberta, Canada. Copyright 2012 ACM /12/10...$ IT careers [8]. The importance of these competencies is consistent with recent articles promoting architecture [1, 9] and the need to compose systems from working components [5]. The model-view-controller (MVC) architecture provides an exemplary use of architecture in web development. By presenting web development as separate components, students learn how data models, controller logic and display templates (views) relate to each other. The emphasis on architecture motivated the choice of Ruby on Rails [2] as the development framework used in the web courses discussed in this paper. The Rails framework provides a clean separation of the MVC components, each residing in its own folder in the file structure. An additional benefit is that the framework provides automatic scaffold generation for quickly building a working web application. Most relevant for this paper, the Rails framework makes use of an Object- Relation Mapping (ORM) for its data model component. Use of an ORM in introductory web development courses has several advantages. First, it abstracts away the details of SQL queries and replaces it with the syntax and object-based notation consistent with the framework s programming language. Second, it provides a practical context for teaching or reviewing object-based programming. Finally, it permits database-independent development. Students can develop an application with one database knowing that deployment can use a different database with little or no changes to the application. The first advantage is particularly important for emphasizing architecture since the use of an ORM allows the course to focus on the role of the database with respect to the rest of the application, rather than dwelling on the details of the database. Despite the benefits of using an ORM, application development still presents challenges for students learning to develop software applications. Successfully accessing content requires precise references to data objects and their properties. As we will see, students encounter difficulties specifying the correct referent, whether for display in a view or for integration with other components in an application. These reference errors are the focus of this paper. The thesis is that a major insight to many of these errors involves understanding that humans can automatically resolve ambiguous references whereas computer systems whether through an ORM, SQL or other notations require exact specification of the referent. More specifically, the paper

2 draws upon the rhetorical device of metonymy to explain a class of reference errors observed among students. As we will see, student work is often more consistent with their experience in everyday communication than what is required for producing correct code. Previous analysis has already identified metonymy as a unifying account for a broad range of programming errors [7]. In this sense, the analysis and study presented in this paper complement previous work identifying common misconceptions that produce student errors. Like the analysis in this paper, some of these misconceptions originate from human language [3]. However, these previously studied misconceptions are generally based on words that have different meanings in everyday communication than they do in programming languages (e.g. if or while). This paper examines the potential role of metonymy in the context of application development and data access. The goal is to explain errors, predict when they are likely to occur and suggest teaching strategies for addressing the errors. The next section explains metonymy and its relevance to programming. The following section then presents metonymy in the context of database access using an ORM with the goal of identifying when it occurs. This analysis leads to an empirical study that reveals student responses consistent with the analysis. Finally, we use the analysis to recommend possible approaches for teaching. 2. METONYMY AND PROGRAMMING Metonymy is a rhetorical device used to reference an item by stating another item associated with it. For example, consider this sentence: the host opened the wine to be served with the meal. People have little difficulty understanding that it was not the wine that was actually opened. Rather, the host opened the bottle containing the wine. Here the stated referent (wine) actually refers to its container (bottle). Humans readily use metonymy in everyday communication and quickly resolve the referent with little to no conscious awareness of the needed inference (for an extensive review of metonymy in everyday communication, see Lakoff and Johnson [6]). As will be discussed, computer programming languages generally do not resolve intended referents in this way. As a consequence, the practice of using metonymy in everyday communication may be an impediment for successfully learning how to specify precise referents in computing. Use of metonymy is particularly common when the goal is to contrast against another possible referent. For example, our host may have two bottles of wine to choose from: a Bordeaux and a Burgundy 1. If the goal is to emphasize the choice between the two wines, we may state, The host opened the Burgundy to be served with the meal. Explicitly mentioning the bottle does not improve communication since both wines come in a bottle and listeners effortlessly infer that it is the bottle (of Burgundy wine) being opened. Figure 1 illustrates the use of metonymy for this example. It indicates that specifying the type of wine indicates which bottle should be opened. The bottle itself is not explicitly referenced since it does not have the distinguishing qualities relevant for the choice. 1 Referring to a wine by its region is yet another example of metonymy. Here the reference to Burgundy (or Bordeaux) is not a reference to a region in France, but to the wine that comes from that region. Stated Referent Intended Referent for Selection Type Of Burgundy Contains Bottle-1 Wine Type Of Bordeaux Contains Bottle-2 Figure 1: Metonymy selects the referent. Country id: integer name: string population: integer languages: string continent: string Has Many Belongs To City id: integer name: string population: integer country_id: integer Figure 2: Example models with Rails relations. While everyday language permits flexible expression using metonymy, it cannot usually be applied in the context of programming and application development. Previous work [7] surveys common programming errors where metonymy provides some insight. These errors may involve arrays, objects, and linked lists. For example, when referencing a value in an array, a student may mistakenly reference the index to that value, perhaps in the context of swapping array values. In this paper, the focus is on metonymic errors in the context of ORM access. Even though ORM offers a simplified method for accessing a database, it nevertheless requires precise references to objects (database rows or records) and properties (database columns or fields). As we will see, metonymy suggests a natural tendency for humans (particularly novice developers) to reference an object instead of a property in specific cases (or vice versa). In the next section, ORM terminology is reviewed and a working example is developed. 3. ORM EXAMPLE Before we present any errors, let us first review database access in the context of the Rails ORM, Active Record. For the rest of the paper, examples are based on two schema models presented in Figure 2. The Country model and the City model are adequate to explain student errors and develop exercises for studying them. In addition to a few attributes (e.g. name, population, languages), both models have a primary key (id), which Active Record provides by default. Also note that city has a foreign key (country id). This foreign key provides the basis of a relationship between the two models. Using Active

3 Record terminology, we say that a City belongs to a Country and that a Country has many Cities. Once the models are specified and the relationships declared, Active Record provides object-oriented access to the database by automatically defining classes and methods for the models. Class methods selectively query records from the database: france_country = Country.find_by_name( France ) london_city = City.find_by_name( London ) Specified Referent Intended Referent for Selection France Name Obj-1 Continent Country Is a Is a Europe Germany Name Obj-2 Continent all_city_objects = City.all some_objects = City.where( population > 1000 ) The assigned variable names document what the methods return. In the examples above, the Ruby on Rails framework dynamically defines methods such as find_by_name, which are based on the model s properties. Given an object (record) from the database, instance methods 2 can be called with them: france_city_objects = france_country.cities uk_country_object = london_city.country Finally, attribute values can be assigned to an object, which can then be saved to the database: new_country = Country.new new_country.name = Fredonia new_country.population = new_country.save Even though Active Record simplifies database access using object-based notation, student developers are still required to correctly state the intended referent. For example, if the goal is to list a country, more precisely, the name of the country, the reference must explicitly reference the name property with the country object: new_country.name However, given the prevalence of metonymy in human languages, students may be tempted to simply indicate the object: new_country Other circumstances may call for simply referencing the object (representing the entire database record), perhaps to gain access to other fields associated with it. Considering the use of metonymy, students may be inclined to simply indicate the name (a string) since it is the name that clearly distinguishes it from other country objects. Figure 3 provides a working example that is structurally similar to the wine example. As the figure indicates, Obj-1 and Obj-2 are usefully identified by their name property. However, simply providing the name attribute will not be sufficient if the application requires a reference to the object. In the next section, we review actual student work in the context of the analysis presented here. 2 Technically all object-based references are method calls in Ruby even if they seem like properties. Parentheses are optional for method calls in Ruby. Figure 3: Reference error. 4. STUDY OF STUDENT WORK An exercise with ORM questions was developed to assess student ability to access database content using the Rails ORM, Active Record. The exercise presented the schema shown in Figure 2. The exercise also presented a few working examples similar to those presented in the previous section. The first two questions (presented with answers below) ask students to provide expressions that require an explicit reference to the name property: The country name with id 5. Answer: Country.find(5).name The population of the city of Toronto. Answer: City.find by name( Toronto ).population While there are many correct answers for each question, all correct answers require an explicit reference to the name property. However, as previously discussed, students may (mistakenly) just reference the object. For example, for the first question, they may omit the name reference and thus just provide the object: Country.find(5). For the second question, they may mistakenly omit the name reference when matching the city name: City.Toronto.population. Consistent with the use of metonymy, an identifying property (e.g. name) can be interchanged with the referent itself. The last two questions in the exercise were expressly developed to explore how students specify referents. Both questions ask students to delete an object from an array: Assume that country_list is an array of Country objects. Provide ruby code that uses the remove method to delete the country named France from the array. Answer: country obj = Country.find by name( France ) country list.remove(country obj) Provide the Ruby code that uses the remove method to delete the country whose continent is Europe. For this example, you may assume that there is only one country from Europe in the table. Answer: country obj = Country.find by continent( Europe ) country list.remove(country obj) The answers to both questions are structurally identical. However, the first requires use of the name property and the second requires the use of the continent property. Since the name property is commonly used to identify the object, we

4 hypothesize that it is more likely to be used in place of the object itself. Given the scope of the paper, the analysis focuses on the four questions (first two questions and last two questions) just discussed. However, all the questions to the exercise are provided in the appendix. 4.1 Method TheORMquestionswereofferedasanexerciseinasecond web development course at a large university. While the exercise was offered to all students, students actively chose to participate in the study by submitting their answers in a sealed envelop to the instructor, which were then turned over to the study s investigator. Seventeen students (14 male, 3 female) submitted their answers for analysis. The average age was 25 and the average number of prior programming courses was Results Results focus on student answers to the previously discussed questions (the first two questions and the last two questions in the exercise). These questions directly address metonymic usage. While the other questions may also involve metonymy-based errors, they are more difficult to analyze since they require more complex answers. Furthermore, students responded to fewer of them (students provided answers for only 66% of these questions). Student responses are categorized by whether they successfully referenced the needed property in their answers. In this section, student answers are presented without interpretation. The next section discusses the answers in the context of metonymy. The country name with id 5 (question 1). A correct answer accesses the country object and then references the name attribute. Of the 17 responses, 9 students produced an answer that did not resolve to the name attribute, compared to 5 students who explicitly referenced the name attribute. The remaining 3 students did not produce an answer that could be interpreted as belonging to either group. The population of the city of Toronto. (question 2). A correct answer selects the City object by matching the city name to the name property. 7 students explicitly referenced the name property, including 3 with fully correct answers. 8 responses did not explicitly use thenamepropertyanywhereintheiranswers. 1student did not provide an answer and 1 student provided an unfinished answer (missing a closing parenthesis). For the last two questions (questions 8 and 9), 16 of the 17 students had answers that could be classified into one of the three categories. Just property. The answer just provides the property value to indicate what should be deleted. Examples: country_list.remove( France ) or country_list.remove( Europe ) For question 8 (remove object using the name property), 8 students provided an answer in this category. For question 9 (remove object using the continent property), 2 students provided an answer in this category. Table 1: Frequency counts for last two questions Remove by Continent (Q 9) Remove by Just Match No Name (Q 8) property property answer Just property Match property No answer Match property (correct approach). The answer matches the property value to its attribute to select the country object that should be deleted. Example: country_list.remove( Country.find_by_continent( Europe )) Forquestion8(removeobjectusingthenameproperty), 4 students provided an answer in this category. For question 9 (remove object using the continent property), 6 students provided an answer in this category. No answer. No answer is provided. Forquestion8(removeobjectusingthenameproperty), 4 students provided no answer. For question 9 (remove object using the continent property), 8 students provided no answer. Table 1 presents the frequencies of how each student responded to both questions. For example, 2 students (upperright cell) referenced just the property ( France for question 8 and Europe for question 9) for both questions 8 and 9. Four students (center cell) correctly matched the properties to access the object for removal. Note that no students correctly matched the property for question 8 but then just used the property for question 9. The difference in student responses for the two questions will be further discussed in the next section. Figure 4 summarizes the frequency of observed reference errors for each question as a percentage of student answers (N = 17 and includes blank answers). The error bars indicate 95% confidence intervals 3. The lower end of the confidence intervals for questions 1, 2 and 8 set minimal expectations for this population of students and indicate that at least a quarter of the student answers have problems specifying the correct referent. In the next section, the reference errors will be discussed in the context of metonymy. 4.3 Discussion The results indicate that a substantive number of student programming errors for ORM access involve problems specifying the correct referent. Here those errors are analyzed in the context of metonymic expression. For question 1, most students (9 of 17) provided the whole object (entity representing the full database record) when the question asked for the name. Consistent with metonymy, the name and the object itself can be used interchangeably in common language (e.g. France and the country of France). With this experience, students may be inclined to reference the whole object in place of just the name property. 3 The confidence intervals are calculated using the Clopper and Pearson exact method [4], which does not require an a priori estimation of the proportion.

5 Percent Observed Q1 Q2 Q8 Q9 Figure 4: Observed reference errors by questions. For question 2, many students (8 of 17) did not compare the string Toronto to the name property for identifying the needed city object. Instead, and consistent with metonymic expression, they used the name Toronto as a proxy for the city itself. Similarly, for question 8, most students used the country name France in place of the country object with the name of France. In contrast to question 8, relatively fewer students committed reference errors for question 9. Even though the correct answers for question 8 and question 9 are structurally identical, fewer students just used a string when the object is required. Use of metonymy in common language explains the discrepancy. For question 9, the identifying property is the continent Europe. Since the continent name is not normally adequate to identify a particular country, common language usually does not permit reference to a continent as a means for identifying a country. In this way, students are more likely to think of the continent as a property of the country and not the country itself. While use of metonymy offers an explanation for student answers, results do not conclusively indicate that metonymy accounts for the difference in responses between question 8 and 9. First, it is possible that the relative order of questions 8 and 9 account for differences in responses. Student experience with a prior question could influence how they answer a subsequent question. Second, despite the structural similarity of question 8 and 9, they are not phrased identically. Different phrasing could lead to different answers. Finally, given the small sample size, the difference between question 8 and question 9 is not statistically reliable. These shortcomings could be addressed with further study using a larger sample and controlling for order and question presentation. Study findings are also subject to the student population. Diverse populations may yield varying frequencies of reference errors. In particular, students who are just beginning to learn programming may commit more reference errors than observed here. Given this study s population with an average of three courses (1 year on a quarter system) of prior programming experience, we can expect reference errors in at least a quarter of the student answers (lower limit of the confidence interval) for similar questions for students with less programming experience. Of course, additional studies could further clarify prevalence of reference errors among various populations. 5. IMPLICATIONS Despite noted limitations in the study, the findings demonstrate student difficulties in correctly specifying a referent in the context of data access. An immediate practical consequence is that it calls attention to the commonality of these mistakes. Instructors can accordingly alert students to these pitfalls and providing supporting examples. Our understanding of metonymy in human communication provides a framework for identifying the errors and categorizing them. By knowing where these errors occur, we can develop questions that evaluate student progress towards addressing them. It also opens an avenue of inquiry for exploring possible teaching strategies. For example, it might be helpful to teach students about metonymy in everyday language and contrast it with what is required for application development, where correct referents cannot be automatically inferred. Theoretical analysis based on metonymy also indicates that non-identifying properties may produce fewer reference errors. The study s results provide preliminary empirical evidence that supports this analysis. If so, instructors may want to use examples and problems with non-identifying properties before they present those with identifying properties. In any case, additional studies could explore such instructional strategies and evaluate their effectiveness. Such work may draw upon established strategies for identifying misconceptions and addressing them [3]. Finally the work identifies a critical competence that has broad applicability in computing. Not limited to programming, correct referent specification is needed wherever application development or configuration calls for explicit representations consisting of entities and properties. Computing systems will not be able to automate referent resolution in the near future. To do so would require an explicit domain model and full understanding of natural language. Until then, the ability to precisely and literally specify a referent remains critical for many areas of computing. 6. ACKNOWLEDGMENTS Thanks to John Rogers, who allowed the study to be conducted in his web development class. 7. REFERENCES [1] S. J. Andriole and E. Roberts. Point/counterpoint: Technology curriculum for the early 21st century. Commun. ACM, 51(7):27 32, July [2] M. Bachle and P. Kirchberg. Ruby on rails. Software, IEEE, 24(6): , nov.-dec [3] M. Clancy. Misconceptions and attitudes that interfere with learning to program. In S. Fincher and M. Petre, editors, Computer science education research, pages Taylor and Francis Group, London, [4] C. Clopper and E. Pearson. The use of confidence or fiducial limits illustrated in the case of the binomial. Biometrika, 26(4): , [5] J. J. Ekstrom and B. Lunt. Education at the seams: preparing students to stitch systems together; curriculum and issues for 4-year it programs. In Proceedings of the 4th conference on Information technology curriculum, CITC4 03, pages , New York, NY, USA, ACM.

6 [6] G. Lakoff and M. Johnson. Metaphors We Live By. The University of Chicago Press, Chicago, IL, [7] C. S. Miller. Metonymy and student programming errors. Technical Report 20, DePaul University, [8] C. S. Miller and L. Dettori. Employers perspectives on IT learning outcomes. In Proceedings of the 9th ACM SIGITE conference on Information technology education, SIGITE 08, pages , New York, NY, USA, ACM. [9] K. A. Morneau and S. Talley. Architecture: an emerging core competence for it professionals. In Proceedings of the 8th ACM SIGITE conference on Information technology education, SIGITE 07, pages 9 12, New York, NY, USA, ACM. APPENDIX A. EXERCISE QUESTIONS The following questions were those used for the student exercise and whose answers were analyzed for the study. In addition to the questions below, the students were presented with the Country and City models presented in Figure 2. The exercise also provided several examples that access data based on the models. For the following items, provide the ruby code that produces the following: 1. The country name with id The population of the city of Toronto. 3. The country name where Timbuktu is located. 4. The number of cities listed for France. 5. A listing of all of the cities in Canada. 6. Create a new city record for Saskatoon (population: ) and have it indicate that it belongs to the Canada record. 7. Assume is a Country object. Using template view code, produce a table that lists all of the cities and their populations that belong Ruby has a remove method that allows an object to be deleted from an array of objects. For example if word_list has the contents [ cat, dog, cow, horse ], then word_list.remove( dog ) would delete the string dog from the array. That is, the contents of word_list would then be [ cat, cow, horse ]. 8. Assume that country_list is an array of Country objects. Provide ruby code that uses the remove method to delete the country named France from the array. 9. Provide the ruby code that uses the remove method to delete the country whose continent is Europe. For this example, you may assume that there is only one country from Europe in the table.